@danielx/civet 0.6.3 → 0.6.4

package/dist/browser.js

@@ -31,6 +31,119 @@ var Civet = (() => {
   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;
@@ -54,6 +167,13 @@ var Civet = (() => {
         }
         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]);
@@ -84,6 +204,126 @@ var Civet = (() => {
         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;
@@ -98,6 +338,356 @@ var Civet = (() => {
           })
         );
       }
+      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;
@@ -219,10 +809,123 @@ var Civet = (() => {
           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);
       }
@@ -259,62 +962,6 @@ var Civet = (() => {
         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 = {
@@ -402,6 +1049,79 @@ var Civet = (() => {
         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");
       }
@@ -489,6 +1209,20 @@ var Civet = (() => {
         }
         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 {
@@ -577,55 +1311,914 @@ var Civet = (() => {
           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]
             };
           }
         }
@@ -634,14 +2227,198 @@ var Civet = (() => {
           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,
@@ -654,17 +2431,36 @@ var Civet = (() => {
         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
       };
     }
   });
@@ -1959,13 +3755,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) {
@@ -2340,7 +4136,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];
@@ -2745,7 +4541,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) {
@@ -3735,7 +5531,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;
@@ -4286,14 +6082,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()]
         });
@@ -4304,7 +6100,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]
           });
@@ -4447,7 +6243,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()
           });
@@ -5258,7 +7054,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;
@@ -5350,7 +7146,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;
@@ -5466,7 +7262,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;
@@ -5642,7 +7438,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;
@@ -5829,7 +7625,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;
@@ -6115,9 +7911,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 = {
@@ -6125,7 +7922,7 @@ ${input.slice(result.pos)}
           base: "$",
           id: "$"
         };
-        const exp = {
+        let exp = {
           type: "AmpersandRef",
           children: [ref],
           names: [],
@@ -6134,9 +7931,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
           };
         }
@@ -8988,7 +10788,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) {
@@ -9017,7 +10817,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) {
@@ -9046,7 +10846,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) {
@@ -9108,7 +10908,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;
       });
@@ -9391,7 +11191,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;
@@ -9419,7 +11219,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;
@@ -10520,7 +12320,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
         };
@@ -10887,7 +12687,7 @@ ${input.slice(result.pos)}
         return {
           type: "TryExpression",
           blocks: t.blocks,
-          children: module.wrapIIFE(t)
+          children: wrapIIFE(t)
         };
       });
       function TryExpression(state) {
@@ -11851,7 +13651,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) {
@@ -11879,7 +13679,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) {
@@ -13760,7 +15560,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 {
@@ -13769,7 +15569,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;
@@ -13777,7 +15577,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;
@@ -16544,7 +18344,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,
@@ -17024,7 +18824,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)
@@ -17104,7 +18904,7 @@ ${input.slice(result.pos)}
           children: [".", id],
           name: id
         };
-        const expr = module.processCallMemberExpression({
+        const expr = processCallMemberExpression({
           type: "CallExpression",
           children: [at, access, ...rest.flat()]
         });
@@ -17128,7 +18928,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()]
         });
@@ -17326,7 +19126,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) {
@@ -17485,7 +19285,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,
@@ -17497,7 +19297,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,
@@ -17511,7 +19311,7 @@ ${input.slice(result.pos)}
         var rest = $2;
         if (rest.length) {
           rest = rest.flat();
-          return module.processCallMemberExpression({
+          return processCallMemberExpression({
             type: "CallExpression",
             children: [member, ...rest]
           });
@@ -17579,7 +19379,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()
           });
@@ -18672,7 +20472,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, '"]']
@@ -21018,1999 +22818,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) {
@@ -23315,44 +23330,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}`);
-          }
-        }
-      };
     }
   });