@danielx/civet 0.6.3 → 0.6.4

package/dist/main.mjs

@@ -28,6 +28,119 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var require_lib = __commonJS({
   "source/lib.js"(exports, module) {
     "use strict";
+    function addParentPointers(node, parent) {
+      if (node == null)
+        return;
+      if (typeof node !== "object")
+        return;
+      if (Array.isArray(node)) {
+        for (const child of node) {
+          addParentPointers(child, parent);
+        }
+        return;
+      }
+      node.parent = parent;
+      if (node.children) {
+        for (const child of node.children) {
+          addParentPointers(child, node);
+        }
+      }
+    }
+    function addPostfixStatement(statement, ws, post) {
+      let children, expressions;
+      if (post.blockPrefix?.length) {
+        let indent = post.blockPrefix[0][0];
+        expressions = [...post.blockPrefix, [indent, statement]];
+        children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
+      } else {
+        expressions = [["", statement]];
+        children = [" { ", ...expressions, " }"];
+      }
+      const block = {
+        type: "BlockStatement",
+        children,
+        expressions
+      };
+      children = [...post.children];
+      children.push(block);
+      if (!isWhitespaceOrEmpty(ws))
+        children.push(ws);
+      post = { ...post, children, block };
+      if (post.type === "IfStatement") {
+        post.then = block;
+      }
+      return post;
+    }
+    function adjustAtBindings(statements, asThis = false) {
+      gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
+        const { ref } = binding;
+        if (asThis) {
+          const atBinding = binding.binding;
+          atBinding.children.pop();
+          atBinding.type = void 0;
+          binding.children.unshift(ref.id, ": this.", ref.base);
+          binding.type = "Property";
+          binding.ref = void 0;
+          return;
+        }
+        if (ref.names[0] !== ref.base) {
+          binding.children.unshift(ref.base, ": ");
+        }
+      });
+    }
+    function adjustBindingElements(elements) {
+      const names = elements.flatMap((p) => p.names || []), { length } = elements;
+      let blockPrefix, restIndex = -1, restCount = 0;
+      elements.forEach(({ type }, i) => {
+        if (type === "BindingRestElement") {
+          if (restIndex < 0)
+            restIndex = i;
+          restCount++;
+        }
+      });
+      if (restCount === 0) {
+        return {
+          children: elements,
+          names,
+          blockPrefix,
+          length
+        };
+      } else if (restCount === 1) {
+        const rest = elements[restIndex];
+        const after = elements.slice(restIndex + 1);
+        const restIdentifier = rest.binding.ref || rest.binding;
+        names.push(...rest.names || []);
+        let l = after.length;
+        if (l) {
+          if (arrayElementHasTrailingComma(after[l - 1]))
+            l++;
+          blockPrefix = {
+            type: "PostRestBindingElements",
+            children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", l.toString(), ")"],
+            names: after.flatMap((p) => p.names)
+          };
+        }
+        return {
+          names,
+          children: [...elements.slice(0, restIndex), {
+            ...rest,
+            children: rest.children.slice(0, -1)
+          }],
+          blockPrefix,
+          length
+        };
+      }
+      const err = {
+        type: "Error",
+        children: ["Multiple rest elements in array pattern"]
+      };
+      return {
+        names,
+        children: [...elements, err],
+        blockPrefix,
+        length
+      };
+    }
     function aliasBinding(p, ref) {
       if (p.type === "Identifier") {
         p.children[0] = ref;
@@ -51,6 +164,13 @@ var require_lib = __commonJS({
       }
       return false;
     }
+    var assert = {
+      equal(a, b, msg) {
+        if (a !== b) {
+          throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`);
+        }
+      }
+    };
     function blockWithPrefix(prefixStatements, block) {
       if (prefixStatements && prefixStatements.length) {
         const indent = getIndent(block.expressions[0]);
@@ -81,6 +201,126 @@ var require_lib = __commonJS({
       removeParentPointers(node);
       return deepCopy(node);
     }
+    function constructInvocation(fn, arg) {
+      const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
+      let expr = fn.expr;
+      while (expr.type === "ParenthesizedExpression") {
+        expr = expr.expression;
+      }
+      if (expr.ampersandBlock) {
+        const { ref, body } = expr;
+        ref.type = "PipedExpression";
+        ref.children = [makeLeftHandSideExpression(arg)];
+        return {
+          type: "UnwrappedExpression",
+          children: [skipIfOnlyWS(fn.leadingComment), ...body, skipIfOnlyWS(fn.trailingComment)]
+        };
+      }
+      expr = fn.expr;
+      const lhs = makeLeftHandSideExpression(expr);
+      let comment = skipIfOnlyWS(fn.trailingComment);
+      if (comment)
+        lhs.children.splice(2, 0, comment);
+      comment = skipIfOnlyWS(fn.leadingComment);
+      if (comment)
+        lhs.children.splice(1, 0, comment);
+      switch (arg.type) {
+        case "CommaExpression":
+          arg = makeLeftHandSideExpression(arg);
+          break;
+      }
+      return {
+        type: "CallExpression",
+        children: [lhs, "(", arg, ")"]
+      };
+    }
+    function constructPipeStep(fn, arg, returning) {
+      const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(skipIfOnlyWS), " ", arg];
+      switch (fn.expr.token) {
+        case "yield":
+        case "await":
+          if (returning) {
+            return [
+              children,
+              returning
+            ];
+          }
+          return [
+            children,
+            null
+          ];
+        case "return":
+          return [{
+            type: "ReturnStatement",
+            children
+          }, null];
+      }
+      if (returning) {
+        return [
+          constructInvocation(fn, arg),
+          returning
+        ];
+      }
+      return [constructInvocation(fn, arg), null];
+    }
+    var initialSpacingRe = /^(?:\r?\n|\n)*((?:\r?\n|\n)\s+)/;
+    function dedentBlockString({ $loc, token: str }, spacing, trim = true) {
+      if (spacing == null)
+        spacing = str.match(initialSpacingRe);
+      if (spacing) {
+        str = str.replaceAll(spacing[1], "\n");
+        const l = spacing.length;
+        $loc.pos += l;
+        $loc.length -= l;
+      }
+      if (trim) {
+        str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "");
+      }
+      str = str.replace(/(\\.|`|\$\{)/g, (s) => {
+        if (s[0] === "\\") {
+          return s;
+        }
+        return `\\${s}`;
+      });
+      return {
+        $loc,
+        token: str
+      };
+    }
+    function dedentBlockSubstitutions($0) {
+      const [s, strWithSubstitutions, e] = $0;
+      if (strWithSubstitutions.length === 0) {
+        return $0;
+      }
+      let initialSpacing, i = 0, l = strWithSubstitutions.length, results = [s];
+      const { token } = strWithSubstitutions[0];
+      if (token) {
+        initialSpacing = token.match(initialSpacingRe);
+      } else {
+        initialSpacing = false;
+      }
+      while (i < l) {
+        let segment = strWithSubstitutions[i];
+        if (segment.token) {
+          segment = dedentBlockString(segment, initialSpacing, false);
+          if (i === 0) {
+            segment.token = segment.token.replace(/^(\r?\n|\n)/, "");
+          }
+          if (i === l - 1) {
+            segment.token = segment.token.replace(/(\r?\n|\n)[ \t]*$/, "");
+          }
+          results.push(segment);
+        } else {
+          results.push(segment);
+        }
+        i++;
+      }
+      results.push(e);
+      return {
+        type: "TemplateLiteral",
+        children: results
+      };
+    }
     function deepCopy(node) {
       if (node == null)
         return node;
@@ -95,6 +335,356 @@ var require_lib = __commonJS({
         })
       );
     }
+    function expressionizeIfClause(clause, b, e) {
+      const children = clause.children.slice(1);
+      children.push("?", b);
+      if (e) {
+        children.push(e[0], ":", ...e.slice(2));
+      } else {
+        children.push(":void 0");
+      }
+      return {
+        type: "IfExpression",
+        children
+      };
+    }
+    function expressionizeIteration(exp) {
+      const i = exp.children.indexOf(exp.block);
+      if (exp.subtype === "DoStatement") {
+        insertReturn(exp.block);
+        exp.children.splice(i, 1, ...wrapIIFE(exp.children, exp.async));
+        return;
+      }
+      const resultsRef = {
+        type: "Ref",
+        base: "results",
+        id: "results"
+      };
+      insertPush(exp.block, resultsRef);
+      exp.children.splice(
+        i,
+        1,
+        wrapIIFE([
+          "const ",
+          resultsRef,
+          "=[];",
+          ...exp.children,
+          "; return ",
+          resultsRef
+        ], exp.async)
+      );
+    }
+    function processBinaryOpExpression($0) {
+      const expandedOps = expandChainedComparisons($0);
+      let i = 2;
+      while (i < expandedOps.length) {
+        const op = expandedOps[i];
+        if (op.special) {
+          let [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
+          if (op2.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
+            a = ["typeof ", makeLeftHandSideExpression(a)];
+            if (op2.negated) {
+              op2 = { ...op2, token: "!==", negated: false };
+            } else {
+              op2 = { ...op2, token: "===" };
+            }
+          }
+          if (op2.asConst) {
+            a = makeAsConst(a);
+            b = makeAsConst(b);
+          }
+          let children;
+          if (op2.call) {
+            wsOp = insertTrimmingSpace(wsOp, "");
+            if (op2.reversed) {
+              wsB = insertTrimmingSpace(wsB, "");
+              children = [wsOp, op2.call, "(", wsB, b, ", ", a, ")", op2.suffix];
+            } else {
+              children = [wsOp, op2.call, "(", a, ",", wsB, b, ")", op2.suffix];
+            }
+          } else if (op2.method) {
+            wsOp = insertTrimmingSpace(wsOp, "");
+            wsB = insertTrimmingSpace(wsB, "");
+            if (op2.reversed) {
+              children = [wsB, b, wsOp, ".", op2.method, "(", a, ")"];
+            } else {
+              children = [a, wsOp, ".", op2.method, "(", wsB, b, ")"];
+            }
+          } else if (op2.token) {
+            children = [a, wsOp, op2, wsB, b];
+            if (op2.negated)
+              children = ["(", ...children, ")"];
+          } else {
+            throw new Error("Unknown operator: " + JSON.stringify(op2));
+          }
+          if (op2.negated)
+            children.unshift("!");
+          expandedOps.splice(i - 2, 5, {
+            children
+          });
+        } else {
+          i += 4;
+        }
+      }
+      return expandedOps;
+    }
+    function processCallMemberExpression(node) {
+      const { children } = node;
+      for (let i = 0; i < children.length; i++) {
+        const glob = children[i];
+        if (glob?.type === "PropertyGlob") {
+          const prefix = children.slice(0, i).concat(glob.dot);
+          const parts = [];
+          for (const part of glob.object.properties) {
+            if (part.type === "MethodDefinition") {
+              throw new Error("Glob pattern cannot have method definition");
+            }
+            if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
+              throw new Error("Glob pattern must have call or member expression value");
+            }
+            let value = part.value ?? part.name;
+            const wValue = getTrimmingSpace(part.value);
+            value = prefix.concat(insertTrimmingSpace(value, ""));
+            if (wValue)
+              value.unshift(wValue);
+            if (part.type === "SpreadProperty") {
+              parts.push({
+                type: part.type,
+                value,
+                dots: part.dots,
+                delim: part.delim,
+                names: part.names,
+                children: part.children.slice(0, 2).concat(value, part.delim)
+              });
+            } else {
+              parts.push({
+                type: part.type === "Identifier" ? "Property" : part.type,
+                name: part.name,
+                value,
+                delim: part.delim,
+                names: part.names,
+                children: [
+                  isWhitespaceOrEmpty(part.children[0]) && part.children[0],
+                  part.name,
+                  isWhitespaceOrEmpty(part.children[2]) && part.children[2],
+                  part.children[3]?.token === ":" ? part.children[3] : ":",
+                  value,
+                  part.delim
+                ]
+              });
+            }
+          }
+          const object = {
+            type: "ObjectExpression",
+            children: [
+              glob.object.children[0],
+              ...parts,
+              glob.object.children.at(-1)
+            ],
+            properties: parts
+          };
+          if (i === children.length - 1)
+            return object;
+          return processCallMemberExpression({
+            ...node,
+            children: [object, ...children.slice(i + 1)]
+          });
+        } else if (glob?.type === "PropertyBind") {
+          const prefix = children.slice(0, i);
+          return processCallMemberExpression({
+            ...node,
+            children: [
+              prefix,
+              {
+                ...glob,
+                type: "PropertyAccess",
+                children: [...glob.children, ".bind(", prefix, ")"]
+              },
+              ...children.slice(i + 1)
+            ]
+          });
+        }
+      }
+      return node;
+    }
+    function wrapIterationReturningResults(statement, outerRef) {
+      if (statement.type === "DoStatement") {
+        if (outerRef) {
+          insertPush(statement.block, outerRef);
+        } else {
+          insertReturn(statement.block);
+        }
+        return;
+      }
+      const resultsRef = {
+        type: "Ref",
+        base: "results",
+        id: "results"
+      };
+      const declaration = {
+        type: "Declaration",
+        children: ["const ", resultsRef, "=[];"]
+      };
+      insertPush(statement.block, resultsRef);
+      statement.children.unshift(declaration);
+      if (outerRef) {
+        statement.children.push(";", outerRef, ".push(", resultsRef, ");");
+      } else {
+        statement.children.push(";return ", resultsRef, ";");
+      }
+    }
+    function insertPush(node, ref) {
+      if (!node)
+        return;
+      switch (node.type) {
+        case "BlockStatement":
+          if (node.expressions.length) {
+            const last = node.expressions[node.expressions.length - 1];
+            insertPush(last, ref);
+          } else {
+            node.expressions.push([ref, ".push(void 0);"]);
+          }
+          return;
+        case "CaseBlock":
+          node.clauses.forEach((clause) => {
+            insertPush(clause, ref);
+          });
+          return;
+        case "WhenClause":
+          insertPush(node.block, ref);
+          return;
+        case "DefaultClause":
+          insertPush(node.block, ref);
+          return;
+      }
+      if (!Array.isArray(node))
+        return;
+      const [, exp] = node;
+      if (!exp)
+        return;
+      const indent = getIndent(node);
+      switch (exp.type) {
+        case "BreakStatement":
+        case "ContinueStatement":
+        case "DebuggerStatement":
+        case "EmptyStatement":
+        case "ReturnStatement":
+        case "ThrowStatement":
+        case "Declaration":
+          return;
+        case "ForStatement":
+        case "IterationStatement":
+        case "DoStatement":
+          wrapIterationReturningResults(exp, ref);
+          return;
+        case "BlockStatement":
+          insertPush(exp.expressions[exp.expressions.length - 1], ref);
+          return;
+        case "IfStatement":
+          insertPush(exp.then, ref);
+          if (exp.else)
+            insertPush(exp.else[2], ref);
+          else
+            exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
+          return;
+        case "PatternMatchingStatement":
+          insertPush(exp.children[0][0], ref);
+          return;
+        case "SwitchStatement":
+          insertPush(exp.children[2], ref);
+          return;
+        case "TryStatement":
+          exp.blocks.forEach((block) => insertPush(block, ref));
+          return;
+      }
+      if (node[node.length - 1]?.type === "SemicolonDelimiter")
+        return;
+      node.splice(1, 0, ref, ".push(");
+      node.push(")");
+    }
+    function wrapWithReturn(expression) {
+      const children = expression ? ["return ", expression] : ["return"];
+      return {
+        type: "ReturnStatement",
+        children
+      };
+    }
+    function expandChainedComparisons([first, binops]) {
+      const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
+      const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
+      let results = [];
+      let i = 0;
+      let l = binops.length;
+      let start = 0;
+      let chains = [];
+      while (i < l) {
+        const [, op] = binops[i];
+        if (relationalOps.includes(op.token) || op.relational) {
+          chains.push(i);
+        } else if (lowerPrecedenceOps.includes(op.token)) {
+          processChains();
+          first = [];
+        }
+        i++;
+      }
+      processChains();
+      return results;
+      function processChains() {
+        if (chains.length > 1) {
+          chains.forEach((index, k) => {
+            if (k > 0) {
+              results.push(" ", "&&", " ");
+            }
+            const [pre, op, post, exp] = binops[index];
+            let endIndex;
+            if (k < chains.length - 1) {
+              endIndex = chains[k + 1];
+            } else {
+              endIndex = i + 1;
+            }
+            results = results.concat(first, ...binops.slice(start, endIndex));
+            first = [exp].concat(binops.slice(index + 1, endIndex));
+            start = endIndex;
+          });
+        } else {
+          results = results.concat(first, ...binops.slice(start, i + 1));
+          start = i + 1;
+        }
+        chains.length = 0;
+      }
+    }
+    function processParams(f) {
+      const { type, parameters, block } = f;
+      if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
+        parameters.tp.parameters.push(",");
+      }
+      if (!block)
+        return;
+      const { expressions } = block;
+      if (!expressions)
+        return;
+      const { blockPrefix } = parameters;
+      let indent;
+      if (!expressions.length) {
+        indent = "";
+      } else {
+        indent = expressions[0][0];
+      }
+      const [splices, thisAssignments] = gatherBindingCode(parameters, {
+        injectParamProps: f.name === "constructor"
+      });
+      const delimiter = {
+        type: "SemicolonDelimiter",
+        children: [";"]
+      };
+      const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
+        (s) => s.type ? {
+          ...s,
+          children: [indent, ...s.children, delimiter]
+        } : [indent, s, delimiter]
+      );
+      expressions.unshift(...prefix);
+    }
     function removeParentPointers(node) {
       if (node == null)
         return;
@@ -216,10 +806,123 @@ var require_lib = __commonJS({
         node.hoistDec = null;
       });
     }
+    function insertReturn(node) {
+      if (!node)
+        return;
+      switch (node.type) {
+        case "BlockStatement":
+          if (node.expressions.length) {
+            const last = node.expressions[node.expressions.length - 1];
+            insertReturn(last);
+          } else {
+            if (node.parent.type === "CatchClause") {
+              node.expressions.push(["return"]);
+            }
+          }
+          return;
+        case "WhenClause":
+          node.children.splice(node.children.indexOf(node.break), 1);
+          if (node.block.expressions.length) {
+            insertReturn(node.block);
+          } else {
+            node.block.expressions.push(wrapWithReturn());
+          }
+          return;
+        case "DefaultClause":
+          insertReturn(node.block);
+          return;
+      }
+      if (!Array.isArray(node))
+        return;
+      const [, exp, semi] = node;
+      if (semi?.type === "SemicolonDelimiter")
+        return;
+      let indent = getIndent(node);
+      if (!exp)
+        return;
+      switch (exp.type) {
+        case "BreakStatement":
+        case "ContinueStatement":
+        case "DebuggerStatement":
+        case "EmptyStatement":
+        case "ReturnStatement":
+        case "ThrowStatement":
+        case "Declaration":
+          return;
+        case "ForStatement":
+        case "IterationStatement":
+        case "DoStatement":
+          wrapIterationReturningResults(exp);
+          return;
+        case "BlockStatement":
+          insertReturn(exp.expressions[exp.expressions.length - 1]);
+          return;
+        case "IfStatement":
+          insertReturn(exp.then);
+          if (exp.else)
+            insertReturn(exp.else[2]);
+          else
+            exp.children.push(["", {
+              type: "ReturnStatement",
+              children: [";return"]
+            }]);
+          return;
+        case "PatternMatchingStatement":
+          insertReturn(exp.children[0][0]);
+          return;
+        case "SwitchStatement":
+          insertSwitchReturns(exp);
+          return;
+        case "TryStatement":
+          exp.blocks.forEach((block) => insertReturn(block));
+          return;
+      }
+      if (node[node.length - 1]?.type === "SemicolonDelimiter")
+        return;
+      const returnStatement = wrapWithReturn(node[1]);
+      node.splice(1, 1, returnStatement);
+    }
+    function insertSwitchReturns(exp) {
+      switch (exp.type) {
+        case "SwitchStatement":
+          exp.caseBlock.clauses.forEach((clause) => {
+            insertReturn(clause);
+          });
+          return;
+        case "SwitchExpression":
+          exp.caseBlock.clauses.forEach(insertReturn);
+          return;
+      }
+    }
+    function isEmptyBareBlock(node) {
+      if (node?.type !== "BlockStatement")
+        return false;
+      const { bare, expressions } = node;
+      return bare && (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
+    }
     function isFunction(node) {
       const { type } = node;
       return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || node.async;
     }
+    function isVoidType(t) {
+      return t?.type === "LiteralType" && t.t.type === "VoidType";
+    }
+    function isWhitespaceOrEmpty(node) {
+      if (!node)
+        return true;
+      if (node.type === "Ref")
+        return false;
+      if (node.token)
+        return node.token.match(/^\s*$/);
+      if (node.children)
+        node = node.children;
+      if (!node.length)
+        return true;
+      if (typeof node === "string")
+        return node.match(/^\s*$/);
+      if (Array.isArray(node))
+        return node.every(isWhitespaceOrEmpty);
+    }
     function gatherRecursiveWithinFunction(node, predicate) {
       return gatherRecursive(node, predicate, isFunction);
     }
@@ -256,62 +959,6 @@ var require_lib = __commonJS({
       if (target.token)
         return target.token.match(/^ ?/)[0];
     }
-    function needsRef(exp) {
-      switch (exp.type) {
-        case "Identifier":
-        case "Literal":
-        case "Ref":
-          return false;
-        default:
-          return true;
-      }
-    }
-    function maybeRef(exp, base = "ref") {
-      if (!needsRef(exp))
-        return exp;
-      return {
-        type: "Ref",
-        base,
-        id: base
-      };
-    }
-    function literalValue(literal) {
-      let { raw } = literal;
-      switch (raw) {
-        case "null":
-          return null;
-        case "true":
-          return true;
-        case "false":
-          return false;
-      }
-      if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-        return raw.slice(1, -1);
-      }
-      const numeric = literal.children.find(
-        (child) => child.type === "NumericLiteral"
-      );
-      if (numeric) {
-        raw = raw.replace(/_/g, "");
-        const { token } = numeric;
-        if (token.endsWith("n")) {
-          return BigInt(raw.slice(0, -1));
-        } else if (token.match(/[\.eE]/)) {
-          return parseFloat(raw);
-        } else if (token.startsWith("0")) {
-          switch (token.charAt(1).toLowerCase()) {
-            case "x":
-              return parseInt(raw.replace(/0[xX]/, ""), 16);
-            case "b":
-              return parseInt(raw.replace(/0[bB]/, ""), 2);
-            case "o":
-              return parseInt(raw.replace(/0[oO]/, ""), 8);
-          }
-        }
-        return parseInt(raw, 10);
-      }
-      throw new Error("Unrecognized literal " + JSON.stringify(literal));
-    }
     function forRange(open, forDeclaration, range, stepExp, close) {
       const { start, end, inclusive } = range;
       const counterRef = {
@@ -399,6 +1046,79 @@ var require_lib = __commonJS({
       insertRestSplices(statements, splices, thisAssignments);
       return [splices, thisAssignments];
     }
+    function literalValue(literal) {
+      let { raw } = literal;
+      switch (raw) {
+        case "null":
+          return null;
+        case "true":
+          return true;
+        case "false":
+          return false;
+      }
+      if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+        return raw.slice(1, -1);
+      }
+      const numeric = literal.children.find(
+        (child) => child.type === "NumericLiteral"
+      );
+      if (numeric) {
+        raw = raw.replace(/_/g, "");
+        const { token } = numeric;
+        if (token.endsWith("n")) {
+          return BigInt(raw.slice(0, -1));
+        } else if (token.match(/[\.eE]/)) {
+          return parseFloat(raw);
+        } else if (token.startsWith("0")) {
+          switch (token.charAt(1).toLowerCase()) {
+            case "x":
+              return parseInt(raw.replace(/0[xX]/, ""), 16);
+            case "b":
+              return parseInt(raw.replace(/0[bB]/, ""), 2);
+            case "o":
+              return parseInt(raw.replace(/0[oO]/, ""), 8);
+          }
+        }
+        return parseInt(raw, 10);
+      }
+      throw new Error("Unrecognized literal " + JSON.stringify(literal));
+    }
+    var asConst = {
+      ts: true,
+      children: [" as const"]
+    };
+    function makeAsConst(node) {
+      if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
+        return { ...node, children: [...node.children, asConst] };
+      }
+      return node;
+    }
+    function makeLeftHandSideExpression(expression) {
+      switch (expression.type) {
+        case "Ref":
+        case "Identifier":
+        case "Literal":
+        case "CallExpression":
+        case "MemberExpression":
+        case "ParenthesizedExpression":
+          return expression;
+        default:
+          return {
+            type: "ParenthesizedExpression",
+            children: ["(", expression, ")"],
+            expression
+          };
+      }
+    }
+    function maybeRef(exp, base = "ref") {
+      if (!needsRef(exp))
+        return exp;
+      return {
+        type: "Ref",
+        base,
+        id: base
+      };
+    }
     function modifyString(str) {
       return str.replace(/(^.?|[^\\]{2})(\\\\)*\n/g, "$1$2\\n");
     }
@@ -486,6 +1206,20 @@ var require_lib = __commonJS({
       }
       return parts;
     }
+    function needsRef(expression, base = "ref") {
+      switch (expression.type) {
+        case "Ref":
+        case "Identifier":
+        case "Literal":
+          return;
+        default:
+          return {
+            type: "Ref",
+            base,
+            id: base
+          };
+      }
+    }
     function processCoffeeInterpolation(s, parts, e, $loc) {
       if (parts.length === 0 || parts.length === 1 && parts[0].token != null) {
         return {
@@ -574,55 +1308,914 @@ var require_lib = __commonJS({
         thisAssignments
       };
     }
-    function processUnaryExpression(pre, exp, post) {
-      if (!(pre.length || post))
-        return exp;
-      if (post?.token === "?") {
-        post = {
-          $loc: post.$loc,
-          token: " != null"
-        };
+    function processFunctions(statements, config) {
+      gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
+        processParams(f);
+        if (!processReturnValue(f) && config.implicitReturns) {
+          const { block, returnType } = f;
+          const isVoid = isVoidType(returnType?.t);
+          const isBlock = block?.type === "BlockStatement";
+          if (!isVoid && isBlock) {
+            insertReturn(block);
+          }
+        }
+      });
+      gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
+        processParams(f);
+        if (!processReturnValue(f) && config.implicitReturns) {
+          const { signature, block } = f;
+          const isConstructor = signature.name === "constructor";
+          const isVoid = isVoidType(signature.returnType?.t);
+          const isSet = signature.modifier?.set;
+          if (!isConstructor && !isSet && !isVoid) {
+            insertReturn(block);
+          }
+        }
+      });
+    }
+    function processSwitchExpressions(statements) {
+      gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(insertSwitchReturns);
+    }
+    function processTryExpressions(statements) {
+      gatherRecursiveAll(statements, (n) => n.type === "TryExpression").forEach(({ blocks }) => {
+        blocks.forEach(insertReturn);
+      });
+    }
+    function processBindingPatternLHS(lhs, tail) {
+      adjustAtBindings(lhs, true);
+      const [splices, thisAssignments] = gatherBindingCode(lhs);
+      tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
+    }
+    function processAssignments(statements) {
+      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
+        let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
+        if ($1.some((left) => left[left.length - 1].special)) {
+          if ($1.length !== 1) {
+            throw new Error("Only one assignment with id= is allowed");
+          }
+          const [, lhs, , op] = $1[0];
+          const { call } = op;
+          op[op.length - 1] = "=";
+          $2 = [call, "(", lhs, ", ", $2, ")"];
+        }
+        let wrapped = false;
+        while (i < len) {
+          const lastAssignment = $1[i++];
+          const [, lhs, , op] = lastAssignment;
+          if (op.token !== "=")
+            continue;
+          if (lhs.type === "ObjectExpression" || lhs.type === "ObjectBindingPattern") {
+            if (!wrapped) {
+              wrapped = true;
+              lhs.children.splice(0, 0, "(");
+              tail.push(")");
+            }
+          }
+        }
+        i = len - 1;
+        while (i >= 0) {
+          const lastAssignment = $1[i];
+          if (lastAssignment[3].token === "=") {
+            const lhs = lastAssignment[1];
+            if (lhs.type === "MemberExpression") {
+              const members = lhs.children;
+              const lastMember = members[members.length - 1];
+              if (lastMember.type === "SliceExpression") {
+                const { start, end, children: c } = lastMember;
+                c[0].token = ".splice(";
+                c[1] = start;
+                c[2] = ", ";
+                if (end)
+                  c[3] = [end, " - ", start];
+                else
+                  c[3] = ["1/0"];
+                c[4] = [", ...", $2];
+                c[5] = ")";
+                lastAssignment.pop();
+                if (isWhitespaceOrEmpty(lastAssignment[2]))
+                  lastAssignment.pop();
+                if ($1.length > 1) {
+                  throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
+                }
+                exp.children = [$1];
+                exp.names = [];
+                return;
+              }
+            } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
+              processBindingPatternLHS(lhs, tail);
+            }
+          }
+          i--;
+        }
+        const names = $1.flatMap(([, l]) => l.names || []);
+        exp.children = [$1, $2, ...tail];
+        exp.names = names;
+      });
+      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
+        function extractAssignment(lhs) {
+          let expr = lhs;
+          while (expr.type === "ParenthesizedExpression") {
+            expr = expr.expression;
+          }
+          if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
+            if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
+              post.push([", ", lhs]);
+            } else {
+              pre.push([lhs, ", "]);
+            }
+            return expr.assigned;
+          }
+        }
+        const pre = [], post = [];
         switch (exp.type) {
-          case "Identifier":
+          case "AssignmentExpression":
+            if (!exp.lhs)
+              return;
+            exp.lhs.forEach((lhsPart, i) => {
+              let newLhs2 = extractAssignment(lhsPart[1]);
+              if (newLhs2) {
+                lhsPart[1] = newLhs2;
+              }
+            });
+            break;
+          case "UpdateExpression":
+            let newLhs = extractAssignment(exp.assigned);
+            if (newLhs) {
+              const i = exp.children.indexOf(exp.assigned);
+              exp.assigned = exp.children[i] = newLhs;
+            }
+            break;
+        }
+        if (pre.length)
+          exp.children.unshift(...pre);
+        if (post.length)
+          exp.children.push(...post);
+      });
+    }
+    function attachPostfixStatementAsExpression(exp, post) {
+      let clause;
+      switch (post[1].type) {
+        case "ForStatement":
+        case "IterationStatement":
+        case "DoStatement":
+          clause = addPostfixStatement(exp, ...post);
+          return {
+            type: "IterationExpression",
+            children: [clause],
+            block: clause.block
+          };
+        case "IfStatement":
+          clause = expressionizeIfClause(post[1], exp);
+          return clause;
+        default:
+          throw new Error("Unknown postfix statement");
+      }
+    }
+    function getPatternConditions(pattern, ref, conditions) {
+      if (pattern.rest)
+        return;
+      switch (pattern.type) {
+        case "ArrayBindingPattern": {
+          const { elements, length } = pattern, hasRest = elements.some((e) => e.rest), comparator = hasRest ? " >= " : " === ", l = [comparator, (length - hasRest).toString()];
+          conditions.push(
+            ["Array.isArray(", ref, ")"],
+            [ref, ".length", l]
+          );
+          elements.forEach(({ children: [, e] }, i) => {
+            const subRef = [ref, "[", i.toString(), "]"];
+            getPatternConditions(e, subRef, conditions);
+          });
+          const postRest = pattern.children.find((c) => c?.blockPrefix);
+          if (postRest) {
+            const postElements = postRest.blockPrefix.children[1], { length: postLength } = postElements;
+            postElements.forEach(({ children: [, e] }, i) => {
+              const subRef = [ref, "[", ref, ".length - ", (postLength + i).toString(), "]"];
+              getPatternConditions(e, subRef, conditions);
+            });
+          }
+          break;
+        }
+        case "ObjectBindingPattern": {
+          conditions.push(
+            ["typeof ", ref, " === 'object'"],
+            [ref, " != null"]
+          );
+          pattern.properties.forEach((p) => {
+            switch (p.type) {
+              case "PinProperty":
+              case "BindingProperty": {
+                const { name, value } = p;
+                let subRef;
+                switch (name.type) {
+                  case "ComputedPropertyName":
+                    conditions.push([name.expression, " in ", ref]);
+                    subRef = [ref, name];
+                    break;
+                  case "Literal":
+                  case "StringLiteral":
+                  case "NumericLiteral":
+                    conditions.push([name, " in ", ref]);
+                    subRef = [ref, "[", name, "]"];
+                    break;
+                  default:
+                    conditions.push(["'", name, "' in ", ref]);
+                    subRef = [ref, ".", name];
+                }
+                if (value) {
+                  getPatternConditions(value, subRef, conditions);
+                }
+                break;
+              }
+            }
+          });
+          break;
+        }
+        case "ConditionFragment":
+          conditions.push(
+            [ref, " ", pattern.children]
+          );
+          break;
+        case "RegularExpressionLiteral": {
+          conditions.push(
+            ["typeof ", ref, " === 'string'"],
+            [pattern, ".test(", ref, ")"]
+          );
+          break;
+        }
+        case "PinPattern":
+          conditions.push([
+            ref,
+            " === ",
+            pattern.identifier
+          ]);
+          break;
+        case "Literal":
+          conditions.push([
+            ref,
+            " === ",
+            pattern
+          ]);
+          break;
+        default:
+          break;
+      }
+    }
+    function elideMatchersFromArrayBindings(elements) {
+      return elements.map((el) => {
+        if (el.type === "BindingRestElement") {
+          return ["", el, void 0];
+        }
+        const { children: [ws, e, sep] } = el;
+        switch (e.type) {
           case "Literal":
-            return {
-              ...exp,
-              children: [...pre, ...exp.children, post]
-            };
+          case "RegularExpressionLiteral":
+          case "StringLiteral":
+          case "PinPattern":
+            return sep;
           default:
-            const expression = {
-              ...exp,
-              children: [...pre, "(", exp.children, ")", post]
-            };
-            return {
-              type: "ParenthesizedExpression",
-              children: ["(", expression, ")"],
-              expression
-            };
+            return [ws, nonMatcherBindings(e), sep];
         }
-      }
-      if (exp.type === "Literal") {
-        if (pre.length === 1 && pre[0].token === "-") {
-          const children = [pre[0], ...exp.children];
-          if (post)
-            exp.children.push(post);
+      });
+    }
+    function elideMatchersFromPropertyBindings(properties) {
+      return properties.map((p) => {
+        switch (p.type) {
+          case "BindingProperty": {
+            const { children, name, value } = p;
+            const [ws] = children;
+            const sep = children[children.length - 1];
+            switch (value && value.type) {
+              case "ArrayBindingPattern":
+              case "ObjectBindingPattern":
+                return {
+                  ...p,
+                  children: [ws, name, ": ", nonMatcherBindings(value)]
+                };
+              case "Identifier":
+                return p;
+              case "Literal":
+              case "RegularExpressionLiteral":
+              case "StringLiteral":
+              default:
+                return {
+                  ...p,
+                  children: [ws, name, sep]
+                };
+            }
+          }
+          case "PinProperty":
+          case "BindingRestProperty":
+          default:
+            return p;
+        }
+      });
+    }
+    function nonMatcherBindings(pattern) {
+      switch (pattern.type) {
+        case "ArrayBindingPattern": {
+          const elements = elideMatchersFromArrayBindings(pattern.elements);
+          const children = ["[", elements, "]"];
           return {
-            type: "Literal",
+            ...pattern,
             children,
-            raw: `-${exp.raw}`
+            elements
           };
         }
-      }
-      const l = pre.length;
-      if (l) {
-        const last = pre[l - 1];
-        if (last.type === "Await" && last.op) {
-          if (exp.type !== "ParenthesizedExpression") {
-            exp = ["(", exp, ")"];
-          }
-          exp = {
-            type: "CallExpression",
-            children: [" Promise", last.op, exp]
+        case "PostRestBindingElements": {
+          const els = elideMatchersFromArrayBindings(pattern.children[1]);
+          return {
+            ...pattern,
+            children: [
+              pattern.children[0],
+              els,
+              ...pattern.children.slice(2)
+            ]
+          };
+        }
+        case "ObjectBindingPattern":
+          return ["{", elideMatchersFromPropertyBindings(pattern.properties), "}"];
+        default:
+          return pattern;
+      }
+    }
+    function aggregateDuplicateBindings(bindings, ReservedWord) {
+      const props = gatherRecursiveAll(bindings, (n) => n.type === "BindingProperty");
+      const arrayBindings = gatherRecursiveAll(bindings, (n) => n.type === "ArrayBindingPattern");
+      arrayBindings.forEach((a) => {
+        const { elements } = a;
+        elements.forEach((element) => {
+          if (Array.isArray(element)) {
+            const [, e] = element;
+            if (e.type === "Identifier") {
+              props.push(e);
+            } else if (e.type === "BindingRestElement") {
+              props.push(e);
+            }
+          }
+        });
+      });
+      const declarations = [];
+      const propsGroupedByName = /* @__PURE__ */ new Map();
+      for (const p of props) {
+        const { name, value } = p;
+        const key = value?.name || name?.name || name;
+        if (propsGroupedByName.has(key)) {
+          propsGroupedByName.get(key).push(p);
+        } else {
+          propsGroupedByName.set(key, [p]);
+        }
+      }
+      propsGroupedByName.forEach((shared, key) => {
+        if (!key)
+          return;
+        if (ReservedWord({
+          pos: 0,
+          input: key
+        })) {
+          shared.forEach((p) => {
+            const ref = {
+              type: "Ref",
+              base: `_${key}`,
+              id: key
+            };
+            aliasBinding(p, ref);
+          });
+          return;
+        }
+        if (shared.length === 1)
+          return;
+        const refs = shared.map((p) => {
+          const ref = {
+            type: "Ref",
+            base: key,
+            id: key
+          };
+          aliasBinding(p, ref);
+          return ref;
+        });
+        declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
+          return i === 0 ? r : [", ", r];
+        }), "]"]);
+      });
+      return declarations;
+    }
+    function processPatternMatching(statements, ReservedWord) {
+      gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
+        const { caseBlock } = s;
+        const { clauses } = caseBlock;
+        let errors = false;
+        let isPattern = false;
+        if (clauses.some((c) => c.type === "PatternClause")) {
+          isPattern = true;
+          clauses.forEach((c) => {
+            if (!(c.type === "PatternClause" || c.type === "DefaultClause")) {
+              errors = true;
+              c.children.push({
+                type: "Error",
+                message: "Can't mix pattern matching and non-pattern matching clauses"
+              });
+            }
+          });
+        }
+        if (errors || !isPattern)
+          return;
+        let { expression } = s;
+        if (expression.type === "ParenthesizedExpression") {
+          expression = expression.expression;
+        }
+        let ref = needsRef(expression, "m") || expression;
+        let hoistDec = ref !== expression ? [["", ["const ", ref, " = ", expression], ";"]] : void 0;
+        let prev = [], root = prev;
+        const l = clauses.length;
+        clauses.forEach((c, i) => {
+          if (c.type === "DefaultClause") {
+            prev.push(c.block);
+            return;
+          }
+          let { patterns, block } = c;
+          let pattern = patterns[0];
+          const indent = block.expressions?.[0]?.[0] || "";
+          const alternativeConditions = patterns.map((pattern2, i2) => {
+            const conditions = [];
+            getPatternConditions(pattern2, ref, conditions);
+            return conditions;
+          });
+          const conditionExpression = alternativeConditions.map((conditions, i2) => {
+            const conditionArray = conditions.map((c2, i3) => {
+              if (i3 === 0)
+                return c2;
+              return [" && ", ...c2];
+            });
+            if (i2 === 0)
+              return conditionArray;
+            return [" || ", ...conditionArray];
+          });
+          const condition = {
+            type: "ParenthesizedExpression",
+            children: ["(", conditionExpression, ")"],
+            expression: conditionExpression
+          };
+          const prefix = [];
+          switch (pattern.type) {
+            case "ArrayBindingPattern":
+              if (pattern.length === 0)
+                break;
+            case "ObjectBindingPattern": {
+              if (pattern.properties?.length === 0)
+                break;
+              let [splices, thisAssignments] = gatherBindingCode(pattern);
+              const patternBindings = nonMatcherBindings(pattern);
+              splices = splices.map((s2) => [", ", nonMatcherBindings(s2)]);
+              thisAssignments = thisAssignments.map((a) => [indent, a, ";"]);
+              const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices], ReservedWord);
+              prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";"]);
+              prefix.push(...thisAssignments);
+              prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";"]));
+              break;
+            }
+          }
+          block.expressions.unshift(...prefix);
+          const next = [];
+          if (block.bare) {
+            block.children.unshift(" {");
+            block.children.push("}");
+            block.bare = false;
+          }
+          if (i < l - 1)
+            next.push("\n", "else ");
+          prev.push(["", {
+            type: "IfStatement",
+            children: ["if", condition, block, next],
+            then: block,
+            else: next,
+            hoistDec
+          }]);
+          hoistDec = void 0;
+          prev = next;
+        });
+        if (s.type === "SwitchExpression") {
+          insertReturn(root[0]);
+          root.splice(0, 1, wrapIIFE(root[0]));
+        }
+        s.type = "PatternMatchingStatement";
+        s.children = [root];
+        addParentPointers(s, s.parent);
+      });
+    }
+    function processPipelineExpressions(statements) {
+      gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
+        const [ws, , body] = s.children;
+        let [, arg] = s.children;
+        let i = 0, l = body.length;
+        const refDec = [];
+        const children = [ws, refDec];
+        let usingRef = null;
+        for (i = 0; i < l; i++) {
+          const step = body[i];
+          const [leadingComment, pipe, trailingComment, expr] = step;
+          const returns = pipe.token === "||>";
+          let ref, result, returning = returns ? arg : null;
+          if (pipe.token === "|>=") {
+            let initRef;
+            if (i === 0) {
+              outer:
+                switch (arg.type) {
+                  case "MemberExpression":
+                    if (arg.children.length <= 2)
+                      break;
+                  case "CallExpression":
+                    const access = arg.children.pop();
+                    switch (access.type) {
+                      case "PropertyAccess":
+                      case "SliceExpression":
+                        break;
+                      default:
+                        children.unshift({
+                          type: "Error",
+                          $loc: pipe.token.$loc,
+                          message: `Can't assign to ${access.type}`
+                        });
+                        arg.children.push(access);
+                        break outer;
+                    }
+                    usingRef = needsRef({});
+                    initRef = {
+                      type: "AssignmentExpression",
+                      children: [usingRef, " = ", arg, ","]
+                    };
+                    arg = {
+                      type: "MemberExpression",
+                      children: [usingRef, access]
+                    };
+                    break;
+                }
+              children.pop();
+              const lhs = [[
+                [refDec, initRef],
+                arg,
+                [],
+                { token: "=", children: [" = "] }
+              ]];
+              Object.assign(s, {
+                type: "AssignmentExpression",
+                children: [lhs, children],
+                names: null,
+                lhs,
+                assigned: arg,
+                exp: children
+              });
+              arg = clone(arg);
+              if (arg.children[0].type === "Ref") {
+                arg.children[0] = usingRef;
+              }
+            } else {
+              children.unshift({
+                type: "Error",
+                $loc: pipe.token.$loc,
+                message: "Can't use |>= in the middle of a pipeline"
+              });
+            }
+          } else {
+            s.children = children;
+          }
+          if (returns && (ref = needsRef(arg))) {
+            usingRef = usingRef || ref;
+            arg = {
+              type: "ParenthesizedExpression",
+              children: ["(", {
+                type: "AssignmentExpression",
+                children: [usingRef, " = ", arg]
+              }, ")"]
+            };
+            returning = usingRef;
+          }
+          [result, returning] = constructPipeStep(
+            {
+              leadingComment: skipIfOnlyWS(leadingComment),
+              trailingComment: skipIfOnlyWS(trailingComment),
+              expr
+            },
+            arg,
+            returning
+          );
+          if (result.type === "ReturnStatement") {
+            if (i < l - 1) {
+              result.children.push({
+                type: "Error",
+                message: "Can't continue a pipeline after returning"
+              });
+            }
+            arg = result;
+            if (children[children.length - 1] === ",") {
+              children.pop();
+              children.push(";");
+            }
+            break;
+          }
+          if (returning) {
+            arg = returning;
+            children.push(result, ",");
+          } else {
+            arg = result;
+          }
+        }
+        if (usingRef) {
+          refDec.unshift("let ", usingRef, ";");
+        }
+        children.push(arg);
+        addParentPointers(s, s.parent);
+      });
+    }
+    function processProgram(root, config, m, ReservedWord) {
+      assert.equal(m.forbidClassImplicitCall.length, 1, "forbidClassImplicitCall");
+      assert.equal(m.forbidIndentedApplication.length, 1, "forbidIndentedApplication");
+      assert.equal(m.forbidTrailingMemberProperty.length, 1, "forbidTrailingMemberProperty");
+      assert.equal(m.forbidMultiLineImplicitObjectLiteral.length, 1, "forbidMultiLineImplicitObjectLiteral");
+      assert.equal(m.JSXTagStack.length, 0, "JSXTagStack should be empty");
+      addParentPointers(root);
+      const { expressions: statements } = root;
+      processPipelineExpressions(statements);
+      processAssignments(statements);
+      processPatternMatching(statements, ReservedWord);
+      processFunctions(statements, config);
+      processSwitchExpressions(statements);
+      processTryExpressions(statements);
+      hoistRefDecs(statements);
+      gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
+      statements.unshift(...m.prelude);
+      if (config.autoLet) {
+        createLetDecs(statements, []);
+      } else if (config.autoVar) {
+        createVarDecs(statements, []);
+      }
+      populateRefs(statements);
+      adjustAtBindings(statements);
+    }
+    function findDecs(statements) {
+      const declarationNames = gatherNodes(statements, ({ type }) => type === "Declaration").flatMap((d) => d.names);
+      return new Set(declarationNames);
+    }
+    function populateRefs(statements) {
+      const refNodes = gatherRecursive(statements, ({ type }) => 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;
+          ref.type = "Identifier";
+          let n = 0;
+          let name = base;
+          while (names.has(name)) {
+            n++;
+            name = `${base}${n}`;
+          }
+          names.add(name);
+          ref.children = ref.names = [name];
+        });
+      }
+    }
+    function createVarDecs(statements, scopes, pushVar) {
+      function hasDec(name) {
+        return scopes.some((s) => s.has(name));
+      }
+      function findAssignments(statements2, decs2) {
+        let assignmentStatements2 = gatherNodes(statements2, (node) => {
+          return node.type === "AssignmentExpression";
+        });
+        if (assignmentStatements2.length) {
+          assignmentStatements2 = assignmentStatements2.concat(findAssignments(assignmentStatements2.map((s) => s.children), decs2));
+        }
+        return assignmentStatements2;
+      }
+      if (!pushVar) {
+        pushVar = function(name) {
+          varIds.push(name);
+          decs.add(name);
+        };
+      }
+      const decs = findDecs(statements);
+      scopes.push(decs);
+      const varIds = [];
+      const assignmentStatements = findAssignments(statements, scopes);
+      const undeclaredIdentifiers = assignmentStatements.flatMap((a) => a.names);
+      undeclaredIdentifiers.filter((x, i, a) => {
+        if (!hasDec(x))
+          return a.indexOf(x) === i;
+      }).forEach(pushVar);
+      const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
+      const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
+      const blockNodes = new Set(gatherNodes(statements, (s) => s.type === "BlockStatement"));
+      fnNodes.forEach(({ block }) => blockNodes.delete(block));
+      forNodes.forEach(({ block }) => blockNodes.delete(block));
+      blockNodes.forEach((block) => {
+        createVarDecs(block.expressions, scopes, pushVar);
+      });
+      forNodes.forEach(({ block, declaration }) => {
+        scopes.push(new Set(declaration.names));
+        createVarDecs(block.expressions, scopes, pushVar);
+        scopes.pop();
+      });
+      fnNodes.forEach(({ block, parameters }) => {
+        scopes.push(new Set(parameters.names));
+        createVarDecs(block.expressions, scopes);
+        scopes.pop();
+      });
+      if (varIds.length) {
+        const indent = getIndent(statements[0]);
+        let delimiter = ";";
+        if (statements[0][1]?.parent?.root) {
+          delimiter = ";\n";
+        }
+        statements.unshift([indent, "var ", varIds.join(", "), delimiter]);
+      }
+      scopes.pop();
+    }
+    function createLetDecs(statements, scopes) {
+      function findVarDecs(statements2, decs) {
+        const declarationNames = gatherRecursive(
+          statements2,
+          (node) => node.type === "Declaration" && node.children && node.children.length > 0 && node.children[0].token && node.children[0].token.startsWith("var") || node.type === "FunctionExpression"
+        ).filter((node) => node.type === "Declaration").flatMap((node) => node.names);
+        return new Set(declarationNames);
+      }
+      let declaredIdentifiers = findVarDecs(statements);
+      function hasDec(name) {
+        return declaredIdentifiers.has(name) || scopes.some((s) => s.has(name));
+      }
+      function gatherBlockOrOther(statement) {
+        return gatherNodes(statement, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration").flatMap((node) => {
+          if (node.type == "BlockStatement")
+            return node.bare ? gatherBlockOrOther(node.expressions) : node;
+          else if (node.children && node.children.length)
+            return [...gatherBlockOrOther(node.children), node];
+          else
+            return [];
+        });
+      }
+      let currentScope = /* @__PURE__ */ new Set();
+      scopes.push(currentScope);
+      const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
+      const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
+      let targetStatements = [];
+      for (const statement of statements) {
+        const nodes = gatherBlockOrOther(statement);
+        let undeclaredIdentifiers = [];
+        for (const node of nodes) {
+          if (node.type == "BlockStatement") {
+            let block = node;
+            let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
+            let forNode = forNodes.find((forNode2) => forNode2.block === block);
+            if (fnNode != null) {
+              scopes.push(new Set(fnNode.parameters.names));
+              createLetDecs(block.expressions, scopes);
+              scopes.pop();
+            } else if (forNode != null) {
+              scopes.push(new Set(forNode.declaration.names));
+              createLetDecs(block.expressions, scopes);
+              scopes.pop();
+            } else
+              createLetDecs(block.expressions, scopes);
+            continue;
+          }
+          if (node.names == null)
+            continue;
+          let names = node.names.filter((name) => !hasDec(name));
+          if (node.type == "AssignmentExpression")
+            undeclaredIdentifiers.push(...names);
+          names.forEach((name) => currentScope.add(name));
+        }
+        if (undeclaredIdentifiers.length > 0) {
+          let indent = statement[0];
+          let firstIdentifier = gatherNodes(statement[1], (node) => node.type == "Identifier")[0];
+          if (undeclaredIdentifiers.length == 1 && statement[1].type == "AssignmentExpression" && statement[1].names.length == 1 && statement[1].names[0] == undeclaredIdentifiers[0] && firstIdentifier && firstIdentifier.names == undeclaredIdentifiers[0] && gatherNodes(statement[1], (node) => node.type === "ObjectBindingPattern").length == 0)
+            statement[1].children.unshift(["let "]);
+          else {
+            let tail = "\n";
+            if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0)
+              tail = void 0;
+            targetStatements.push([indent, "let ", undeclaredIdentifiers.join(", "), tail]);
+          }
+        }
+        targetStatements.push(statement);
+      }
+      scopes.pop();
+      statements.splice(0, statements.length, targetStatements);
+    }
+    function processReturnValue(func) {
+      const { block } = func;
+      const values = gatherRecursiveWithinFunction(
+        block,
+        ({ type }) => type === "ReturnValue"
+      );
+      if (!values.length)
+        return false;
+      const ref = {
+        type: "Ref",
+        base: "ret",
+        id: "ret"
+      };
+      let declared;
+      values.forEach((value) => {
+        value.children = [ref];
+        const ancestor = findAncestor(
+          value,
+          ({ type }) => type === "Declaration",
+          isFunction
+        );
+        if (ancestor)
+          declared = true;
+      });
+      if (!declared) {
+        let returnType = func.returnType ?? func.signature?.returnType;
+        if (returnType) {
+          const { t } = returnType;
+          if (t.type === "TypePredicate") {
+            returnType = ": boolean";
+          } else if (t.type === "AssertsType") {
+            returnType = void 0;
+          }
+        }
+        block.expressions.unshift([
+          getIndent(block.expressions[0]),
+          {
+            type: "Declaration",
+            children: ["let ", ref, returnType],
+            names: []
+          },
+          ";"
+        ]);
+      }
+      gatherRecursiveWithinFunction(
+        block,
+        (r) => r.type === "ReturnStatement" && !r.expression
+      ).forEach((r) => {
+        r.expression = ref;
+        r.children.splice(-1, 1, " ", ref);
+      });
+      if (block.children.at(-2)?.type !== "ReturnStatement") {
+        block.expressions.push([
+          [getIndent(block.expressions.at(-1))],
+          {
+            type: "ReturnStatement",
+            expression: ref,
+            children: ["return ", ref]
+          }
+        ]);
+      }
+      return true;
+    }
+    function processUnaryExpression(pre, exp, post) {
+      if (!(pre.length || post))
+        return exp;
+      if (post?.token === "?") {
+        post = {
+          $loc: post.$loc,
+          token: " != null"
+        };
+        switch (exp.type) {
+          case "Identifier":
+          case "Literal":
+          case "AmpersandRef":
+            return {
+              ...exp,
+              children: [...pre, ...exp.children, post]
+            };
+          default:
+            const expression = {
+              ...exp,
+              children: [...pre, "(", exp.children, ")", post]
+            };
+            return {
+              type: "ParenthesizedExpression",
+              children: ["(", expression, ")"],
+              expression
+            };
+        }
+      }
+      if (exp.type === "Literal") {
+        if (pre.length === 1 && pre[0].token === "-") {
+          const children = [pre[0], ...exp.children];
+          if (post)
+            exp.children.push(post);
+          return {
+            type: "Literal",
+            children,
+            raw: `-${exp.raw}`
+          };
+        }
+      }
+      const l = pre.length;
+      if (l) {
+        const last = pre[l - 1];
+        if (last.type === "Await" && last.op) {
+          if (exp.type !== "ParenthesizedExpression") {
+            exp = ["(", exp, ")"];
+          }
+          exp = {
+            type: "CallExpression",
+            children: [" Promise", last.op, exp]
           };
         }
       }
@@ -631,14 +2224,198 @@ var require_lib = __commonJS({
         children: [...pre, exp, post]
       };
     }
+    function prune2(node) {
+      if (node === null || node === void 0)
+        return;
+      if (node.length === 0)
+        return;
+      if (Array.isArray(node)) {
+        const a = node.map((n) => prune2(n)).filter((n) => !!n);
+        if (a.length > 1)
+          return a;
+        if (a.length === 1)
+          return a[0];
+        return;
+      }
+      if (node.children != null) {
+        node.children = prune2(node.children);
+        return node;
+      }
+      return node;
+    }
+    function reorderBindingRestProperty(props) {
+      const names = props.flatMap((p) => p.names);
+      let restIndex = -1;
+      let restCount = 0;
+      props.forEach(({ type }, i) => {
+        if (type === "BindingRestProperty") {
+          if (restIndex < 0)
+            restIndex = i;
+          restCount++;
+        }
+      });
+      if (restCount === 0) {
+        return {
+          children: props,
+          names
+        };
+      } else if (restCount === 1) {
+        let after = props.slice(restIndex + 1);
+        let rest = props[restIndex];
+        props = props.slice(0, restIndex);
+        if (after.length) {
+          const [restDelim] = rest.children.slice(-1), lastAfterProp = after[after.length - 1], lastAfterChildren = lastAfterProp.children, [lastDelim] = lastAfterChildren.slice(-1);
+          rest = { ...rest, children: [...rest.children.slice(0, -1), lastDelim] };
+          after = [...after.slice(0, -1), { ...lastAfterProp, children: [...lastAfterChildren.slice(0, -1), restDelim] }];
+        }
+        const children = [...props, ...after, rest];
+        return {
+          children,
+          names
+        };
+      }
+      return {
+        children: [{
+          type: "Error",
+          message: "Multiple rest properties in object pattern"
+        }, props]
+      };
+    }
+    function replaceNodes(root, predicate, replacer) {
+      if (root == null)
+        return root;
+      const array = Array.isArray(root) ? root : root.children;
+      if (!array)
+        return root;
+      array.forEach((node, i) => {
+        if (node == null)
+          return;
+        if (predicate(node)) {
+          array[i] = replacer(node, root);
+        } else {
+          replaceNodes(node, predicate, replacer);
+        }
+      });
+      return root;
+    }
+    function skipIfOnlyWS(target) {
+      if (!target)
+        return target;
+      if (Array.isArray(target)) {
+        if (target.length === 1) {
+          return skipIfOnlyWS(target[0]);
+        } else if (target.every((e) => skipIfOnlyWS(e) === void 0)) {
+          return void 0;
+        }
+        return target;
+      }
+      if (target.token != null && target.token.trim() === "") {
+        return void 0;
+      }
+      return target;
+    }
+    function typeOfJSX(node, config, getRef) {
+      switch (node.type) {
+        case "JSXElement":
+          return typeOfJSXElement(node, config, getRef);
+        case "JSXFragment":
+          return typeOfJSXFragment(node, config, getRef);
+      }
+    }
+    function typeOfJSXElement(node, config, getRef) {
+      if (config.solid) {
+        if (config.server && !config.client) {
+          return ["string"];
+        }
+        let { tag } = node;
+        const clientType = tag[0] === tag[0].toLowerCase() ? [getRef("IntrinsicElements"), '<"', tag, '">'] : ["ReturnType<typeof ", tag, ">"];
+        if (config.server) {
+          return ["string", " | ", clientType];
+        } else {
+          return clientType;
+        }
+      }
+    }
+    function typeOfJSXFragment(node, config, getRef) {
+      if (config.solid) {
+        let type = [];
+        let lastType;
+        for (let child of node.jsxChildren) {
+          switch (child.type) {
+            case "JSXText":
+              if (lastType !== "JSXText") {
+                type.push("string");
+              }
+              break;
+            case "JSXElement":
+              type.push(typeOfJSXElement(child, config, getRef));
+              break;
+            case "JSXFragment":
+              type.push(...typeOfJSXFragment(child, config, getRef));
+              break;
+            case "JSXChildExpression":
+              if (child.expression) {
+                type.push(["typeof ", child.expression]);
+              }
+              break;
+            default:
+              throw new Error(`unknown child in JSXFragment: ${JSON.stringify(child)}`);
+          }
+          lastType = child.type;
+        }
+        if (type.length === 1) {
+          return type[0];
+        } else {
+          type = type.flatMap((t) => [t, ", "]);
+          type.pop();
+          return ["[", type, "]"];
+        }
+      }
+    }
+    function wrapIIFE(exp, async) {
+      let prefix, suffix;
+      if (async) {
+        prefix = "(async ()=>";
+        suffix = ")()";
+      } else if (hasAwait(exp)) {
+        prefix = "(await (async ()=>";
+        suffix = ")())";
+      } else {
+        prefix = "(()=>";
+        suffix = ")()";
+      }
+      const expressions = Array.isArray(exp) ? [[...exp]] : [exp];
+      const block = {
+        type: "BlockStatement",
+        expressions,
+        children: ["{", expressions, "}"],
+        bare: false
+      };
+      return [
+        prefix,
+        block,
+        suffix
+      ];
+    }
     module.exports = {
+      addParentPointers,
+      addPostfixStatement,
+      adjustAtBindings,
+      adjustBindingElements,
       aliasBinding,
       arrayElementHasTrailingComma,
+      attachPostfixStatementAsExpression,
       blockWithPrefix,
       clone,
+      constructInvocation,
+      constructPipeStep,
       convertMethodToFunction,
       convertObjectToJSXAttributes,
+      dedentBlockString,
+      dedentBlockSubstitutions,
       deepCopy,
+      expressionizeIfClause,
+      expressionizeIteration,
       findAncestor,
       forRange,
       gatherBindingCode,
@@ -651,17 +2428,36 @@ var require_lib = __commonJS({
       hasAwait,
       hasYield,
       hoistRefDecs,
+      insertReturn,
+      insertSwitchReturns,
       insertTrimmingSpace,
+      isEmptyBareBlock,
       isFunction,
+      isVoidType,
+      isWhitespaceOrEmpty,
       lastAccessInCallExpression,
       literalValue,
+      makeAsConst,
+      makeLeftHandSideExpression,
       modifyString,
+      needsRef,
+      processBinaryOpExpression,
+      processCallMemberExpression,
       processCoffeeInterpolation,
       processConstAssignmentDeclaration,
       processLetAssignmentDeclaration,
+      processParams,
+      processProgram,
+      processReturnValue,
       processUnaryExpression,
+      prune: prune2,
       quoteString,
-      removeParentPointers
+      removeParentPointers,
+      reorderBindingRestProperty,
+      replaceNodes,
+      skipIfOnlyWS,
+      typeOfJSX,
+      wrapIIFE
     };
   }
 });
@@ -1956,13 +3752,13 @@ ${input.slice(result.pos)}
     var $R65 = $R(new RegExp("[ \\t]*", "suy"));
     var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var statements = $4;
-      module.processProgram({
+      processProgram({
         type: "BlockStatement",
         expressions: statements,
         children: [statements],
         bare: true,
         root: true
-      });
+      }, module.config, module, ReservedWord);
       return $0;
     });
     function Program(state) {
@@ -2337,7 +4133,7 @@ ${input.slice(result.pos)}
       var ws = $4;
       var args = $5;
       var close = $6;
-      if (args.length === 1 && args[0].type === "IterationExpression" && args[0].subtype !== "DoStatement" && !args[0].async && module.isEmptyBareBlock(args[0].block)) {
+      if (args.length === 1 && args[0].type === "IterationExpression" && args[0].subtype !== "DoStatement" && !args[0].async && isEmptyBareBlock(args[0].block)) {
         return $skip;
       }
       return [ta?.[0], open, insertTrimmingSpace(ws, ""), args, close];
@@ -2742,7 +4538,7 @@ ${input.slice(result.pos)}
     }
     var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q(BinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
       if ($2.length)
-        return module.processBinaryOpExpression($0);
+        return processBinaryOpExpression($0);
       return $1;
     });
     function BinaryOpExpression(state) {
@@ -3732,7 +5528,7 @@ ${input.slice(result.pos)}
     var ExtendsTarget$0 = $TS($S(ExpressionWithIndentedApplicationForbidden, $E(TypeArguments)), function($skip, $loc, $0, $1, $2) {
       var exp = $1;
       var ta = $2;
-      exp = module.makeLeftHandSideExpression(exp);
+      exp = makeLeftHandSideExpression(exp);
       if (ta)
         return [exp, ta];
       return exp;
@@ -4283,14 +6079,14 @@ ${input.slice(result.pos)}
     }
     var CallExpression$0 = $TS($S($EXPECT($L14, fail, 'CallExpression "super"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
       var rest = $3;
-      return module.processCallMemberExpression({
+      return processCallMemberExpression({
         type: "CallExpression",
         children: [$1, ...$2, ...rest.flat()]
       });
     });
     var CallExpression$1 = $TS($S($EXPECT($L15, fail, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
       var rest = $3;
-      return module.processCallMemberExpression({
+      return processCallMemberExpression({
         type: "CallExpression",
         children: [$1, ...$2, ...rest.flat()]
       });
@@ -4301,7 +6097,7 @@ ${input.slice(result.pos)}
       var rest = $3;
       if (rest.length || trailing.length) {
         rest = rest.flat();
-        return module.processCallMemberExpression({
+        return processCallMemberExpression({
           type: "CallExpression",
           children: [member, ...trailing, ...rest]
         });
@@ -4444,7 +6240,7 @@ ${input.slice(result.pos)}
     var MemberExpression$0 = $TS($S($C(PrimaryExpression, SuperProperty, MetaProperty), $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
       var rest = $2;
       if (rest.length || Array.isArray($1)) {
-        return module.processCallMemberExpression({
+        return processCallMemberExpression({
           type: "MemberExpression",
           children: [$1, ...rest].flat()
         });
@@ -5255,7 +7051,7 @@ ${input.slice(result.pos)}
       var props = $0;
       if (!props)
         return { children: [], names: [] };
-      return module.reorderBindingRestProperty(props);
+      return reorderBindingRestProperty(props);
     });
     function ObjectBindingPatternContent(state) {
       let eventData;
@@ -5347,7 +7143,7 @@ ${input.slice(result.pos)}
       var elements = $0;
       if (!elements)
         return { children: [], names: [], length: 0 };
-      return module.adjustBindingElements(elements);
+      return adjustBindingElements(elements);
     });
     function ArrayBindingPatternContent(state) {
       let eventData;
@@ -5463,7 +7259,7 @@ ${input.slice(result.pos)}
       var props = $2;
       if (!props.length)
         return $skip;
-      return module.reorderBindingRestProperty(props.flat());
+      return reorderBindingRestProperty(props.flat());
     });
     function NestedBindingProperties(state) {
       let eventData;
@@ -5639,7 +7435,7 @@ ${input.slice(result.pos)}
       var elements = $2;
       if (!elements.length)
         return $skip;
-      return module.adjustBindingElements(elements.flat());
+      return adjustBindingElements(elements.flat());
     });
     function NestedBindingElements(state) {
       let eventData;
@@ -5826,7 +7622,7 @@ ${input.slice(result.pos)}
     var FunctionDeclaration$0 = $TS($S(FunctionExpression), function($skip, $loc, $0, $1) {
       if ($1.id)
         return $1;
-      return module.makeLeftHandSideExpression($1);
+      return makeLeftHandSideExpression($1);
     });
     function FunctionDeclaration(state) {
       let eventData;
@@ -6112,9 +7908,10 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E($S($N($EXPECT($R3, fail, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2) {
+    var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($R3, fail, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3) {
       var callExpRest = $1;
-      var binopRHS = $2;
+      var unaryPostfix = $2;
+      var binopRHS = $3;
       if (!callExpRest && !binopRHS)
         return $skip;
       const ref = {
@@ -6122,7 +7919,7 @@ ${input.slice(result.pos)}
         base: "$",
         id: "$"
       };
-      const exp = {
+      let exp = {
         type: "AmpersandRef",
         children: [ref],
         names: [],
@@ -6131,9 +7928,12 @@ ${input.slice(result.pos)}
       if (callExpRest) {
         exp.children.push(...callExpRest[1]);
       }
+      if (unaryPostfix) {
+        exp = processUnaryExpression([], exp, unaryPostfix);
+      }
       if (binopRHS) {
         return {
-          children: module.processBinaryOpExpression([exp, binopRHS[1]]),
+          children: processBinaryOpExpression([exp, binopRHS[1]]),
           ref
         };
       }
@@ -8985,7 +10785,7 @@ ${input.slice(result.pos)}
       var statement = $1;
       var post = $2;
       if (post)
-        return module.addPostfixStatement(statement, ...post);
+        return addPostfixStatement(statement, ...post);
       return statement;
     });
     function PostfixedStatement(state) {
@@ -9014,7 +10814,7 @@ ${input.slice(result.pos)}
       var expression = $1;
       var post = $2;
       if (post)
-        return module.attachPostfixStatementAsExpression(expression, post);
+        return attachPostfixStatementAsExpression(expression, post);
       return expression;
     });
     function PostfixedExpression(state) {
@@ -9043,7 +10843,7 @@ ${input.slice(result.pos)}
       var expression = $1;
       var post = $2;
       if (post)
-        return module.attachPostfixStatementAsExpression(expression, post);
+        return attachPostfixStatementAsExpression(expression, post);
       return expression;
     });
     function NonPipelinePostfixedExpression(state) {
@@ -9105,7 +10905,7 @@ ${input.slice(result.pos)}
     var Statement$7 = LabelledStatement;
     var Statement$8 = $TS($S(ExpressionStatement), function($skip, $loc, $0, $1) {
       if ($1.type === "ObjectExpression" || $1.type === "FunctionExpression" && !$1.id) {
-        return module.makeLeftHandSideExpression($1);
+        return makeLeftHandSideExpression($1);
       }
       return $1;
     });
@@ -9388,7 +11188,7 @@ ${input.slice(result.pos)}
       var clause = $1;
       var b = $2;
       var e = $3;
-      return module.expressionizeIfClause(clause, b, e);
+      return expressionizeIfClause(clause, b, e);
     });
     function IfExpression(state) {
       let eventData;
@@ -9416,7 +11216,7 @@ ${input.slice(result.pos)}
       var clause = $1;
       var b = $2;
       var e = $3;
-      return module.expressionizeIfClause(clause, b, e);
+      return expressionizeIfClause(clause, b, e);
     });
     function UnlessExpression(state) {
       let eventData;
@@ -10517,7 +12317,7 @@ ${input.slice(result.pos)}
       var e = $0;
       return {
         type: "SwitchExpression",
-        children: module.wrapIIFE(e.children),
+        children: wrapIIFE(e.children),
         expression: e.expression,
         caseBlock: e.caseBlock
       };
@@ -10884,7 +12684,7 @@ ${input.slice(result.pos)}
       return {
         type: "TryExpression",
         blocks: t.blocks,
-        children: module.wrapIIFE(t)
+        children: wrapIIFE(t)
       };
     });
     function TryExpression(state) {
@@ -11848,7 +13648,7 @@ ${input.slice(result.pos)}
     var DebuggerExpression$0 = $TS($S(Debugger), function($skip, $loc, $0, $1) {
       return {
         type: "DebuggerExpression",
-        children: module.wrapIIFE($1)
+        children: wrapIIFE($1)
       };
     });
     function DebuggerExpression(state) {
@@ -11876,7 +13676,7 @@ ${input.slice(result.pos)}
     var ThrowExpression$0 = $TS($S(Throw, ExtendedExpression), function($skip, $loc, $0, $1, $2) {
       return {
         type: "ThrowExpression",
-        children: module.wrapIIFE($0)
+        children: wrapIIFE($0)
       };
     });
     function ThrowExpression(state) {
@@ -13757,7 +15557,7 @@ ${input.slice(result.pos)}
       }
     }
     var TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
-      return module.dedentBlockSubstitutions($0);
+      return dedentBlockSubstitutions($0);
     });
     var TemplateLiteral$1 = $TS($S(Backtick, $Q($C(TemplateCharacters, TemplateSubstitution)), Backtick), function($skip, $loc, $0, $1, $2, $3) {
       return {
@@ -13766,7 +15566,7 @@ ${input.slice(result.pos)}
       };
     });
     var TemplateLiteral$2 = $TS($S(TripleDoubleQuote, $Q($C(TripleDoubleStringCharacters, CoffeeStringSubstitution)), TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
-      return module.dedentBlockSubstitutions($0);
+      return dedentBlockSubstitutions($0);
     });
     var TemplateLiteral$3 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
       var s = $1;
@@ -13774,7 +15574,7 @@ ${input.slice(result.pos)}
       var e = $3;
       return {
         type: "TemplateLiteral",
-        children: [s, module.dedentBlockString(str), e]
+        children: [s, dedentBlockString(str), e]
       };
     });
     var TemplateLiteral$4 = CoffeeInterpolatedDoubleQuotedString;
@@ -16541,7 +18341,7 @@ ${input.slice(result.pos)}
         ],
         jsxChildren: [$1].concat($2.map(([, tag]) => tag))
       };
-      const type = module.typeOfJSX(jsx);
+      const type = typeOfJSX(jsx, module.config, module.getRef);
       return type ? [
         { ts: true, children: ["("] },
         jsx,
@@ -17021,7 +18821,7 @@ ${input.slice(result.pos)}
           }
           if (exprs.length === 1) {
             let root = exprs[0];
-            while (root.length && module.isWhitespaceOrEmpty(root[root.length - 1])) {
+            while (root.length && isWhitespaceOrEmpty(root[root.length - 1])) {
               root = root.slice(0, -1);
             }
             while (root?.length === 1)
@@ -17101,7 +18901,7 @@ ${input.slice(result.pos)}
         children: [".", id],
         name: id
       };
-      const expr = module.processCallMemberExpression({
+      const expr = processCallMemberExpression({
         type: "CallExpression",
         children: [at, access, ...rest.flat()]
       });
@@ -17125,7 +18925,7 @@ ${input.slice(result.pos)}
     var JSXAttribute$4 = $TS($S(Identifier, $P(InlineJSXCallExpressionRest), $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
       var id = $1;
       var rest = $2;
-      const expr = module.processCallMemberExpression({
+      const expr = processCallMemberExpression({
         type: "CallExpression",
         children: [id, ...rest.flat()]
       });
@@ -17323,7 +19123,7 @@ ${input.slice(result.pos)}
     }
     var InlineJSXAttributeValue$0 = $TS($S(InlineJSXUnaryExpression, $Q(InlineJSXBinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
       if ($2.length)
-        return module.processBinaryOpExpression($0);
+        return processBinaryOpExpression($0);
       return $1;
     });
     function InlineJSXAttributeValue(state) {
@@ -17482,7 +19282,7 @@ ${input.slice(result.pos)}
     var InlineJSXCallExpression$0 = $TS($S($EXPECT($L14, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
       var args = $2;
       var rest = $3;
-      return module.processCallMemberExpression({
+      return processCallMemberExpression({
         type: "CallExpression",
         children: [
           $1,
@@ -17494,7 +19294,7 @@ ${input.slice(result.pos)}
     var InlineJSXCallExpression$1 = $TS($S($EXPECT($L15, fail, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
       var args = $2;
       var rest = $3;
-      return module.processCallMemberExpression({
+      return processCallMemberExpression({
         type: "CallExpression",
         children: [
           $1,
@@ -17508,7 +19308,7 @@ ${input.slice(result.pos)}
       var rest = $2;
       if (rest.length) {
         rest = rest.flat();
-        return module.processCallMemberExpression({
+        return processCallMemberExpression({
           type: "CallExpression",
           children: [member, ...rest]
         });
@@ -17576,7 +19376,7 @@ ${input.slice(result.pos)}
     var InlineJSXMemberExpression$0 = $TS($S($C(InlineJSXPrimaryExpression, SuperProperty, MetaProperty), $Q(InlineJSXMemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
       var rest = $2;
       if (rest.length || Array.isArray($1)) {
-        return module.processCallMemberExpression({
+        return processCallMemberExpression({
           type: "MemberExpression",
           children: [$1, ...rest].flat()
         });
@@ -18669,7 +20469,7 @@ ${input.slice(result.pos)}
             ...block.properties.map((property, i) => {
               let init, isString;
               if (property.init) {
-                init = module.replaceNodes(
+                init = replaceNodes(
                   deepCopy(property.init),
                   (n) => n.type === "Identifier" && names.has(n.name),
                   (n) => [id, '["', n.name, '"]']
@@ -21015,1999 +22815,214 @@ ${input.slice(result.pos)}
           multiLineImplicitObjectLiteralForbidden: {
             get() {
               const { forbidMultiLineImplicitObjectLiteral: s } = module;
-              return s[s.length - 1];
-            }
-          },
-          newlineBinaryOpForbidden: {
-            get() {
-              const { forbidNewlineBinaryOp: s } = module;
-              return s[s.length - 1];
-            }
-          },
-          currentJSXTag: {
-            get() {
-              const { JSXTagStack: s } = module;
-              return s[s.length - 1];
-            }
-          }
-        });
-      }
-      module.config = parse2.config = {
-        autoVar: false,
-        autoLet: false,
-        coffeeBinaryExistential: false,
-        coffeeBooleans: false,
-        coffeeClasses: false,
-        coffeeComment: false,
-        coffeeDo: false,
-        coffeeEq: false,
-        coffeeForLoops: false,
-        coffeeInterpolation: false,
-        coffeeIsnt: false,
-        coffeeJSX: false,
-        coffeeLineContinuation: false,
-        coffeeNot: false,
-        coffeeOf: false,
-        coffeePrototype: false,
-        defaultElement: "div",
-        implicitReturns: true,
-        objectIs: false,
-        react: false,
-        solid: false,
-        client: false,
-        rewriteTsImports: true,
-        server: false,
-        tab: void 0,
-        verbose: false
-      };
-      module.asAny = {
-        ts: true,
-        children: [" as any"]
-      };
-      module.asConst = {
-        ts: true,
-        children: [" as const"]
-      };
-      module.prelude = [];
-      const preludeVar = "var ";
-      const declareRef = {
-        indexOf(indexOfRef) {
-          const typeSuffix = {
-            ts: true,
-            children: [": <T>(this: T[], searchElement: T) => boolean"]
-          };
-          module.prelude.push(["", [preludeVar, indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
-        },
-        hasProp(hasPropRef) {
-          const typeSuffix = {
-            ts: true,
-            children: [": <T>(this: T, prop: keyof T) => boolean"]
-          };
-          module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
-        },
-        is(isRef) {
-          const typeSuffix = {
-            ts: true,
-            children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
-          };
-          module.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
-        },
-        modulo(moduloRef) {
-          const typeSuffix = {
-            ts: true,
-            children: [": (a: number, b: number) => number"]
-          };
-          module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
-        },
-        xor(xorRef) {
-          const typeSuffix = {
-            ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
-          };
-          module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
-        },
-        xnor(xnorRef) {
-          const typeSuffix = {
-            ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
-          };
-          module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
-        },
-        returnSymbol(ref) {
-          module.prelude.push({
-            children: [
-              preludeVar,
-              ref,
-              ` = Symbol("return")';
-`
-            ]
-          });
-        },
-        JSX(jsxRef) {
-          module.prelude.push({
-            ts: true,
-            children: [
-              "import type { JSX as ",
-              jsxRef,
-              " } from 'solid-js';\n"
-            ]
-          });
-        },
-        IntrinsicElements(intrinsicElementsRef) {
-          const JSX = module.getRef("JSX");
-          module.prelude.push({
-            ts: true,
-            children: [
-              "type ",
-              intrinsicElementsRef,
-              "<K extends keyof ",
-              JSX,
-              ".IntrinsicElements> =\n",
-              "  ",
-              JSX,
-              ".IntrinsicElements[K] extends ",
-              JSX,
-              ".DOMAttributes<infer T> ? T : unknown;\n"
-            ]
-          });
-        }
-      };
-      const refs = {};
-      module.getRef = function(base) {
-        if (refs.hasOwnProperty(base))
-          return refs[base];
-        const ref = {
-          type: "Ref",
-          base,
-          id: base
-        };
-        if (declareRef.hasOwnProperty(base))
-          declareRef[base](ref);
-        return refs[base] = ref;
-      };
-      module.makeAsConst = function(node) {
-        if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
-          return { ...node, children: [...node.children, module.asConst] };
-        }
-        return node;
-      };
-      module.typeOfJSX = function(node) {
-        switch (node.type) {
-          case "JSXElement":
-            return module.typeOfJSXElement(node);
-          case "JSXFragment":
-            return module.typeOfJSXFragment(node);
-        }
-      };
-      module.typeOfJSXElement = function(node) {
-        if (module.config.solid) {
-          if (module.config.server && !module.config.client) {
-            return ["string"];
-          }
-          let { tag } = node;
-          const clientType = tag[0] === tag[0].toLowerCase() ? [module.getRef("IntrinsicElements"), '<"', tag, '">'] : ["ReturnType<typeof ", tag, ">"];
-          if (module.config.server) {
-            return ["string", " | ", clientType];
-          } else {
-            return clientType;
-          }
-        }
-      };
-      module.typeOfJSXFragment = function(node) {
-        if (module.config.solid) {
-          let type = [];
-          let lastType;
-          for (let child of node.jsxChildren) {
-            switch (child.type) {
-              case "JSXText":
-                if (lastType !== "JSXText") {
-                  type.push("string");
-                }
-                break;
-              case "JSXElement":
-                type.push(module.typeOfJSXElement(child));
-                break;
-              case "JSXFragment":
-                type.push(...module.typeOfJSXFragment(child));
-                break;
-              case "JSXChildExpression":
-                if (child.expression) {
-                  type.push(["typeof ", child.expression]);
-                }
-                break;
-              default:
-                throw new Error(`unknown child in JSXFragment: ${JSON.stringify(child)}`);
-            }
-            lastType = child.type;
-          }
-          if (type.length === 1) {
-            return type[0];
-          } else {
-            type = type.flatMap((t) => [t, ", "]);
-            type.pop();
-            return ["[", type, "]"];
-          }
-        }
-      };
-      Object.defineProperty(module.config, "deno", {
-        set(b) {
-          module.config.rewriteTsImports = !b;
-        }
-      });
-      module.config.deno = typeof Deno !== "undefined";
-      Object.defineProperty(module.config, "coffeeCompat", {
-        set(b) {
-          for (const option of [
-            "autoVar",
-            "coffeeBinaryExistential",
-            "coffeeBooleans",
-            "coffeeClasses",
-            "coffeeComment",
-            "coffeeDo",
-            "coffeeEq",
-            "coffeeForLoops",
-            "coffeeInterpolation",
-            "coffeeIsnt",
-            "coffeeJSX",
-            "coffeeLineContinuation",
-            "coffeeNot",
-            "coffeeOf",
-            "coffeePrototype"
-          ]) {
-            module.config[option] = b;
-          }
-          if (b) {
-            module.config.objectIs = false;
-          }
-        }
-      });
-    });
-    function Reset(state) {
-      let eventData;
-      if (state.events) {
-        const result = state.events.enter?.("Reset", state);
-        if (result) {
-          if (result.cache)
-            return result.cache;
-          eventData = result.data;
-        }
-      }
-      if (state.tokenize) {
-        const result = $TOKEN("Reset", state, Reset$0(state));
-        if (state.events)
-          state.events.exit?.("Reset", state, result, eventData);
-        return result;
-      } else {
-        const result = Reset$0(state);
-        if (state.events)
-          state.events.exit?.("Reset", state, result, eventData);
-        return result;
-      }
-    }
-    var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L0, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
-      var directives = $2;
-      directives.forEach((directive) => {
-        if (directive.type === "CivetPrologue") {
-          Object.assign(module.config, directive.config);
-        }
-      });
-      module.processCallMemberExpression = (node) => {
-        const { children } = node;
-        for (let i = 0; i < children.length; i++) {
-          const glob = children[i];
-          if (glob?.type === "PropertyGlob") {
-            const prefix = children.slice(0, i).concat(glob.dot);
-            const parts = [];
-            for (const part of glob.object.properties) {
-              if (part.type === "MethodDefinition") {
-                throw new Error("Glob pattern cannot have method definition");
-              }
-              if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
-                throw new Error("Glob pattern must have call or member expression value");
-              }
-              let value = part.value ?? part.name;
-              const wValue = getTrimmingSpace(part.value);
-              value = prefix.concat(insertTrimmingSpace(value, ""));
-              if (wValue)
-                value.unshift(wValue);
-              if (part.type === "SpreadProperty") {
-                parts.push({
-                  type: part.type,
-                  value,
-                  dots: part.dots,
-                  delim: part.delim,
-                  names: part.names,
-                  children: part.children.slice(0, 2).concat(value, part.delim)
-                });
-              } else {
-                parts.push({
-                  type: part.type === "Identifier" ? "Property" : part.type,
-                  name: part.name,
-                  value,
-                  delim: part.delim,
-                  names: part.names,
-                  children: [
-                    module.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
-                    part.name,
-                    module.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
-                    part.children[3]?.token === ":" ? part.children[3] : ":",
-                    value,
-                    part.delim
-                  ]
-                });
-              }
-            }
-            const object = {
-              type: "ObjectExpression",
-              children: [
-                glob.object.children[0],
-                ...parts,
-                glob.object.children.at(-1)
-              ],
-              properties: parts
-            };
-            if (i === children.length - 1)
-              return object;
-            return module.processCallMemberExpression({
-              ...node,
-              children: [object, ...children.slice(i + 1)]
-            });
-          } else if (glob?.type === "PropertyBind") {
-            const prefix = children.slice(0, i);
-            return module.processCallMemberExpression({
-              ...node,
-              children: [
-                prefix,
-                {
-                  ...glob,
-                  type: "PropertyAccess",
-                  children: [...glob.children, ".bind(", prefix, ")"]
-                },
-                ...children.slice(i + 1)
-              ]
-            });
-          }
-        }
-        return node;
-      };
-      module.needsRef = function(expression, base = "ref") {
-        switch (expression.type) {
-          case "Ref":
-          case "Identifier":
-          case "Literal":
-            return;
-          default:
-            return {
-              type: "Ref",
-              base,
-              id: base
-            };
-        }
-      };
-      module.expressionizeIfClause = function(clause, b, e) {
-        const children = clause.children.slice(1);
-        children.push("?", b);
-        if (e) {
-          children.push(e[0], ":", ...e.slice(2));
-        } else {
-          children.push(":void 0");
-        }
-        return {
-          type: "IfExpression",
-          children
-        };
-      };
-      module.addPostfixStatement = function(statement, ws, post) {
-        let children, expressions;
-        if (post.blockPrefix?.length) {
-          let indent = post.blockPrefix[0][0];
-          expressions = [...post.blockPrefix, [indent, statement]];
-          children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
-        } else {
-          expressions = [["", statement]];
-          children = [" { ", ...expressions, " }"];
-        }
-        const block = {
-          type: "BlockStatement",
-          children,
-          expressions
-        };
-        children = [...post.children];
-        children.push(block);
-        if (!module.isWhitespaceOrEmpty(ws))
-          children.push(ws);
-        post = { ...post, children, block };
-        if (post.type === "IfStatement") {
-          post.then = block;
-        }
-        return post;
-      };
-      function expressionizeIteration(exp) {
-        const i = exp.children.indexOf(exp.block);
-        if (exp.subtype === "DoStatement") {
-          insertReturn(exp.block);
-          exp.children.splice(i, 1, ...module.wrapIIFE(exp.children, exp.async));
-          return;
-        }
-        const resultsRef = {
-          type: "Ref",
-          base: "results",
-          id: "results"
-        };
-        insertPush(exp.block, resultsRef);
-        exp.children.splice(
-          i,
-          1,
-          module.wrapIIFE([
-            "const ",
-            resultsRef,
-            "=[];",
-            ...exp.children,
-            "; return ",
-            resultsRef
-          ], exp.async)
-        );
-      }
-      module.wrapIIFE = (exp, async) => {
-        let prefix, suffix;
-        if (async) {
-          prefix = "(async ()=>";
-          suffix = ")()";
-        } else if (hasAwait(exp)) {
-          prefix = "(await (async ()=>";
-          suffix = ")())";
-        } else {
-          prefix = "(()=>";
-          suffix = ")()";
-        }
-        const expressions = Array.isArray(exp) ? [[...exp]] : [exp];
-        const block = {
-          type: "BlockStatement",
-          expressions,
-          children: ["{", expressions, "}"],
-          bare: false
-        };
-        return [
-          prefix,
-          block,
-          suffix
-        ];
-      };
-      function wrapIterationReturningResults(statement, outerRef) {
-        if (statement.type === "DoStatement") {
-          if (outerRef) {
-            insertPush(statement.block, outerRef);
-          } else {
-            insertReturn(statement.block);
-          }
-          return;
-        }
-        const resultsRef = {
-          type: "Ref",
-          base: "results",
-          id: "results"
-        };
-        const declaration = {
-          type: "Declaration",
-          children: ["const ", resultsRef, "=[];"]
-        };
-        insertPush(statement.block, resultsRef);
-        statement.children.unshift(declaration);
-        if (outerRef) {
-          statement.children.push(";", outerRef, ".push(", resultsRef, ");");
-        } else {
-          statement.children.push(";return ", resultsRef, ";");
-        }
-      }
-      function insertPush(node, ref) {
-        if (!node)
-          return;
-        switch (node.type) {
-          case "BlockStatement":
-            if (node.expressions.length) {
-              const last = node.expressions[node.expressions.length - 1];
-              insertPush(last, ref);
-            } else {
-              node.expressions.push([ref, ".push(void 0);"]);
-            }
-            return;
-          case "CaseBlock":
-            node.clauses.forEach((clause) => {
-              insertPush(clause, ref);
-            });
-            return;
-          case "WhenClause":
-            insertPush(node.block, ref);
-            return;
-          case "DefaultClause":
-            insertPush(node.block, ref);
-            return;
-        }
-        if (!Array.isArray(node))
-          return;
-        const [, exp] = node;
-        if (!exp)
-          return;
-        const indent = getIndent(node);
-        switch (exp.type) {
-          case "BreakStatement":
-          case "ContinueStatement":
-          case "DebuggerStatement":
-          case "EmptyStatement":
-          case "ReturnStatement":
-          case "ThrowStatement":
-          case "Declaration":
-            return;
-          case "ForStatement":
-          case "IterationStatement":
-          case "DoStatement":
-            wrapIterationReturningResults(exp, ref);
-            return;
-          case "BlockStatement":
-            insertPush(exp.expressions[exp.expressions.length - 1], ref);
-            return;
-          case "IfStatement":
-            insertPush(exp.then, ref);
-            if (exp.else)
-              insertPush(exp.else[2], ref);
-            else
-              exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
-            return;
-          case "PatternMatchingStatement":
-            insertPush(exp.children[0][0], ref);
-            return;
-          case "SwitchStatement":
-            insertPush(exp.children[2], ref);
-            return;
-          case "TryStatement":
-            exp.blocks.forEach((block) => insertPush(block, ref));
-            return;
-        }
-        if (node[node.length - 1]?.type === "SemicolonDelimiter")
-          return;
-        node.splice(1, 0, ref, ".push(");
-        node.push(")");
-      }
-      function wrapWithReturn(expression) {
-        const children = expression ? ["return ", expression] : ["return"];
-        return {
-          type: "ReturnStatement",
-          children
-        };
-      }
-      function insertSwitchReturns(exp) {
-        switch (exp.type) {
-          case "SwitchStatement":
-            exp.caseBlock.clauses.forEach((clause) => {
-              insertReturn(clause);
-            });
-            return;
-          case "SwitchExpression":
-            exp.caseBlock.clauses.forEach(insertReturn);
-            return;
-        }
-      }
-      function insertReturn(node) {
-        if (!node)
-          return;
-        switch (node.type) {
-          case "BlockStatement":
-            if (node.expressions.length) {
-              const last = node.expressions[node.expressions.length - 1];
-              insertReturn(last);
-            } else {
-              if (node.parent.type === "CatchClause") {
-                node.expressions.push(["return"]);
-              }
-            }
-            return;
-          case "WhenClause":
-            node.children.splice(node.children.indexOf(node.break), 1);
-            if (node.block.expressions.length) {
-              insertReturn(node.block);
-            } else {
-              node.block.expressions.push(wrapWithReturn());
-            }
-            return;
-          case "DefaultClause":
-            insertReturn(node.block);
-            return;
-        }
-        if (!Array.isArray(node))
-          return;
-        const [, exp, semi] = node;
-        if (semi?.type === "SemicolonDelimiter")
-          return;
-        let indent = getIndent(node);
-        if (!exp)
-          return;
-        switch (exp.type) {
-          case "BreakStatement":
-          case "ContinueStatement":
-          case "DebuggerStatement":
-          case "EmptyStatement":
-          case "ReturnStatement":
-          case "ThrowStatement":
-          case "Declaration":
-            return;
-          case "ForStatement":
-          case "IterationStatement":
-          case "DoStatement":
-            wrapIterationReturningResults(exp);
-            return;
-          case "BlockStatement":
-            insertReturn(exp.expressions[exp.expressions.length - 1]);
-            return;
-          case "IfStatement":
-            insertReturn(exp.then);
-            if (exp.else)
-              insertReturn(exp.else[2]);
-            else
-              exp.children.push(["", {
-                type: "ReturnStatement",
-                children: [";return"]
-              }]);
-            return;
-          case "PatternMatchingStatement":
-            insertReturn(exp.children[0][0]);
-            return;
-          case "SwitchStatement":
-            insertSwitchReturns(exp);
-            return;
-          case "TryStatement":
-            exp.blocks.forEach((block) => insertReturn(block));
-            return;
-        }
-        if (node[node.length - 1]?.type === "SemicolonDelimiter")
-          return;
-        const returnStatement = wrapWithReturn(node[1]);
-        node.splice(1, 1, returnStatement);
-      }
-      module.makeLeftHandSideExpression = function(expression) {
-        switch (expression.type) {
-          case "Ref":
-          case "Identifier":
-          case "Literal":
-          case "CallExpression":
-          case "MemberExpression":
-          case "ParenthesizedExpression":
-            return expression;
-          default:
-            return {
-              type: "ParenthesizedExpression",
-              children: ["(", expression, ")"],
-              expression
-            };
-        }
-      };
-      module.isWhitespaceOrEmpty = function(node) {
-        if (!node)
-          return true;
-        if (node.type === "Ref")
-          return false;
-        if (node.token)
-          return node.token.match(/^\s*$/);
-        if (node.children)
-          node = node.children;
-        if (!node.length)
-          return true;
-        if (typeof node === "string")
-          return node.match(/^\s*$/);
-        if (Array.isArray(node))
-          return node.every(module.isWhitespaceOrEmpty);
-      };
-      module.isTemplateLiteral = function(node) {
-        let s = node;
-        while (s && s[0] && !s.token)
-          s = s[0];
-        return s.token?.startsWith?.("`");
-      };
-      module.isEmptyBareBlock = function(node) {
-        if (node?.type !== "BlockStatement")
-          return false;
-        const { bare, expressions } = node;
-        return bare && (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
-      };
-      module.processBinaryOpExpression = function($02) {
-        const expandedOps = module.expandChainedComparisons($02);
-        let i = 2;
-        while (i < expandedOps.length) {
-          const op = expandedOps[i];
-          if (op.special) {
-            let [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
-            if (op2.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
-              a = ["typeof ", module.makeLeftHandSideExpression(a)];
-              if (op2.negated) {
-                op2 = { ...op2, token: "!==", negated: false };
-              } else {
-                op2 = { ...op2, token: "===" };
-              }
-            }
-            if (op2.asConst) {
-              a = module.makeAsConst(a);
-              b = module.makeAsConst(b);
-            }
-            let children;
-            if (op2.call) {
-              wsOp = insertTrimmingSpace(wsOp, "");
-              if (op2.reversed) {
-                wsB = insertTrimmingSpace(wsB, "");
-                children = [wsOp, op2.call, "(", wsB, b, ", ", a, ")", op2.suffix];
-              } else {
-                children = [wsOp, op2.call, "(", a, ",", wsB, b, ")", op2.suffix];
-              }
-            } else if (op2.method) {
-              wsOp = insertTrimmingSpace(wsOp, "");
-              wsB = insertTrimmingSpace(wsB, "");
-              if (op2.reversed) {
-                children = [wsB, b, wsOp, ".", op2.method, "(", a, ")"];
-              } else {
-                children = [a, wsOp, ".", op2.method, "(", wsB, b, ")"];
-              }
-            } else if (op2.token) {
-              children = [a, wsOp, op2, wsB, b];
-              if (op2.negated)
-                children = ["(", ...children, ")"];
-            } else {
-              throw new Error("Unknown operator: " + JSON.stringify(op2));
-            }
-            if (op2.negated)
-              children.unshift("!");
-            expandedOps.splice(i - 2, 5, {
-              children
-            });
-          } else {
-            i += 4;
-          }
-        }
-        return expandedOps;
-      };
-      module.expandChainedComparisons = function([first, binops]) {
-        const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
-        const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
-        let results = [];
-        let i = 0;
-        let l = binops.length;
-        let start = 0;
-        let chains = [];
-        while (i < l) {
-          const [, op] = binops[i];
-          if (relationalOps.includes(op.token) || op.relational) {
-            chains.push(i);
-          } else if (lowerPrecedenceOps.includes(op.token)) {
-            processChains();
-            first = [];
-          }
-          i++;
-        }
-        processChains();
-        return results;
-        function processChains() {
-          if (chains.length > 1) {
-            chains.forEach((index, k) => {
-              if (k > 0) {
-                results.push(" ", "&&", " ");
-              }
-              const [pre, op, post, exp] = binops[index];
-              let endIndex;
-              if (k < chains.length - 1) {
-                endIndex = chains[k + 1];
-              } else {
-                endIndex = i + 1;
-              }
-              results = results.concat(first, ...binops.slice(start, endIndex));
-              first = [exp].concat(binops.slice(index + 1, endIndex));
-              start = endIndex;
-            });
-          } else {
-            results = results.concat(first, ...binops.slice(start, i + 1));
-            start = i + 1;
-          }
-          chains.length = 0;
-        }
-      };
-      module.parsePosition = function() {
-        let s = Error().stack.split(/\n    at /);
-        s.shift();
-        s = s.filter((e) => !e.match(/^eval/)).map((e) => e.split(" ")[0]);
-        s = s.slice(1, s.indexOf("Program") + 1);
-        return s;
-      };
-      module.prune = function(node) {
-        if (node === null || node === void 0)
-          return;
-        if (node.length === 0)
-          return;
-        if (Array.isArray(node)) {
-          const a = node.map((n) => module.prune(n)).filter((n) => !!n);
-          if (a.length > 1)
-            return a;
-          if (a.length === 1)
-            return a[0];
-          return;
-        }
-        if (node.children != null) {
-          node.children = module.prune(node.children);
-          return node;
-        }
-        return node;
-      };
-      module.skipIfOnlyWS = function(target) {
-        if (!target)
-          return target;
-        if (Array.isArray(target)) {
-          if (target.length === 1) {
-            return module.skipIfOnlyWS(target[0]);
-          } else if (target.every((e) => module.skipIfOnlyWS(e) === void 0)) {
-            return void 0;
-          }
-          return target;
-        }
-        if (target.token != null && target.token.trim() === "") {
-          return void 0;
-        }
-        return target;
-      };
-      const initialSpacingRe = /^(?:\r?\n|\n)*((?:\r?\n|\n)\s+)/;
-      module.dedentBlockSubstitutions = function($02) {
-        const [s, strWithSubstitutions, e] = $02;
-        if (strWithSubstitutions.length === 0) {
-          return $02;
-        }
-        let initialSpacing, i = 0, l = strWithSubstitutions.length, results = [s];
-        const { token } = strWithSubstitutions[0];
-        if (token) {
-          initialSpacing = token.match(initialSpacingRe);
-        } else {
-          initialSpacing = false;
-        }
-        while (i < l) {
-          let segment = strWithSubstitutions[i];
-          if (segment.token) {
-            segment = module.dedentBlockString(segment, initialSpacing, false);
-            if (i === 0) {
-              segment.token = segment.token.replace(/^(\r?\n|\n)/, "");
-            }
-            if (i === l - 1) {
-              segment.token = segment.token.replace(/(\r?\n|\n)[ \t]*$/, "");
-            }
-            results.push(segment);
-          } else {
-            results.push(segment);
-          }
-          i++;
-        }
-        results.push(e);
-        return {
-          type: "TemplateLiteral",
-          children: results
-        };
-      };
-      module.dedentBlockString = function({ $loc: $loc2, token: str }, spacing, trim = true) {
-        if (spacing == null)
-          spacing = str.match(initialSpacingRe);
-        if (spacing) {
-          str = str.replaceAll(spacing[1], "\n");
-          const l = spacing.length;
-          $loc2.pos += l;
-          $loc2.length -= l;
-        }
-        if (trim) {
-          str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "");
-        }
-        str = str.replace(/(\\.|`|\$\{)/g, (s) => {
-          if (s[0] === "\\") {
-            return s;
-          }
-          return `\\${s}`;
-        });
-        return {
-          $loc: $loc2,
-          token: str
-        };
-      };
-      module.adjustBindingElements = function(elements) {
-        const names = elements.flatMap((p) => p.names || []), { length } = elements;
-        let blockPrefix, restIndex = -1, restCount = 0;
-        elements.forEach(({ type }, i) => {
-          if (type === "BindingRestElement") {
-            if (restIndex < 0)
-              restIndex = i;
-            restCount++;
-          }
-        });
-        if (restCount === 0) {
-          return {
-            children: elements,
-            names,
-            blockPrefix,
-            length
-          };
-        } else if (restCount === 1) {
-          const rest = elements[restIndex];
-          const after = elements.slice(restIndex + 1);
-          const restIdentifier = rest.binding.ref || rest.binding;
-          names.push(...rest.names || []);
-          let l = after.length;
-          if (l) {
-            if (arrayElementHasTrailingComma(after[l - 1]))
-              l++;
-            blockPrefix = {
-              type: "PostRestBindingElements",
-              children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", l.toString(), ")"],
-              names: after.flatMap((p) => p.names)
-            };
-          }
-          return {
-            names,
-            children: [...elements.slice(0, restIndex), {
-              ...rest,
-              children: rest.children.slice(0, -1)
-            }],
-            blockPrefix,
-            length
-          };
-        }
-        const err = {
-          type: "Error",
-          children: ["Multiple rest elements in array pattern"]
-        };
-        return {
-          names,
-          children: [...elements, err],
-          blockPrefix,
-          length
-        };
-      };
-      module.reorderBindingRestProperty = function(props) {
-        const names = props.flatMap((p) => p.names);
-        let restIndex = -1;
-        let restCount = 0;
-        props.forEach(({ type }, i) => {
-          if (type === "BindingRestProperty") {
-            if (restIndex < 0)
-              restIndex = i;
-            restCount++;
-          }
-        });
-        if (restCount === 0) {
-          return {
-            children: props,
-            names
-          };
-        } else if (restCount === 1) {
-          let after = props.slice(restIndex + 1);
-          let rest = props[restIndex];
-          props = props.slice(0, restIndex);
-          if (after.length) {
-            const [restDelim] = rest.children.slice(-1), lastAfterProp = after[after.length - 1], lastAfterChildren = lastAfterProp.children, [lastDelim] = lastAfterChildren.slice(-1);
-            rest = { ...rest, children: [...rest.children.slice(0, -1), lastDelim] };
-            after = [...after.slice(0, -1), { ...lastAfterProp, children: [...lastAfterChildren.slice(0, -1), restDelim] }];
-          }
-          const children = [...props, ...after, rest];
-          return {
-            children,
-            names
-          };
-        }
-        return {
-          children: [{
-            type: "Error",
-            message: "Multiple rest properties in object pattern"
-          }, props]
-        };
-      };
-      function addParentPointers(node, parent) {
-        if (node == null)
-          return;
-        if (typeof node !== "object")
-          return;
-        if (Array.isArray(node)) {
-          for (const child of node) {
-            addParentPointers(child, parent);
-          }
-          return;
-        }
-        node.parent = parent;
-        if (node.children) {
-          for (const child of node.children) {
-            addParentPointers(child, node);
-          }
-        }
-      }
-      module.replaceNodes = (root, predicate, replacer) => {
-        if (root == null)
-          return root;
-        const array = Array.isArray(root) ? root : root.children;
-        if (!array)
-          return root;
-        array.forEach((node, i) => {
-          if (node == null)
-            return;
-          if (predicate(node)) {
-            array[i] = replacer(node, root);
-          } else {
-            module.replaceNodes(node, predicate, replacer);
-          }
-        });
-        return root;
-      };
-      function processParams(f) {
-        const { type, parameters, block } = f;
-        if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
-          parameters.tp.parameters.push(",");
-        }
-        if (!block)
-          return;
-        const { expressions } = block;
-        if (!expressions)
-          return;
-        const { blockPrefix } = parameters;
-        let indent;
-        if (!expressions.length) {
-          indent = "";
-        } else {
-          indent = expressions[0][0];
-        }
-        const [splices, thisAssignments] = gatherBindingCode(parameters, {
-          injectParamProps: f.name === "constructor"
-        });
-        const delimiter = {
-          type: "SemicolonDelimiter",
-          children: [";"]
-        };
-        const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
-          (s) => s.type ? {
-            ...s,
-            children: [indent, ...s.children, delimiter]
-          } : [indent, s, delimiter]
-        );
-        expressions.unshift(...prefix);
-      }
-      function adjustAtBindings(statements, asThis = false) {
-        gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
-          const { ref } = binding;
-          if (asThis) {
-            const atBinding = binding.binding;
-            atBinding.children.pop();
-            atBinding.type = void 0;
-            binding.children.unshift(ref.id, ": this.", ref.base);
-            binding.type = "Property";
-            binding.ref = void 0;
-            return;
-          }
-          if (ref.names[0] !== ref.base) {
-            binding.children.unshift(ref.base, ": ");
-          }
-        });
-      }
-      function processReturnValue(func) {
-        const { block } = func;
-        const values = gatherRecursiveWithinFunction(
-          block,
-          ({ type }) => type === "ReturnValue"
-        );
-        if (!values.length)
-          return false;
-        const ref = {
-          type: "Ref",
-          base: "ret",
-          id: "ret"
-        };
-        let declared;
-        values.forEach((value) => {
-          value.children = [ref];
-          const ancestor = findAncestor(
-            value,
-            ({ type }) => type === "Declaration",
-            isFunction
-          );
-          if (ancestor)
-            declared = true;
-        });
-        if (!declared) {
-          let returnType = func.returnType ?? func.signature?.returnType;
-          if (returnType) {
-            const { t } = returnType;
-            if (t.type === "TypePredicate") {
-              returnType = ": boolean";
-            } else if (t.type === "AssertsType") {
-              returnType = void 0;
-            }
-          }
-          block.expressions.unshift([
-            getIndent(block.expressions[0]),
-            {
-              type: "Declaration",
-              children: ["let ", ref, returnType],
-              names: []
-            },
-            ";"
-          ]);
-        }
-        gatherRecursiveWithinFunction(
-          block,
-          (r) => r.type === "ReturnStatement" && !r.expression
-        ).forEach((r) => {
-          r.expression = ref;
-          r.children.splice(-1, 1, " ", ref);
-        });
-        if (block.children.at(-2)?.type !== "ReturnStatement") {
-          block.expressions.push([
-            [getIndent(block.expressions.at(-1))],
-            {
-              type: "ReturnStatement",
-              expression: ref,
-              children: ["return ", ref]
-            }
-          ]);
-        }
-        return true;
-      }
-      function isVoidType(t) {
-        return t?.type === "LiteralType" && t.t.type === "VoidType";
-      }
-      function processFunctions(statements) {
-        gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
-          processParams(f);
-          if (!processReturnValue(f) && module.config.implicitReturns) {
-            const { block, returnType } = f;
-            const isVoid = isVoidType(returnType?.t);
-            const isBlock = block?.type === "BlockStatement";
-            if (!isVoid && isBlock) {
-              insertReturn(block);
-            }
-          }
-        });
-        gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
-          processParams(f);
-          if (!processReturnValue(f) && module.config.implicitReturns) {
-            const { signature, block } = f;
-            const isConstructor = signature.name === "constructor";
-            const isVoid = isVoidType(signature.returnType?.t);
-            const isSet = signature.modifier?.set;
-            if (!isConstructor && !isSet && !isVoid) {
-              insertReturn(block);
-            }
-          }
-        });
-      }
-      function processSwitchExpressions(statements) {
-        if (module.config.implicitReturns) {
-          gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(insertSwitchReturns);
-        }
-      }
-      function processTryExpressions(statements) {
-        if (module.config.implicitReturns) {
-          gatherRecursiveAll(statements, (n) => n.type === "TryExpression").forEach(({ blocks }) => {
-            blocks.forEach(insertReturn);
-          });
-        }
-      }
-      function processBindingPatternLHS(lhs, tail) {
-        adjustAtBindings(lhs, true);
-        const [splices, thisAssignments] = gatherBindingCode(lhs);
-        tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
-      }
-      function processAssignments(statements) {
-        gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
-          let { lhs: $12, exp: $22 } = exp, tail = [], i = 0, len = $12.length;
-          if ($12.some((left) => left[left.length - 1].special)) {
-            if ($12.length !== 1) {
-              throw new Error("Only one assignment with id= is allowed");
-            }
-            const [, lhs, , op] = $12[0];
-            const { call } = op;
-            op[op.length - 1] = "=";
-            $22 = [call, "(", lhs, ", ", $22, ")"];
-          }
-          let wrapped = false;
-          while (i < len) {
-            const lastAssignment = $12[i++];
-            const [, lhs, , op] = lastAssignment;
-            if (op.token !== "=")
-              continue;
-            if (lhs.type === "ObjectExpression" || lhs.type === "ObjectBindingPattern") {
-              if (!wrapped) {
-                wrapped = true;
-                lhs.children.splice(0, 0, "(");
-                tail.push(")");
-              }
-            }
-          }
-          i = len - 1;
-          while (i >= 0) {
-            const lastAssignment = $12[i];
-            if (lastAssignment[3].token === "=") {
-              const lhs = lastAssignment[1];
-              if (lhs.type === "MemberExpression") {
-                const members = lhs.children;
-                const lastMember = members[members.length - 1];
-                if (lastMember.type === "SliceExpression") {
-                  const { start, end, children: c } = lastMember;
-                  c[0].token = ".splice(";
-                  c[1] = start;
-                  c[2] = ", ";
-                  if (end)
-                    c[3] = [end, " - ", start];
-                  else
-                    c[3] = ["1/0"];
-                  c[4] = [", ...", $22];
-                  c[5] = ")";
-                  lastAssignment.pop();
-                  if (module.isWhitespaceOrEmpty(lastAssignment[2]))
-                    lastAssignment.pop();
-                  if ($12.length > 1) {
-                    throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
-                  }
-                  exp.children = [$12];
-                  exp.names = [];
-                  return;
-                }
-              } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
-                processBindingPatternLHS(lhs, tail);
-              }
-            }
-            i--;
-          }
-          const names = $12.flatMap(([, l]) => l.names || []);
-          exp.children = [$12, $22, ...tail];
-          exp.names = names;
-        });
-        gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
-          function extractAssignment(lhs) {
-            let expr = lhs;
-            while (expr.type === "ParenthesizedExpression") {
-              expr = expr.expression;
-            }
-            if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
-              if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
-                post.push([", ", lhs]);
-              } else {
-                pre.push([lhs, ", "]);
-              }
-              return expr.assigned;
-            }
-          }
-          const pre = [], post = [];
-          switch (exp.type) {
-            case "AssignmentExpression":
-              if (!exp.lhs)
-                return;
-              exp.lhs.forEach((lhsPart, i) => {
-                let newLhs2 = extractAssignment(lhsPart[1]);
-                if (newLhs2) {
-                  lhsPart[1] = newLhs2;
-                }
-              });
-              break;
-            case "UpdateExpression":
-              let newLhs = extractAssignment(exp.assigned);
-              if (newLhs) {
-                const i = exp.children.indexOf(exp.assigned);
-                exp.assigned = exp.children[i] = newLhs;
-              }
-              break;
-          }
-          if (pre.length)
-            exp.children.unshift(...pre);
-          if (post.length)
-            exp.children.push(...post);
-        });
-      }
-      module.attachPostfixStatementAsExpression = function(exp, post) {
-        let clause;
-        switch (post[1].type) {
-          case "ForStatement":
-          case "IterationStatement":
-          case "DoStatement":
-            clause = module.addPostfixStatement(exp, ...post);
-            return {
-              type: "IterationExpression",
-              children: [clause],
-              block: clause.block
-            };
-          case "IfStatement":
-            clause = module.expressionizeIfClause(post[1], exp);
-            return clause;
-          default:
-            throw new Error("Unknown postfix statement");
-        }
-      };
-      function getPatternConditions(pattern, ref, conditions) {
-        if (pattern.rest)
-          return;
-        switch (pattern.type) {
-          case "ArrayBindingPattern": {
-            const { elements, length } = pattern, hasRest = elements.some((e) => e.rest), comparator = hasRest ? " >= " : " === ", l = [comparator, (length - hasRest).toString()];
-            conditions.push(
-              ["Array.isArray(", ref, ")"],
-              [ref, ".length", l]
-            );
-            elements.forEach(({ children: [, e] }, i) => {
-              const subRef = [ref, "[", i.toString(), "]"];
-              getPatternConditions(e, subRef, conditions);
-            });
-            const postRest = pattern.children.find((c) => c?.blockPrefix);
-            if (postRest) {
-              const postElements = postRest.blockPrefix.children[1], { length: postLength } = postElements;
-              postElements.forEach(({ children: [, e] }, i) => {
-                const subRef = [ref, "[", ref, ".length - ", (postLength + i).toString(), "]"];
-                getPatternConditions(e, subRef, conditions);
-              });
-            }
-            break;
-          }
-          case "ObjectBindingPattern": {
-            conditions.push(
-              ["typeof ", ref, " === 'object'"],
-              [ref, " != null"]
-            );
-            pattern.properties.forEach((p) => {
-              switch (p.type) {
-                case "PinProperty":
-                case "BindingProperty": {
-                  const { name, value } = p;
-                  let subRef;
-                  switch (name.type) {
-                    case "ComputedPropertyName":
-                      conditions.push([name.expression, " in ", ref]);
-                      subRef = [ref, name];
-                      break;
-                    case "Literal":
-                    case "StringLiteral":
-                    case "NumericLiteral":
-                      conditions.push([name, " in ", ref]);
-                      subRef = [ref, "[", name, "]"];
-                      break;
-                    default:
-                      conditions.push(["'", name, "' in ", ref]);
-                      subRef = [ref, ".", name];
-                  }
-                  if (value) {
-                    getPatternConditions(value, subRef, conditions);
-                  }
-                  break;
-                }
-              }
-            });
-            break;
-          }
-          case "ConditionFragment":
-            conditions.push(
-              [ref, " ", pattern.children]
-            );
-            break;
-          case "RegularExpressionLiteral": {
-            conditions.push(
-              ["typeof ", ref, " === 'string'"],
-              [pattern, ".test(", ref, ")"]
-            );
-            break;
-          }
-          case "PinPattern":
-            conditions.push([
-              ref,
-              " === ",
-              pattern.identifier
-            ]);
-            break;
-          case "Literal":
-            conditions.push([
-              ref,
-              " === ",
-              pattern
-            ]);
-            break;
-          default:
-            break;
-        }
-      }
-      function elideMatchersFromArrayBindings(elements) {
-        return elements.map((el) => {
-          if (el.type === "BindingRestElement") {
-            return ["", el, void 0];
-          }
-          const { children: [ws, e, sep] } = el;
-          switch (e.type) {
-            case "Literal":
-            case "RegularExpressionLiteral":
-            case "StringLiteral":
-            case "PinPattern":
-              return sep;
-            default:
-              return [ws, nonMatcherBindings(e), sep];
-          }
-        });
-      }
-      function elideMatchersFromPropertyBindings(properties) {
-        return properties.map((p) => {
-          switch (p.type) {
-            case "BindingProperty": {
-              const { children, name, value } = p;
-              const [ws] = children;
-              const sep = children[children.length - 1];
-              switch (value && value.type) {
-                case "ArrayBindingPattern":
-                case "ObjectBindingPattern":
-                  return {
-                    ...p,
-                    children: [ws, name, ": ", nonMatcherBindings(value)]
-                  };
-                case "Identifier":
-                  return p;
-                case "Literal":
-                case "RegularExpressionLiteral":
-                case "StringLiteral":
-                default:
-                  return {
-                    ...p,
-                    children: [ws, name, sep]
-                  };
-              }
-            }
-            case "PinProperty":
-            case "BindingRestProperty":
-            default:
-              return p;
-          }
-        });
-      }
-      function nonMatcherBindings(pattern) {
-        switch (pattern.type) {
-          case "ArrayBindingPattern": {
-            const elements = elideMatchersFromArrayBindings(pattern.elements);
-            const children = ["[", elements, "]"];
-            return {
-              ...pattern,
-              children,
-              elements
-            };
-          }
-          case "PostRestBindingElements": {
-            const els = elideMatchersFromArrayBindings(pattern.children[1]);
-            return {
-              ...pattern,
-              children: [
-                pattern.children[0],
-                els,
-                ...pattern.children.slice(2)
-              ]
-            };
-          }
-          case "ObjectBindingPattern":
-            return ["{", elideMatchersFromPropertyBindings(pattern.properties), "}"];
-          default:
-            return pattern;
-        }
-      }
-      function aggregateDuplicateBindings(bindings) {
-        const props = gatherRecursiveAll(bindings, (n) => n.type === "BindingProperty");
-        const arrayBindings = gatherRecursiveAll(bindings, (n) => n.type === "ArrayBindingPattern");
-        arrayBindings.forEach((a) => {
-          const { elements } = a;
-          elements.forEach((element) => {
-            if (Array.isArray(element)) {
-              const [, e] = element;
-              if (e.type === "Identifier") {
-                props.push(e);
-              } else if (e.type === "BindingRestElement") {
-                props.push(e);
-              }
-            }
-          });
-        });
-        const declarations = [];
-        const propsGroupedByName = /* @__PURE__ */ new Map();
-        for (const p of props) {
-          const { name, value } = p;
-          const key = value?.name || name?.name || name;
-          if (propsGroupedByName.has(key)) {
-            propsGroupedByName.get(key).push(p);
-          } else {
-            propsGroupedByName.set(key, [p]);
-          }
-        }
-        propsGroupedByName.forEach((shared, key) => {
-          if (!key)
-            return;
-          if (ReservedWord({
-            pos: 0,
-            input: key
-          })) {
-            shared.forEach((p) => {
-              const ref = {
-                type: "Ref",
-                base: `_${key}`,
-                id: key
-              };
-              aliasBinding(p, ref);
-            });
-            return;
-          }
-          if (shared.length === 1)
-            return;
-          const refs = shared.map((p) => {
-            const ref = {
-              type: "Ref",
-              base: key,
-              id: key
-            };
-            aliasBinding(p, ref);
-            return ref;
-          });
-          declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
-            return i === 0 ? r : [", ", r];
-          }), "]"]);
-        });
-        return declarations;
-      }
-      function processPatternMatching(statements) {
-        gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
-          const { caseBlock } = s;
-          const { clauses } = caseBlock;
-          let errors = false;
-          let isPattern = false;
-          if (clauses.some((c) => c.type === "PatternClause")) {
-            isPattern = true;
-            clauses.forEach((c) => {
-              if (!(c.type === "PatternClause" || c.type === "DefaultClause")) {
-                errors = true;
-                c.children.push({
-                  type: "Error",
-                  message: "Can't mix pattern matching and non-pattern matching clauses"
-                });
-              }
-            });
-          }
-          if (errors || !isPattern)
-            return;
-          let { expression } = s;
-          if (expression.type === "ParenthesizedExpression") {
-            expression = expression.expression;
-          }
-          let ref = module.needsRef(expression, "m") || expression;
-          let hoistDec = ref !== expression ? [["", ["const ", ref, " = ", expression], ";"]] : void 0;
-          let prev = [], root = prev;
-          const l = clauses.length;
-          clauses.forEach((c, i) => {
-            if (c.type === "DefaultClause") {
-              prev.push(c.block);
-              return;
-            }
-            let { patterns, block } = c;
-            let pattern = patterns[0];
-            const indent = block.expressions?.[0]?.[0] || "";
-            const alternativeConditions = patterns.map((pattern2, i2) => {
-              const conditions = [];
-              getPatternConditions(pattern2, ref, conditions);
-              return conditions;
-            });
-            const conditionExpression = alternativeConditions.map((conditions, i2) => {
-              const conditionArray = conditions.map((c2, i3) => {
-                if (i3 === 0)
-                  return c2;
-                return [" && ", ...c2];
-              });
-              if (i2 === 0)
-                return conditionArray;
-              return [" || ", ...conditionArray];
-            });
-            const condition = {
-              type: "ParenthesizedExpression",
-              children: ["(", conditionExpression, ")"],
-              expression: conditionExpression
-            };
-            const prefix = [];
-            switch (pattern.type) {
-              case "ArrayBindingPattern":
-                if (pattern.length === 0)
-                  break;
-              case "ObjectBindingPattern": {
-                if (pattern.properties?.length === 0)
-                  break;
-                let [splices, thisAssignments] = gatherBindingCode(pattern);
-                const patternBindings = nonMatcherBindings(pattern);
-                splices = splices.map((s2) => [", ", nonMatcherBindings(s2)]);
-                thisAssignments = thisAssignments.map((a) => [indent, a, ";"]);
-                const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices]);
-                prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";"]);
-                prefix.push(...thisAssignments);
-                prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";"]));
-                break;
-              }
-            }
-            block.expressions.unshift(...prefix);
-            const next = [];
-            if (block.bare) {
-              block.children.unshift(" {");
-              block.children.push("}");
-              block.bare = false;
-            }
-            if (i < l - 1)
-              next.push("\n", "else ");
-            prev.push(["", {
-              type: "IfStatement",
-              children: ["if", condition, block, next],
-              then: block,
-              else: next,
-              hoistDec
-            }]);
-            hoistDec = void 0;
-            prev = next;
-          });
-          if (module.config.implicitReturns && s.type === "SwitchExpression") {
-            insertReturn(root[0]);
-            root.splice(0, 1, module.wrapIIFE(root[0]));
-          }
-          s.type = "PatternMatchingStatement";
-          s.children = [root];
-          addParentPointers(s, s.parent);
-        });
-      }
-      function processPipelineExpressions(statements) {
-        gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
-          const [ws, , body] = s.children;
-          let [, arg] = s.children;
-          let i = 0, l = body.length;
-          const refDec = [];
-          const children = [ws, refDec];
-          let usingRef = null;
-          for (i = 0; i < l; i++) {
-            const step = body[i];
-            const [leadingComment, pipe, trailingComment, expr] = step;
-            const returns = pipe.token === "||>";
-            let ref, result, returning = returns ? arg : null;
-            if (pipe.token === "|>=") {
-              let initRef;
-              if (i === 0) {
-                outer:
-                  switch (arg.type) {
-                    case "MemberExpression":
-                      if (arg.children.length <= 2)
-                        break;
-                    case "CallExpression":
-                      const access = arg.children.pop();
-                      switch (access.type) {
-                        case "PropertyAccess":
-                        case "SliceExpression":
-                          break;
-                        default:
-                          children.unshift({
-                            type: "Error",
-                            $loc: pipe.token.$loc,
-                            message: `Can't assign to ${access.type}`
-                          });
-                          arg.children.push(access);
-                          break outer;
-                      }
-                      usingRef = module.needsRef({});
-                      initRef = {
-                        type: "AssignmentExpression",
-                        children: [usingRef, " = ", arg, ","]
-                      };
-                      arg = {
-                        type: "MemberExpression",
-                        children: [usingRef, access]
-                      };
-                      break;
-                  }
-                children.pop();
-                const lhs = [[
-                  [refDec, initRef],
-                  arg,
-                  [],
-                  { token: "=", children: [" = "] }
-                ]];
-                Object.assign(s, {
-                  type: "AssignmentExpression",
-                  children: [lhs, children],
-                  names: null,
-                  lhs,
-                  assigned: arg,
-                  exp: children
-                });
-                arg = clone(arg);
-                if (arg.children[0].type === "Ref") {
-                  arg.children[0] = usingRef;
-                }
-              } else {
-                children.unshift({
-                  type: "Error",
-                  $loc: pipe.token.$loc,
-                  message: "Can't use |>= in the middle of a pipeline"
-                });
-              }
-            } else {
-              s.children = children;
-            }
-            if (returns && (ref = module.needsRef(arg))) {
-              usingRef = usingRef || ref;
-              arg = {
-                type: "ParenthesizedExpression",
-                children: ["(", {
-                  type: "AssignmentExpression",
-                  children: [usingRef, " = ", arg]
-                }, ")"]
-              };
-              returning = usingRef;
+              return s[s.length - 1];
             }
-            [result, returning] = module.constructPipeStep(
-              {
-                leadingComment: module.skipIfOnlyWS(leadingComment),
-                trailingComment: module.skipIfOnlyWS(trailingComment),
-                expr
-              },
-              arg,
-              returning
-            );
-            if (result.type === "ReturnStatement") {
-              if (i < l - 1) {
-                result.children.push({
-                  type: "Error",
-                  message: "Can't continue a pipeline after returning"
-                });
-              }
-              arg = result;
-              if (children[children.length - 1] === ",") {
-                children.pop();
-                children.push(";");
-              }
-              break;
+          },
+          newlineBinaryOpForbidden: {
+            get() {
+              const { forbidNewlineBinaryOp: s } = module;
+              return s[s.length - 1];
             }
-            if (returning) {
-              arg = returning;
-              children.push(result, ",");
-            } else {
-              arg = result;
+          },
+          currentJSXTag: {
+            get() {
+              const { JSXTagStack: s } = module;
+              return s[s.length - 1];
             }
           }
-          if (usingRef) {
-            refDec.unshift("let ", usingRef, ";");
-          }
-          children.push(arg);
-          addParentPointers(s, s.parent);
         });
       }
-      module.processProgram = function(root) {
-        assert.equal(module.forbidClassImplicitCall.length, 1, "forbidClassImplicitCall");
-        assert.equal(module.forbidIndentedApplication.length, 1, "forbidIndentedApplication");
-        assert.equal(module.forbidTrailingMemberProperty.length, 1, "forbidTrailingMemberProperty");
-        assert.equal(module.forbidMultiLineImplicitObjectLiteral.length, 1, "forbidMultiLineImplicitObjectLiteral");
-        assert.equal(module.JSXTagStack.length, 0, "JSXTagStack should be empty");
-        addParentPointers(root);
-        const { expressions: statements } = root;
-        processPipelineExpressions(statements);
-        processAssignments(statements);
-        processPatternMatching(statements);
-        processFunctions(statements);
-        processSwitchExpressions(statements);
-        processTryExpressions(statements);
-        hoistRefDecs(statements);
-        gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
-        statements.unshift(...module.prelude);
-        if (module.config.autoLet) {
-          createLetDecs(statements, []);
-        } else if (module.config.autoVar) {
-          createVarDecs(statements, []);
-        }
-        populateRefs(statements);
-        adjustAtBindings(statements);
-      };
-      function findDecs(statements) {
-        const declarationNames = gatherNodes(statements, ({ type }) => type === "Declaration").flatMap((d) => d.names);
-        return new Set(declarationNames);
-      }
-      function populateRefs(statements) {
-        const refNodes = gatherRecursive(statements, ({ type }) => 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;
-            ref.type = "Identifier";
-            let n = 0;
-            let name = base;
-            while (names.has(name)) {
-              n++;
-              name = `${base}${n}`;
-            }
-            names.add(name);
-            ref.children = ref.names = [name];
+      module.config = parse2.config = {
+        autoVar: false,
+        autoLet: false,
+        coffeeBinaryExistential: false,
+        coffeeBooleans: false,
+        coffeeClasses: false,
+        coffeeComment: false,
+        coffeeDo: false,
+        coffeeEq: false,
+        coffeeForLoops: false,
+        coffeeInterpolation: false,
+        coffeeIsnt: false,
+        coffeeJSX: false,
+        coffeeLineContinuation: false,
+        coffeeNot: false,
+        coffeeOf: false,
+        coffeePrototype: false,
+        defaultElement: "div",
+        implicitReturns: true,
+        objectIs: false,
+        react: false,
+        solid: false,
+        client: false,
+        rewriteTsImports: true,
+        server: false,
+        tab: void 0,
+        verbose: false
+      };
+      const asAny = {
+        ts: true,
+        children: [" as any"]
+      };
+      module.prelude = [];
+      const preludeVar = "var ";
+      const declareRef = {
+        indexOf(indexOfRef) {
+          const typeSuffix = {
+            ts: true,
+            children: [": <T>(this: T[], searchElement: T) => boolean"]
+          };
+          module.prelude.push(["", [preludeVar, indexOfRef, typeSuffix, " = [].indexOf", asAny, ";\n"]]);
+        },
+        hasProp(hasPropRef) {
+          const typeSuffix = {
+            ts: true,
+            children: [": <T>(this: T, prop: keyof T) => boolean"]
+          };
+          module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.hasOwnProperty", asAny, ";\n"]]);
+        },
+        is(isRef) {
+          const typeSuffix = {
+            ts: true,
+            children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
+          };
+          module.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", asAny, ";\n"]]);
+        },
+        modulo(moduloRef) {
+          const typeSuffix = {
+            ts: true,
+            children: [": (a: number, b: number) => number"]
+          };
+          module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
+        },
+        xor(xorRef) {
+          const typeSuffix = {
+            ts: true,
+            children: [": (a: unknown, b: unknown) => boolean"]
+          };
+          module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
+        },
+        xnor(xnorRef) {
+          const typeSuffix = {
+            ts: true,
+            children: [": (a: unknown, b: unknown) => boolean"]
+          };
+          module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
+        },
+        returnSymbol(ref) {
+          module.prelude.push({
+            children: [
+              preludeVar,
+              ref,
+              ` = Symbol("return")';
+`
+            ]
           });
-        }
-      }
-      function createVarDecs(statements, scopes, pushVar) {
-        function hasDec(name) {
-          return scopes.some((s) => s.has(name));
-        }
-        function findAssignments(statements2, decs2) {
-          let assignmentStatements2 = gatherNodes(statements2, (node) => {
-            return node.type === "AssignmentExpression";
+        },
+        JSX(jsxRef) {
+          module.prelude.push({
+            ts: true,
+            children: [
+              "import type { JSX as ",
+              jsxRef,
+              " } from 'solid-js';\n"
+            ]
           });
-          if (assignmentStatements2.length) {
-            assignmentStatements2 = assignmentStatements2.concat(findAssignments(assignmentStatements2.map((s) => s.children), decs2));
-          }
-          return assignmentStatements2;
-        }
-        if (!pushVar) {
-          pushVar = function(name) {
-            varIds.push(name);
-            decs.add(name);
-          };
-        }
-        const decs = findDecs(statements);
-        scopes.push(decs);
-        const varIds = [];
-        const assignmentStatements = findAssignments(statements, scopes);
-        const undeclaredIdentifiers = assignmentStatements.flatMap((a) => a.names);
-        undeclaredIdentifiers.filter((x, i, a) => {
-          if (!hasDec(x))
-            return a.indexOf(x) === i;
-        }).forEach(pushVar);
-        const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
-        const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
-        const blockNodes = new Set(gatherNodes(statements, (s) => s.type === "BlockStatement"));
-        fnNodes.forEach(({ block }) => blockNodes.delete(block));
-        forNodes.forEach(({ block }) => blockNodes.delete(block));
-        blockNodes.forEach((block) => {
-          createVarDecs(block.expressions, scopes, pushVar);
-        });
-        forNodes.forEach(({ block, declaration }) => {
-          scopes.push(new Set(declaration.names));
-          createVarDecs(block.expressions, scopes, pushVar);
-          scopes.pop();
-        });
-        fnNodes.forEach(({ block, parameters }) => {
-          scopes.push(new Set(parameters.names));
-          createVarDecs(block.expressions, scopes);
-          scopes.pop();
-        });
-        if (varIds.length) {
-          const indent = getIndent(statements[0]);
-          let delimiter = ";";
-          if (statements[0][1]?.parent?.root) {
-            delimiter = ";\n";
-          }
-          statements.unshift([indent, "var ", varIds.join(", "), delimiter]);
-        }
-        scopes.pop();
-      }
-      function createLetDecs(statements, scopes) {
-        function findVarDecs(statements2, decs) {
-          const declarationNames = gatherRecursive(
-            statements2,
-            (node) => node.type === "Declaration" && node.children && node.children.length > 0 && node.children[0].token && node.children[0].token.startsWith("var") || node.type === "FunctionExpression"
-          ).filter((node) => node.type === "Declaration").flatMap((node) => node.names);
-          return new Set(declarationNames);
-        }
-        let declaredIdentifiers = findVarDecs(statements);
-        function hasDec(name) {
-          return declaredIdentifiers.has(name) || scopes.some((s) => s.has(name));
-        }
-        function gatherBlockOrOther(statement) {
-          return gatherNodes(statement, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration").flatMap((node) => {
-            if (node.type == "BlockStatement")
-              return node.bare ? gatherBlockOrOther(node.expressions) : node;
-            else if (node.children && node.children.length)
-              return [...gatherBlockOrOther(node.children), node];
-            else
-              return [];
+        },
+        IntrinsicElements(intrinsicElementsRef) {
+          const JSX = module.getRef("JSX");
+          module.prelude.push({
+            ts: true,
+            children: [
+              "type ",
+              intrinsicElementsRef,
+              "<K extends keyof ",
+              JSX,
+              ".IntrinsicElements> =\n",
+              "  ",
+              JSX,
+              ".IntrinsicElements[K] extends ",
+              JSX,
+              ".DOMAttributes<infer T> ? T : unknown;\n"
+            ]
           });
         }
-        let currentScope = /* @__PURE__ */ new Set();
-        scopes.push(currentScope);
-        const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
-        const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
-        let targetStatements = [];
-        for (const statement of statements) {
-          const nodes = gatherBlockOrOther(statement);
-          let undeclaredIdentifiers = [];
-          for (const node of nodes) {
-            if (node.type == "BlockStatement") {
-              let block = node;
-              let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
-              let forNode = forNodes.find((forNode2) => forNode2.block === block);
-              if (fnNode != null) {
-                scopes.push(new Set(fnNode.parameters.names));
-                createLetDecs(block.expressions, scopes);
-                scopes.pop();
-              } else if (forNode != null) {
-                scopes.push(new Set(forNode.declaration.names));
-                createLetDecs(block.expressions, scopes);
-                scopes.pop();
-              } else
-                createLetDecs(block.expressions, scopes);
-              continue;
-            }
-            if (node.names == null)
-              continue;
-            let names = node.names.filter((name) => !hasDec(name));
-            if (node.type == "AssignmentExpression")
-              undeclaredIdentifiers.push(...names);
-            names.forEach((name) => currentScope.add(name));
+      };
+      const refs = {};
+      module.getRef = function(base) {
+        if (refs.hasOwnProperty(base))
+          return refs[base];
+        const ref = {
+          type: "Ref",
+          base,
+          id: base
+        };
+        if (declareRef.hasOwnProperty(base))
+          declareRef[base](ref);
+        return refs[base] = ref;
+      };
+      Object.defineProperty(module.config, "deno", {
+        set(b) {
+          module.config.rewriteTsImports = !b;
+        }
+      });
+      module.config.deno = typeof Deno !== "undefined";
+      Object.defineProperty(module.config, "coffeeCompat", {
+        set(b) {
+          for (const option of [
+            "autoVar",
+            "coffeeBinaryExistential",
+            "coffeeBooleans",
+            "coffeeClasses",
+            "coffeeComment",
+            "coffeeDo",
+            "coffeeEq",
+            "coffeeForLoops",
+            "coffeeInterpolation",
+            "coffeeIsnt",
+            "coffeeJSX",
+            "coffeeLineContinuation",
+            "coffeeNot",
+            "coffeeOf",
+            "coffeePrototype"
+          ]) {
+            module.config[option] = b;
           }
-          if (undeclaredIdentifiers.length > 0) {
-            let indent = statement[0];
-            let firstIdentifier = gatherNodes(statement[1], (node) => node.type == "Identifier")[0];
-            if (undeclaredIdentifiers.length == 1 && statement[1].type == "AssignmentExpression" && statement[1].names.length == 1 && statement[1].names[0] == undeclaredIdentifiers[0] && firstIdentifier && firstIdentifier.names == undeclaredIdentifiers[0] && gatherNodes(statement[1], (node) => node.type === "ObjectBindingPattern").length == 0)
-              statement[1].children.unshift(["let "]);
-            else {
-              let tail = "\n";
-              if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0)
-                tail = void 0;
-              targetStatements.push([indent, "let ", undeclaredIdentifiers.join(", "), tail]);
-            }
+          if (b) {
+            module.config.objectIs = false;
           }
-          targetStatements.push(statement);
-        }
-        scopes.pop();
-        statements.splice(0, statements.length, targetStatements);
-      }
-      module.constructInvocation = function(fn, arg) {
-        const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
-        let expr = fn.expr;
-        while (expr.type === "ParenthesizedExpression") {
-          expr = expr.expression;
-        }
-        if (expr.ampersandBlock) {
-          const { ref, body } = expr;
-          ref.type = "PipedExpression";
-          ref.children = [module.makeLeftHandSideExpression(arg)];
-          return {
-            type: "UnwrappedExpression",
-            children: [module.skipIfOnlyWS(fn.leadingComment), ...body, module.skipIfOnlyWS(fn.trailingComment)]
-          };
-        }
-        expr = fn.expr;
-        const lhs = module.makeLeftHandSideExpression(expr);
-        let comment = module.skipIfOnlyWS(fn.trailingComment);
-        if (comment)
-          lhs.children.splice(2, 0, comment);
-        comment = module.skipIfOnlyWS(fn.leadingComment);
-        if (comment)
-          lhs.children.splice(1, 0, comment);
-        switch (arg.type) {
-          case "CommaExpression":
-            arg = module.makeLeftHandSideExpression(arg);
-            break;
         }
-        return {
-          type: "CallExpression",
-          children: [lhs, "(", arg, ")"]
-        };
-      };
-      module.constructPipeStep = function(fn, arg, returning) {
-        const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(module.skipIfOnlyWS), " ", arg];
-        switch (fn.expr.token) {
-          case "yield":
-          case "await":
-            if (returning) {
-              return [
-                children,
-                returning
-              ];
-            }
-            return [
-              children,
-              null
-            ];
-          case "return":
-            return [{
-              type: "ReturnStatement",
-              children
-            }, null];
+      });
+    });
+    function Reset(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("Reset", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
         }
-        if (returning) {
-          return [
-            module.constructInvocation(fn, arg),
-            returning
-          ];
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("Reset", state, Reset$0(state));
+        if (state.events)
+          state.events.exit?.("Reset", state, result, eventData);
+        return result;
+      } else {
+        const result = Reset$0(state);
+        if (state.events)
+          state.events.exit?.("Reset", state, result, eventData);
+        return result;
+      }
+    }
+    var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L0, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
+      var directives = $2;
+      directives.forEach((directive) => {
+        if (directive.type === "CivetPrologue") {
+          Object.assign(module.config, directive.config);
         }
-        return [module.constructInvocation(fn, arg), null];
-      };
+      });
       return $0;
     });
     function Init(state) {
@@ -23312,44 +23327,40 @@ ${input.slice(result.pos)}
     exports.parse = parse2;
     exports.default = { parse: parse2 };
     var {
-      aliasBinding,
-      arrayElementHasTrailingComma,
+      addPostfixStatement,
+      adjustBindingElements,
+      attachPostfixStatementAsExpression,
       blockWithPrefix,
-      clone,
-      convertMethodToFunction,
       convertObjectToJSXAttributes,
       deepCopy,
-      findAncestor,
+      dedentBlockString,
+      dedentBlockSubstitutions,
+      expressionizeIfClause,
       forRange,
       gatherBindingCode,
-      gatherNodes,
-      gatherRecursive,
-      gatherRecursiveAll,
-      gatherRecursiveWithinFunction,
-      getIndent,
       getTrimmingSpace,
       hasAwait,
       hasYield,
-      hoistRefDecs,
       insertTrimmingSpace,
-      isFunction,
+      isEmptyBareBlock,
+      isWhitespaceOrEmpty,
       lastAccessInCallExpression,
       literalValue,
+      makeLeftHandSideExpression,
       modifyString,
+      processBinaryOpExpression,
+      processCallMemberExpression,
       processCoffeeInterpolation,
       processConstAssignmentDeclaration,
       processLetAssignmentDeclaration,
+      processProgram,
       processUnaryExpression,
       quoteString,
-      removeParentPointers
+      reorderBindingRestProperty,
+      replaceNodes,
+      typeOfJSX,
+      wrapIIFE
     } = require_lib();
-    var assert = {
-      equal(a, b, msg) {
-        if (a !== b) {
-          throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`);
-        }
-      }
-    };
   }
 });