@danielx/civet 0.9.1 → 0.9.3

package/dist/main.mjs

@@ -485,15 +485,16 @@ ${body}`;
 // source/parser.hera
 var import_lib2 = __toESM(require_machine());
 
-// source/parser/lib.civet
-var lib_exports = {};
-__export(lib_exports, {
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\lib.civet.jsx
+var lib_civet_exports = {};
+__export(lib_civet_exports, {
   addPostfixStatement: () => addPostfixStatement,
   adjustBindingElements: () => adjustBindingElements,
   adjustIndexAccess: () => adjustIndexAccess,
   append: () => append,
   attachPostfixStatementAsExpression: () => attachPostfixStatementAsExpression,
   blockWithPrefix: () => blockWithPrefix,
+  braceBlock: () => braceBlock,
   convertNamedImportsToObject: () => convertNamedImportsToObject,
   convertObjectToJSXAttributes: () => convertObjectToJSXAttributes,
   convertWithClause: () => convertWithClause,
@@ -561,7 +562,7 @@ __export(lib_exports, {
   wrapTypeInPromise: () => wrapTypeInPromise
 });
 
-// source/parser/util.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\util.civet.jsx
 function len(arr, length) {
   return arr.length === length;
 }
@@ -585,10 +586,8 @@ var assert = {
   }
 };
 function addParentPointers(node, parent) {
-  if (node == null)
-    return;
-  if (typeof node !== "object")
-    return;
+  if (node == null) return;
+  if (typeof node !== "object") return;
   if (Array.isArray(node)) {
     for (const child of node) {
       addParentPointers(child, parent);
@@ -654,8 +653,7 @@ function isToken(node) {
   return node != null && node.token != null;
 }
 function isEmptyBareBlock(node) {
-  if (node?.type !== "BlockStatement")
-    return false;
+  if (node?.type !== "BlockStatement") return false;
   const { bare, expressions } = node;
   return bare && (Array.isArray(expressions) && len(expressions, 0) || Array.isArray(expressions) && len(expressions, 1) && Array.isArray(expressions[0]) && expressions[0].length >= 2 && typeof expressions[0][1] === "object" && expressions[0][1] != null && "type" in expressions[0][1] && expressions[0][1].type === "EmptyStatement");
 }
@@ -688,20 +686,13 @@ function isStatement(node) {
   statementTypes.has(node.type);
 }
 function isWhitespaceOrEmpty(node) {
-  if (!node)
-    return true;
-  if (node.type === "Ref")
-    return false;
-  if (node.token)
-    return /^\s*$/.test(node.token);
-  if (node.children)
-    node = node.children;
-  if (!node.length)
-    return true;
-  if (typeof node === "string")
-    return /^\s*$/.test(node);
-  if (Array.isArray(node))
-    return node.every(isWhitespaceOrEmpty);
+  if (!node) return true;
+  if (node.type === "Ref") return false;
+  if (node.token) return /^\s*$/.test(node.token);
+  if (node.children) node = node.children;
+  if (!node.length) return true;
+  if (typeof node === "string") return /^\s*$/.test(node);
+  if (Array.isArray(node)) return node.every(isWhitespaceOrEmpty);
   return false;
 }
 function firstNonSpace(node) {
@@ -745,12 +736,14 @@ function isExit(node) {
   let ref3;
   let ref4;
   switch (node.type) {
+    // Exit from normal flow
     case "ReturnStatement":
     case "ThrowStatement":
     case "BreakStatement":
     case "ContinueStatement": {
       return true;
     }
+    // if checks then and else clause
     case "IfStatement": {
       return (
         // `insertReturn` for IfStatement adds a return to children
@@ -774,9 +767,11 @@ function isExit(node) {
     case "BlockStatement": {
       return node.expressions.some((s) => isExit(s[1]));
     }
+    // Infinite loops
     case "IterationStatement": {
       return isLoopStatement(node) && gatherRecursiveWithinFunction(node.block, ($1) => $1.type === "BreakStatement").length === 0;
     }
+    // TODO: Distinguish between break of this loop vs. break of inner loops
     default: {
       return false;
     }
@@ -980,6 +975,57 @@ function literalValue(literal) {
     }
   }
 }
+function literalType(literal) {
+  let t;
+  switch (literal.type) {
+    case "RegularExpressionLiteral": {
+      t = "RegExp";
+      break;
+    }
+    case "TemplateLiteral": {
+      t = "string";
+      break;
+    }
+    case "Literal": {
+      switch (literal.subtype) {
+        case "NullLiteral": {
+          t = "null";
+          break;
+        }
+        case "BooleanLiteral": {
+          t = "boolean";
+          break;
+        }
+        case "NumericLiteral": {
+          if (literal.raw.endsWith("n")) {
+            t = "bigint";
+          } else {
+            t = "number";
+          }
+          ;
+          break;
+        }
+        case "StringLiteral": {
+          t = "string";
+          break;
+        }
+        default: {
+          throw new Error(`unknown literal subtype ${literal.subtype}`);
+        }
+      }
+      ;
+      break;
+    }
+    default: {
+      throw new Error(`unknown literal type ${literal.type}`);
+    }
+  }
+  return {
+    type: "TypeLiteral",
+    t,
+    children: [t]
+  };
+}
 function makeNumericLiteral(n) {
   const s = n.toString();
   return {
@@ -996,8 +1042,7 @@ function makeNumericLiteral(n) {
   };
 }
 function startsWith(target, value) {
-  if (!target)
-    return;
+  if (!target) return;
   if (Array.isArray(target)) {
     let i = 0;
     let l = target.length;
@@ -1012,12 +1057,9 @@ function startsWith(target, value) {
       return startsWith(target[i], value);
     }
   }
-  if (typeof target === "string")
-    return value.test(target);
-  if (target.children)
-    return startsWith(target.children, value);
-  if (target.token)
-    return value.test(target.token);
+  if (typeof target === "string") return value.test(target);
+  if (target.children) return startsWith(target.children, value);
+  if (target.token) return value.test(target.token);
   return;
 }
 function startsWithPredicate(node, predicate, skip = isWhitespaceOrEmpty) {
@@ -1148,10 +1190,8 @@ function replaceNodes(root, predicate, replacer) {
   return root;
 }
 function removeHoistDecs(node) {
-  if (node == null)
-    return;
-  if (typeof node !== "object")
-    return;
+  if (node == null) return;
+  if (typeof node !== "object") return;
   if ("hoistDec" in node) {
     node.hoistDec = void 0;
   }
@@ -1283,8 +1323,7 @@ function makeNode(node) {
   return node;
 }
 function skipIfOnlyWS(target) {
-  if (!target)
-    return target;
+  if (!target) return target;
   if (Array.isArray(target)) {
     if (target.length === 1) {
       return skipIfOnlyWS(target[0]);
@@ -1299,7 +1338,7 @@ function skipIfOnlyWS(target) {
   return target;
 }
 function spliceChild(node, child, del, ...replacements) {
-  const children = node?.children ?? node;
+  const children = Array.isArray(node) ? node : node.children;
   if (!Array.isArray(children)) {
     throw new Error("spliceChild: non-array node has no children field");
   }
@@ -1345,8 +1384,9 @@ function parenthesizeType(type) {
     children: ["(", type, ")"]
   });
 }
-function wrapIIFE(expressions, asyncFlag, generator) {
+function wrapIIFE(expressions, asyncFlag, generatorStar) {
   let awaitPrefix;
+  const generator = generatorStar ? [generatorStar] : [];
   const async = [];
   if (asyncFlag) {
     async.push("async ");
@@ -1358,9 +1398,9 @@ function wrapIIFE(expressions, asyncFlag, generator) {
     };
   }
   let yieldWrap = false;
-  if (!generator) {
+  if (!generator.length) {
     if (hasYield(expressions)) {
-      generator = "*";
+      generator.push("*");
       yieldWrap = true;
     }
   }
@@ -1371,30 +1411,34 @@ function wrapIIFE(expressions, asyncFlag, generator) {
     bare: false,
     root: false
   });
+  const parameterList = [];
   const parameters = {
     type: "Parameters",
-    children: ["()"],
+    children: ["(", parameterList, ")"],
+    parameters: parameterList,
     names: []
   };
   const signature = {
+    type: "FunctionSignature",
     modifier: {
       async: !!async.length,
-      generator: !!generator
+      generator: !!generator.length
     },
-    returnType: void 0
+    parameters,
+    returnType: void 0,
+    children: generator.length ? [async, "function", generator, parameters] : [async, parameters]
   };
   let fn;
-  if (generator) {
+  if (generator.length) {
     fn = makeNode({
       type: "FunctionExpression",
       signature,
       parameters,
       returnType: void 0,
-      ts: false,
       async,
       block,
       generator,
-      children: [async, "function", generator, parameters, block]
+      children: [...signature.children, block]
     });
   } else {
     fn = makeNode({
@@ -1402,10 +1446,9 @@ function wrapIIFE(expressions, asyncFlag, generator) {
       signature,
       parameters,
       returnType: void 0,
-      ts: false,
       async,
       block,
-      children: [async, parameters, "=>", block]
+      children: [...signature.children, "=>", block]
     });
   }
   const children = [makeLeftHandSideExpression(fn), "()"];
@@ -1414,8 +1457,19 @@ function wrapIIFE(expressions, asyncFlag, generator) {
       children.splice(1, 0, ".bind(this)");
     }
     if (gatherRecursiveWithinFunction(block, (a2) => typeof a2 === "object" && a2 != null && "token" in a2 && a2.token === "arguments").length) {
-      let ref9;
-      children[children.length - 1] = (ref9 = parameters.children)[ref9.length - 1] = "(arguments)";
+      const binding = {
+        type: "Identifier",
+        name: "arguments",
+        names: ["arguments"],
+        children: ["arguments"]
+      };
+      parameterList.push({
+        type: "Parameter",
+        children: [binding],
+        names: ["arguments"],
+        binding
+      });
+      children[children.length - 1] = "(arguments)";
     }
   }
   let exp = makeNode({
@@ -1467,7 +1521,7 @@ function flatJoin(array, separator) {
   return result;
 }
 
-// source/parser/traversal.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\traversal.civet.jsx
 function gatherRecursiveWithinFunction(node, predicate) {
   return gatherRecursive(node, predicate, isFunction);
 }
@@ -1534,7 +1588,6 @@ function gatherNodes(node, predicate) {
     }
     default: {
       return gatherNodes(
-        //@ts-ignore
         node.children,
         predicate
       );
@@ -1555,7 +1608,6 @@ function gatherRecursive(node, predicate, skipPredicate) {
     return [node];
   }
   return gatherRecursive(
-    //@ts-ignore
     node.children,
     predicate,
     skipPredicate
@@ -1569,7 +1621,6 @@ function gatherRecursiveAll(node, predicate) {
     return node.flatMap((n) => gatherRecursiveAll(n, predicate));
   }
   const nodes = gatherRecursiveAll(
-    //@ts-ignore
     node.children,
     predicate
   );
@@ -1579,7 +1630,7 @@ function gatherRecursiveAll(node, predicate) {
   return nodes;
 }
 
-// source/parser/ref.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\ref.civet.jsx
 function makeRef(base = "ref", id = base) {
   return {
     type: "Ref",
@@ -1640,9 +1691,10 @@ function maybeRefAssignment(exp, base = "ref") {
   }
 }
 
-// source/parser/binding.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\binding.civet.jsx
 function adjustAtBindings(statements, asThis = false) {
-  gatherRecursiveAll(statements, ($) => $.type === "AtBindingProperty").forEach((binding) => {
+  for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "AtBindingProperty"), i1 = 0, len3 = ref1.length; i1 < len3; i1++) {
+    const binding = ref1[i1];
     const { ref } = binding;
     if (asThis) {
       const atBinding = binding.binding;
@@ -1653,20 +1705,18 @@ function adjustAtBindings(statements, asThis = false) {
       binding.ref = void 0;
       return;
     }
-    if (ref.names[0] !== ref.base) {
-      return binding.children.unshift(ref.base, ": ");
+    if (!(ref.names[0] === ref.base)) {
+      binding.children.unshift(ref.base, ": ");
     }
-    ;
-    return;
-  });
+  }
 }
 function adjustBindingElements(elements) {
   const names = elements.flatMap(($1) => $1.names || []);
   const { length } = elements;
   let blockPrefix, restIndex = -1, restCount = 0;
-  for (let i1 = 0, len3 = elements.length; i1 < len3; i1++) {
-    const i = i1;
-    const { type } = elements[i1];
+  for (let i2 = 0, len1 = elements.length; i2 < len1; i2++) {
+    const i = i2;
+    const { type } = elements[i2];
     if (type === "BindingRestElement") {
       if (restIndex < 0) {
         restIndex = i;
@@ -1688,8 +1738,7 @@ function adjustBindingElements(elements) {
     names.push(...rest.names || []);
     let l = after.length;
     if (l) {
-      if (arrayElementHasTrailingComma(after[l - 1]))
-        l++;
+      if (arrayElementHasTrailingComma(after[l - 1])) l++;
       const elements2 = trimFirstSpace(after);
       blockPrefix = {
         type: "PostRestBindingElements",
@@ -1724,35 +1773,63 @@ function gatherBindingCode(statements, opts) {
   const thisAssignments = [];
   const splices = [];
   function insertRestSplices(s, p, thisAssignments2) {
-    gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
+    let m;
+    for (let ref2 = gatherRecursiveAll(
+      s,
+      (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding" || opts?.assignPins && (m = n.type, m === "PinPattern" || m === "PinProperty")
+    ), i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
+      let n = ref2[i3];
       if (n.type === "AtBinding") {
         const { ref } = n;
         const { id } = ref;
         thisAssignments2.push([`this.${id} = `, ref]);
-        return;
+        continue;
+      }
+      if (opts?.assignPins) {
+        if (n.type === "PinProperty") {
+          n.children = n.children.flatMap(($2) => $2 === n.name ? [n.name, ": ", n.value] : $2);
+          updateParentPointers(n);
+          n = n.value;
+        }
+        if (n.type === "PinPattern") {
+          n.ref = makeRef(
+            n.expression.type === "Identifier" ? n.expression.name : "pin"
+          );
+          n.children = [n.ref];
+          updateParentPointers(n);
+          thisAssignments2.push({
+            type: "AssignmentExpression",
+            children: [n.expression, " = ", n.ref],
+            names: [],
+            lhs: n.expression,
+            assigned: n.expression,
+            expression: n.ref
+          });
+          continue;
+        }
       }
       if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-        for (let ref1 = n.names, i2 = 0, len1 = ref1.length; i2 < len1; i2++) {
-          const id = ref1[i2];
+        for (let ref3 = n.names, i4 = 0, len3 = ref3.length; i4 < len3; i4++) {
+          const id = ref3[i4];
           thisAssignments2.push({
             type: "AssignmentExpression",
             children: [`this.${id} = `, id],
             js: true
           });
         }
-        return;
+        continue;
       }
       const { blockPrefix } = n;
       p.push(blockPrefix);
-      return insertRestSplices(blockPrefix, p, thisAssignments2);
-    });
+      insertRestSplices(blockPrefix, p, thisAssignments2);
+    }
   }
   insertRestSplices(statements, splices, thisAssignments);
   return [splices, thisAssignments];
 }
 function arrayElementHasTrailingComma(elementNode) {
-  let ref2;
-  const lastChild = (ref2 = elementNode.children)[ref2.length - 1];
+  let ref4;
+  const lastChild = (ref4 = elementNode.children)[ref4.length - 1];
   return lastChild && lastChild[lastChild.length - 1]?.token === ",";
 }
 function gatherBindingPatternTypeSuffix(pattern) {
@@ -1764,8 +1841,8 @@ function gatherBindingPatternTypeSuffix(pattern) {
     case "ArrayBindingPattern": {
       {
         const results = [];
-        for (let ref3 = pattern.elements, i3 = 0, len22 = ref3.length; i3 < len22; i3++) {
-          const elem = ref3[i3];
+        for (let ref5 = pattern.elements, i5 = 0, len4 = ref5.length; i5 < len4; i5++) {
+          const elem = ref5[i5];
           let { typeSuffix } = elem;
           typeSuffix ??= elem.binding?.typeSuffix;
           if (typeSuffix) {
@@ -1803,8 +1880,8 @@ function gatherBindingPatternTypeSuffix(pattern) {
       {
         let restType;
         const results1 = [];
-        for (let ref4 = pattern.properties, i4 = 0, len3 = ref4.length; i4 < len3; i4++) {
-          const prop = ref4[i4];
+        for (let ref6 = pattern.properties, i6 = 0, len5 = ref6.length; i6 < len5; i6++) {
+          const prop = ref6[i6];
           let { typeSuffix } = prop;
           typeSuffix ??= prop.value?.typeSuffix;
           if (typeSuffix) {
@@ -1854,12 +1931,12 @@ function gatherBindingPatternTypeSuffix(pattern) {
   return pattern;
 }
 
-// source/parser/comptime.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\comptime.civet.jsx
 import { resolve, dirname } from "node:path";
 import { createRequire } from "node:module";
 import vm from "node:vm";
 
-// source/parser/helper.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\helper.civet.jsx
 var preludeVar = "var ";
 function ts(children) {
   return {
@@ -2089,7 +2166,7 @@ function extractPreludeFor(node) {
   return state.prelude.filter((s) => gatherRecursive(s, helpers.has.bind(helpers)).length);
 }
 
-// source/generate.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\generate.civet.jsx
 function stringify(node) {
   try {
     return JSON.stringify(removeParentPointers(node));
@@ -2170,7 +2247,7 @@ function gen(root, options) {
     throw new Error(`Unknown node ${stringify(node)}`);
   }
 }
-var generate_default = gen;
+var generate_civet_default = gen;
 function prune(node) {
   if (!(node != null)) {
     return;
@@ -2198,7 +2275,7 @@ function prune(node) {
   return node;
 }
 
-// source/parser/comptime.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\comptime.civet.jsx
 function expressionizeComptime(statement) {
   const { expressions } = statement.block;
   const expression = wrapIIFE(expressions, hasAwait(expressions));
@@ -2237,7 +2314,7 @@ function runComptime(statements) {
       content
     ];
     const options = { js: true };
-    let js = generate_default(prune(content), options);
+    let js = generate_civet_default(prune(content), options);
     js = `"use strict";${js}`;
     if (options.errors != null) {
       return;
@@ -2321,10 +2398,8 @@ 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") {
@@ -2496,6 +2571,7 @@ function serialize(value, context) {
           ref1 = `new ${val.constructor.name}([${Array.from(val, ($1) => `${$1}n`).join(",")}])`;
           break;
         }
+        // Spelled differently for browsers, where `Buffer` doesn't exist
         case globalThis.Buffer?.prototype:
         case context?.Buffer?.prototype: {
           ref1 = `Buffer.from([${val.join(",")}])`;
@@ -2520,7 +2596,8 @@ function serialize(value, context) {
   return recurse(value);
 }
 
-// source/parser/function.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\function.civet.jsx
+var concatAssign = (lhs, rhs) => (rhs?.[Symbol.isConcatSpreadable] ?? Array.isArray(rhs) ? lhs.push.apply(lhs, rhs) : lhs.push(rhs), lhs);
 function getTypeArguments(args) {
   while (typeof args === "object" && args != null && "args" in args) {
     args = args.args;
@@ -2578,8 +2655,7 @@ function wrapTypeInApplication(t, id, raw) {
   };
 }
 function implicitFunctionBlock(f) {
-  if (f.abstract || f.block || f.signature?.optional)
-    return;
+  if (f.abstract || f.block || f.signature?.optional) return;
   const { name, parent } = f;
   let ancestor = parent;
   let child = f;
@@ -2718,16 +2794,14 @@ function patternAsValue(pattern) {
     case "ArrayBindingPattern": {
       const children = [...pattern.children];
       const index = children.indexOf(pattern.elements);
-      if (index < 0)
-        throw new Error("failed to find elements in ArrayBindingPattern");
+      if (index < 0) throw new Error("failed to find elements in ArrayBindingPattern");
       const elements = children[index] = pattern.elements.map(patternAsValue);
       return { ...pattern, elements, children };
     }
     case "ObjectBindingPattern": {
       const children = [...pattern.children];
       const index = children.indexOf(pattern.properties);
-      if (index < 0)
-        throw new Error("failed to find properties in ArrayBindingPattern");
+      if (index < 0) throw new Error("failed to find properties in ArrayBindingPattern");
       const properties = children[index] = pattern.properties.map(patternAsValue);
       return { ...pattern, properties, children };
     }
@@ -2820,8 +2894,7 @@ function patternBindings(pattern) {
   }
 }
 function assignResults(node, collect) {
-  if (!node)
-    return;
+  if (!node) return;
   switch (node.type) {
     case "BlockStatement":
       if (node.expressions.length) {
@@ -2956,8 +3029,7 @@ function assignResults(node, collect) {
   node[1] = collect(node[1]);
 }
 function insertReturn(node) {
-  if (!node)
-    return;
+  if (!node) return;
   switch (node.type) {
     case "BlockStatement": {
       if (node.expressions.length) {
@@ -2974,6 +3046,7 @@ function insertReturn(node) {
       }
       return;
     }
+    // NOTE: "CaseClause"s don't get a return statement inserted
     case "WhenClause": {
       if (node.break) {
         const breakIndex = node.children.indexOf(node.break);
@@ -2997,8 +3070,7 @@ function insertReturn(node) {
       return;
     }
   }
-  if (!Array.isArray(node))
-    return;
+  if (!Array.isArray(node)) return;
   let [, exp, semi] = node;
   if (semi?.type === "SemicolonDelimiter") {
     return;
@@ -3078,14 +3150,12 @@ function insertReturn(node) {
     }
     case "IfStatement": {
       insertReturn(exp.then);
-      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)
-        ]);
+      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)
+      ]);
       return;
     }
     case "PatternMatchingStatement": {
@@ -3382,6 +3452,183 @@ function processParams(f) {
   if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
     parameters.tp.parameters.push(",");
   }
+  let tt, before = [], rest, after = [];
+  function append2(p) {
+    (rest ? after : before).push(p);
+  }
+  for (let ref16 = parameters.parameters, i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
+    const param = ref16[i8];
+    switch (param.type) {
+      case "ThisType": {
+        if (tt) {
+          append2({
+            type: "Error",
+            message: "Only one typed this parameter is allowed"
+          });
+          append2(param);
+        } else {
+          tt = trimFirstSpace(param);
+          if (before.length || rest) {
+            let ref17;
+            let delim = (ref17 = tt.children)[ref17.length - 1];
+            if (Array.isArray(delim)) {
+              delim = delim[delim.length - 1];
+            }
+            if (!(typeof delim === "object" && delim != null && "token" in delim && delim.token === ",")) {
+              tt = {
+                ...tt,
+                children: [...tt.children, ", "]
+              };
+            }
+          }
+        }
+        ;
+        break;
+      }
+      case "FunctionRestParameter": {
+        if (rest) {
+          append2({
+            type: "Error",
+            message: "Only one rest parameter is allowed"
+          });
+          append2(param);
+        } else {
+          rest = param;
+        }
+        ;
+        break;
+      }
+      default: {
+        append2(param);
+      }
+    }
+  }
+  parameters.names = before.flatMap(($6) => $6.names);
+  parameters.parameters.splice(0, 1 / 0, ...[]);
+  if (tt) {
+    parameters.parameters.push(tt);
+  }
+  parameters.parameters.push(...before);
+  if (rest) {
+    const restIdentifier = rest.binding.ref || rest.binding;
+    parameters.names.push(...rest.names || []);
+    rest.children.pop();
+    if (after.length) {
+      if (rest.binding.type === "ArrayBindingPattern" || rest.binding.type === "ObjectBindingPattern") {
+        parameters.parameters.push({
+          type: "Error",
+          message: "Non-end rest parameter cannot be binding pattern"
+        });
+      }
+      after = trimFirstSpace(after);
+      const names = after.flatMap(($7) => $7.names);
+      const elements = after.map((p) => {
+        if (p.type === "Error") {
+          return p;
+        }
+        return {
+          ...p,
+          // omit individual argument types from output
+          children: p.children.filter((a2) => a2 !== p.typeSuffix),
+          type: "BindingElement"
+        };
+      });
+      const pattern = gatherBindingPatternTypeSuffix(makeNode({
+        type: "ArrayBindingPattern",
+        elements,
+        length: after.length,
+        children: ["[", elements, "]"],
+        names
+      }));
+      const { typeSuffix } = pattern;
+      const blockPrefix = parameters.blockPrefix = makeNode({
+        type: "PostRestBindingElements",
+        children: [
+          pattern,
+          " = ",
+          restIdentifier,
+          ".splice(-",
+          after.length.toString(),
+          ")"
+        ],
+        elements,
+        names
+      });
+      if (rest.typeSuffix) {
+        let optionalType = function(typeSuffix3, fallback) {
+          const t2 = typeSuffix3?.t ?? fallback;
+          if (typeSuffix3?.optional) {
+            return [
+              t2,
+              {
+                type: "Error",
+                message: "Optional parameter not allowed in/after rest parameter"
+              }
+            ];
+          }
+          return t2;
+        };
+        const ref = makeRef("rest");
+        const restRef = [
+          { children: [ref], ts: true },
+          { children: [restIdentifier], js: true }
+        ];
+        blockPrefix.children[blockPrefix.children.indexOf(restIdentifier)] = restRef;
+        blockPrefix.children.push({
+          ts: true,
+          children: [
+            ", ",
+            restIdentifier,
+            " = ",
+            ref,
+            " as ",
+            trimFirstSpace(rest.typeSuffix.t)
+          ]
+        });
+        const bindingIndex = rest.rest.children.indexOf(rest.rest.binding);
+        assert.notEqual(bindingIndex, -1, "Could not find binding in rest parameter");
+        rest.rest.children[bindingIndex] = rest.rest.binding = { ...rest.rest.binding, js: true };
+        rest.rest.children.splice(bindingIndex + 1, 0, {
+          children: [ref],
+          ts: true
+        });
+        const oldSuffix = rest.typeSuffix;
+        const colon = oldSuffix.colon ?? ": ";
+        const afterTypes = after.flatMap((p) => {
+          return [",", optionalType(p.typeSuffix, " unknown")];
+        });
+        const t = [
+          "[",
+          "...",
+          optionalType(oldSuffix, "unknown[]"),
+          ...afterTypes,
+          "]"
+        ];
+        const typeSuffix2 = makeNode({
+          type: "TypeSuffix",
+          ts: true,
+          colon,
+          t,
+          children: [
+            ...oldSuffix.children.filter(($8) => (
+              // spaces and colon
+              $8 !== oldSuffix.optional && $8 !== oldSuffix.t
+            )),
+            !oldSuffix.colon ? colon : void 0,
+            t
+          ]
+        });
+        const suffixIndex = rest.children.indexOf(rest.typeSuffix);
+        assert.notEqual(suffixIndex, -1, "Could not find typeSuffix in rest parameter");
+        rest.children[suffixIndex] = rest.typeSuffix = typeSuffix2;
+        blockPrefix.children.splice(-1, 0, {
+          ts: true,
+          children: [" as [", afterTypes.slice(1), "]"]
+        });
+      }
+    }
+    parameters.parameters.push(rest);
+  }
   if (!block) {
     return;
   }
@@ -3396,28 +3643,29 @@ function processParams(f) {
     indent = expressions[0][0];
   }
   const [splices, thisAssignments] = gatherBindingCode(parameters, {
-    injectParamProps: isConstructor
+    injectParamProps: isConstructor,
+    assignPins: true
   });
   if (isConstructor) {
-    const { ancestor } = findAncestor(f, ($6) => $6.type === "ClassExpression");
+    const { ancestor } = findAncestor(f, ($9) => $9.type === "ClassExpression");
     if (ancestor != null) {
-      const fields = new Set(gatherRecursiveWithinFunction(ancestor, ($7) => $7.type === "FieldDefinition").map(($8) => $8.id).filter((a2) => typeof a2 === "object" && a2 != null && "type" in a2 && a2.type === "Identifier").map(($9) => $9.name));
+      const fields = new Set(gatherRecursiveWithinFunction(ancestor, ($10) => $10.type === "FieldDefinition").map(($11) => $11.id).filter((a3) => typeof a3 === "object" && a3 != null && "type" in a3 && a3.type === "Identifier").map(($12) => $12.name));
       const classExpressions = ancestor.body.expressions;
-      let index = findChildIndex(classExpressions, f);
-      assert.notEqual(index, -1, "Could not find constructor in class");
+      let index2 = findChildIndex(classExpressions, f);
+      assert.notEqual(index2, -1, "Could not find constructor in class");
       let m4;
-      while (m4 = classExpressions[index - 1]?.[1], typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor") {
-        index--;
+      while (m4 = classExpressions[index2 - 1]?.[1], typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor") {
+        index2--;
       }
-      const fStatement = classExpressions[index];
-      for (let ref16 = gatherRecursive(parameters, ($10) => $10.type === "Parameter"), i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
-        const parameter = ref16[i8];
+      const fStatement = classExpressions[index2];
+      for (let ref18 = gatherRecursive(parameters, ($13) => $13.type === "Parameter"), i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
+        const parameter = ref18[i9];
         const { accessModifier } = parameter;
         if (!(accessModifier || parameter.typeSuffix)) {
           continue;
         }
-        for (let ref17 = gatherRecursive(parameter, ($11) => $11.type === "AtBinding"), i9 = 0, len8 = ref17.length; i9 < len8; i9++) {
-          const binding = ref17[i9];
+        for (let ref19 = gatherRecursive(parameter, ($14) => $14.type === "AtBinding"), i10 = 0, len9 = ref19.length; i10 < len9; i10++) {
+          const binding = ref19[i10];
           const typeSuffix = binding.parent?.typeSuffix;
           if (!(accessModifier || typeSuffix)) {
             continue;
@@ -3430,7 +3678,7 @@ function processParams(f) {
           if (fields.has(id)) {
             continue;
           }
-          classExpressions.splice(index++, 0, [fStatement[0], {
+          classExpressions.splice(index2++, 0, [fStatement[0], {
             type: "FieldDefinition",
             id,
             typeSuffix,
@@ -3445,34 +3693,53 @@ function processParams(f) {
     type: "SemicolonDelimiter",
     children: [";"]
   };
-  const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
-    (s) => s.type ? {
-      // TODO: figure out how to get JS only statement tuples
-      ...s,
-      children: [indent, ...s.children, delimiter]
-    } : [indent, s, delimiter]
-  );
+  let prefix = [];
+  for (let ref20 = splices, i11 = 0, len10 = ref20.length; i11 < len10; i11++) {
+    const binding = ref20[i11];
+    assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding");
+    prefix.push(makeNode({
+      type: "Declaration",
+      children: ["let ", binding],
+      names: binding.names,
+      bindings: [],
+      // avoid implicit return of any bindings
+      decl: "let"
+    }));
+  }
+  concatAssign(prefix, thisAssignments);
+  prefix = prefix.map((s) => s?.js ? ["", makeNode({
+    // TODO: figure out how to get JS only statement tuples
+    ...s,
+    children: [indent, ...s.children, delimiter]
+  })] : [indent, s, delimiter]);
   if (!prefix.length) {
     return;
   }
+  let index = -1;
   if (isConstructor) {
-    const superCalls = gatherNodes(
-      expressions,
-      (a3) => typeof a3 === "object" && a3 != null && "type" in a3 && a3.type === "CallExpression" && "children" in a3 && Array.isArray(a3.children) && a3.children.length >= 1 && typeof a3.children[0] === "object" && a3.children[0] != null && "token" in a3.children[0] && a3.children[0].token === "super"
-    );
-    if (superCalls.length) {
-      const { child } = findAncestor(superCalls[0], (a4) => a4 === block);
-      const index = findChildIndex(expressions, child);
-      if (index < 0) {
-        throw new Error("Could not find super call within top-level expressions");
-      }
-      expressions.splice(index + 1, 0, ...prefix);
-      return;
-    }
+    index = findSuperCall(block);
   }
-  expressions.unshift(...prefix);
+  expressions.splice(index + 1, 0, ...prefix);
+  updateParentPointers(block);
   braceBlock(block);
 }
+function findSuperCall(block) {
+  const { expressions } = block;
+  const superCalls = gatherNodes(
+    expressions,
+    (a4) => typeof a4 === "object" && a4 != null && "type" in a4 && a4.type === "CallExpression" && "children" in a4 && Array.isArray(a4.children) && a4.children.length >= 1 && typeof a4.children[0] === "object" && a4.children[0] != null && "token" in a4.children[0] && a4.children[0].token === "super"
+  );
+  if (superCalls.length) {
+    const { child } = findAncestor(superCalls[0], (a5) => a5 === block);
+    const index = findChildIndex(expressions, child);
+    if (index < 0) {
+      throw new Error("Could not find super call within top-level expressions");
+    }
+    return index;
+  } else {
+    return -1;
+  }
+}
 function processSignature(f) {
   const { block, signature } = f;
   if (!f.async?.length && hasAwait(block)) {
@@ -3480,8 +3747,8 @@ function processSignature(f) {
       f.async.push("async ");
       signature.modifier.async = true;
     } else {
-      for (let ref18 = gatherRecursiveWithinFunction(block, ($12) => $12.type === "Await"), i10 = 0, len9 = ref18.length; i10 < len9; i10++) {
-        const a = ref18[i10];
+      for (let ref21 = gatherRecursiveWithinFunction(block, ($15) => $15.type === "Await"), i12 = 0, len11 = ref21.length; i12 < len11; i12++) {
+        const a = ref21[i12];
         const i = findChildIndex(a.parent, a);
         a.parent.children.splice(i + 1, 0, {
           type: "Error",
@@ -3495,9 +3762,9 @@ function processSignature(f) {
       f.generator.push("*");
       signature.modifier.generator = true;
     } else {
-      for (let ref19 = gatherRecursiveWithinFunction(block, ($13) => $13.type === "YieldExpression"), i11 = 0, len10 = ref19.length; i11 < len10; i11++) {
-        const y = ref19[i11];
-        const i = y.children.findIndex(($14) => $14.type === "Yield");
+      for (let ref22 = gatherRecursiveWithinFunction(block, ($16) => $16.type === "YieldExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
+        const y = ref22[i13];
+        const i = y.children.findIndex(($17) => $17.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}`
@@ -3510,8 +3777,8 @@ function processSignature(f) {
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref20 = gatherRecursiveAll(statements, ($15) => $15.type === "FunctionExpression" || $15.type === "ArrowFunction" || $15.type === "MethodDefinition"), i12 = 0, len11 = ref20.length; i12 < len11; i12++) {
-    const f = ref20[i12];
+  for (let ref23 = gatherRecursiveAll(statements, ($18) => $18.type === "FunctionExpression" || $18.type === "ArrowFunction" || $18.type === "MethodDefinition"), i14 = 0, len13 = ref23.length; i14 < len13; i14++) {
+    const f = ref23[i14];
     if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
     }
@@ -3567,9 +3834,9 @@ function expressionizeIteration(exp) {
   }
   let done;
   if (!async) {
-    let ref21;
-    if ((ref21 = blockContainingStatement(exp)) && typeof ref21 === "object" && "block" in ref21 && "index" in ref21) {
-      const { block: parentBlock, index } = ref21;
+    let ref24;
+    if ((ref24 = blockContainingStatement(exp)) && typeof ref24 === "object" && "block" in ref24 && "index" in ref24) {
+      const { block: parentBlock, index } = ref24;
       statements[0][0] = parentBlock.expressions[index][0];
       parentBlock.expressions.splice(index, index + 1 - index, ...statements);
       updateParentPointers(parentBlock);
@@ -3586,8 +3853,8 @@ function expressionizeIteration(exp) {
   }
 }
 function processIterationExpressions(statements) {
-  for (let ref22 = gatherRecursiveAll(statements, ($16) => $16.type === "IterationExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
-    const s = ref22[i13];
+  for (let ref25 = gatherRecursiveAll(statements, ($19) => $19.type === "IterationExpression"), i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
+    const s = ref25[i15];
     expressionizeIteration(s);
   }
 }
@@ -3608,38 +3875,40 @@ function processCoffeeDo(ws, expression) {
   ws = trimFirstSpace(ws);
   const args = [];
   if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "ArrowFunction" || typeof expression === "object" && expression != null && "type" in expression && expression.type === "FunctionExpression") {
-    const { parameters } = expression;
+    let { parameters } = expression;
+    const parameterList = parameters.parameters;
+    const results1 = [];
+    for (let i16 = 0, len15 = parameterList.length; i16 < len15; i16++) {
+      let parameter = parameterList[i16];
+      if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
+        let ref26;
+        if (ref26 = parameter.initializer) {
+          const initializer = ref26;
+          args.push(initializer.expression, parameter.delim);
+          parameter = {
+            ...parameter,
+            initializer: void 0,
+            children: parameter.children.filter((a6) => a6 !== initializer)
+          };
+        } else {
+          args.push(parameter.children.filter(
+            (a7) => a7 !== parameter.typeSuffix
+          ));
+        }
+      }
+      results1.push(parameter);
+    }
+    ;
+    const newParameterList = results1;
     const newParameters = {
       ...parameters,
-      children: (() => {
-        const results1 = [];
-        for (let ref23 = parameters.children, i14 = 0, len13 = ref23.length; i14 < len13; i14++) {
-          let parameter = ref23[i14];
-          if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-            let ref24;
-            if (ref24 = parameter.initializer) {
-              const initializer = ref24;
-              args.push(initializer.expression, parameter.delim);
-              parameter = {
-                ...parameter,
-                initializer: void 0,
-                children: parameter.children.filter((a5) => a5 !== initializer)
-              };
-            } else {
-              args.push(parameter.children.filter(
-                (a6) => a6 !== parameter.typeSuffix
-              ));
-            }
-          }
-          results1.push(parameter);
-        }
-        return results1;
-      })()
+      parameters: newParameterList,
+      children: parameters.children.map(($20) => $20 === parameterList ? newParameterList : $20)
     };
     expression = {
       ...expression,
       parameters: newParameters,
-      children: expression.children.map(($17) => $17 === parameters ? newParameters : $17)
+      children: expression.children.map(($21) => $21 === parameters ? newParameters : $21)
     };
   }
   return {
@@ -3661,12 +3930,16 @@ function makeAmpersandFunction(rhs) {
     ref = makeRef("$");
     inplacePrepend(ref, body);
   }
-  if (startsWithPredicate(body, ($18) => $18.type === "ObjectExpression")) {
+  if (startsWithPredicate(body, ($22) => $22.type === "ObjectExpression")) {
     body = makeLeftHandSideExpression(body);
   }
+  const parameterList = [
+    typeSuffix ? [ref, typeSuffix] : ref
+  ];
   const parameters = makeNode({
     type: "Parameters",
-    children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
+    children: typeSuffix ? ["(", parameterList, ")"] : [parameterList],
+    parameters: parameterList,
     names: []
   });
   const expressions = [[" ", body]];
@@ -3700,14 +3973,14 @@ function makeAmpersandFunction(rhs) {
   }
   if (gatherRecursiveWithinFunction(
     block,
-    (a7) => a7 === ref
+    (a8) => a8 === ref
   ).length > 1) {
     fn.ampersandBlock = false;
   }
   return fn;
 }
 
-// source/parser/block.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\block.civet.jsx
 function blockWithPrefix(prefixStatements, block) {
   if (prefixStatements && prefixStatements.length) {
     const expressions = [...prefixStatements, ...block.expressions];
@@ -3794,10 +4067,8 @@ function getIndent(statement) {
   if (Array.isArray(indent)) {
     indent = indent.flat(Infinity);
     return indent.filter((n) => n && !(n.type === "Comment")).map((n) => {
-      if (typeof n === "string")
-        return n;
-      if (n.token != null)
-        return n.token;
+      if (typeof n === "string") return n;
+      if (n.token != null) return n.token;
       return "";
     });
   }
@@ -3925,7 +4196,7 @@ function blockContainingStatement(exp) {
   };
 }
 
-// source/parser/op.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\op.civet.jsx
 var precedenceOrder = [
   ["||", "??"],
   ["^^"],
@@ -3989,7 +4260,7 @@ function processExpandedBinaryOpExpression(expandedOps) {
   while (i < expandedOps.length) {
     let op = expandedOps[i];
     if (op.special) {
-      let advanceLeft2 = function(allowEqual) {
+      let advanceLeft = function(allowEqual) {
         while (start >= 4) {
           const prevPrec = getPrecedence(expandedOps[start - 2]);
           if (!(prevPrec > prec || allowEqual && prevPrec === prec)) {
@@ -3998,7 +4269,7 @@ function processExpandedBinaryOpExpression(expandedOps) {
           start -= 4;
         }
         return false;
-      }, advanceRight2 = function(allowEqual) {
+      }, advanceRight = function(allowEqual) {
         while (end + 4 < expandedOps.length) {
           const nextPrec = getPrecedence(expandedOps[end + 2]);
           if (!(nextPrec > prec || allowEqual && nextPrec === prec)) {
@@ -4008,24 +4279,23 @@ function processExpandedBinaryOpExpression(expandedOps) {
         }
         return false;
       };
-      var advanceLeft = advanceLeft2, advanceRight = advanceRight2;
       let start = i - 2, end = i + 2;
       const prec = getPrecedence(op);
       let error;
       switch (op.assoc) {
         case "left":
         case void 0: {
-          advanceLeft2(true);
-          advanceRight2(false);
+          advanceLeft(true);
+          advanceRight(false);
           break;
         }
         case "right": {
-          advanceLeft2(false);
-          advanceRight2(true);
+          advanceLeft(false);
+          advanceRight(true);
           break;
         }
         case "non": {
-          if (advanceLeft2(false) || advanceRight2(false)) {
+          if (advanceLeft(false) || advanceRight(false)) {
             error = {
               type: "Error",
               message: `non-associative operator ${op.token} used at same precedence level without parenthesization`
@@ -4035,13 +4305,13 @@ function processExpandedBinaryOpExpression(expandedOps) {
           break;
         }
         case "arguments": {
-          if (advanceLeft2(false)) {
+          if (advanceLeft(false)) {
             error = {
               type: "Error",
               message: `arguments operator ${op.token} used at same precedence level as ${expandedOps[start - 2].token} to the left`
             };
           }
-          advanceRight2(true);
+          advanceRight(true);
           break;
         }
         default: {
@@ -4125,13 +4395,11 @@ function processExpandedBinaryOpExpression(expandedOps) {
         type = "CallExpression";
       } else if (op.token) {
         children = [a, wsOp, op, wsB, b];
-        if (op.negated)
-          children = ["(", ...children, ")"];
+        if (op.negated) children = ["(", ...children, ")"];
       } else {
         throw new Error("Unknown operator: " + JSON.stringify(op));
       }
-      if (op.negated)
-        children.unshift("!");
+      if (op.negated) children.unshift("!");
       if (error != null) {
         children.push(error);
       }
@@ -4264,7 +4532,7 @@ function expandChainedComparisons([first, binops]) {
   }
 }
 
-// source/parser/pattern-matching.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\pattern-matching.civet.jsx
 function processPatternTest(lhs, patterns) {
   const { ref, refAssignmentComma } = maybeRefAssignment(lhs, "m");
   const conditionExpression = flatJoin(patterns.map(($1) => getPatternConditions($1, ref)).map(($2) => flatJoin($2, " && ")), " || ");
@@ -4386,8 +4654,7 @@ function processPatternMatching(statements) {
   });
 }
 function getPatternConditions(pattern, ref, conditions = []) {
-  if (pattern.rest)
-    return conditions;
+  if (pattern.rest) return conditions;
   switch (pattern.type) {
     case "ArrayBindingPattern": {
       const { elements, length } = pattern, hasRest = elements.some((e) => e.rest), l = (length - +hasRest).toString(), lengthCheck = hasRest ? [ref, ".length >= ", l] : [getHelperRef("len"), "(", ref, ", ", l, ")"];
@@ -4498,7 +4765,7 @@ function getPatternConditions(pattern, ref, conditions = []) {
   }
   return conditions;
 }
-function getPatternBlockPrefix(pattern, ref, decl = "const ", suffix) {
+function getPatternBlockPrefix(pattern, ref, decl = "const ", typeSuffix) {
   switch (pattern.type) {
     case "ArrayBindingPattern": {
       if (!pattern.length) {
@@ -4529,7 +4796,7 @@ function getPatternBlockPrefix(pattern, ref, decl = "const ", suffix) {
   return [
     ["", {
       type: "Declaration",
-      children: [decl, patternBindings2, suffix, " = ", ref, ...splices],
+      children: [decl, patternBindings2, typeSuffix, " = ", ref, ...splices],
       names: [],
       bindings: []
       // avoid implicit return of any bindings
@@ -4718,7 +4985,7 @@ function aliasBinding(p, ref) {
   }
 }
 
-// source/parser/declaration.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\declaration.civet.jsx
 function len2(arr, length) {
   return arr.length === length;
 }
@@ -4762,21 +5029,51 @@ function processAssignmentDeclaration(decl, pattern, typeSuffix, ws, assign, e)
   });
 }
 function processDeclarations(statements) {
-  gatherRecursiveAll(statements, ($) => $.type === "Declaration").forEach((statement) => {
-    const { bindings } = statement;
-    return bindings?.forEach((binding) => {
-      const { typeSuffix } = binding;
-      if (typeSuffix && typeSuffix.optional && typeSuffix.t) {
-        convertOptionalType(typeSuffix);
-      }
-      const { initializer } = binding;
+  for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "Declaration"), i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
+    const declaration = ref1[i1];
+    const { bindings } = declaration;
+    if (!(bindings != null)) {
+      continue;
+    }
+    for (let i2 = 0, len22 = bindings.length; i2 < len22; i2++) {
+      const binding = bindings[i2];
+      let { typeSuffix, initializer } = binding;
+      if (typeSuffix && typeSuffix.optional) {
+        if (initializer && !typeSuffix.t) {
+          const expression = trimFirstSpace(initializer.expression);
+          let m;
+          if (m = expression.type, m === "Identifier" || m === "MemberExpression") {
+            typeSuffix.children.push(": ", typeSuffix.t = {
+              type: "TypeTypeof",
+              children: ["typeof ", expression],
+              expression
+            });
+          } else if (expression.type === "Literal" || expression.type === "RegularExpressionLiteral" || expression.type === "TemplateLiteral") {
+            typeSuffix.children.push(": ", typeSuffix.t = literalType(expression));
+          } else {
+            spliceChild(binding, typeSuffix, 1, {
+              type: "Error",
+              message: `Optional type can only be inferred from literals or member expressions, not ${expression.type}`
+            });
+            continue;
+          }
+        }
+        if (typeSuffix.t) {
+          convertOptionalType(typeSuffix);
+        } else {
+          spliceChild(binding, typeSuffix, 1);
+          binding.children.push(initializer = binding.initializer = {
+            type: "Initializer",
+            expression: "undefined",
+            children: [" = ", "undefined"]
+          });
+        }
+      }
       if (initializer) {
-        return prependStatementExpressionBlock(initializer, statement);
+        prependStatementExpressionBlock(initializer, declaration);
       }
-      ;
-      return;
-    });
-  });
+    }
+  }
 }
 function prependStatementExpressionBlock(initializer, statement) {
   let { expression: exp } = initializer;
@@ -4938,16 +5235,16 @@ function processDeclarationConditionStatement(s) {
     if (conditions.length) {
       let children = condition.children;
       if (s.negated) {
-        let m;
-        if (!(m = condition.expression, typeof m === "object" && m != null && "type" in m && m.type === "UnaryExpression" && "children" in m && Array.isArray(m.children) && len2(m.children, 2) && Array.isArray(m.children[0]) && len2(m.children[0], 1) && m.children[0][0] === "!" && typeof m.children[1] === "object" && m.children[1] != null && "type" in m.children[1] && m.children[1].type === "ParenthesizedExpression")) {
+        let m1;
+        if (!(m1 = condition.expression, typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "UnaryExpression" && "children" in m1 && Array.isArray(m1.children) && len2(m1.children, 2) && Array.isArray(m1.children[0]) && len2(m1.children[0], 1) && m1.children[0][0] === "!" && typeof m1.children[1] === "object" && m1.children[1] != null && "type" in m1.children[1] && m1.children[1].type === "ParenthesizedExpression")) {
           throw new Error("Unsupported negated condition");
         }
         ;
         ({ children } = condition.expression.children[1]);
       }
       children.unshift("(");
-      for (let i1 = 0, len1 = conditions.length; i1 < len1; i1++) {
-        const c = conditions[i1];
+      for (let i3 = 0, len3 = conditions.length; i3 < len3; i3++) {
+        const c = conditions[i3];
         children.push(" && ", c);
       }
       children.push(")");
@@ -4969,11 +5266,11 @@ function processDeclarationConditionStatement(s) {
     ancestor.expressions.splice(index + 1, 0, ...blockPrefix);
     updateParentPointers(ancestor);
     braceBlock(ancestor);
-    let ref1;
+    let ref2;
     switch (s.type) {
       case "IfStatement": {
-        if (ref1 = s.else?.block) {
-          const elseBlock = ref1;
+        if (ref2 = s.else?.block) {
+          const elseBlock = ref2;
           if (elseBlock.bare && !elseBlock.semicolon) {
             elseBlock.children.push(elseBlock.semicolon = ";");
           }
@@ -5064,11 +5361,12 @@ function processDeclarationConditionStatement(s) {
 function dynamizeFromClause(from) {
   from = from.slice(1);
   from = trimFirstSpace(from);
-  let ref2;
-  if (ref2 = from[from.length - 1]?.assertion) {
-    const assert2 = ref2;
-    let ref3;
-    ref3 = from[from.length - 1], ref3.children = ref3.children.filter((a2) => a2 !== assert2);
+  let ref3;
+  if (ref3 = from[from.length - 1]?.assertion) {
+    const assert2 = ref3;
+    let ref4;
+    ref4 = from[from.length - 1];
+    ref4.children = ref4.children.filter((a2) => a2 !== assert2);
     from.push(", {", assert2.keyword, ":", assert2.object, "}");
   }
   return ["(", ...from, ")"];
@@ -5077,20 +5375,20 @@ function dynamizeImportDeclaration(decl) {
   const { imports } = decl;
   let { star, binding, specifiers } = imports;
   const justDefault = binding && !specifiers && !star;
-  let ref4;
+  let ref5;
   {
     if (binding) {
       if (specifiers) {
-        ref4 = makeRef();
+        ref5 = makeRef();
       } else {
-        ref4 = binding;
+        ref5 = binding;
       }
     } else {
-      ref4 = convertNamedImportsToObject(imports, true);
+      ref5 = convertNamedImportsToObject(imports, true);
     }
   }
   ;
-  const pattern = ref4;
+  const pattern = ref5;
   const c = "const";
   const expression = [
     justDefault ? "(" : void 0,
@@ -5213,7 +5511,7 @@ function convertWithClause(withClause, extendsClause) {
   return [extendsToken, insertTrimmingSpace(ws, " "), wrapped];
 }
 
-// source/parser/unary.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\unary.civet.jsx
 function processUnaryExpression(pre, exp, post) {
   if (!(pre.length || post)) {
     return exp;
@@ -5375,7 +5673,7 @@ function processUnaryNestedExpression(pre, args, post) {
   return processUnaryExpression(pre, args, post);
 }
 
-// source/parser/pipe.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\pipe.civet.jsx
 function constructInvocation(fn, arg) {
   let expr = fn.expr;
   while (expr.type === "ParenthesizedExpression") {
@@ -5398,11 +5696,9 @@ function constructInvocation(fn, arg) {
     lhs = makeLeftHandSideExpression(lhs);
   }
   let comment = skipIfOnlyWS(fn.trailingComment);
-  if (comment)
-    lhs.children.push(comment);
+  if (comment) lhs.children.push(comment);
   comment = skipIfOnlyWS(fn.leadingComment);
-  if (comment)
-    lhs.children.splice(1, 0, comment);
+  if (comment) lhs.children.splice(1, 0, comment);
   switch (arg.type) {
     case "CommaExpression": {
       arg = makeLeftHandSideExpression(arg);
@@ -5491,27 +5787,26 @@ function processPipelineExpressions(statements) {
         let initRef;
         if (i2 === 0) {
           checkValidLHS(arg);
-          outer:
-            switch (arg.type) {
-              case "MemberExpression": {
-                if (arg.children.length <= 2) {
-                  break;
-                }
-              }
-              case "CallExpression": {
-                const access = arg.children.pop();
-                usingRef = makeRef();
-                initRef = {
-                  type: "AssignmentExpression",
-                  children: [usingRef, " = ", arg, comma]
-                };
-                arg = {
-                  type: "MemberExpression",
-                  children: [usingRef, access]
-                };
+          outer: switch (arg.type) {
+            case "MemberExpression": {
+              if (arg.children.length <= 2) {
                 break;
               }
             }
+            case "CallExpression": {
+              const access = arg.children.pop();
+              usingRef = makeRef();
+              initRef = {
+                type: "AssignmentExpression",
+                children: [usingRef, " = ", arg, comma]
+              };
+              arg = {
+                type: "MemberExpression",
+                children: [usingRef, access]
+              };
+              break;
+            }
+          }
           const lhs = [[
             [initRef],
             arg,
@@ -5539,8 +5834,7 @@ function processPipelineExpressions(statements) {
           });
         }
       } else {
-        if (i2 === 0)
-          s.children = children;
+        if (i2 === 0) s.children = children;
       }
       if (returns && (ref = needsRef(arg))) {
         usingRef = usingRef || ref;
@@ -5604,7 +5898,7 @@ function processPipelineExpressions(statements) {
   });
 }
 
-// source/parser/for.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\for.civet.jsx
 function processRangeExpression(start, ws1, range, end) {
   ws1 = [ws1, range.children[0]];
   const ws2 = range.children[1];
@@ -5627,10 +5921,8 @@ function processRangeExpression(start, ws1, range, end) {
   const abs = ref;
   const lengthAdjust = 1 - Number(!range.left.inclusive) - Number(!range.right.inclusive);
   let ref1;
-  if (lengthAdjust > 0)
-    ref1 = ` + ${lengthAdjust}`;
-  else if (lengthAdjust < 0)
-    ref1 = ` - ${-lengthAdjust}`;
+  if (lengthAdjust > 0) ref1 = ` + ${lengthAdjust}`;
+  else if (lengthAdjust < 0) ref1 = ` - ${-lengthAdjust}`;
   else {
     ref1 = void 0;
   }
@@ -5766,10 +6058,8 @@ function forRange(open, forDeclaration, range, stepExp, close) {
     asc = stepValue > 0;
   }
   let ref3;
-  if (stepRef)
-    ref3 = start;
-  else
-    ref3 = maybeRef(start, "start");
+  if (stepRef) ref3 = start;
+  else ref3 = maybeRef(start, "start");
   let startRef = ref3;
   let endRef = maybeRef(end, "end");
   const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
@@ -5946,8 +6236,7 @@ function processForInOf($0) {
     };
   }
   let ws2, decl2;
-  if (declaration2)
-    [, , ws2, decl2] = declaration2;
+  if (declaration2) [, , ws2, decl2] = declaration2;
   switch (inOf.token) {
     case "of": {
       const counterRef = makeRef("i");
@@ -6012,8 +6301,8 @@ function processForInOf($0) {
   };
 }
 
-// source/parser/auto-dec.civet
-var concatAssign = (lhs, rhs) => (rhs?.[Symbol.isConcatSpreadable] ?? Array.isArray(rhs) ? lhs.push.apply(lhs, rhs) : lhs.push(rhs), lhs);
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\auto-dec.civet.jsx
+var concatAssign2 = (lhs, rhs) => (rhs?.[Symbol.isConcatSpreadable] ?? Array.isArray(rhs) ? lhs.push.apply(lhs, rhs) : lhs.push(rhs), lhs);
 function findDecs(statements) {
   const declarations = gatherNodes(statements, ($) => $.type === "Declaration");
   const declarationNames = declarations.flatMap((d) => d.names);
@@ -6068,8 +6357,7 @@ function createConstLetDecs(statements, scopes, letOrConst) {
         }
         continue;
       }
-      if (node.names == null)
-        continue;
+      if (node.names == null) continue;
       let names = node.names.filter((name) => !hasDec(name));
       if (node.type == "AssignmentExpression") {
         undeclaredIdentifiers.push(...names);
@@ -6105,19 +6393,17 @@ function createVarDecs(block, scopes, pushVar) {
   function findAssignments(statements2, decs2) {
     let assignmentStatements2 = gatherNodes(statements2, ($3) => $3.type === "AssignmentExpression");
     if (assignmentStatements2.length) {
-      concatAssign(
+      concatAssign2(
         assignmentStatements2,
         findAssignments(assignmentStatements2.map((s) => s.children), decs2)
       );
     }
     return assignmentStatements2;
   }
-  if (!pushVar) {
-    pushVar = function(name) {
-      varIds.push(name);
-      return decs.add(name);
-    };
-  }
+  pushVar ??= (name) => {
+    varIds.push(name);
+    return decs.add(name);
+  };
   const { expressions: statements } = block;
   const decs = findDecs(statements);
   scopes.push(decs);
@@ -6125,8 +6411,7 @@ function createVarDecs(block, scopes, pushVar) {
   const assignmentStatements = findAssignments(statements, scopes);
   const undeclaredIdentifiers = assignmentStatements.flatMap(($4) => $4?.names || []);
   undeclaredIdentifiers.filter((x, i, a) => {
-    if (!hasDec(x))
-      return a.indexOf(x) === i;
+    if (!hasDec(x)) return a.indexOf(x) === i;
     return;
   }).forEach(pushVar);
   const fnNodes = gatherNodes(statements, isFunction);
@@ -6162,7 +6447,7 @@ function createVarDecs(block, scopes, pushVar) {
   scopes.pop();
 }
 
-// source/parser/string.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\string.civet.jsx
 function getIndentLevel(str, tab) {
   if (tab != null && tab != 1) {
     const tabs = str.match(/\t/g);
@@ -6330,7 +6615,7 @@ function quoteString(str) {
   return JSON.stringify(str);
 }
 
-// source/parser/lib.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\lib.civet.jsx
 var xor = (a, b) => a ? !b && a : b;
 function addPostfixStatement(statement, ws, post) {
   const expressions = [
@@ -6344,8 +6629,7 @@ function addPostfixStatement(statement, ws, post) {
     bare: false
   });
   const children = [...post.children, block];
-  if (!isWhitespaceOrEmpty(ws))
-    children.push(ws);
+  if (!isWhitespaceOrEmpty(ws)) children.push(ws);
   post = makeNode({ ...post, children, block });
   if (post.type === "IfStatement") {
     post.then = block;
@@ -6417,8 +6701,7 @@ function expressionizeBlock(blockOrExpression) {
     let i1 = 0;
     for (const [ws, s, _delim] of expressions) {
       const i = i1++;
-      if (!isExpression(s))
-        return;
+      if (!isExpression(s)) return;
       const wrapped = makeLeftHandSideExpression(s);
       if (i === l - 1) {
         results.push([ws, wrapped]);
@@ -6780,8 +7063,7 @@ function processCallMemberExpression(node) {
             prefix = [ref].concat(glob.dot);
           }
         }
-        if (wValue)
-          value.unshift(wValue);
+        if (wValue) value.unshift(wValue);
         if (part.type === "SpreadProperty") {
           parts.push({
             type: part.type,
@@ -6824,8 +7106,7 @@ function processCallMemberExpression(node) {
         ],
         properties: parts
       };
-      if (i === children.length - 1)
-        return object;
+      if (i === children.length - 1) return object;
       return processCallMemberExpression({
         // in case there are more
         ...node,
@@ -6966,10 +7247,8 @@ function lastAccessInCallExpression(exp) {
     ;
     ({ children } = exp);
     i = children.length - 1;
-    while (i >= 0 && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional"))
-      i--;
-    if (i < 0)
-      return;
+    while (i >= 0 && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional")) i--;
+    if (i < 0) return;
   } while (children[i].type === "MemberExpression" && (exp = children[i]));
   return children[i];
 }
@@ -7042,8 +7321,7 @@ function convertObjectToJSXAttributes(obj) {
       rest.push(part);
       continue;
     }
-    if (i > 0)
-      parts.push(" ");
+    if (i > 0) parts.push(" ");
     switch (part.type) {
       case "Identifier": {
         parts.push([part.name, "={", part.name, "}"]);
@@ -7089,16 +7367,16 @@ function makeGetterMethod(name, ws, value, returnType, block, kind = { token: "g
   const { token } = kind;
   ws = trimFirstSpace(ws);
   let setVal;
-  const parameters = token === "get" ? {
-    type: "Parameters",
-    children: ["()"],
-    names: [],
-    implicit: true
-  } : {
+  const parameterList = [];
+  const isGet = token === "get";
+  if (!isGet) {
+    parameterList.push(setVal = makeRef("value"));
+  }
+  const parameters = {
     type: "Parameters",
-    children: ["(", setVal = makeRef("value"), ")"],
-    names: [],
-    implicit: false
+    children: ["(", parameterList, ")"],
+    parameters: parameterList,
+    implicit: isGet
   };
   let expressions;
   if (block) {
@@ -7114,7 +7392,7 @@ function makeGetterMethod(name, ws, value, returnType, block, kind = { token: "g
     };
   }
   if (autoReturn) {
-    const finalStatement = token === "get" ? [[expressions[0]?.[0] || "", ws], wrapWithReturn(value)] : [[expressions[0]?.[0] || "", ws], [value, " = ", setVal]];
+    const finalStatement = isGet ? [[expressions[0]?.[0] || "", ws], wrapWithReturn(value)] : [[expressions[0]?.[0] || "", ws], [value, " = ", setVal]];
     expressions.push(finalStatement);
   }
   const children = [kind, " ", name, parameters, returnType, block];
@@ -7143,7 +7421,7 @@ function processBindingPatternLHS(lhs, tail) {
 }
 function processAssignments(statements) {
   for (let ref7 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len3 = ref7.length; i5 < len3; i5++) {
-    let extractAssignment2 = function(lhs) {
+    let extractAssignment = function(lhs) {
       let expr = lhs;
       while (expr.type === "ParenthesizedExpression") {
         expr = expr.expression;
@@ -7162,7 +7440,6 @@ function processAssignments(statements) {
       ;
       return;
     };
-    var extractAssignment = extractAssignment2;
     const exp = ref7[i5];
     checkValidLHS(exp.assigned);
     const pre = [], post = [];
@@ -7175,7 +7452,7 @@ function processAssignments(statements) {
         for (let ref9 = exp.lhs, i6 = 0, len4 = ref9.length; i6 < len4; i6++) {
           const lhsPart = ref9[i6];
           let ref10;
-          if (ref10 = extractAssignment2(lhsPart[1])) {
+          if (ref10 = extractAssignment(lhsPart[1])) {
             const newLhs = ref10;
             lhsPart[1] = newLhs;
           }
@@ -7184,7 +7461,7 @@ function processAssignments(statements) {
         break;
       }
       case "UpdateExpression": {
-        if (ref8 = extractAssignment2(exp.assigned)) {
+        if (ref8 = extractAssignment(exp.assigned)) {
           const newLhs = ref8;
           const i = exp.children.indexOf(exp.assigned);
           exp.assigned = exp.children[i] = newLhs;
@@ -7240,13 +7517,11 @@ function processAssignments(statements) {
       }
     }
     if ($1.some(($8) => $8[$8.length - 1].special)) {
-      if ($1.length !== 1)
-        throw new Error("Only one assignment with id= is allowed");
+      if ($1.length !== 1) throw new Error("Only one assignment with id= is allowed");
       const [, lhs, , op] = $1[0];
       const { call, omitLhs } = op;
       const index = exp.children.indexOf($2);
-      if (index < 0)
-        throw new Error("Assertion error: exp not in AssignmentExpression");
+      if (index < 0) throw new Error("Assertion error: exp not in AssignmentExpression");
       exp.children.splice(
         index,
         1,
@@ -7297,8 +7572,7 @@ function processAssignments(statements) {
             c[4] = [", ...", $2];
             c[5] = ")";
             lastAssignment.pop();
-            if (isWhitespaceOrEmpty(lastAssignment[2]))
-              lastAssignment.pop();
+            if (isWhitespaceOrEmpty(lastAssignment[2])) lastAssignment.pop();
             if ($1.length > 1) {
               throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
             }
@@ -7358,8 +7632,7 @@ function processAssignments(statements) {
     exp.names = $1.flatMap(([, l]) => l.names || []);
     if (tail.length) {
       const index = exp.children.indexOf($2);
-      if (index < 0)
-        throw new Error("Assertion error: exp not in AssignmentExpression");
+      if (index < 0) throw new Error("Assertion error: exp not in AssignmentExpression");
       exp.children.splice(index + 1, 0, ...tail);
     }
     if (block) {
@@ -7536,10 +7809,8 @@ function processTypes(node) {
         const space = getTrimmingSpace(unary);
         inplaceInsertTrimmingSpace(unary, "");
         let ref16;
-        if (unary.suffix.length)
-          ref16 = unary;
-        else
-          ref16 = unary.t;
+        if (unary.suffix.length) ref16 = unary;
+        else ref16 = unary.t;
         const t = ref16;
         const arg = makeNode({
           type: "TypeArgument",
@@ -7615,6 +7886,7 @@ function processStatementExpressions(statements) {
         ;
         break;
       }
+      // else do nothing, handled separately currently
       default: {
         replaceNode(statement, wrapIIFE([["", statement]]), exp);
       }
@@ -7731,6 +8003,91 @@ function processBreaksContinues(statements) {
     delete label.special;
   }
 }
+function processCoffeeClasses(statements) {
+  for (let ref21 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
+    const ce = ref21[i11];
+    const { expressions } = ce.body;
+    const indent = expressions[0]?.[0] ?? "\n";
+    const autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
+    if (autoBinds.length) {
+      let construct;
+      for (const [, c] of expressions) {
+        if (typeof c === "object" && c != null && "type" in c && c.type === "MethodDefinition" && "name" in c && c.name === "constructor" && c.block) {
+          construct = c;
+          break;
+        }
+      }
+      if (!construct) {
+        const parametersList = [];
+        const parameters = {
+          type: "Parameters",
+          children: [parametersList],
+          parameters: parametersList,
+          names: []
+        };
+        const signature = {
+          type: "MethodSignature",
+          children: ["constructor(", parameters, ")"],
+          parameters,
+          modifier: {},
+          returnType: void 0
+        };
+        const block = makeEmptyBlock();
+        construct = {
+          ...signature,
+          type: "MethodDefinition",
+          name: "constructor",
+          block,
+          signature,
+          children: [...signature.children, block]
+        };
+        expressions.unshift([indent, construct]);
+      }
+      const index = findSuperCall(construct.block);
+      construct.block.expressions.splice(
+        index + 1,
+        0,
+        ...(() => {
+          const results3 = [];
+          for (let i12 = 0, len10 = autoBinds.length; i12 < len10; i12++) {
+            const [, a] = autoBinds[i12];
+            results3.push([indent, ["this.", a.name, " = this.", a.name, ".bind(this)"], ";"]);
+          }
+          return results3;
+        })()
+      );
+    }
+    const privates = expressions.filter(($15) => $15[1]?.type === "CoffeeClassPrivate");
+    if (!privates.length) {
+      continue;
+    }
+    const { parent } = ce;
+    for (let i13 = expressions.length + -1; i13 >= 0; --i13) {
+      const i = i13;
+      if (expressions[i][1]?.type === "CoffeeClassPrivate") {
+        expressions.splice(i, 1);
+      }
+    }
+    let wrapped = wrapIIFE([
+      ...privates,
+      [indent, wrapWithReturn(ce)]
+    ]);
+    if (ce && typeof ce === "object" && "binding" in ce) {
+      let { binding } = ce;
+      binding = trimFirstSpace(binding);
+      wrapped = makeNode({
+        type: "AssignmentExpression",
+        children: [binding, " = ", wrapped],
+        lhs: binding,
+        // TODO: incorrect shape
+        assigned: binding,
+        expression: wrapped,
+        names: [ce.name]
+      });
+    }
+    replaceNode(ce, wrapped, parent);
+  }
+}
 function processProgram(root) {
   const state2 = getState();
   const config2 = getConfig();
@@ -7745,7 +8102,7 @@ function processProgram(root) {
   if (config2.iife || config2.repl) {
     rootIIFE = wrapIIFE(root.expressions, root.topLevelAwait);
     const newExpressions = [["", rootIIFE]];
-    root.children = root.children.map(($13) => $13 === root.expressions ? newExpressions : $13);
+    root.children = root.children.map(($16) => $16 === root.expressions ? newExpressions : $16);
     root.expressions = newExpressions;
   }
   addParentPointers(root);
@@ -7764,6 +8121,9 @@ function processProgram(root) {
   processBreaksContinues(statements);
   hoistRefDecs(statements);
   processFunctions(statements, config2);
+  if (config2.coffeeClasses) {
+    processCoffeeClasses(statements);
+  }
   statements.unshift(...state2.prelude);
   if (config2.autoLet) {
     createConstLetDecs(statements, [], "let");
@@ -7787,10 +8147,10 @@ async function processProgramAsync(root) {
   await processComptime(statements);
 }
 function processRepl(root, rootIIFE) {
-  const topBlock = gatherRecursive(rootIIFE, ($14) => $14.type === "BlockStatement")[0];
+  const topBlock = gatherRecursive(rootIIFE, ($17) => $17.type === "BlockStatement")[0];
   let i = 0;
-  for (let ref21 = gatherRecursiveWithinFunction(topBlock, ($15) => $15.type === "Declaration"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
-    const decl = ref21[i11];
+  for (let ref22 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref22.length; i14 < len11; i14++) {
+    const decl = ref22[i14];
     if (!decl.names?.length) {
       continue;
     }
@@ -7803,8 +8163,8 @@ function processRepl(root, rootIIFE) {
       root.expressions.splice(i++, 0, ["", `var ${decl.names.join(",")}`, ";"]);
     }
   }
-  for (let ref22 = gatherRecursive(topBlock, ($16) => $16.type === "FunctionExpression"), i12 = 0, len10 = ref22.length; i12 < len10; i12++) {
-    const func = ref22[i12];
+  for (let ref23 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref23.length; i15 < len12; i15++) {
+    const func = ref23[i15];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
         replaceNode(func, void 0);
@@ -7816,8 +8176,8 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($17) => $17.type === "ClassExpression"), i13 = 0, len11 = ref23.length; i13 < len11; i13++) {
-    const classExp = ref23[i13];
+  for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref24.length; i16 < len13; i16++) {
+    const classExp = ref24[i16];
     let m8;
     if (classExp.name && classExp.parent === topBlock || (m8 = classExp.parent, typeof m8 === "object" && m8 != null && "type" in m8 && m8.type === "ReturnStatement" && "parent" in m8 && m8.parent === topBlock)) {
       classExp.children.unshift(classExp.name, "=");
@@ -7826,14 +8186,13 @@ function processRepl(root, rootIIFE) {
   }
 }
 function populateRefs(statements) {
-  const refNodes = gatherRecursive(statements, ($18) => $18.type === "Ref");
+  const refNodes = gatherRecursive(statements, ($21) => $21.type === "Ref");
   if (refNodes.length) {
     const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
     const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
     refNodes.forEach((ref) => {
       const { type, base } = ref;
-      if (type !== "Ref")
-        return;
+      if (type !== "Ref") return;
       ref.type = "Identifier";
       let n = 0;
       let name = base;
@@ -7849,8 +8208,8 @@ function populateRefs(statements) {
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
   const liftedIfs = /* @__PURE__ */ new Set();
-  for (let ref24 = gatherRecursiveAll(statements, ($19) => $19.type === "Placeholder"), i14 = 0, len12 = ref24.length; i14 < len12; i14++) {
-    const exp = ref24[i14];
+  for (let ref25 = gatherRecursiveAll(statements, ($22) => $22.type === "Placeholder"), i17 = 0, len14 = ref25.length; i17 < len14; i17++) {
+    const exp = ref25[i17];
     let ancestor;
     if (exp.subtype === ".") {
       ({ ancestor } = findAncestor(
@@ -7959,11 +8318,11 @@ function processPlaceholders(statements) {
   for (const [ancestor, placeholders] of placeholderMap) {
     let ref = makeRef("$");
     let typeSuffix;
-    for (let i15 = 0, len13 = placeholders.length; i15 < len13; i15++) {
-      const placeholder = placeholders[i15];
+    for (let i18 = 0, len15 = placeholders.length; i18 < len15; i18++) {
+      const placeholder = placeholders[i18];
       typeSuffix ??= placeholder.typeSuffix;
-      let ref25;
-      (ref25 = placeholder.children)[ref25.length - 1] = ref;
+      let ref26;
+      (ref26 = placeholder.children)[ref26.length - 1] = ref;
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -7984,16 +8343,16 @@ function processPlaceholders(statements) {
       }
       case "PipelineExpression": {
         const i = findChildIndex(parent, ancestor);
-        let ref26;
+        let ref27;
         if (i === 1) {
-          ref26 = ancestor === parent.children[i];
+          ref27 = ancestor === parent.children[i];
         } else if (i === 2) {
-          ref26 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          ref27 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
         } else {
-          ref26 = void 0;
+          ref27 = void 0;
         }
         ;
-        outer = ref26;
+        outer = ref27;
         break;
       }
       case "AssignmentExpression":
@@ -8008,9 +8367,9 @@ function processPlaceholders(statements) {
       fnExp = makeLeftHandSideExpression(fnExp);
     }
     replaceNode(ancestor, fnExp, parent);
-    let ref27;
-    if (ref27 = getTrimmingSpace(body)) {
-      const ws = ref27;
+    let ref28;
+    if (ref28 = getTrimmingSpace(body)) {
+      const ws = ref28;
       inplaceInsertTrimmingSpace(body, "");
       inplacePrepend(ws, fnExp);
     }
@@ -8023,8 +8382,7 @@ function reorderBindingRestProperty(props) {
   let restCount = 0;
   props.forEach(({ type }, i) => {
     if (type === "BindingRestProperty") {
-      if (restIndex < 0)
-        restIndex = i;
+      if (restIndex < 0) restIndex = i;
       return restCount++;
     }
     ;
@@ -8055,8 +8413,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  let ref28;
-  if (Array.isArray(rest.delim) && (ref28 = rest.delim)[ref28.length - 1]?.token === ",") {
+  let ref29;
+  if (Array.isArray(rest.delim) && (ref29 = rest.delim)[ref29.length - 1]?.token === ",") {
     rest.delim = rest.delim.slice(0, -1);
     rest.children = [...rest.children.slice(0, -1), rest.delim];
   }
@@ -9403,10 +9761,8 @@ function NonPipelineExpression(ctx, state2) {
 var NestedExpressionizedStatement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)(EOS), PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, ExpressionizedStatementWithTrailingCallExpressions)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var expression = $3;
   var trailing = $5;
-  if (!expression)
-    return $skip;
-  if (!trailing)
-    return expression;
+  if (!expression) return $skip;
+  if (!trailing) return expression;
   return {
     type: "CallExpression",
     children: [expression, ...trailing]
@@ -9416,8 +9772,7 @@ function NestedExpressionizedStatement(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NestedExpressionizedStatement", NestedExpressionizedStatement$0);
 }
 var ExpressionizedStatementWithTrailingCallExpressions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ExpressionizedStatement, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
-  if (!$2)
-    return $1;
+  if (!$2) return $1;
   return {
     type: "CallExpression",
     children: [
@@ -9442,8 +9797,7 @@ function ExpressionizedStatement(ctx, state2) {
 }
 var StatementExpression$0 = DebuggerStatement;
 var StatementExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(IfStatement), function($skip, $loc, $0, $1) {
-  if (!$1.else && $1.then.implicit)
-    return $skip;
+  if (!$1.else && $1.then.implicit) return $skip;
   return $1;
 });
 var StatementExpression$2 = IterationExpression;
@@ -9455,8 +9809,7 @@ function StatementExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "StatementExpression", StatementExpression$$);
 }
 var CommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(AssignmentExpression, (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
-  if ($2.length == 0)
-    return $1;
+  if ($2.length == 0) return $1;
   return $0;
 });
 function CommaExpression(ctx, state2) {
@@ -9465,8 +9818,7 @@ function CommaExpression(ctx, state2) {
 var Arguments$0 = ExplicitArguments;
 var Arguments$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidTrailingMemberProperty, (0, import_lib2.$E)(ImplicitArguments), RestoreTrailingMemberProperty), function($skip, $loc, $0, $1, $2, $3) {
   var args = $2;
-  if (args)
-    return args;
+  if (args) return args;
   return $skip;
 });
 var Arguments$$ = [Arguments$0, Arguments$1];
@@ -9478,10 +9830,8 @@ var ImplicitArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ApplicationSt
   var ws = $3;
   var args = $6;
   var close = $9;
-  if (!args)
-    return $skip;
-  if (skipImplicitArguments(args))
-    return $skip;
+  if (!args) return $skip;
+  if (skipImplicitArguments(args)) return $skip;
   return {
     type: "Call",
     args,
@@ -9527,14 +9877,12 @@ var ForbiddenImplicitCalls$3 = (0, import_lib2.$S)(ClassImplicitCallForbidden, (
 var ForbiddenImplicitCalls$4 = (0, import_lib2.$S)(Identifier, (0, import_lib2.$EXPECT)($L3, 'ForbiddenImplicitCalls "="'), Whitespace);
 var ForbiddenImplicitCalls$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(Identifier, (0, import_lib2.$N)((0, import_lib2.$EXPECT)($L4, 'ForbiddenImplicitCalls "("'))), function($skip, $loc, $0, $1, $2) {
   var id = $1;
-  if (state.operators.has(id.name))
-    return $0;
+  if (state.operators.has(id.name)) return $0;
   return $skip;
 });
 var ForbiddenImplicitCalls$6 = (0, import_lib2.$TS)((0, import_lib2.$S)(OmittedNegation, (0, import_lib2.$E)(_), Identifier), function($skip, $loc, $0, $1, $2, $3) {
   var id = $3;
-  if (state.operators.has(id.name))
-    return $0;
+  if (state.operators.has(id.name)) return $0;
   return $skip;
 });
 var ForbiddenImplicitCalls$7 = (0, import_lib2.$S)(PostfixStatement, NoBlock);
@@ -9557,18 +9905,15 @@ function ArgumentsWithTrailingCallExpressions(ctx, state2) {
 }
 var TrailingCallExpressions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Q)(ExplicitCallExpressionRest), (0, import_lib2.$E)(IndentedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
   $1 = $1.flat();
-  if (!$1.length && !$2)
-    return $skip;
-  if (!$2)
-    return $1;
+  if (!$1.length && !$2) return $skip;
+  if (!$2) return $1;
   return [...$1, ...$2];
 });
 function TrailingCallExpressions(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "TrailingCallExpressions", TrailingCallExpressions$0);
 }
 var IndentedTrailingCallExpressions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedTrailingCallExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2.length)
-    return $skip;
+  if (!$2.length) return $skip;
   return $2.flat();
 });
 var IndentedTrailingCallExpressions$1 = (0, import_lib2.$TV)((0, import_lib2.$P)(NestedTrailingCallExpression), function($skip, $loc, $0, $1) {
@@ -9616,8 +9961,7 @@ var ArgumentList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N
   ];
 });
 var ArgumentList$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(NestedArguments, (0, import_lib2.$Q)((0, import_lib2.$S)(OptionalCommaDelimiter, NestedArguments))), function($skip, $loc, $0, $1, $2) {
-  if (!Array.isArray($1))
-    $1 = [$1];
+  if (!Array.isArray($1)) $1 = [$1];
   return [
     ...trimFirstSpace($1),
     ...$2.flatMap(
@@ -9644,8 +9988,7 @@ function NestedArguments(ctx, state2) {
 }
 var NestedArgumentList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, AllowPipeline, AllowTrailingMemberProperty, (0, import_lib2.$Q)(NestedArgument), RestoreTrailingMemberProperty, RestorePipeline, PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var args = $4;
-  if (!args.length)
-    return $skip;
+  if (!args.length) return $skip;
   return stripTrailingImplicitComma(args.flat());
 });
 function NestedArgumentList(ctx, state2) {
@@ -9699,8 +10042,7 @@ function ArgumentPart(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ArgumentPart", ArgumentPart$$);
 }
 var BinaryOpExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(UnaryExpression, (0, import_lib2.$Q)(BinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
-  if (!$2.length)
-    return $1;
+  if (!$2.length) return $1;
   return processBinaryOpExpression($0);
 });
 function BinaryOpExpression(ctx, state2) {
@@ -9754,8 +10096,7 @@ function IsLike(ctx, state2) {
 }
 var WRHS$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$S)(Nested, (0, import_lib2.$E)(_)), RHS)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var wrhs = $2;
-  if (!wrhs)
-    return $skip;
+  if (!wrhs) return $skip;
   return wrhs;
 });
 var WRHS$1 = (0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$S)(EOS, __), _), RHS);
@@ -9817,8 +10158,7 @@ function UnaryBody(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "UnaryBody", UnaryBody$$);
 }
 var MaybeNestedCoffeeDoBody$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, CoffeeDoBody)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2)
-    return $skip;
+  if (!$2) return $skip;
   return $2;
 });
 var MaybeNestedCoffeeDoBody$1 = (0, import_lib2.$S)((0, import_lib2.$E)(_), CoffeeDoBody);
@@ -9907,8 +10247,7 @@ var UpdateExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(UpdateExpressi
   };
 });
 var UpdateExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(LeftHandSideExpression, (0, import_lib2.$E)((0, import_lib2.$S)(UpdateExpressionSymbol, (0, import_lib2.$EXPECT)($R4, "UpdateExpression /(?!\\p{ID_Start}|[_$0-9(\\[{])/")))), function($skip, $loc, $0, $1, $2) {
-  if (!$2)
-    return $1;
+  if (!$2) return $1;
   return {
     type: "UpdateExpression",
     assigned: $1,
@@ -10041,14 +10380,14 @@ var ArrowFunction$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$
   var returnType = $3;
   var arrow = $4;
   var expOrBlock = $5;
-  if (!async)
-    async = [];
+  if (!async) async = [];
   return {
     type: "ArrowFunction",
     signature: {
       modifier: {
         async: !!async.length
       },
+      parameters,
       returnType
     },
     parameters,
@@ -10065,8 +10404,7 @@ function ArrowFunction(ctx, state2) {
 var FatArrow$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), FatArrowToken), function($skip, $loc, $0, $1, $2) {
   var ws = $1;
   var arrow = $2;
-  if (!ws)
-    ws = " ";
+  if (!ws) ws = " ";
   return [ws, arrow];
 });
 function FatArrow(ctx, state2) {
@@ -10133,8 +10471,7 @@ function TernaryRest(ctx, state2) {
 }
 var NestedTernaryRest$0 = (0, import_lib2.$S)(Nested, QuestionMark, MaybeNestedExpression, Nested, Colon, MaybeNestedExpression);
 var NestedTernaryRest$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, QuestionMark, MaybeNestedExpression, Nested, Colon, MaybeNestedExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if ($2)
-    return $2;
+  if ($2) return $2;
   return $skip;
 });
 var NestedTernaryRest$$ = [NestedTernaryRest$0, NestedTernaryRest$1];
@@ -10173,8 +10510,7 @@ function PipelineExpression(ctx, state2) {
 var PipelineExpressionBody$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PipelineExpressionBodySameLine, PushIndent, (0, import_lib2.$Q)((0, import_lib2.$S)((0, import_lib2.$S)(Nested, Pipe, __, PipelineTailItem), PipelineExpressionBodySameLine)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
   var first = $1;
   var rest = $3;
-  if (!rest.length)
-    return $skip;
+  if (!rest.length) return $skip;
   return [
     ...first,
     ...rest.map(([nested, line]) => [nested, ...line]).flat()
@@ -10237,8 +10573,7 @@ var OptimizedParenthesizedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S
   const { expression } = $1;
   switch (expression.type) {
     case "StatementExpression":
-      if (expression.statement.type !== "IterationExpression")
-        break;
+      if (expression.statement.type !== "IterationExpression") break;
     case "IterationExpression":
       return expression;
   }
@@ -10249,8 +10584,7 @@ function OptimizedParenthesizedExpression(ctx, state2) {
 }
 var ParenthesizedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(PostfixedCommaExpression, __, CloseParen)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
   var open = $1;
-  if (!$3)
-    return $skip;
+  if (!$3) return $skip;
   const [expression, ws, close] = $3;
   if (expression.type === "ParenthesizedExpression" && expression.implicit) {
     return {
@@ -10308,8 +10642,7 @@ function PlaceholderTypeSuffix(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PlaceholderTypeSuffix", PlaceholderTypeSuffix$0);
 }
 var ClassDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ClassExpression), function($skip, $loc, $0, $1) {
-  if ($1.id)
-    return $1;
+  if ($1.id) return $1;
   return makeLeftHandSideExpression($1);
 });
 function ClassDeclaration(ctx, state2) {
@@ -10354,10 +10687,8 @@ var ClassHeritage$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ExtendsClause, (0
 var ClassHeritage$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(WithClause), (0, import_lib2.$E)(ImplementsClause)), function($skip, $loc, $0, $1, $2) {
   var withClause = $1;
   var implementsClause = $2;
-  if (withClause)
-    return [convertWithClause(withClause), implementsClause];
-  if (implementsClause)
-    return implementsClause;
+  if (withClause) return [convertWithClause(withClause), implementsClause];
+  if (implementsClause) return implementsClause;
   return $skip;
 });
 var ClassHeritage$$ = [ClassHeritage$0, ClassHeritage$1];
@@ -10492,8 +10823,7 @@ var ClassBody$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, OpenBrace, AllowA
   var expressions = $4;
   var ws2 = $6;
   var close = $7;
-  if (!expressions)
-    expressions = [];
+  if (!expressions) expressions = [];
   return {
     type: "BlockStatement",
     subtype: "ClassBody",
@@ -10503,8 +10833,7 @@ var ClassBody$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, OpenBrace, AllowA
 });
 var ClassBody$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenBrace, (0, import_lib2.$E)(NestedClassElements), InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var expressions = $2;
-  if (!expressions)
-    expressions = $0[1] = [];
+  if (!expressions) expressions = $0[1] = [];
   return {
     type: "BlockStatement",
     subtype: "ClassBody",
@@ -10519,8 +10848,7 @@ function ClassBody(ctx, state2) {
 var ClassBracedContent$0 = NestedClassElements;
 var ClassBracedContent$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidNewlineBinaryOp, (0, import_lib2.$Q)((0, import_lib2.$S)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$N)(EOS)), ClassElement, StatementDelimiter)), RestoreNewlineBinaryOp), function($skip, $loc, $0, $1, $2, $3) {
   var stmts = $2;
-  if (!stmts)
-    return $skip;
+  if (!stmts) return $skip;
   return stmts;
 });
 var ClassBracedContent$$ = [ClassBracedContent$0, ClassBracedContent$1];
@@ -10529,8 +10857,7 @@ function ClassBracedContent(ctx, state2) {
 }
 var NestedClassElements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedClassElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var elements = $2;
-  if (!elements.length)
-    return $skip;
+  if (!elements.length) return $skip;
   return elements;
 });
 function NestedClassElements(ctx, state2) {
@@ -10588,8 +10915,7 @@ function ClassSignatureBody(ctx, state2) {
 }
 var NestedClassSignatureElements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedClassSignatureElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var elements = $2;
-  if (!elements.length)
-    return $skip;
+  if (!elements.length) return $skip;
   return elements;
 });
 function NestedClassSignatureElements(ctx, state2) {
@@ -10606,8 +10932,7 @@ function ClassSignatureElement(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ClassSignatureElement", ClassSignatureElement$$);
 }
 var AccessModifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$C)(Public, Private, Protected), NotDedented)), (0, import_lib2.$E)((0, import_lib2.$S)(Readonly, NotDedented))), function($skip, $loc, $0, $1, $2) {
-  if (!($1 || $2))
-    return $skip;
+  if (!($1 || $2)) return $skip;
   return {
     ts: true,
     children: $0
@@ -10620,7 +10945,7 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
   var id = $2;
   var exp = $6;
   switch (exp.type) {
-    case "FunctionExpression":
+    case "FunctionExpression": {
       const fnTokenIndex = exp.children.findIndex((c) => c?.token?.startsWith("function"));
       const children = exp.children.slice();
       if (exp.generator) {
@@ -10630,8 +10955,29 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
       }
       return {
         ...exp,
-        children
+        type: "MethodDefinition",
+        name: id.name,
+        signature: { ...exp.signature, id, name: id.name },
+        children
+      };
+    }
+    case "ArrowFunction": {
+      const block = { ...exp.block };
+      const children = exp.children.filter((c) => !(Array.isArray(c) && c[c.length - 1]?.token?.includes("=>"))).map((c) => c === exp.block ? block : c);
+      children.unshift(id);
+      exp = {
+        ...exp,
+        type: "MethodDefinition",
+        name: id.name,
+        signature: { ...exp.signature, id, name: id.name },
+        block,
+        children,
+        autoBind: true
       };
+      block.parent = exp;
+      braceBlock(block);
+      return exp;
+    }
     default:
       return {
         type: "FieldDefinition",
@@ -10641,11 +10987,11 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
   }
 });
 var FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly, ClassElementName, (0, import_lib2.$E)(TypeSuffix), __, ConstAssignment, MaybeNestedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-  var r = $1;
+  var readonly = $1;
   var id = $2;
   var typeSuffix = $3;
   var ca = $5;
-  r.children[0].$loc = {
+  readonly.children[0].$loc = {
     pos: ca.$loc.pos - 1,
     length: ca.$loc.length + 1
   };
@@ -10653,21 +10999,36 @@ var FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly,
     type: "FieldDefinition",
     id,
     typeSuffix,
-    children: $0
+    children: $0,
+    readonly
+  };
+});
+var FieldDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEnabled, ActualAssignment), function($skip, $loc, $0, $1, $2) {
+  var assignment = $2;
+  return {
+    type: "CoffeeClassPrivate",
+    children: [assignment],
+    assignment
   };
 });
-var FieldDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Abstract, (0, import_lib2.$E)(_))), (0, import_lib2.$E)((0, import_lib2.$S)(Readonly, (0, import_lib2.$E)(_))), ClassElementName, (0, import_lib2.$E)(TypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+var FieldDefinition$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Abstract, (0, import_lib2.$E)(_))), (0, import_lib2.$E)((0, import_lib2.$S)(Readonly, (0, import_lib2.$E)(_))), ClassElementName, (0, import_lib2.$E)(TypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+  var abstract = $1;
+  var readonly = $2;
   var id = $3;
   var typeSuffix = $4;
+  var initializer = $5;
   return {
     type: "FieldDefinition",
     children: $0,
-    ts: $1 ? true : void 0,
+    ts: abstract ? true : void 0,
     id,
-    typeSuffix
+    typeSuffix,
+    abstract,
+    readonly,
+    initializer
   };
 });
-var FieldDefinition$$ = [FieldDefinition$0, FieldDefinition$1, FieldDefinition$2];
+var FieldDefinition$$ = [FieldDefinition$0, FieldDefinition$1, FieldDefinition$2, FieldDefinition$3];
 function FieldDefinition(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "FieldDefinition", FieldDefinition$$);
 }
@@ -10703,8 +11064,7 @@ var HashThis$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(At
   var at = $1;
   var id = $2;
   var beforeIn = $3;
-  if (beforeIn != null && at == null)
-    return ['"', id.name, '"'];
+  if (beforeIn != null && at == null) return ['"', id.name, '"'];
   return {
     type: "MemberExpression",
     children: [at ?? "this", {
@@ -10831,8 +11191,7 @@ var CallExpressionRest$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
 var CallExpressionRest$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(OptionalShorthand), ArgumentsWithTrailingCallExpressions), function($skip, $loc, $0, $1, $2) {
   var optional = $1;
   var argsWithTrailing = $2;
-  if (!optional)
-    return argsWithTrailing;
+  if (!optional) return argsWithTrailing;
   const call = argsWithTrailing[0];
   return [{
     ...call,
@@ -10858,8 +11217,7 @@ var ExplicitCallExpressionRest$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0,
 var ExplicitCallExpressionRest$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(OptionalShorthand), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
   var optional = $1;
   var call = $2;
-  if (!optional)
-    return call;
+  if (!optional) return call;
   return {
     ...call,
     children: [optional, ...call.children],
@@ -10927,8 +11285,7 @@ function MemberBase(ctx, state2) {
 var MemberExpressionRest$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R10, "MemberExpressionRest /(?=[\\/\\[{?.!@#'\u2019:])/"), (0, import_lib2.$Q)(InlineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2, $3) {
   var comments = $2;
   var body = $3;
-  if (Array.isArray(body))
-    return [...comments, ...body];
+  if (Array.isArray(body)) return [...comments, ...body];
   return {
     ...body,
     children: [...comments, ...body.children]
@@ -10941,8 +11298,7 @@ var MemberExpressionRestBody$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, im
   var dot = $1;
   var comments = $2;
   var content = $3;
-  if (!dot && !comments.length)
-    return content;
+  if (!dot && !comments.length) return content;
   if (dot) {
     if (dot.type === "Optional" && content.type === "SliceExpression") {
       return [...dot.children.slice(0, -1), ...comments, content];
@@ -11039,8 +11395,7 @@ var SliceParameters$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Loc, (0, import
     const inc = [];
     if (dots.right.inclusive) {
       end = [makeLeftHandSideExpression(end), ` ${sign} 1`];
-      if (!reversed)
-        inc.push(" || 1/0");
+      if (!reversed) inc.push(" || 1/0");
     }
     children = [start, [...ws, dots.children[0], { token: ", ", $loc: dots.$loc }], [dots.children[1], end, ...inc]];
   } else {
@@ -11291,10 +11646,12 @@ var Parameters$0 = NonEmptyParameters;
 var Parameters$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(TypeParameters), Loc), function($skip, $loc, $0, $1, $2) {
   var tp = $1;
   var p = $2;
+  const parameters = [];
   return {
     type: "Parameters",
-    children: [tp, { $loc: p.$loc, token: "()" }],
+    children: [tp, { $loc: p.$loc, token: "(" }, parameters, ")"],
     tp,
+    parameters,
     names: [],
     implicit: true
   };
@@ -11317,10 +11674,11 @@ 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];
   return {
     type: "Parameters",
-    children: ["(", $1, ")"],
-    names: $1.names
+    children: ["(", parameters, ")"],
+    parameters
   };
 });
 var ArrowParameters$1 = Parameters;
@@ -11331,83 +11689,13 @@ function ArrowParameters(ctx, state2) {
 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;
-  var params = $3;
+  var parameters = $3;
   var close = $4;
-  let tt, before = [], rest, after = [], errors = [];
-  function append2(p) {
-    (rest ? after : before).push(p);
-  }
-  for (const param of params) {
-    switch (param.type) {
-      case "ThisType":
-        if (tt) {
-          append2({
-            type: "Error",
-            message: "Only one typed this parameter is allowed"
-          });
-          append2(param);
-        } else {
-          tt = trimFirstSpace(param);
-          if (before.length || rest) {
-            let delim = tt.children.at(-1);
-            if (Array.isArray(delim))
-              delim = delim.at(-1);
-            if (delim?.token !== ",") {
-              tt = {
-                ...tt,
-                children: [...tt.children, ", "]
-              };
-            }
-          }
-        }
-        break;
-      case "FunctionRestParameter":
-        if (rest) {
-          append2({
-            type: "Error",
-            message: "Only one rest parameter is allowed"
-          });
-          append2(param);
-        } else {
-          rest = param;
-        }
-        break;
-      default:
-        append2(param);
-    }
-  }
-  const names = before.flatMap((p) => p.names);
-  if (rest) {
-    const restIdentifier = rest.binding.ref || rest.binding;
-    names.push(...rest.names || []);
-    let blockPrefix;
-    if (after.length) {
-      blockPrefix = {
-        children: ["[", trimFirstSpace(after), "] = ", restIdentifier, ".splice(-", after.length.toString(), ")"],
-        names: after.flatMap((p) => p.names)
-      };
-    }
-    return {
-      type: "Parameters",
-      children: [
-        tp,
-        open,
-        tt,
-        ...before,
-        // Remove delimiter
-        { ...rest, children: rest.children.slice(0, -1) },
-        close
-      ],
-      tp,
-      names,
-      blockPrefix
-    };
-  }
   return {
     type: "Parameters",
-    children: [tp, open, tt, ...before, close],
-    names,
-    tp
+    children: [tp, open, parameters, close],
+    tp,
+    parameters
   };
 });
 function NonEmptyParameters(ctx, state2) {
@@ -11428,8 +11716,7 @@ function ParameterList(ctx, state2) {
 }
 var NestedParameterList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedParameter), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var params = $2;
-  if (!params.length)
-    return $skip;
+  if (!params.length) return $skip;
   return params;
 });
 function NestedParameterList(ctx, state2) {
@@ -11453,12 +11740,15 @@ function Parameter(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "Parameter", Parameter$$);
 }
 var FunctionRestParameter$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(EOS), BindingRestElement, (0, import_lib2.$E)(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
-  var id = $2;
+  var rest = $2;
+  var typeSuffix = $3;
   return {
     type: "FunctionRestParameter",
     children: $0.slice(1),
-    names: id.names,
-    binding: id.binding
+    rest,
+    names: rest.names,
+    binding: rest.binding,
+    typeSuffix
   };
 });
 function FunctionRestParameter(ctx, state2) {
@@ -11545,7 +11835,7 @@ var PinPattern$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Caret, SingleLineExp
   var expression = $2;
   return {
     type: "PinPattern",
-    children: $0,
+    children: [expression],
     expression
   };
 });
@@ -11606,8 +11896,7 @@ function ObjectBindingPattern(ctx, state2) {
 var ObjectBindingPatternContent$0 = NestedBindingProperties;
 var ObjectBindingPatternContent$1 = (0, import_lib2.$TV)((0, import_lib2.$E)(BindingPropertyList), function($skip, $loc, $0, $1) {
   var props = $0;
-  if (!props)
-    return { children: [], names: [] };
+  if (!props) return { children: [], names: [] };
   return reorderBindingRestProperty(props);
 });
 var ObjectBindingPatternContent$$ = [ObjectBindingPatternContent$0, ObjectBindingPatternContent$1];
@@ -11647,8 +11936,7 @@ function ArrayBindingPattern(ctx, state2) {
 var ArrayBindingPatternContent$0 = NestedBindingElements;
 var ArrayBindingPatternContent$1 = (0, import_lib2.$TV)((0, import_lib2.$E)(BindingElementList), function($skip, $loc, $0, $1) {
   var elements = $0;
-  if (!elements)
-    return { children: [], names: [], length: 0 };
+  if (!elements) return { children: [], names: [], length: 0 };
   return adjustBindingElements(elements);
 });
 var ArrayBindingPatternContent$$ = [ArrayBindingPatternContent$0, ArrayBindingPatternContent$1];
@@ -11673,8 +11961,7 @@ var NestedBindingElementList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Nested
   var indent = $1;
   var elements = $2;
   return elements.map((element, i) => {
-    if (i > 0)
-      return element;
+    if (i > 0) return element;
     return {
       ...element,
       children: [indent, ...element.children.slice(1)]
@@ -11691,8 +11978,7 @@ function Elision(ctx, state2) {
 }
 var NestedBindingProperties$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedBindingPropertyList), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var props = $2;
-  if (!props.length)
-    return $skip;
+  if (!props.length) return $skip;
   return reorderBindingRestProperty(props.flat());
 });
 function NestedBindingProperties(ctx, state2) {
@@ -11702,8 +11988,7 @@ var NestedBindingPropertyList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Neste
   var ws = $1;
   var props = $2;
   return props.map((prop, i) => {
-    if (i > 0)
-      return prop;
+    if (i > 0) return prop;
     return prepend(ws, prop);
   });
 });
@@ -11765,6 +12050,7 @@ var BindingProperty$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
       name: binding,
       value: {
         type: "PinPattern",
+        children: [binding],
         expression: binding
       }
     };
@@ -11828,8 +12114,7 @@ function BindingTypeSuffix(ctx, state2) {
 }
 var NestedBindingElements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedBindingElementList), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var elements = $2;
-  if (!elements.length)
-    return $skip;
+  if (!elements.length) return $skip;
   return adjustBindingElements(elements.flat());
 });
 function NestedBindingElements(ctx, state2) {
@@ -11868,7 +12153,7 @@ var BindingRestElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
   var typeSuffix = $4;
   return {
     type: "BindingRestElement",
-    children: [ws, [dots, binding]],
+    children: [ws, dots, binding],
     dots,
     binding,
     typeSuffix,
@@ -11908,10 +12193,8 @@ function EmptyBindingPattern(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "EmptyBindingPattern", EmptyBindingPattern$0);
 }
 var FunctionDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(FunctionExpression), function($skip, $loc, $0, $1) {
-  if ($1.type !== "FunctionExpression")
-    return $skip;
-  if ($1.id)
-    return $1;
+  if ($1.type !== "FunctionExpression") return $skip;
+  if ($1.id) return $1;
   return makeLeftHandSideExpression($1);
 });
 function FunctionDeclaration(ctx, state2) {
@@ -11925,10 +12208,8 @@ var FunctionSignature$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
   var w = $5;
   var parameters = $6;
   var returnType = $7;
-  if (!async)
-    async = [];
-  if (!generator)
-    generator = [];
+  if (!async) async = [];
+  if (!generator) generator = [];
   const id = wid?.[1];
   return {
     type: "FunctionSignature",
@@ -11973,16 +12254,16 @@ var FunctionExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
   var open = $2;
   var op = $3;
   var close = $4;
-  if (op.special && op.call && !op.negated)
-    return op.call;
+  if (op.special && op.call && !op.negated) return op.call;
   const refA = makeRef("a"), refB = makeRef("b"), body = processBinaryOpExpression([refA, [
     [[], op, [], refB]
     // BinaryOpRHS
   ]]);
+  const parameterList = [[refA, ","], refB];
   const parameters = {
     type: "Parameters",
-    children: ["(", refA, ",", refB, ")"],
-    names: []
+    children: ["(", parameterList, ")"],
+    parameters: parameterList
   };
   const block = {
     expressions: [body]
@@ -12143,10 +12424,8 @@ var OperatorSignature$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
   var w2 = $8;
   var parameters = $9;
   var returnType = $10;
-  if (!async)
-    async = [];
-  if (!generator)
-    generator = [];
+  if (!async) async = [];
+  if (!generator) generator = [];
   if (!func) {
     func = { $loc: op.$loc, token: "function" };
   } else {
@@ -12215,8 +12494,7 @@ var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
   var returnType = $3;
   var arrow = $5;
   var block = $6;
-  if (!async)
-    async = [];
+  if (!async) async = [];
   const generator = [];
   return {
     type: "FunctionExpression",
@@ -12261,8 +12539,7 @@ var ExplicitBlock$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$
   var block = $4;
   var ws2 = $6;
   var close = $7;
-  if (!block)
-    return $skip;
+  if (!block) return $skip;
   return {
     ...block,
     children: [ws1, open, ...block.children, ws2, close],
@@ -12275,8 +12552,7 @@ var ExplicitBlock$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(IndentedAtLeast,
   var block = $4;
   var ws2 = $6;
   var close = $7;
-  if (!block)
-    return $skip;
+  if (!block) return $skip;
   return {
     ...block,
     children: [ws1, open, ...block.children, ws2, close],
@@ -12301,8 +12577,7 @@ function EmptyBracedContent(ctx, state2) {
 }
 var ImplicitNestedBlock$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)(EOS), InsertOpenBrace, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var open = $2;
-  if (!$4)
-    return $skip;
+  if (!$4) return $skip;
   const [block, ...tail] = $4;
   return {
     ...block,
@@ -12332,8 +12607,7 @@ function Block(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "Block", Block$$);
 }
 var BareNestedBlock$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)(EOS), AllowAll, (0, import_lib2.$E)(NestedBlockStatements), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
-  if (!$3)
-    return $skip;
+  if (!$3) return $skip;
   return $3;
 });
 function BareNestedBlock(ctx, state2) {
@@ -12469,8 +12743,7 @@ var BracedBlock$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenBrace, (0
   var s = $3;
   var ws = $4;
   var c = $5;
-  if (!s.children.length)
-    return $skip;
+  if (!s.children.length) return $skip;
   return {
     type: "BlockStatement",
     expressions: s.expressions,
@@ -12488,8 +12761,7 @@ var NoPostfixBracedBlock$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpen
   var s = $3;
   var ws = $4;
   var c = $5;
-  if (!s.expressions.length)
-    return $skip;
+  if (!s.expressions.length) return $skip;
   return {
     type: "BlockStatement",
     expressions: s.expressions,
@@ -12507,8 +12779,7 @@ var NoCommaBracedBlock$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenBr
   var s = $3;
   var ws = $4;
   var c = $5;
-  if (!s.children.length)
-    return $skip;
+  if (!s.children.length) return $skip;
   return {
     type: "BlockStatement",
     expressions: s.expressions,
@@ -12549,11 +12820,9 @@ var SingleLineStatements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidNewl
   var stmts = $2;
   var last = $3;
   const expressions = [...stmts];
-  if (last)
-    expressions.push(last);
+  if (last) expressions.push(last);
   const children = [expressions];
-  if (hasTrailingComment(expressions))
-    children.push(["\n"]);
+  if (hasTrailingComment(expressions)) children.push(["\n"]);
   return {
     type: "BlockStatement",
     expressions,
@@ -12568,8 +12837,7 @@ var PostfixedSingleLineStatements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((
   var stmts = $1;
   var last = $2;
   const children = [...stmts];
-  if (last)
-    children.push(last);
+  if (last) children.push(last);
   return {
     type: "BlockStatement",
     expressions: children,
@@ -12584,8 +12852,7 @@ var PostfixedSingleLineNoCommaStatements$0 = (0, import_lib2.$TS)((0, import_lib
   var stmts = $1;
   var last = $2;
   const children = [...stmts];
-  if (last)
-    children.push(last);
+  if (last) children.push(last);
   return {
     type: "BlockStatement",
     expressions: children,
@@ -12598,8 +12865,7 @@ function PostfixedSingleLineNoCommaStatements(ctx, state2) {
 }
 var NestedBlockStatements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedBlockStatement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var statements = $2;
-  if (!statements.length)
-    return $skip;
+  if (!statements.length) return $skip;
   statements = statements.flat();
   return {
     type: "BlockStatement",
@@ -12626,8 +12892,7 @@ var BlockStatementPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
   var ws = $2;
   var statement = $3;
   var delimiter = $4;
-  if (ws)
-    statement = prepend(ws, statement);
+  if (ws) statement = prepend(ws, statement);
   return [statement, delimiter];
 });
 function BlockStatementPart(ctx, state2) {
@@ -12654,7 +12919,7 @@ function LiteralContent(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "LiteralContent", LiteralContent$$);
 }
 var NullLiteral$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L38, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  return { $loc, token: $1 };
+  return { type: "NullLiteral", $loc, token: $1 };
 });
 function NullLiteral(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NullLiteral", NullLiteral$0);
@@ -12669,17 +12934,17 @@ var _BooleanLiteral$0 = (0, import_lib2.$T)((0, import_lib2.$S)(CoffeeBooleansEn
   return value[1];
 });
 var _BooleanLiteral$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L39, '_BooleanLiteral "true"'), (0, import_lib2.$EXPECT)($L40, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  return { $loc, token: $1 };
+  return { type: "BooleanLiteral", $loc, token: $1 };
 });
 var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
 function _BooleanLiteral(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "_BooleanLiteral", _BooleanLiteral$$);
 }
 var CoffeeScriptBooleanLiteral$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L41, 'CoffeeScriptBooleanLiteral "yes"'), (0, import_lib2.$EXPECT)($L42, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  return { $loc, token: "true" };
+  return { type: "BooleanLiteral", $loc, token: "true" };
 });
 var CoffeeScriptBooleanLiteral$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L43, 'CoffeeScriptBooleanLiteral "no"'), (0, import_lib2.$EXPECT)($L44, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  return { $loc, token: "false" };
+  return { type: "BooleanLiteral", $loc, token: "false" };
 });
 var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
 function CoffeeScriptBooleanLiteral(ctx, state2) {
@@ -12776,8 +13041,7 @@ var _ArrayLiteral$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBracket, Clos
   var open = $1;
   var close = $2;
   var content = $5;
-  if (!content)
-    return $skip;
+  if (!content) return $skip;
   let last = content[content.length - 1];
   let lastArray = Array.isArray(last) ? last : last.children;
   if (isComma(lastArray[lastArray.length - 1])) {
@@ -12797,8 +13061,7 @@ var _ArrayLiteral$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBracket, Clos
 });
 var _ArrayLiteral$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBracket, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(ArrayLiteralContent, __, CloseBracket)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
   var open = $1;
-  if (!$3)
-    return $skip;
+  if (!$3) return $skip;
   const [content, ws, close] = $3;
   if (content.type === "RangeExpression") {
     return prepend(ws, content);
@@ -12933,8 +13196,7 @@ var ArrayLiteralContent$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(ElementList
   var list = $1;
   var delimiter = $2;
   var nested = $3;
-  if (!nested)
-    return list;
+  if (!nested) return list;
   return [...list, delimiter, ...nested];
 });
 var ArrayLiteralContent$3 = (0, import_lib2.$TV)((0, import_lib2.$Q)((0, import_lib2.$S)(__, ElementListWithIndentedApplicationForbidden, ArrayElementDelimiter)), function($skip, $loc, $0, $1) {
@@ -12958,13 +13220,10 @@ var NestedElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Nested, ElementLi
   var list = $2;
   var delimiter = $3;
   const { length } = list;
-  if (!length)
-    return $skip;
+  if (!length) return $skip;
   return list.map((e, i) => {
-    if (i === 0)
-      e = prepend(indent, e);
-    if (i === length - 1)
-      e = append(e, delimiter);
+    if (i === 0) e = prepend(indent, e);
+    if (i === length - 1) e = append(e, delimiter);
     return e;
   });
 });
@@ -12981,8 +13240,7 @@ function ArrayElementDelimiter(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ArrayElementDelimiter", ArrayElementDelimiter$$);
 }
 var ElementListWithIndentedApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidIndentedApplication, (0, import_lib2.$E)(ElementList), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
-  if ($2)
-    return $2;
+  if ($2) return $2;
   return $skip;
 });
 function ElementListWithIndentedApplicationForbidden(ctx, state2) {
@@ -12999,8 +13257,7 @@ function ElementList(ctx, state2) {
 var SingleLineElementList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(EOS), ArrayElementExpression, (0, import_lib2.$Q)(ElementListRest)), function($skip, $loc, $0, $1, $2, $3) {
   var first = $2;
   var rest = $3;
-  if (!rest.length)
-    return [first];
+  if (!rest.length) return [first];
   return [
     append(first, rest[0][0])
   ].concat(
@@ -13065,8 +13322,7 @@ var NestedBulletedArray$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_
   var open = $1;
   var content = $4;
   var close = $6;
-  if (!content.length)
-    return $skip;
+  if (!content.length) return $skip;
   content = content.flat();
   const last = content[content.length - 1];
   if (last.children?.at(-1)?.implicit) {
@@ -13084,8 +13340,7 @@ var BulletedArray$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenBracket
   var open = $1;
   var content = $2;
   var close = $3;
-  if (!content)
-    return $skip;
+  if (!content) return $skip;
   content = [
     ...trimFirstSpace(content[0]),
     // replace first space with bracket
@@ -13114,11 +13369,9 @@ function NestedArrayBullet(ctx, state2) {
 var ArrayBullet$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(BulletIndent, (0, import_lib2.$E)((0, import_lib2.$S)(ElementList, ArrayBulletDelimiter)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var bullet = $1;
   var content = $2;
-  if (!content)
-    return $skip;
+  if (!content) return $skip;
   let [list, delimiter] = content;
-  if (!list.length)
-    return $skip;
+  if (!list.length) return $skip;
   list = list.slice();
   list[0] = prepend(bullet, list[0]);
   if (delimiter) {
@@ -13145,8 +13398,7 @@ var BulletIndent$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Bullet), function(
     $loc,
     level: getIndentLevel(" ".repeat(state.currentIndent.level) + bullet + ws, config.tab)
   };
-  if (config.verbose)
-    console.log("pushing bullet indent", indent);
+  if (config.verbose) console.log("pushing bullet indent", indent);
   state.indentLevels.push(indent);
   return indent;
 });
@@ -13191,8 +13443,7 @@ var BracedObjectLiteral$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBrace,
   var open = $1;
   var close = $2;
   var properties = $5;
-  if (!properties?.length)
-    return $skip;
+  if (!properties?.length) return $skip;
   let last = properties[properties.length - 1];
   if (last.delim?.implicit) {
     last = {
@@ -13211,8 +13462,7 @@ var BracedObjectLiteral$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBrace,
 });
 var BracedObjectLiteral$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBrace, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(BracedObjectLiteralContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
   var open = $1;
-  if (!$3)
-    return $skip;
+  if (!$3) return $skip;
   const [properties, ...close] = $3;
   return {
     type: "ObjectExpression",
@@ -13230,8 +13480,7 @@ var SingleLineObjectProperties$0 = (0, import_lib2.$TV)((0, import_lib2.$Q)((0,
   return line.flatMap(([prop, delim]) => {
     prop = Array.isArray(prop) ? prop : [prop];
     let last = prop[prop.length - 1];
-    if (!last)
-      return [];
+    if (!last) return [];
     last = {
       ...last,
       delim,
@@ -13268,8 +13517,7 @@ function BracedObjectLiteralContent(ctx, state2) {
 }
 var NestedImplicitObjectLiteral$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenBrace, PushIndent, AllowPipeline, (0, import_lib2.$E)(NestedImplicitPropertyDefinitions), RestorePipeline, PopIndent, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
   var properties = $4;
-  if (!properties)
-    return $skip;
+  if (!properties) return $skip;
   return {
     type: "ObjectExpression",
     properties,
@@ -13303,8 +13551,7 @@ function NestedImplicitPropertyDefinition(ctx, state2) {
 }
 var NestedPropertyDefinitions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedPropertyDefinition), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var defs = $2;
-  if (!defs.length)
-    return $skip;
+  if (!defs.length) return $skip;
   return defs.flat();
 });
 function NestedPropertyDefinitions(ctx, state2) {
@@ -13314,8 +13561,7 @@ var NestedPropertyDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Nested
   var ws = $1;
   var inlineProps = $2;
   return inlineProps.flatMap(([prop, delim], i) => {
-    if (!Array.isArray(prop))
-      prop = [prop];
+    if (!Array.isArray(prop)) prop = [prop];
     if (i === 0) {
       const [first, ...rest] = prop;
       prop = [prepend(ws, first), ...rest];
@@ -13448,8 +13694,7 @@ var PropertyDefinition$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
       children: def.children.flatMap((c, i) => i ? [",", c] : [c])
     };
   }
-  if (!def.block || def.block.empty)
-    return $skip;
+  if (!def.block || def.block.empty) return $skip;
   return prepend(ws, def);
 });
 var PropertyDefinition$4 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), DotDotDot, Expression), function($skip, $loc, $0, $1, $2, $3) {
@@ -13471,8 +13716,11 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
   var post = $5;
   if (!pre.length && !post) {
     switch (value.type) {
+      // `{identifier}` remains `{identifier}`, the one shorthand JS supports
       case "Identifier":
         return prepend(ws, value);
+      // PropertyGlob like x.{a,b} turns into ObjectExpression {a: x.a, b: x.b}
+      // (via `processCallMemberExpression`)
       case "ObjectExpression":
         let first = value.properties[0];
         if (first) {
@@ -13486,8 +13734,7 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     }
   }
   const last = lastAccessInCallExpression(value);
-  if (!last)
-    return $skip;
+  if (!last) return $skip;
   let name, ref, refAssignment;
   const { expression, type } = last;
   if (type === "Index") {
@@ -13500,11 +13747,10 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
       value = {
         ...value,
         children: value.children.map((c) => {
-          if (c === last)
-            return {
-              type: "Index",
-              children: ["[", ref, "]"]
-            };
+          if (c === last) return {
+            type: "Index",
+            children: ["[", ref, "]"]
+          };
           return c;
         })
       };
@@ -13516,11 +13762,9 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     }
   } else {
     ({ name } = last);
-    if (!name)
-      return $skip;
+    if (!name) return $skip;
   }
-  if (name[0] === "#")
-    name = name.slice(1);
+  if (name[0] === "#") name = name.slice(1);
   return {
     type: "Property",
     children: [ws, name, ": ", processUnaryExpression(pre, value, post)],
@@ -13591,8 +13835,7 @@ var ComputedPropertyName$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBracke
 });
 var ComputedPropertyName$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenBracket, TemplateLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3) {
   var expression = $2;
-  if ($2.type === "StringLiteral")
-    return $2;
+  if ($2.type === "StringLiteral") return $2;
   return {
     type: "ComputedPropertyName",
     children: $0,
@@ -13619,8 +13862,7 @@ function Decorator(ctx, state2) {
 }
 var Decorators$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidClassImplicitCall, (0, import_lib2.$Q)((0, import_lib2.$S)(__, Decorator)), __, RestoreClassImplicitCall), function($skip, $loc, $0, $1, $2, $3, $4) {
   var decorators = $2;
-  if (!decorators.length)
-    return $skip;
+  if (!decorators.length) return $skip;
   return $0;
 });
 function Decorators(ctx, state2) {
@@ -13659,8 +13901,7 @@ var MethodDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(GetOrSet, (0,
   var ws = $2;
   var content = $4;
   var block = $6;
-  if (!content)
-    return $skip;
+  if (!content) return $skip;
   const [base, rest, returnType] = content;
   const value = [base, rest];
   if (!rest.length) {
@@ -13671,12 +13912,9 @@ var MethodDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(GetOrSet, (0,
         ({ name: name2 } = lastAccess2);
       }
     }
-    if (!name2)
-      ({ name: name2 } = base);
-    if (!name2)
-      return $skip;
-    if (name2[0] === "#")
-      name2 = name2.slice(1);
+    if (!name2) ({ name: name2 } = base);
+    if (!name2) return $skip;
+    if (name2[0] === "#") name2 = name2.slice(1);
     const autoReturn = !block || base.type !== "Identifier";
     return makeGetterMethod(name2, ws, base, returnType, block, kind, autoReturn);
   }
@@ -13749,10 +13987,8 @@ var MethodModifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(GetOrSet, (0, im
 var MethodModifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, __)), (0, import_lib2.$E)((0, import_lib2.$S)(Star, __))), function($skip, $loc, $0, $1, $2) {
   var async = $1;
   var generator = $2;
-  if (!async)
-    async = [];
-  if (!generator)
-    generator = [];
+  if (!async) async = [];
+  if (!generator) generator = [];
   return {
     async,
     generator,
@@ -13793,8 +14029,7 @@ var MethodSignature$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(MethodModifier,
   } else if (name.token) {
     name = name.token.match(/^(?:"|')/) ? name.token.slice(1, -1) : name.token;
   }
-  if (optional)
-    optional = { ...optional, ts: true };
+  if (optional) optional = { ...optional, ts: true };
   return {
     type: "MethodSignature",
     children: [...modifier.children, name, ws1, optional, ws2, parameters, returnType],
@@ -13851,8 +14086,7 @@ var AssignmentOp$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(AssignmentOpSymbol
       children: [$1, ...$2]
     };
   }
-  if (typeof $1 !== "string")
-    return $1;
+  if (typeof $1 !== "string") return $1;
   return { $loc, token: $1 };
 });
 function AssignmentOp(ctx, state2) {
@@ -13970,10 +14204,8 @@ var NotDedentedBinaryOp$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_
   var ws2 = $2;
   var op = $3;
   const ws = [];
-  if (ws1)
-    ws.push(...ws1);
-  if (ws2)
-    ws.push(...ws2);
+  if (ws1) ws.push(...ws1);
+  if (ws2) ws.push(...ws2);
   return [ws, op];
 });
 var NotDedentedBinaryOp$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(NestedBinaryOpAllowed, Nested, (0, import_lib2.$E)(_), (0, import_lib2.$N)(Identifier), (0, import_lib2.$C)((0, import_lib2.$N)((0, import_lib2.$EXPECT)($L75, 'NotDedentedBinaryOp "*"')), (0, import_lib2.$N)(ImportDeclaration)), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
@@ -13981,8 +14213,7 @@ var NotDedentedBinaryOp$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(NestedBinar
   var ws2 = $3;
   var op = $6;
   const ws = [...ws1];
-  if (ws2)
-    ws.push(...ws2);
+  if (ws2) ws.push(...ws2);
   return [ws, op];
 });
 var NotDedentedBinaryOp$$ = [NotDedentedBinaryOp$0, NotDedentedBinaryOp$1];
@@ -13991,8 +14222,7 @@ function NotDedentedBinaryOp(ctx, state2) {
 }
 var IdentifierBinaryOp$0 = (0, import_lib2.$TV)(Identifier, function($skip, $loc, $0, $1) {
   var id = $0;
-  if (state.operators.has(id.name))
-    return id;
+  if (state.operators.has(id.name)) return id;
   return $skip;
 });
 function IdentifierBinaryOp(ctx, state2) {
@@ -14006,14 +14236,12 @@ function BinaryOp(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "BinaryOp", BinaryOp$0);
 }
 var _BinaryOp$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(BinaryOpSymbol), function($skip, $loc, $0, $1) {
-  if (typeof $1 === "string")
-    return { $loc, token: $1 };
+  if (typeof $1 === "string") return { $loc, token: $1 };
   return $1;
 });
 var _BinaryOp$1 = (0, import_lib2.$TV)(Identifier, function($skip, $loc, $0, $1) {
   var id = $0;
-  if (!state.operators.has(id.name))
-    return $skip;
+  if (!state.operators.has(id.name)) return $skip;
   return {
     token: id.name,
     call: id,
@@ -14023,8 +14251,7 @@ var _BinaryOp$1 = (0, import_lib2.$TV)(Identifier, function($skip, $loc, $0, $1)
 });
 var _BinaryOp$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(OmittedNegation, __, Identifier), function($skip, $loc, $0, $1, $2, $3) {
   var id = $3;
-  if (!state.operators.has(id.name))
-    return $skip;
+  if (!state.operators.has(id.name)) return $skip;
   return {
     token: id.name,
     call: id,
@@ -14107,13 +14334,11 @@ var BinaryOpSymbol$24 = (0, import_lib2.$T)((0, import_lib2.$EXPECT)($L92, 'Bina
   return "!==";
 });
 var BinaryOpSymbol$25 = (0, import_lib2.$TV)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L93, 'BinaryOpSymbol "!="'), (0, import_lib2.$EXPECT)($L94, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
-  if (config.coffeeEq)
-    return "!==";
+  if (config.coffeeEq) return "!==";
   return "!=";
 });
 var BinaryOpSymbol$26 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L95, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-  if (config.coffeeIsnt)
-    return "!==";
+  if (config.coffeeIsnt) return "!==";
   return $skip;
 });
 var BinaryOpSymbol$27 = (0, import_lib2.$EXPECT)($L96, 'BinaryOpSymbol "==="');
@@ -14121,8 +14346,7 @@ var BinaryOpSymbol$28 = (0, import_lib2.$T)((0, import_lib2.$C)((0, import_lib2.
   return "===";
 });
 var BinaryOpSymbol$29 = (0, import_lib2.$TV)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L99, 'BinaryOpSymbol "=="'), (0, import_lib2.$EXPECT)($L100, 'BinaryOpSymbol "\u2261"'), (0, import_lib2.$EXPECT)($L101, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
-  if (config.coffeeEq)
-    return "===";
+  if (config.coffeeEq) return "===";
   return "==";
 });
 var BinaryOpSymbol$30 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L102, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
@@ -14320,8 +14544,7 @@ var UnaryOp$1 = AwaitOp;
 var UnaryOp$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)(Delete, Void, Typeof), (0, import_lib2.$N)((0, import_lib2.$EXPECT)($R30, "UnaryOp /[:.]/")), (0, import_lib2.$E)(_)), function($skip, $loc, $0, $1, $2, $3) {
   var op = $1;
   var ws = $3;
-  if (!ws)
-    return [op, [" "]];
+  if (!ws) return [op, [" "]];
   return [op, ws];
 });
 var UnaryOp$3 = (0, import_lib2.$T)((0, import_lib2.$S)(Not, (0, import_lib2.$N)((0, import_lib2.$EXPECT)($R30, "UnaryOp /[:.]/")), (0, import_lib2.$E)((0, import_lib2.$EXPECT)($L18, 'UnaryOp " "')), (0, import_lib2.$E)(_)), function(value) {
@@ -14365,8 +14588,7 @@ function StatementListItem(ctx, state2) {
 var PostfixedStatement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Statement, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
   var statement = $1;
   var post = $2;
-  if (post)
-    return addPostfixStatement(statement, ...post);
+  if (post) return addPostfixStatement(statement, ...post);
   return statement;
 });
 function PostfixedStatement(ctx, state2) {
@@ -14381,8 +14603,7 @@ function NoCommaStatementListItem(ctx, state2) {
 var PostfixedNoCommaStatement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(NoCommaStatement, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
   var statement = $1;
   var post = $2;
-  if (post)
-    return addPostfixStatement(statement, ...post);
+  if (post) return addPostfixStatement(statement, ...post);
   return statement;
 });
 function PostfixedNoCommaStatement(ctx, state2) {
@@ -14391,8 +14612,7 @@ function PostfixedNoCommaStatement(ctx, state2) {
 var PostfixedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
   var expression = $1;
   var post = $2;
-  if (post)
-    return attachPostfixStatementAsExpression(expression, post);
+  if (post) return attachPostfixStatementAsExpression(expression, post);
   return expression;
 });
 function PostfixedExpression(ctx, state2) {
@@ -14401,8 +14621,7 @@ function PostfixedExpression(ctx, state2) {
 var PostfixedCommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PostfixedExpression, (0, import_lib2.$C)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement), (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, AssignmentExpression)))), function($skip, $loc, $0, $1, $2) {
   var expression = $1;
   var post = $2;
-  if (!post.length)
-    return $1;
+  if (!post.length) return $1;
   if (post.length === 2 && !Array.isArray(post[1])) {
     return attachPostfixStatementAsExpression(expression, post);
   }
@@ -14431,10 +14650,8 @@ var Statement$2 = (0, import_lib2.$T)((0, import_lib2.$S)(IfStatement, (0, impor
   return value[0];
 });
 var Statement$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(IterationStatement, (0, import_lib2.$N)(ShouldExpressionize)), function($skip, $loc, $0, $1, $2) {
-  if ($1.generator)
-    return $skip;
-  if ($1.reduction)
-    return $skip;
+  if ($1.generator) return $skip;
+  if ($1.reduction) return $skip;
   return $1;
 });
 var Statement$4 = (0, import_lib2.$T)((0, import_lib2.$S)(SwitchStatement, (0, import_lib2.$N)(ShouldExpressionize)), function(value) {
@@ -14509,8 +14726,7 @@ var Label$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Colon, IdentifierName, Wh
   var colon = $1;
   var id = $2;
   var w = $3;
-  if (id.name === "void")
-    return $skip;
+  if (id.name === "void") return $skip;
   return {
     type: "Label",
     name: id.name,
@@ -14822,8 +15038,7 @@ function ForClause(ctx, state2) {
 var ForStatementControlWithWhen$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForStatementControlWithReduction, (0, import_lib2.$E)(WhenCondition)), function($skip, $loc, $0, $1, $2) {
   var control = $1;
   var condition = $2;
-  if (!condition)
-    return control;
+  if (!condition) return control;
   const expressions = [["", {
     type: "ContinueStatement",
     children: ["continue"]
@@ -15113,8 +15328,7 @@ var SwitchStatement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Switch, ForbidN
   var s = $1;
   var condition = $3;
   var caseBlock = $5;
-  if (!condition)
-    return $skip;
+  if (!condition) return $skip;
   if (condition.type === "EmptyCondition") {
     caseBlock.clauses.forEach(({ cases }) => {
       if (cases) {
@@ -15177,8 +15391,7 @@ function CaseBlock(ctx, state2) {
 }
 var NestedCaseClauses$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedCaseClause), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var clauses = $2;
-  if (clauses.length)
-    return clauses;
+  if (clauses.length) return clauses;
   return $skip;
 });
 function NestedCaseClauses(ctx, state2) {
@@ -15257,8 +15470,7 @@ function PatternExpressionList(ctx, state2) {
 var PatternExpression$0 = BindingPattern;
 var PatternExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidIndentedApplication, (0, import_lib2.$E)((0, import_lib2.$P)(SingleLineBinaryOpRHS)), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
   var pattern = $2;
-  if (!pattern)
-    return $skip;
+  if (!pattern) return $skip;
   return {
     type: "ConditionFragment",
     children: pattern
@@ -15273,8 +15485,7 @@ var CaseExpressionList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
   var rest = $2;
   const result = rest.map(([ws, _comma, exp, col]) => {
     exp = trimFirstSpace(exp);
-    if (ws.length)
-      return [insertTrimmingSpace("case ", ws), exp, col];
+    if (ws.length) return [insertTrimmingSpace("case ", ws), exp, col];
     return ["case ", exp, col];
   });
   result.unshift(first);
@@ -15286,8 +15497,7 @@ function CaseExpressionList(ctx, state2) {
 var CaseExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PropertyName, (0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$E)(_), Colon))), function($skip, $loc, $0, $1, $2) {
   var value = $1;
   if (value.type === "ComputedPropertyName") {
-    if (value.implicit)
-      return value.expression;
+    if (value.implicit) return value.expression;
     return { ...value, type: "ArrayExpression" };
   }
   return value;
@@ -15304,8 +15514,7 @@ function ImpliedColon(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ImpliedColon", ImpliedColon$$);
 }
 var IgnoreColon$0 = (0, import_lib2.$TV)((0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), Colon)), function($skip, $loc, $0, $1) {
-  if ($1)
-    return $1[0];
+  if ($1) return $1[0];
 });
 function IgnoreColon(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "IgnoreColon", IgnoreColon$0);
@@ -15336,8 +15545,7 @@ var CatchBinding$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E
   var parameter = $5;
   var ws3 = $7;
   var close = $8;
-  if (!parameter)
-    return $skip;
+  if (!parameter) return $skip;
   return {
     type: "CatchBinding",
     parameter,
@@ -15349,8 +15557,7 @@ var CatchBinding$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(_, InsertOpenParen
   var open = $2;
   var parameter = $5;
   var close = $7;
-  if (!parameter)
-    return $skip;
+  if (!parameter) return $skip;
   return {
     type: "CatchBinding",
     parameter,
@@ -15437,8 +15644,7 @@ var Condition$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, InsertOpe
   var open = $2;
   var expression = $3;
   var close = $4;
-  if (!expression)
-    return $skip;
+  if (!expression) return $skip;
   return {
     type: "ParenthesizedExpression",
     children: [open, expression, close],
@@ -15449,8 +15655,7 @@ var Condition$4 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenParen, Expr
   var open = $1;
   var expression = $2;
   var close = $3;
-  if (expression.type === "ParenthesizedExpression")
-    return expression;
+  if (expression.type === "ParenthesizedExpression") return expression;
   expression = trimFirstSpace(expression);
   return {
     type: "ParenthesizedExpression",
@@ -15466,8 +15671,7 @@ var BoundedCondition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenPare
   var open = $1;
   var expression = $2;
   var close = $3;
-  if (expression.type === "ParenthesizedExpression")
-    return expression;
+  if (expression.type === "ParenthesizedExpression") return expression;
   expression = trimFirstSpace(expression);
   return {
     type: "ParenthesizedExpression",
@@ -15480,8 +15684,7 @@ function BoundedCondition(ctx, state2) {
 }
 var DeclarationCondition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidBracedApplication, ForbidIndentedApplication, ForbidNewlineBinaryOp, (0, import_lib2.$E)(LexicalDeclaration), RestoreNewlineBinaryOp, RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var declaration = $4;
-  if (!declaration)
-    return $skip;
+  if (!declaration) return $skip;
   return {
     type: "DeclarationCondition",
     declaration,
@@ -15493,8 +15696,7 @@ function DeclarationCondition(ctx, state2) {
 }
 var ExpressionWithIndentedApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidIndentedApplication, ForbidNewlineBinaryOp, (0, import_lib2.$E)(Expression), RestoreNewlineBinaryOp, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var exp = $3;
-  if (exp)
-    return exp;
+  if (exp) return exp;
   return $skip;
 });
 function ExpressionWithIndentedApplicationForbidden(ctx, state2) {
@@ -15502,8 +15704,7 @@ function ExpressionWithIndentedApplicationForbidden(ctx, state2) {
 }
 var SingleLineExpressionWithIndentedApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidIndentedApplication, ForbidNewlineBinaryOp, (0, import_lib2.$E)(SingleLineAssignmentExpression), RestoreNewlineBinaryOp, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var exp = $3;
-  if (exp)
-    return exp;
+  if (exp) return exp;
   return $skip;
 });
 function SingleLineExpressionWithIndentedApplicationForbidden(ctx, state2) {
@@ -15511,8 +15712,7 @@ function SingleLineExpressionWithIndentedApplicationForbidden(ctx, state2) {
 }
 var ExpressionWithObjectApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidBracedApplication, ForbidIndentedApplication, (0, import_lib2.$E)(Expression), RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var exp = $3;
-  if (exp)
-    return exp;
+  if (exp) return exp;
   return $skip;
 });
 function ExpressionWithObjectApplicationForbidden(ctx, state2) {
@@ -15520,8 +15720,7 @@ function ExpressionWithObjectApplicationForbidden(ctx, state2) {
 }
 var LeftHandSideExpressionWithObjectApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidBracedApplication, ForbidIndentedApplication, ForbidNewlineBinaryOp, (0, import_lib2.$E)(LeftHandSideExpression), RestoreNewlineBinaryOp, RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var exp = $4;
-  if (exp)
-    return exp;
+  if (exp) return exp;
   return $skip;
 });
 function LeftHandSideExpressionWithObjectApplicationForbidden(ctx, state2) {
@@ -15546,8 +15745,7 @@ function RestoreClassImplicitCall(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "RestoreClassImplicitCall", RestoreClassImplicitCall$0);
 }
 var ClassImplicitCallForbidden$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'ClassImplicitCallForbidden ""'), function($skip, $loc, $0, $1) {
-  if (!state.classImplicitCallForbidden)
-    return $skip;
+  if (!state.classImplicitCallForbidden) return $skip;
   return;
 });
 function ClassImplicitCallForbidden(ctx, state2) {
@@ -15575,8 +15773,7 @@ var BracedApplicationAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($
   if (config.verbose) {
     console.log("forbidBracedApplication:", state.forbidBracedApplication);
   }
-  if (state.bracedApplicationForbidden)
-    return $skip;
+  if (state.bracedApplicationForbidden) return $skip;
   return;
 });
 function BracedApplicationAllowed(ctx, state2) {
@@ -15604,8 +15801,7 @@ var IndentedApplicationAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)
   if (config.verbose) {
     console.log("forbidIndentedApplication:", state.forbidIndentedApplication);
   }
-  if (state.indentedApplicationForbidden)
-    return $skip;
+  if (state.indentedApplicationForbidden) return $skip;
   return;
 });
 function IndentedApplicationAllowed(ctx, state2) {
@@ -15633,8 +15829,7 @@ var TrailingMemberPropertyAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPE
   if (config.verbose) {
     console.log("forbidTrailingMemberProperty:", state.forbidTrailingMemberProperty);
   }
-  if (state.trailingMemberPropertyForbidden)
-    return $skip;
+  if (state.trailingMemberPropertyForbidden) return $skip;
 });
 function TrailingMemberPropertyAllowed(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "TrailingMemberPropertyAllowed", TrailingMemberPropertyAllowed$0);
@@ -15661,8 +15856,7 @@ var NestedBinaryOpAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0,
   if (config.verbose) {
     console.log("forbidNestedBinaryOp:", state.forbidNestedBinaryOp);
   }
-  if (state.nestedBinaryOpForbidden)
-    return $skip;
+  if (state.nestedBinaryOpForbidden) return $skip;
 });
 function NestedBinaryOpAllowed(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NestedBinaryOpAllowed", NestedBinaryOpAllowed$0);
@@ -15689,8 +15883,7 @@ var NewlineBinaryOpAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0
   if (config.verbose) {
     console.log("forbidNewlineBinaryOp:", state.forbidNewlineBinaryOp);
   }
-  if (state.newlineBinaryOpForbidden)
-    return $skip;
+  if (state.newlineBinaryOpForbidden) return $skip;
 });
 function NewlineBinaryOpAllowed(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NewlineBinaryOpAllowed", NewlineBinaryOpAllowed$0);
@@ -15717,8 +15910,7 @@ var PipelineAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Pipe
   if (config.verbose) {
     console.log("forbidPipeline:", state.forbidPipeline);
   }
-  if (state.pipelineForbidden)
-    return $skip;
+  if (state.pipelineForbidden) return $skip;
 });
 function PipelineAllowed(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PipelineAllowed", PipelineAllowed$0);
@@ -15747,14 +15939,12 @@ function ExpressionStatement(ctx, state2) {
 }
 var KeywordStatement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Break, (0, import_lib2.$E)((0, import_lib2.$S)(_, LabelIdentifier)), (0, import_lib2.$E)((0, import_lib2.$S)(_, With, MaybeNestedExpression))), function($skip, $loc, $0, $1, $2, $3) {
   const children = [$1];
-  if ($2)
-    children.push($2);
-  if ($3)
-    children.push({
-      type: "Error",
-      subtype: "Warning",
-      message: "'break with' outside of loop that returns a value"
-    });
+  if ($2) children.push($2);
+  if ($3) children.push({
+    type: "Error",
+    subtype: "Warning",
+    message: "'break with' outside of loop that returns a value"
+  });
   return {
     type: "BreakStatement",
     label: $2?.[1],
@@ -15771,14 +15961,12 @@ var KeywordStatement$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Continue, _, S
 });
 var KeywordStatement$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(Continue, (0, import_lib2.$E)((0, import_lib2.$S)(_, LabelIdentifier)), (0, import_lib2.$E)((0, import_lib2.$S)(_, With, MaybeNestedExpression))), function($skip, $loc, $0, $1, $2, $3) {
   const children = [$1];
-  if ($2)
-    children.push($2);
-  if ($3)
-    children.push({
-      type: "Error",
-      subtype: "Warning",
-      message: "'continue with' outside of loop that returns a value"
-    });
+  if ($2) children.push($2);
+  if ($3) children.push({
+    type: "Error",
+    subtype: "Warning",
+    message: "'continue with' outside of loop that returns a value"
+  });
   return {
     type: "ContinueStatement",
     label: $2?.[1],
@@ -15832,10 +16020,8 @@ var MaybeNestedNonPipelineExpression$1 = NestedImplicitObjectLiteral;
 var MaybeNestedNonPipelineExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, NonPipelineExpression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4) {
   var expression = $2;
   var trailing = $4;
-  if (!expression)
-    return $skip;
-  if (!trailing)
-    return expression;
+  if (!expression) return $skip;
+  if (!trailing) return expression;
   return [expression, trailing];
 });
 var MaybeNestedNonPipelineExpression$3 = NonPipelineExpression;
@@ -15848,10 +16034,8 @@ var MaybeNestedPostfixedExpression$1 = NestedImplicitObjectLiteral;
 var MaybeNestedPostfixedExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, PostfixedExpression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4) {
   var expression = $2;
   var trailing = $4;
-  if (!expression)
-    return $skip;
-  if (!trailing)
-    return expression;
+  if (!expression) return $skip;
+  if (!trailing) return expression;
   return [expression, trailing];
 });
 var MaybeNestedPostfixedExpression$3 = PostfixedExpression;
@@ -15863,8 +16047,7 @@ var NestedPostfixedExpressionNoTrailing$0 = NestedBulletedArray;
 var NestedPostfixedExpressionNoTrailing$1 = NestedImplicitObjectLiteral;
 var NestedPostfixedExpressionNoTrailing$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, PostfixedExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var expression = $2;
-  if (!expression)
-    return $skip;
+  if (!expression) return $skip;
   return expression;
 });
 var NestedPostfixedExpressionNoTrailing$$ = [NestedPostfixedExpressionNoTrailing$0, NestedPostfixedExpressionNoTrailing$1, NestedPostfixedExpressionNoTrailing$2];
@@ -15876,10 +16059,8 @@ var MaybeNestedExpression$1 = NestedImplicitObjectLiteral;
 var MaybeNestedExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Expression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4) {
   var expression = $2;
   var trailing = $4;
-  if (!expression)
-    return $skip;
-  if (!trailing)
-    return expression;
+  if (!expression) return $skip;
+  if (!trailing) return expression;
   return [expression, trailing];
 });
 var MaybeNestedExpression$3 = Expression;
@@ -15898,8 +16079,7 @@ var MaybeParenNestedExpression$2 = (0, import_lib2.$T)((0, import_lib2.$S)((0, i
 });
 var MaybeParenNestedExpression$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)(EOS), InsertSpace, InsertOpenParen, PushIndent, (0, import_lib2.$S)(Nested, Expression), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions), InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
   var exp = $5;
-  if (!exp)
-    return $skip;
+  if (!exp) return $skip;
   return $0.slice(1);
 });
 var MaybeParenNestedExpression$$ = [MaybeParenNestedExpression$0, MaybeParenNestedExpression$1, MaybeParenNestedExpression$2, MaybeParenNestedExpression$3];
@@ -16074,8 +16254,7 @@ function OperatorNamedImports(ctx, state2) {
 }
 var FromClause$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(From, __, ModuleSpecifier), function($skip, $loc, $0, $1, $2, $3) {
   var module = $3;
-  if (!Array.isArray(module))
-    return $0;
+  if (!Array.isArray(module)) return $0;
   return [$1, $2, ...module];
 });
 function FromClause(ctx, state2) {
@@ -16083,8 +16262,7 @@ function FromClause(ctx, state2) {
 }
 var ImpliedFromClause$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$S)(From, __), ImpliedFrom), ModuleSpecifier), function($skip, $loc, $0, $1, $2) {
   var module = $2;
-  if (!Array.isArray(module))
-    return $0;
+  if (!Array.isArray(module)) return $0;
   return [$1, ...module];
 });
 function ImpliedFromClause(ctx, state2) {
@@ -16110,8 +16288,7 @@ function ImportAssertion(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ImportAssertion", ImportAssertion$0);
 }
 var TypeAndImportSpecifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(__, TypeKeyword)), ImportSpecifier), function($skip, $loc, $0, $1, $2) {
-  if (!$1)
-    return $2;
+  if (!$1) return $2;
   return { ts: true, children: $0, binding: $2.binding };
 });
 var TypeAndImportSpecifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Operator, OperatorImportSpecifier), function($skip, $loc, $0, $1, $2, $3) {
@@ -16327,8 +16504,7 @@ function ExportFromClause(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ExportFromClause", ExportFromClause$$);
 }
 var TypeAndNamedExports$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(TypeKeyword, __)), NamedExports), function($skip, $loc, $0, $1, $2) {
-  if (!$1)
-    return $2;
+  if (!$1) return $2;
   return { ts: true, children: $0 };
 });
 function TypeAndNamedExports(ctx, state2) {
@@ -16347,8 +16523,7 @@ function NamedExports(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "NamedExports", NamedExports$$);
 }
 var ExportSpecifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, (0, import_lib2.$E)((0, import_lib2.$S)(TypeKeyword, __)), ModuleExportName, (0, import_lib2.$E)((0, import_lib2.$S)(__, As, __, ModuleExportName)), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-  if (!$2)
-    return $0;
+  if (!$2) return $0;
   return { ts: true, children: $0 };
 });
 function ExportSpecifier(ctx, state2) {
@@ -16360,11 +16535,9 @@ function ImplicitExportSpecifier(ctx, state2) {
 }
 var Declaration$0 = (0, import_lib2.$TV)(ImportDeclaration, function($skip, $loc, $0, $1) {
   var decl = $0;
-  if (decl.ts || decl.module || !decl.imports || !decl.from)
-    return $skip;
+  if (decl.ts || decl.module || !decl.imports || !decl.from) return $skip;
   const { imports } = decl;
-  if (!imports.binding && !imports.specifiers)
-    return $skip;
+  if (!imports.binding && !imports.specifiers) return $skip;
   return dynamizeImportDeclaration(decl);
 });
 var Declaration$1 = HoistableDeclaration;
@@ -16634,8 +16807,7 @@ function TripleSingleStringCharacters(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "TripleSingleStringCharacters", TripleSingleStringCharacters$0);
 }
 var CoffeeStringSubstitution$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeSubstitutionStart, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(PostfixedExpression, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
-  if (!$3)
-    return $skip;
+  if (!$3) return $skip;
   return [$1, ...$3];
 });
 function CoffeeStringSubstitution(ctx, state2) {
@@ -16658,7 +16830,12 @@ function CoffeeDoubleQuotedStringCharacters(ctx, state2) {
 }
 var RegularExpressionLiteral$0 = HeregexLiteral;
 var RegularExpressionLiteral$1 = (0, import_lib2.$TV)((0, import_lib2.$TEXT)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L77, 'RegularExpressionLiteral "/"'), RegularExpressionBody, (0, import_lib2.$EXPECT)($L77, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
-  return { type: "RegularExpressionLiteral", $loc, token: $1 };
+  var raw = $0;
+  return {
+    type: "RegularExpressionLiteral",
+    raw,
+    children: [{ $loc, token: raw }]
+  };
 });
 var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
 function RegularExpressionLiteral(ctx, state2) {
@@ -16817,8 +16994,7 @@ function _TemplateLiteral(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "_TemplateLiteral", _TemplateLiteral$$);
 }
 var TemplateSubstitution$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(SubstitutionStart, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(PostfixedExpression, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
-  if (!$3)
-    return $skip;
+  if (!$3) return $skip;
   return [$1, ...$3];
 });
 function TemplateSubstitution(ctx, state2) {
@@ -17663,8 +17839,7 @@ var JSXElement$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(
   var open = $2;
   var children = $3;
   var close = $4;
-  if (!children)
-    return $skip;
+  if (!children) return $skip;
   let parts;
   $0 = $0.slice(1);
   if (close) {
@@ -17687,8 +17862,7 @@ var JSXElement$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeJSXEnabled, JS
   var open = $2;
   var close = $5;
   $0 = $0.slice(1);
-  if (open[1] !== close[2])
-    return $skip;
+  if (open[1] !== close[2]) return $skip;
   return { type: "JSXElement", children: $0, tag: open[1] };
 });
 var JSXElement$$ = [JSXElement$0, JSXElement$1, JSXElement$2];
@@ -17720,8 +17894,7 @@ function JSXOpeningElement(ctx, state2) {
 }
 var JSXOptionalClosingElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(Whitespace), JSXClosingElement), function($skip, $loc, $0, $1, $2) {
   var close = $2;
-  if (state.currentJSXTag !== close[2])
-    return $skip;
+  if (state.currentJSXTag !== close[2]) return $skip;
   return $0;
 });
 var JSXOptionalClosingElement$1 = (0, import_lib2.$EXPECT)($L0, 'JSXOptionalClosingElement ""');
@@ -17737,8 +17910,7 @@ var JSXFragment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)
   var open = $2;
   var children = $3;
   var close = $4;
-  if (!children)
-    return $skip;
+  if (!children) return $skip;
   $0 = $0.slice(1);
   const parts = close ? $0 : [
     ...$0,
@@ -17771,8 +17943,7 @@ function PushJSXOpeningFragment(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PushJSXOpeningFragment", PushJSXOpeningFragment$0);
 }
 var JSXOptionalClosingFragment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2) {
-  if (state.currentJSXTag !== "")
-    return $skip;
+  if (state.currentJSXTag !== "") return $skip;
   return $0;
 });
 var JSXOptionalClosingFragment$1 = (0, import_lib2.$EXPECT)($L0, 'JSXOptionalClosingFragment ""');
@@ -17850,10 +18021,8 @@ var JSXAttributes$0 = (0, import_lib2.$TV)((0, import_lib2.$Q)((0, import_lib2.$
         while (root.length && isWhitespaceOrEmpty(root[root.length - 1])) {
           root = root.slice(0, -1);
         }
-        while (root?.length === 1)
-          root = root[0];
-        if (root?.children)
-          root = root.children;
+        while (root?.length === 1) root = root[0];
+        if (root?.children) root = root.children;
         if (root?.[0]?.token === "`") {
           classValue = ["{", ...exprs, "}"];
         } else {
@@ -17922,8 +18091,7 @@ var JSXAttribute$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(AtThis, (0, import
     children
   });
   const last = lastAccessInCallExpression(expr);
-  if (!last)
-    return $skip;
+  if (!last) return $skip;
   let name;
   if (last.type === "Index") {
     return [
@@ -17949,8 +18117,7 @@ var JSXAttribute$4 = (0, import_lib2.$TS)((0, import_lib2.$S)(Identifier, (0, im
     return convertObjectToJSXAttributes(expr);
   }
   const last = lastAccessInCallExpression(expr);
-  if (!last)
-    return $skip;
+  if (!last) return $skip;
   let name;
   if (last.type === "Index") {
     return [
@@ -18037,8 +18204,7 @@ function JSXAttributeValue(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "JSXAttributeValue", JSXAttributeValue$$);
 }
 var InlineJSXAttributeValue$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(InlineJSXUnaryExpression, (0, import_lib2.$Q)(InlineJSXBinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
-  if ($2.length)
-    return processBinaryOpExpression($0);
+  if ($2.length) return processBinaryOpExpression($0);
   return $1;
 });
 function InlineJSXAttributeValue(ctx, state2) {
@@ -18073,8 +18239,7 @@ function InlineJSXUnaryPostfix(ctx, state2) {
 }
 var InlineJSXUpdateExpression$0 = (0, import_lib2.$S)(UpdateExpressionSymbol, UnaryExpression);
 var InlineJSXUpdateExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InlineJSXCallExpression, (0, import_lib2.$E)(UpdateExpressionSymbol)), function($skip, $loc, $0, $1, $2) {
-  if ($2)
-    return $0;
+  if ($2) return $0;
   return $1;
 });
 var InlineJSXUpdateExpression$$ = [InlineJSXUpdateExpression$0, InlineJSXUpdateExpression$1];
@@ -18130,8 +18295,7 @@ var InlineJSXCallExpressionRest$1 = (0, import_lib2.$TV)((0, import_lib2.$C)(Tem
 });
 var InlineJSXCallExpressionRest$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(OptionalShorthand), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
   var args = $2;
-  if (!$1)
-    return args;
+  if (!$1) return args;
   return [$1, args];
 });
 var InlineJSXCallExpressionRest$$ = [InlineJSXCallExpressionRest$0, InlineJSXCallExpressionRest$1, InlineJSXCallExpressionRest$2];
@@ -18155,8 +18319,7 @@ var InlineJSXMemberExpressionRest$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((
   var dot = $1;
   var comments = $2;
   var content = $3;
-  if (!dot && !comments.length)
-    return content;
+  if (!dot && !comments.length) return content;
   if (dot) {
     if (dot.type === "Optional" && content.type === "SliceExpression") {
       return [...dot.children.slice(0, -1), ...comments, content];
@@ -18244,8 +18407,7 @@ var JSXNested$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(JSXEOS, Indent), func
   var indent = $2;
   const { level } = indent;
   const currentIndent = state.currentIndent;
-  if (level !== currentIndent.level)
-    return $skip;
+  if (level !== currentIndent.level) return $skip;
   return $0;
 });
 function JSXNested(ctx, state2) {
@@ -18366,8 +18528,7 @@ function JSXChildExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "JSXChildExpression", JSXChildExpression$$);
 }
 var IndentedJSXChildExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)(NestedJSXChildExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2)
-    return $skip;
+  if (!$2) return $skip;
   return $2;
 });
 function IndentedJSXChildExpression(ctx, state2) {
@@ -18387,8 +18548,7 @@ var JSXCodeChild$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertInlineOpenBr
   var open = $1;
   var expression = $2;
   var close = $3;
-  if (!expression)
-    return $skip;
+  if (!expression) return $skip;
   return [open, expression, close];
 });
 function JSXCodeChild(ctx, state2) {
@@ -18396,14 +18556,12 @@ function JSXCodeChild(ctx, state2) {
 }
 var JSXCodeChildExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(JSXEOS), ForbidNewlineBinaryOp, (0, import_lib2.$E)(JSXChildExpression), RestoreNewlineBinaryOp), function($skip, $loc, $0, $1, $2, $3, $4) {
   var expression = $3;
-  if (!expression)
-    return $skip;
+  if (!expression) return $skip;
   return expression;
 });
 var JSXCodeChildExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)(JSXEOS), ImplicitNestedBlock), function($skip, $loc, $0, $1, $2) {
   var block = $2;
-  if (!block)
-    return $skip;
+  if (!block) return $skip;
   const statement = {
     type: "DoStatement",
     children: [block],
@@ -18649,8 +18807,7 @@ function NestedInterfaceBlock(ctx, state2) {
 }
 var NestedInterfaceProperties$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedInterfaceProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var props = $2;
-  if (props.length)
-    return props;
+  if (props.length) return props;
   return $skip;
 });
 function NestedInterfaceProperties(ctx, state2) {
@@ -18687,8 +18844,7 @@ function ModuleOrEmptyBlock(ctx, state2) {
 }
 var NestedModuleItems$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedModuleItem), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var items = $2;
-  if (items.length)
-    return items;
+  if (items.length) return items;
   return $skip;
 });
 function NestedModuleItems(ctx, state2) {
@@ -18707,8 +18863,7 @@ function DeclareBlock(ctx, state2) {
 }
 var NestedDeclareElements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedDeclareElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var decs = $2;
-  if (decs.length)
-    return decs;
+  if (decs.length) return decs;
   return $skip;
 });
 function NestedDeclareElements(ctx, state2) {
@@ -18816,8 +18971,7 @@ function EnumBlock(ctx, state2) {
 }
 var NestedEnumProperties$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedEnumPropertyLine), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var props = $2;
-  if (!props.length)
-    return $skip;
+  if (!props.length) return $skip;
   return {
     properties: props.flat().map((p) => p.property),
     children: $0
@@ -18864,12 +19018,13 @@ function TypeIndex(ctx, state2) {
 }
 var TypeSuffix$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$E)(QuestionMark), (0, import_lib2.$E)(_), Colon, MaybeNestedType), function(value) {
   var optional = value[1];
+  var colon = value[3];
   var t = value[4];
-  return { "type": "TypeSuffix", "ts": true, "optional": optional, "t": t, "children": value };
+  return { "type": "TypeSuffix", "ts": true, "optional": optional, "t": t, "colon": colon, "children": value };
 });
 var TypeSuffix$1 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$E)(_), QuestionMark, (0, import_lib2.$E)(_)), function(value) {
   var optional = value[1];
-  return { "type": "TypeSuffix", "ts": true, "optional": optional, "children": value };
+  return { "type": "TypeSuffix", "ts": true, "optional": optional, "colon": void 0, "children": value };
 });
 var TypeSuffix$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NonNullAssertion, (0, import_lib2.$E)(_), (0, import_lib2.$E)((0, import_lib2.$S)(Colon, MaybeNestedType))), function($skip, $loc, $0, $1, $2, $3) {
   var nonnull = $1;
@@ -18880,6 +19035,7 @@ var TypeSuffix$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NonNullAssertion, (0
     ts: true,
     nonnull,
     t,
+    colon,
     children: [$1, $2, colon, t]
   };
 });
@@ -18891,8 +19047,7 @@ var MaybeNestedType$0 = NestedTypeBulletedTuple;
 var MaybeNestedType$1 = NestedInterfaceBlock;
 var MaybeNestedType$2 = NestedTypeBinaryChain;
 var MaybeNestedType$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Type)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2)
-    return $skip;
+  if (!$2) return $skip;
   return $2;
 });
 var MaybeNestedType$4 = Type;
@@ -18904,8 +19059,7 @@ var MaybeNestedTypePrimary$0 = NestedTypeBulletedTuple;
 var MaybeNestedTypePrimary$1 = NestedInterfaceBlock;
 var MaybeNestedTypePrimary$2 = NestedTypeBinaryChain;
 var MaybeNestedTypePrimary$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Type)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2)
-    return $skip;
+  if (!$2) return $skip;
   return $2;
 });
 var MaybeNestedTypePrimary$4 = TypePrimary;
@@ -18917,8 +19071,7 @@ var MaybeNestedTypeUnary$0 = NestedTypeBulletedTuple;
 var MaybeNestedTypeUnary$1 = NestedInterfaceBlock;
 var MaybeNestedTypeUnary$2 = NestedTypeBinaryChain;
 var MaybeNestedTypeUnary$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Type)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2)
-    return $skip;
+  if (!$2) return $skip;
   return $2;
 });
 var MaybeNestedTypeUnary$4 = (0, import_lib2.$S)(NotDedented, TypeUnary);
@@ -18941,8 +19094,7 @@ function ReturnTypeSuffix(ctx, state2) {
 var ReturnType$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(__, (0, import_lib2.$EXPECT)($L240, 'ReturnType "asserts"'), NonIdContinue)), ForbidIndentedApplication, (0, import_lib2.$E)(TypePredicate), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4) {
   var asserts = $1;
   var t = $3;
-  if (!t)
-    return $skip;
+  if (!t) return $skip;
   if (asserts) {
     t = {
       type: "TypeAsserts",
@@ -18964,8 +19116,7 @@ function ReturnType(ctx, state2) {
 var TypePredicate$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(MaybeNestedType, (0, import_lib2.$E)((0, import_lib2.$S)(__, Is, Type))), function($skip, $loc, $0, $1, $2) {
   var lhs = $1;
   var rhs = $2;
-  if (!rhs)
-    return lhs;
+  if (!rhs) return lhs;
   return {
     type: "TypePredicate",
     lhs,
@@ -18984,20 +19135,16 @@ var TypeBinary$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(
   var optionalPrefix = $1;
   var t = $2;
   var ops = $3;
-  if (!ops.length && !optionalPrefix)
-    return t;
-  if (!ops.length)
-    return [optionalPrefix, t];
-  if (!optionalPrefix)
-    return [t, ...ops];
+  if (!ops.length && !optionalPrefix) return t;
+  if (!ops.length) return [optionalPrefix, t];
+  if (!optionalPrefix) return [t, ...ops];
   return [optionalPrefix, t, ops];
 });
 function TypeBinary(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "TypeBinary", TypeBinary$0);
 }
 var NestedTypeBinaryChain$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedTypeBinary), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2.length)
-    return $skip;
+  if (!$2.length) return $skip;
   return $2;
 });
 function NestedTypeBinaryChain(ctx, state2) {
@@ -19007,8 +19154,7 @@ var NestedTypeBinary$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Nested, TypeBi
   var indent = $1;
   var op = $2;
   var t = $4;
-  if (!t)
-    return $skip;
+  if (!t) return $skip;
   return [indent, op, t];
 });
 function NestedTypeBinary(ctx, state2) {
@@ -19018,8 +19164,7 @@ var TypeUnary$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Q)((
   var prefix = $1;
   var t = $2;
   var suffix = $3;
-  if (!prefix.length && !suffix.length)
-    return t;
+  if (!prefix.length && !suffix.length) return t;
   return {
     type: "TypeUnary",
     prefix,
@@ -19078,9 +19223,11 @@ function UnknownAlias(ctx, state2) {
 }
 var TypePrimary$0 = (0, import_lib2.$S)((0, import_lib2.$E)(_), Infer, (0, import_lib2.$E)(_), IdentifierName, (0, import_lib2.$E)((0, import_lib2.$S)(NotDedented, ExtendsToken, Type)));
 var TypePrimary$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), Typeof, (0, import_lib2.$E)(_), UnaryExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $4;
   return {
-    type: "TypeofType",
-    children: $0
+    type: "TypeTypeof",
+    children: $0,
+    expression
   };
 });
 var TypePrimary$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), TypeTuple), function($skip, $loc, $0, $1, $2) {
@@ -19123,8 +19270,7 @@ var TypePrimary$9 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)
   };
 });
 var TypePrimary$10 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), OpenParen, AllowAll, (0, import_lib2.$E)((0, import_lib2.$C)(Type, (0, import_lib2.$S)(EOS, Type))), RestoreAll, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
-  if (!$4)
-    return $skip;
+  if (!$4) return $skip;
   return {
     type: "TypeParenthesized",
     children: [$1, $2, $4, $6, $7]
@@ -19146,8 +19292,7 @@ var TypeTuple$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBracket, AllowAll
   var elements = $3;
   var ws = $5;
   var close = $6;
-  if (!elements)
-    return $skip;
+  if (!elements) return $skip;
   return {
     type: "TypeTuple",
     elements,
@@ -19162,8 +19307,7 @@ var TypeTupleContent$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(TypeElementLis
   var list = $1;
   var delimiter = $2;
   var nested = $3;
-  if (!nested)
-    return list;
+  if (!nested) return list;
   return [...list, delimiter, ...nested];
 });
 var TypeTupleContent$2 = (0, import_lib2.$TV)((0, import_lib2.$Q)((0, import_lib2.$S)(__, TypeElementListWithIndentedApplicationForbidden, ArrayElementDelimiter)), function($skip, $loc, $0, $1) {
@@ -19174,8 +19318,7 @@ function TypeTupleContent(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "TypeTupleContent", TypeTupleContent$$);
 }
 var TypeElementListWithIndentedApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidIndentedApplication, (0, import_lib2.$E)(TypeElementList), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
-  if ($2)
-    return $2;
+  if ($2) return $2;
   return $skip;
 });
 function TypeElementListWithIndentedApplicationForbidden(ctx, state2) {
@@ -19187,8 +19330,7 @@ var TypeElementList$0 = (0, import_lib2.$T)((0, import_lib2.$S)(TypeBulletedTupl
 var TypeElementList$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(EOS), TypeElement, (0, import_lib2.$Q)((0, import_lib2.$S)((0, import_lib2.$S)((0, import_lib2.$E)(_), Comma, (0, import_lib2.$N)(EOS)), TypeElement))), function($skip, $loc, $0, $1, $2, $3) {
   var first = $2;
   var rest = $3;
-  if (!rest.length)
-    return [first];
+  if (!rest.length) return [first];
   return [
     append(first, rest[0][0])
   ].concat(
@@ -19254,13 +19396,10 @@ var NestedTypeElement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Nested, TypeE
   var list = $2;
   var delimiter = $3;
   const { length } = list;
-  if (!length)
-    return $skip;
+  if (!length) return $skip;
   return list.map((e, i) => {
-    if (i === 0)
-      e = prepend(indent, e);
-    if (i === length - 1)
-      e = append(e, delimiter);
+    if (i === 0) e = prepend(indent, e);
+    if (i === length - 1) e = append(e, delimiter);
     return e;
   });
 });
@@ -19271,8 +19410,7 @@ var NestedTypeBulletedTuple$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, imp
   var open = $1;
   var content = $3;
   var close = $4;
-  if (!content.length)
-    return $skip;
+  if (!content.length) return $skip;
   content = content.flat();
   const last = content[content.length - 1];
   let children = Array.isArray(last) ? last : last?.children;
@@ -19296,8 +19434,7 @@ var TypeBulletedTuple$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertOpenBra
   var open = $1;
   var content = $2;
   var close = $3;
-  if (!content)
-    return $skip;
+  if (!content) return $skip;
   content = [
     ...trimFirstSpace(content[0]),
     // replace first space with bracket
@@ -19332,11 +19469,9 @@ function NestedTypeBullet(ctx, state2) {
 var TypeBullet$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(BulletIndent, (0, import_lib2.$E)((0, import_lib2.$S)(TypeElementList, ArrayBulletDelimiter)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var bullet = $1;
   var content = $2;
-  if (!content)
-    return $skip;
+  if (!content) return $skip;
   let [list, delimiter] = content;
-  if (!list.length)
-    return $skip;
+  if (!list.length) return $skip;
   list = list.slice();
   list[0] = prepend(bullet, list[0]);
   if (delimiter) {
@@ -19351,8 +19486,7 @@ function TypeBullet(ctx, state2) {
 var TypeWithPostfix$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(TypeConditional, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), TypeIfClause))), function($skip, $loc, $0, $1, $2) {
   var t = $1;
   var postfix = $2;
-  if (!postfix)
-    return t;
+  if (!postfix) return t;
   return prepend(
     postfix[0],
     expressionizeTypeIf([...postfix[1], $1, void 0])
@@ -19365,8 +19499,7 @@ var TypeConditional$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
   return prepend($1, expressionizeTypeIf($3));
 });
 var TypeConditional$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(TypeCondition, NotDedented, QuestionMark, __, Type, __, Colon, __, Type), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
-  if ($1.negated)
-    return [$1, $2, $3, $4, $9, $6, $7, $8, $5];
+  if ($1.negated) return [$1, $2, $3, $4, $9, $6, $7, $8, $5];
   return $0;
 });
 var TypeConditional$2 = TypeBinary;
@@ -19392,14 +19525,12 @@ function TypeIfThenElse(ctx, state2) {
 }
 var TypeIfClause$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)(If, Unless), OpenParen, AllowAll, (0, import_lib2.$E)(TypeCondition), RestoreAll, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var condition = $4;
-  if (!condition)
-    return $skip;
+  if (!condition) return $skip;
   return [$1, condition];
 });
 var TypeIfClause$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)(If, Unless), ForbidIndentedApplication, (0, import_lib2.$E)(TypeCondition), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4) {
   var condition = $3;
-  if (!condition)
-    return $skip;
+  if (!condition) return $skip;
   return [$1, condition];
 });
 var TypeIfClause$$ = [TypeIfClause$0, TypeIfClause$1];
@@ -19418,8 +19549,7 @@ var TypeBlock$1 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$N)(EO
 });
 var TypeBlock$2 = NestedInterfaceBlock;
 var TypeBlock$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Type)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if (!$2)
-    return $skip;
+  if (!$2) return $skip;
   return $2;
 });
 var TypeBlock$$ = [TypeBlock$0, TypeBlock$1, TypeBlock$2, TypeBlock$3];
@@ -19459,8 +19589,7 @@ var TypeLiteral$1 = Literal;
 var TypeLiteral$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R14, "TypeLiteral /[+-]/"), NumericLiteral), function($skip, $loc, $0, $1, $2) {
   var sign = $1;
   var num = $2;
-  if (sign[0] === "+")
-    return num;
+  if (sign[0] === "+") return num;
   return $0;
 });
 var TypeLiteral$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L224, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
@@ -19576,8 +19705,7 @@ var ImplicitTypeArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(TypeAppli
   var args = $4;
   var close = $5;
   const last = args[args.length - 1];
-  if (isComma(last))
-    args = args.slice(0, -1);
+  if (isComma(last)) args = args.slice(0, -1);
   return {
     type: "TypeArguments",
     ts: true,
@@ -19631,8 +19759,7 @@ function TypeArgumentList(ctx, state2) {
 }
 var NestedTypeArgumentList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedTypeArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
   var args = $2;
-  if (!args.length)
-    return $skip;
+  if (!args.length) return $skip;
   return args.flat();
 });
 function NestedTypeArgumentList(ctx, state2) {
@@ -19743,16 +19870,14 @@ function CivetPrologueContent(ctx, state2) {
 }
 var CivetOption$0 = (0, import_lib2.$TR)((0, import_lib2.$EXPECT)($R99, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([\\p{ID_Continue}.,+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
   const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
-    if (l)
-      return l.toUpperCase();
+    if (l) return l.toUpperCase();
     return "";
   });
   let value = $3 ? $4 : $1 === "-" ? false : true;
   switch (optionName) {
     case "tab":
       value = parseFloat(value);
-      if (isNaN(value))
-        value = 0;
+      if (isNaN(value)) value = 0;
       break;
     case "globals":
     case "symbols":
@@ -19941,144 +20066,126 @@ function InsertType(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "InsertType", InsertType$0);
 }
 var CoffeeBinaryExistentialEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeBinaryExistential)
-    return;
+  if (config.coffeeBinaryExistential) return;
   return $skip;
 });
 function CoffeeBinaryExistentialEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeBinaryExistentialEnabled", CoffeeBinaryExistentialEnabled$0);
 }
 var CoffeeBooleansEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeBooleans)
-    return;
+  if (config.coffeeBooleans) return;
   return $skip;
 });
 function CoffeeBooleansEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeBooleansEnabled", CoffeeBooleansEnabled$0);
 }
 var CoffeeClassesEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeClasses)
-    return;
+  if (config.coffeeClasses) return;
   return $skip;
 });
 function CoffeeClassesEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeClassesEnabled", CoffeeClassesEnabled$0);
 }
 var CoffeeCommentEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeComment)
-    return;
+  if (config.coffeeComment) return;
   return $skip;
 });
 function CoffeeCommentEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeCommentEnabled", CoffeeCommentEnabled$0);
 }
 var CoffeeDivEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeDivEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeDiv)
-    return;
+  if (config.coffeeDiv) return;
   return $skip;
 });
 function CoffeeDivEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeDivEnabled", CoffeeDivEnabled$0);
 }
 var CoffeeDoEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeDo)
-    return;
+  if (config.coffeeDo) return;
   return $skip;
 });
 function CoffeeDoEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeDoEnabled", CoffeeDoEnabled$0);
 }
 var CoffeeForLoopsEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeForLoops)
-    return;
+  if (config.coffeeForLoops) return;
   return $skip;
 });
 function CoffeeForLoopsEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeForLoopsEnabled", CoffeeForLoopsEnabled$0);
 }
 var CoffeeInterpolationEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeInterpolation)
-    return;
+  if (config.coffeeInterpolation) return;
   return $skip;
 });
 function CoffeeInterpolationEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeInterpolationEnabled", CoffeeInterpolationEnabled$0);
 }
 var CoffeeIsntEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeIsnt)
-    return;
+  if (config.coffeeIsnt) return;
   return $skip;
 });
 function CoffeeIsntEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeIsntEnabled", CoffeeIsntEnabled$0);
 }
 var CoffeeJSXEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeJSX)
-    return;
+  if (config.coffeeJSX) return;
   return $skip;
 });
 function CoffeeJSXEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeJSXEnabled", CoffeeJSXEnabled$0);
 }
 var CoffeeLineContinuationEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeLineContinuation)
-    return;
+  if (config.coffeeLineContinuation) return;
   return $skip;
 });
 function CoffeeLineContinuationEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeLineContinuationEnabled", CoffeeLineContinuationEnabled$0);
 }
 var CoffeeNotEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeNot)
-    return;
+  if (config.coffeeNot) return;
   return $skip;
 });
 function CoffeeNotEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeNotEnabled", CoffeeNotEnabled$0);
 }
 var CoffeeOfEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeeOf)
-    return;
+  if (config.coffeeOf) return;
   return $skip;
 });
 function CoffeeOfEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeOfEnabled", CoffeeOfEnabled$0);
 }
 var CoffeePrototypeEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.coffeePrototype)
-    return;
+  if (config.coffeePrototype) return;
   return $skip;
 });
 function CoffeePrototypeEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "CoffeePrototypeEnabled", CoffeePrototypeEnabled$0);
 }
 var JSXCodeNestedEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'JSXCodeNestedEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.jsxCodeNested)
-    return;
+  if (config.jsxCodeNested) return;
   return $skip;
 });
 function JSXCodeNestedEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "JSXCodeNestedEnabled", JSXCodeNestedEnabled$0);
 }
 var JSXCodeSameLineEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'JSXCodeSameLineEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.jsxCodeSameLine)
-    return;
+  if (config.jsxCodeSameLine) return;
   return $skip;
 });
 function JSXCodeSameLineEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "JSXCodeSameLineEnabled", JSXCodeSameLineEnabled$0);
 }
 var ObjectIsEnabled$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
-  if (config.objectIs)
-    return;
+  if (config.objectIs) return;
   return $skip;
 });
 function ObjectIsEnabled(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ObjectIsEnabled", ObjectIsEnabled$0);
 }
 var IsBare$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'IsBare ""'), function($skip, $loc, $0, $1) {
-  if (config.iife || config.repl)
-    return $skip;
+  if (config.iife || config.repl) return $skip;
 });
 function IsBare(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "IsBare", IsBare$0);
@@ -20251,8 +20358,7 @@ function PopIndent(ctx, state2) {
 }
 var Nested$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(EOS, Indent), function($skip, $loc, $0, $1, $2) {
   var indent = $2;
-  if (indent.level === state.currentIndent.level)
-    return $0;
+  if (indent.level === state.currentIndent.level) return $0;
   if (config.verbose) {
     console.log(`failing Nested: ${indent.level} does not match current indent level ${state.currentIndent.level}`);
   }
@@ -20263,8 +20369,7 @@ function Nested(ctx, state2) {
 }
 var IndentedFurther$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(EOS, Indent), function($skip, $loc, $0, $1, $2) {
   var indent = $2;
-  if (indent.level > state.currentIndent.level)
-    return $0;
+  if (indent.level > state.currentIndent.level) return $0;
   return $skip;
 });
 function IndentedFurther(ctx, state2) {
@@ -20272,8 +20377,7 @@ function IndentedFurther(ctx, state2) {
 }
 var IndentedAtLeast$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(EOS, Indent), function($skip, $loc, $0, $1, $2) {
   var indent = $2;
-  if (indent.level >= state.currentIndent.level)
-    return $0;
+  if (indent.level >= state.currentIndent.level) return $0;
   return $skip;
 });
 function IndentedAtLeast(ctx, state2) {
@@ -20281,10 +20385,8 @@ function IndentedAtLeast(ctx, state2) {
 }
 var NotDedented$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(IndentedAtLeast), (0, import_lib2.$E)(_)), function($skip, $loc, $0, $1, $2) {
   const ws = [];
-  if ($1)
-    ws.push(...$1);
-  if ($2)
-    ws.push(...$2);
+  if ($1) ws.push(...$1);
+  if ($2) ws.push(...$2);
   return ws.flat(Infinity).filter(Boolean);
 });
 function NotDedented(ctx, state2) {
@@ -20292,10 +20394,8 @@ function NotDedented(ctx, state2) {
 }
 var SameLineOrIndentedFurther$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(IndentedFurther), (0, import_lib2.$E)(_)), function($skip, $loc, $0, $1, $2) {
   const ws = [];
-  if ($1)
-    ws.push(...$1);
-  if ($2)
-    ws.push(...$2);
+  if ($1) ws.push(...$1);
+  if ($2) ws.push(...$2);
   return ws.flat(Infinity).filter(Boolean);
 });
 function SameLineOrIndentedFurther(ctx, state2) {
@@ -20313,8 +20413,7 @@ var PushExtraIndent1$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Pus
     $loc,
     level: state.currentIndent.level + 1
   };
-  if (config.verbose)
-    console.log("pushing bonus indent", indent);
+  if (config.verbose) console.log("pushing bonus indent", indent);
   state.indentLevels.push(indent);
   return indent;
 });
@@ -20326,11 +20425,9 @@ var parser = function() {
   let ctx = { expectation: "", fail };
   return {
     parse: (input, options = {}) => {
-      if (typeof input !== "string")
-        throw new Error("Input must be a string");
+      if (typeof input !== "string") throw new Error("Input must be a string");
       const parser2 = options.startRule != null ? grammar[options.startRule] : Object.values(grammar)[0];
-      if (!parser2)
-        throw new Error(`Could not find rule with name '${options.startRule}'`);
+      if (!parser2) throw new Error(`Could not find rule with name '${options.startRule}'`);
       const filename2 = options.filename || "<anonymous>";
       reset();
       Object.assign(ctx, { ...options.events, tokenize: options.tokenize });
@@ -20461,9 +20558,9 @@ var wellKnownSymbols = [
   "unscopables"
 ];
 
-// source/sourcemap.civet
-var sourcemap_exports = {};
-__export(sourcemap_exports, {
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\sourcemap.civet.jsx
+var sourcemap_civet_exports = {};
+__export(sourcemap_civet_exports, {
   SourceMap: () => SourceMap,
   base64Encode: () => base64Encode,
   locationTable: () => locationTable,
@@ -20648,10 +20745,8 @@ var VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
 var encodeVlq = function(value) {
   let answer = "";
   let ref1;
-  if (value < 0)
-    ref1 = 1;
-  else
-    ref1 = 0;
+  if (value < 0) ref1 = 1;
+  else ref1 = 0;
   const signBit = ref1;
   let valueToEncode = (Math.abs(value) << 1) + signBit;
   while (valueToEncode || !answer) {
@@ -20765,7 +20860,7 @@ var remapPosition = function(position, sourcemapLines) {
   }
 };
 
-// source/state-cache.civet
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\state-cache.civet.jsx
 var StateCache = class {
   cache = /* @__PURE__ */ new Map();
   get(key) {
@@ -20805,8 +20900,86 @@ var StateCache = class {
   }
 };
 
-// source/main.civet
-var { SourceMap: SourceMap2 } = sourcemap_exports;
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\worker-pool.civet.jsx
+var WorkerPool = class {
+  idle;
+  spawned;
+  jobId;
+  callbacks;
+  todo;
+  threads;
+  constructor(threads) {
+    this.threads = threads;
+    this.idle = [];
+    this.spawned = 0;
+    this.jobId = 0;
+    this.callbacks = /* @__PURE__ */ new Map();
+    this.todo = [];
+  }
+  async run(op, ...args) {
+    const id = this.jobId++;
+    return await new Promise(async (resolve2, reject) => {
+      this.callbacks.set(id, { resolve: resolve2, reject });
+      const job = { id, op, args };
+      if (this.idle.length) {
+        const worker = this.idle.shift();
+        worker.ref();
+        worker.postMessage(job);
+      } else if (this.spawned < this.threads) {
+        (await this.startWorker()).postMessage(job);
+      } else {
+        this.todo.push(job);
+      }
+    });
+  }
+  async startWorker() {
+    this.spawned++;
+    const { Worker } = await import("node:worker_threads");
+    const path = (await import("node:path")).default;
+    ESM_ONLY: globalThis.__dirname = await (async () => {
+      {
+        const { fileURLToPath } = await import("node:url");
+        return path.dirname(fileURLToPath(import.meta.url));
+      }
+    })();
+    const worker = new Worker(path.join(__dirname, "node-worker.mjs"));
+    worker.on("message", (response) => {
+      const callback = this.callbacks.get(response.id);
+      this.callbacks.delete(response.id);
+      if (response.error) {
+        callback.reject(response.error);
+      } else {
+        callback.resolve(response.result);
+      }
+      if (this.spawned > this.threads) {
+        this.spawned--;
+        return worker.terminate();
+      } else if (this.todo.length) {
+        return worker.postMessage(this.todo.shift());
+      } else {
+        this.idle.push(worker);
+        return worker.unref();
+      }
+    });
+    worker.on("error", (error) => {
+      return console.error("Civet worker failed:", error);
+    });
+    return worker;
+  }
+  setThreads(threads1) {
+    this.threads = threads1;
+    while (this.spawned > this.threads) {
+      if (!this.idle.length) {
+        return;
+      }
+      this.spawned--;
+      this.idle.pop().terminate();
+    }
+  }
+};
+
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\main.civet.jsx
+var { SourceMap: SourceMap2 } = sourcemap_civet_exports;
 var ParseErrors = class extends Error {
   name = "ParseErrors";
   errors;
@@ -20864,7 +21037,21 @@ var uncacheable = /* @__PURE__ */ new Set([
   "RestoreNewlineBinaryOp",
   "RestorePipeline"
 ]);
+var workerPool;
 function compile(src, options) {
+  if (!(process.env.CIVET_THREADS == 0)) {
+    const threads = parseInt(options?.threads ?? process.env.CIVET_THREADS, 10);
+    if (threads === 0) {
+      workerPool?.setThreads(0);
+    } else if (!isNaN(threads) && threads > 0 && !options.sync) {
+      if (workerPool != null) {
+        workerPool.setThreads(threads);
+      } else {
+        workerPool = new WorkerPool(threads);
+      }
+      return workerPool.run("compile", src, { ...options, threads: 0 });
+    }
+  }
   if (!options) {
     options = {};
   } else {
@@ -20946,7 +21133,7 @@ ${counts}`;
     }
     if (options.sourceMap || options.inlineMap) {
       options.sourceMap = SourceMap2(src);
-      const code = generate_default(ast2, options);
+      const code = generate_civet_default(ast2, options);
       checkErrors();
       if (options.inlineMap) {
         return SourceMap2.remap(code, options.sourceMap, filename2, filename2 + ".tsx");
@@ -20957,11 +21144,11 @@ ${counts}`;
         };
       }
     }
-    const result = generate_default(ast2, options);
+    const result = generate_civet_default(ast2, options);
     if (options.errors?.length) {
       delete options.errors;
       options.sourceMap = SourceMap2(src);
-      generate_default(ast2, options);
+      generate_civet_default(ast2, options);
       checkErrors();
     }
     return result;
@@ -21040,19 +21227,19 @@ var makeCache = function({ hits, trace } = {}) {
 var isCompileError = function(err) {
   return err instanceof import_lib2.ParseError || err instanceof ParseErrors;
 };
-var main_default = { parse, parseProgram, ParseError: import_lib2.ParseError, ParseErrors, generate: generate_default, sourcemap: sourcemap_exports, SourceMap: SourceMap2, compile, isCompileError };
+var main_civet_default = { parse, parseProgram, ParseError: import_lib2.ParseError, ParseErrors, generate: generate_civet_default, sourcemap: sourcemap_civet_exports, SourceMap: SourceMap2, compile, isCompileError };
 var export_ParseError = import_lib2.ParseError;
 export {
   export_ParseError as ParseError,
   ParseErrors,
   SourceMap2 as SourceMap,
   compile,
-  main_default as default,
-  generate_default as generate,
+  main_civet_default as default,
+  generate_civet_default as generate,
   isCompileError,
-  lib_exports as lib,
+  lib_civet_exports as lib,
   parse,
   parseProgram,
   prune,
-  sourcemap_exports as sourcemap
+  sourcemap_civet_exports as sourcemap
 };