@danielx/civet 0.7.9 → 0.7.11

package/dist/browser.js

@@ -38,9 +38,9 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // ../Hera/dist/machine.js
+  // node_modules/@danielx/hera/dist/machine.js
   var require_machine = __commonJS({
-    "../Hera/dist/machine.js"(exports, module) {
+    "node_modules/@danielx/hera/dist/machine.js"(exports, module) {
       "use strict";
       var __defProp2 = Object.defineProperty;
       var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -79,6 +79,7 @@ var Civet = (() => {
         $TS: () => $TS2,
         $TV: () => $TV2,
         $Y: () => $Y2,
+        ParseError: () => ParseError2,
         Validator: () => Validator2
       });
       module.exports = __toCommonJS2(machine_exports);
@@ -445,11 +446,10 @@ ${input.slice(result.pos)}
               hint = JSON.stringify(hint);
             else
               hint = "EOF";
-            const error = new ParseError(`${filename2}:${line}:${column} Failed to parse
-Expected:
+            const error = new ParseError2("Failed to parse", `Expected:
 	${expectations.join("\n	")}
 Found: ${hint}
-`, "ParseError", filename2, line, column, maxFailPos);
+`, filename2, line, column, maxFailPos);
             throw error;
           }
           if (result) {
@@ -472,15 +472,21 @@ ${input.slice(result.pos)}
           reset
         };
       }
-      var ParseError = class extends Error {
-        constructor(message, name, filename2, line, column, offset) {
+      var ParseError2 = class extends Error {
+        constructor(header, body, filename2, line, column, offset) {
+          let message = `${filename2}:${line}:${column} ${header}`;
+          if (body)
+            message += `
+${body}`;
           super(message);
-          this.message = message;
-          this.name = name;
+          this.header = header;
+          this.body = body;
           this.filename = filename2;
           this.line = line;
           this.column = column;
           this.offset = offset;
+          this.name = "ParseError";
+          this.message = message;
         }
       };
     }
@@ -489,7 +495,9 @@ ${input.slice(result.pos)}
   // source/main.civet
   var main_exports = {};
   __export(main_exports, {
+    ParseError: () => import_lib3.ParseError,
     ParseErrors: () => ParseErrors,
+    SourceMap: () => SourceMap2,
     compile: () => compile,
     default: () => main_default,
     generate: () => generate_default,
@@ -498,7 +506,7 @@ ${input.slice(result.pos)}
     parse: () => parse,
     parseProgram: () => parseProgram,
     prune: () => prune,
-    util: () => util_exports
+    sourcemap: () => sourcemap_exports
   });
 
   // source/parser.hera
@@ -553,6 +561,7 @@ ${input.slice(result.pos)}
     processAssignmentDeclaration: () => processAssignmentDeclaration,
     processBinaryOpExpression: () => processBinaryOpExpression,
     processCallMemberExpression: () => processCallMemberExpression,
+    processCoffeeDo: () => processCoffeeDo,
     processCoffeeInterpolation: () => processCoffeeInterpolation,
     processForInOf: () => processForInOf,
     processProgram: () => processProgram,
@@ -958,27 +967,49 @@ ${input.slice(result.pos)}
       case "DebuggerStatement":
       case "EmptyStatement":
       case "ReturnStatement":
-      case "ThrowStatement":
+      case "ThrowStatement": {
         return;
-      case "Declaration":
+      }
+      case "Declaration": {
+        let ref5;
+        if (exp.bindings?.length) {
+          ref5 = patternAsValue((ref4 = exp.bindings)[ref4.length - 1].pattern);
+        } else {
+          ref5 = "void 0";
+        }
+        ;
+        const value = ref5;
         exp.children.push([
           "",
-          [";", collect(patternAsValue((ref4 = exp.bindings)[ref4.length - 1].pattern))]
+          [";", collect(value)]
         ]);
         return;
+      }
+      case "FunctionExpression": {
+        if (exp.id) {
+          exp.children.push([
+            "",
+            [";", collect(exp.id)]
+          ]);
+          return;
+        }
+        break;
+      }
       case "ForStatement":
       case "IterationStatement":
       case "DoStatement":
-      case "ComptimeStatement":
+      case "ComptimeStatement": {
         wrapIterationReturningResults(exp, outer, collect);
         return;
-      case "BlockStatement":
+      }
+      case "BlockStatement": {
         if (node.expressions.some(isExit)) {
           return;
         }
         assignResults(exp.expressions[exp.expressions.length - 1], collect);
         return;
-      case "IfStatement":
+      }
+      case "IfStatement": {
         assignResults(exp.then, collect);
         if (exp.then.bare && !exp.then.semicolon) {
           exp.then.children.push(exp.then.semicolon = ";");
@@ -986,18 +1017,22 @@ ${input.slice(result.pos)}
         if (exp.else) {
           assignResults(exp.else.block, collect);
         } else {
-          exp.children.push([" else {", collect("undefined"), "}"]);
+          exp.children.push([" else {", collect("void 0"), "}"]);
         }
         return;
-      case "PatternMatchingStatement":
+      }
+      case "PatternMatchingStatement": {
         assignResults(exp.children[0], collect);
         return;
-      case "SwitchStatement":
+      }
+      case "SwitchStatement": {
         assignResults(exp.children[2], collect);
         return;
-      case "TryStatement":
+      }
+      case "TryStatement": {
         exp.blocks.forEach((block) => assignResults(block, collect));
         return;
+      }
     }
     if (node[node.length - 1]?.type === "SemicolonDelimiter") {
       return;
@@ -1008,7 +1043,7 @@ ${input.slice(result.pos)}
     if (!node)
       return;
     switch (node.type) {
-      case "BlockStatement":
+      case "BlockStatement": {
         if (node.expressions.length) {
           if (node.expressions.some(([, exp2]) => isExit(exp2))) {
             return;
@@ -1021,7 +1056,8 @@ ${input.slice(result.pos)}
           }
         }
         return;
-      case "WhenClause":
+      }
+      case "WhenClause": {
         if (node.break) {
           node.children.splice(node.children.indexOf(node.break), 1);
         }
@@ -1031,9 +1067,11 @@ ${input.slice(result.pos)}
           node.block.expressions.push(wrapWithReturn());
         }
         return;
-      case "DefaultClause":
+      }
+      case "DefaultClause": {
         insertReturn(node.block);
         return;
+      }
     }
     if (!Array.isArray(node))
       return;
@@ -1053,23 +1091,36 @@ ${input.slice(result.pos)}
       exp = exp.statement;
       ({ type } = exp);
     }
-    let ref5;
+    let ref6;
     switch (type) {
       case "BreakStatement":
       case "ContinueStatement":
       case "DebuggerStatement":
       case "EmptyStatement":
       case "ReturnStatement":
-      case "ThrowStatement":
+      case "ThrowStatement": {
         return;
-      case "Declaration":
+      }
+      case "Declaration": {
+        let ref7;
+        if (exp.bindings?.length) {
+          ref7 = [" ", patternAsValue((ref6 = exp.bindings)[ref6.length - 1].pattern)];
+        } else {
+          ref7 = [];
+        }
+        ;
+        const value = ref7;
         exp.children.push(["", {
           type: "ReturnStatement",
-          children: [";return ", patternAsValue((ref5 = exp.bindings)[ref5.length - 1].pattern)],
+          children: [
+            ";return",
+            ...value
+          ],
           parent: exp
         }]);
         return;
-      case "FunctionExpression":
+      }
+      case "FunctionExpression": {
         if (exp.id) {
           exp.children.push([
             "",
@@ -1082,16 +1133,19 @@ ${input.slice(result.pos)}
           return;
         }
         break;
+      }
       case "ForStatement":
       case "IterationStatement":
       case "DoStatement":
-      case "ComptimeStatement":
+      case "ComptimeStatement": {
         wrapIterationReturningResults(exp, outer);
         return;
-      case "BlockStatement":
+      }
+      case "BlockStatement": {
         insertReturn(exp.expressions[exp.expressions.length - 1]);
         return;
-      case "IfStatement":
+      }
+      case "IfStatement": {
         insertReturn(exp.then);
         if (exp.else)
           insertReturn(exp.else.block);
@@ -1103,18 +1157,23 @@ ${input.slice(result.pos)}
             parent: exp
           }]);
         return;
-      case "PatternMatchingStatement":
+      }
+      case "PatternMatchingStatement": {
         insertReturn(exp.children[0]);
         return;
-      case "SwitchStatement":
+      }
+      case "SwitchStatement": {
         insertSwitchReturns(exp);
         return;
-      case "TryStatement":
+      }
+      case "TryStatement": {
         exp.blocks.forEach((block) => insertReturn(block));
         return;
+      }
     }
-    if (node[node.length - 1]?.type === "SemicolonDelimiter")
+    if (node[node.length - 1]?.type === "SemicolonDelimiter") {
       return;
+    }
     const returnStatement = wrapWithReturn(node[1]);
     node.splice(1, 1, returnStatement);
   }
@@ -1203,10 +1262,33 @@ ${input.slice(result.pos)}
     }
     expressions.unshift(...prefix);
   }
+  function processSignature(f) {
+    const { block, signature } = f;
+    if (hasAwait(block) && !f.async?.length) {
+      f.async.push("async ");
+      signature.modifier.async = true;
+    }
+    if (hasYield(block) && !f.generator?.length) {
+      if (f.type === "ArrowFunction") {
+        gatherRecursiveWithinFunction(block, ($) => $.type === "YieldExpression").forEach((y) => {
+          const i = y.children.findIndex(($1) => $1.type === "Yield");
+          return y.children.splice(i + 1, 0, {
+            type: "Error",
+            message: "Can't use yield inside of => arrow function"
+          });
+        });
+      } else {
+        f.generator.push("*");
+        signature.modifier.generator = true;
+      }
+    }
+  }
   function processFunctions(statements, config2) {
     gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
-      if (f.type === "FunctionExpression")
+      if (f.type === "FunctionExpression") {
         implicitFunctionBlock(f);
+      }
+      processSignature(f);
       processParams(f);
       return processReturn(f, config2.implicitReturns);
     });
@@ -1254,6 +1336,102 @@ ${input.slice(result.pos)}
     }
     return false;
   }
+  function processCoffeeDo(ws, expression) {
+    ws = insertTrimmingSpace(ws, "");
+    const args = [];
+    if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "ArrowFunction" || typeof expression === "object" && expression != null && "type" in expression && expression.type === "FunctionExpression") {
+      const { parameters } = expression;
+      const newParameters = {
+        ...parameters,
+        children: (() => {
+          const results = [];
+          for (let ref8 = parameters.children, i1 = 0, len3 = ref8.length; i1 < len3; i1++) {
+            let parameter = ref8[i1];
+            if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
+              let ref9;
+              if (ref9 = parameter.initializer) {
+                const initializer = ref9;
+                args.push(initializer.expression, parameter.delim);
+                parameter = {
+                  ...parameter,
+                  initializer: void 0,
+                  children: parameter.children.filter((a2) => a2 !== initializer)
+                };
+              } else {
+                args.push(parameter.children.filter(
+                  (a3) => a3 !== parameter.typeSuffix
+                ));
+              }
+            }
+            results.push(parameter);
+          }
+          return results;
+        })()
+      };
+      expression = {
+        ...expression,
+        parameters: newParameters,
+        children: expression.children.map(($2) => $2 === parameters ? newParameters : $2)
+      };
+    }
+    return {
+      type: "CallExpression",
+      children: [
+        makeLeftHandSideExpression(expression),
+        {
+          type: "Call",
+          args,
+          children: ["(", args, ")"]
+        }
+      ]
+    };
+  }
+  function makeAmpersandFunction(rhs) {
+    let { ref, typeSuffix, body } = rhs;
+    if (!(ref != null)) {
+      ref = makeRef("$");
+      inplacePrepend(ref, body);
+    }
+    if (body?.type === "ObjectExpression") {
+      body = makeLeftHandSideExpression(body);
+    }
+    const parameters = makeNode({
+      type: "Parameters",
+      children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
+      names: []
+    });
+    const expressions = [[" ", body]];
+    const block = makeNode({
+      type: "BlockStatement",
+      bare: true,
+      expressions,
+      children: [expressions],
+      implicitlyReturned: true
+    });
+    const async = [];
+    const children = [async, parameters, " =>", block];
+    const fn = makeNode({
+      type: "ArrowFunction",
+      async,
+      signature: {
+        modifier: {
+          async: !!async
+        }
+      },
+      children,
+      ref,
+      block,
+      parameters,
+      ampersandBlock: true,
+      body
+    });
+    if (isStatement(body)) {
+      braceBlock(block);
+      fn.ampersandBlock = false;
+      delete fn.body;
+    }
+    return fn;
+  }
 
   // source/parser/block.civet
   function blockWithPrefix(prefixStatements, block) {
@@ -1414,6 +1592,9 @@ ${input.slice(result.pos)}
       }
       return false;
     }
+    if (isToken(exp)) {
+      exp = exp.token;
+    }
     if (typeof exp === "string") {
       return /^\s*[\(\[\`\+\-\/]/.test(exp);
     }
@@ -1474,8 +1655,8 @@ ${input.slice(result.pos)}
       node.parent = parent;
     }
     if (node.children) {
-      for (let ref1 = node.children, i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
-        const child = ref1[i1];
+      for (let ref = node.children, i1 = 0, len1 = ref.length; i1 < len1; i1++) {
+        const child = ref[i1];
         addParentPointers(child, node);
       }
     }
@@ -1757,13 +1938,13 @@ ${input.slice(result.pos)}
     return;
   }
   function hasAwait(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
+    return gatherRecursiveWithinFunction(exp, ($1) => $1.type === "Await").length > 0;
   }
   function hasYield(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
+    return gatherRecursiveWithinFunction(exp, ($2) => $2.type === "Yield").length > 0;
   }
   function hasImportDeclaration(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "ImportDeclaration").length > 0;
+    return gatherRecursiveWithinFunction(exp, ($3) => $3.type === "ImportDeclaration").length > 0;
   }
   function deepCopy(node) {
     if (node == null)
@@ -1801,72 +1982,29 @@ ${input.slice(result.pos)}
       }
     }
   }
-  function makeAmpersandFunction(rhs) {
-    let { ref, typeSuffix, body } = rhs;
-    if (!(ref != null)) {
-      ref = makeRef("$");
-      inplacePrepend(ref, body);
-    }
-    if (body?.type === "ObjectExpression") {
-      body = makeLeftHandSideExpression(body);
-    }
-    const parameters = makeNode({
-      type: "Parameters",
-      children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
-      names: []
-    });
-    const expressions = [[" ", body]];
-    const block = makeNode({
-      type: "BlockStatement",
-      bare: true,
-      expressions,
-      children: [expressions],
-      implicitlyReturned: true
-    });
-    const children = [parameters, " =>", block];
-    const async = hasAwait(body);
-    if (async) {
-      children.unshift("async ");
-    }
-    const fn = makeNode({
-      type: "ArrowFunction",
-      signature: {
-        modifier: {
-          async
-        }
-      },
-      children,
-      ref,
-      block,
-      parameters,
-      ampersandBlock: true,
-      body
-    });
-    if (isStatement(body)) {
-      braceBlock(block);
-      fn.ampersandBlock = false;
-      delete fn.body;
-    }
-    return fn;
-  }
+  var skipParens = /* @__PURE__ */ new Set([
+    "AmpersandRef",
+    "CallExpression",
+    "Identifier",
+    "JSXElement",
+    "JSXFragment",
+    "Literal",
+    "MemberExpression",
+    "NewExpression",
+    "ParenthesizedExpression",
+    "Ref",
+    "Placeholder",
+    "StatementExpression"
+    // wrapIIFE
+  ]);
   function makeLeftHandSideExpression(expression) {
-    if (expression.parenthesized) {
-      return expression;
-    }
-    switch (expression.type) {
-      case "AmpersandRef":
-      case "CallExpression":
-      case "Identifier":
-      case "JSXElement":
-      case "JSXFragment":
-      case "Literal":
-      case "MemberExpression":
-      case "NewExpression":
-      case "ParenthesizedExpression":
-      case "Ref":
-      case "Placeholder":
-      case "StatementExpression":
+    if (isASTNodeObject(expression)) {
+      if (expression.parenthesized) {
+        return expression;
+      }
+      if (skipParens.has(expression.type)) {
         return expression;
+      }
     }
     return makeNode({
       type: "ParenthesizedExpression",
@@ -1894,8 +2032,8 @@ ${input.slice(result.pos)}
       node.parent = parent;
     }
     if (depth && isParent(node)) {
-      for (let ref2 = node.children, i3 = 0, len3 = ref2.length; i3 < len3; i3++) {
-        const child = ref2[i3];
+      for (let ref1 = node.children, i3 = 0, len3 = ref1.length; i3 < len3; i3++) {
+        const child = ref1[i3];
         updateParentPointers(child, node, depth - 1);
       }
     }
@@ -1966,11 +2104,11 @@ ${input.slice(result.pos)}
   }
   function wrapIIFE(expressions, asyncFlag) {
     let prefix;
-    let async;
+    const async = [];
     if (asyncFlag) {
-      async = "async ";
+      async.push("async ");
     } else if (hasAwait(expressions)) {
-      async = "async ";
+      async.push("async ");
       prefix = {
         type: "Await",
         children: ["await "]
@@ -1981,8 +2119,7 @@ ${input.slice(result.pos)}
       expressions,
       children: ["{", expressions, "}"],
       bare: false,
-      root: false,
-      parent: void 0
+      root: false
     });
     const parameters = {
       type: "Parameters",
@@ -1991,7 +2128,7 @@ ${input.slice(result.pos)}
     };
     const signature = {
       modifier: {
-        async: !!async
+        async: !!async.length
       },
       returnType: void 0
     };
@@ -2334,8 +2471,6 @@ ${input.slice(result.pos)}
       }
       return expandedOps;
     }
-    ;
-    return recurse;
   }
   function dotNumericLiteral(literal) {
     if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
@@ -2852,7 +2987,13 @@ ${input.slice(result.pos)}
     thisAssignments = thisAssignments.map(($6) => ["", $6, ";"]);
     const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices]);
     return [
-      ["", [decl, patternBindings, suffix, " = ", ref, ...splices], ";"],
+      ["", {
+        type: "Declaration",
+        children: [decl, patternBindings, suffix, " = ", ref, ...splices],
+        names: [],
+        bindings: []
+        // avoid implicit return of any bindings
+      }, ";"],
       ...thisAssignments,
       ...duplicateDeclarations.map(($7) => ["", $7, ";"])
     ];
@@ -3000,9 +3141,18 @@ ${input.slice(result.pos)}
         aliasBinding(p, ref);
         return ref;
       });
-      return declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
-        return i === 0 ? r : [", ", r];
-      }), "]"]);
+      return declarations.push({
+        type: "Declaration",
+        children: [
+          "const ",
+          key,
+          " = [",
+          ...refs.map((r, i) => i === 0 ? r : [", ", r]),
+          "]"
+        ],
+        names: [],
+        bindings: []
+      });
     });
     return declarations;
   }
@@ -3239,7 +3389,6 @@ ${input.slice(result.pos)}
         if (s.negated) {
           let m;
           if (!(m = condition.expression, typeof m === "object" && m != null && "type" in m && m.type === "UnaryExpression" && "children" in m && Array.isArray(m.children) && len2(m.children, 2) && m.children[0] === "!" && typeof m.children[1] === "object" && m.children[1] != null && "type" in m.children[1] && m.children[1].type === "ParenthesizedExpression")) {
-            console.log(condition.expression);
             throw new Error("Unsupported negated condition");
           }
           const { children } = condition.expression.children[1];
@@ -3494,8 +3643,7 @@ ${input.slice(result.pos)}
         token: " != null"
       };
       if (pre.length) {
-        let ref;
-        const lastPre = (ref = pre)[ref.length - 1];
+        const lastPre = pre[pre.length - 1];
         if (lastPre.token === "!") {
           post.token = " == null";
           pre = pre.slice(0, -1);
@@ -3539,9 +3687,9 @@ ${input.slice(result.pos)}
         }
       }
     }
-    let ref1;
-    while (ref1 = pre.length) {
-      const l = ref1;
+    let ref;
+    while (ref = pre.length) {
+      const l = ref;
       const last = pre[l - 1];
       if (last.type === "Await") {
         if (last.op) {
@@ -4147,49 +4295,69 @@ ${input.slice(result.pos)}
       return `${node}`;
     }
   }
-  function gen(node, options) {
-    if (node === null || node === void 0) {
-      return "";
-    }
-    if (typeof node === "string") {
-      options?.updateSourceMap?.(node);
-      return node;
-    }
-    if (Array.isArray(node)) {
-      return node.map(function(child) {
-        return gen(child, options);
-      }).join("");
-    }
-    if (typeof node === "object") {
-      if (options.js && node.ts) {
-        return "";
-      }
-      if (!options.js && node.js) {
+  function gen(root, options) {
+    const updateSourceMap = options?.sourceMap?.updateSourceMap;
+    return recurse(root);
+    function recurse(node) {
+      if (!(node != null)) {
         return "";
       }
-      if (node.type === "Error") {
-        options.errors ??= [];
-        options.errors.push(node);
-        return "";
+      if (typeof node === "string") {
+        updateSourceMap?.(node);
+        return node;
       }
-      if (node.$loc != null) {
-        const { token, $loc } = node;
-        options?.updateSourceMap?.(token, $loc.pos);
-        return token;
+      if (Array.isArray(node)) {
+        return node.map(recurse).join("");
       }
-      if (!node.children) {
-        switch (node.type) {
-          case "Ref": {
-            throw new Error(`Unpopulated ref ${stringify(node)}`);
+      if (typeof node === "object") {
+        if (options.js && node.ts) {
+          return "";
+        }
+        if (!options.js && node.js) {
+          return "";
+        }
+        if (node.type === "Error") {
+          const filename2 = options?.filename ?? "unknown";
+          let line = "?";
+          let column = "?";
+          let offset;
+          if (options && typeof options === "object" && "sourceMap" in options) {
+            const { sourceMap } = options;
+            line = sourceMap.data.srcLine + 1;
+            column = sourceMap.data.srcColumn + 1;
+            offset = sourceMap.data.srcOffset;
           }
+          options.errors ??= [];
+          options.errors.push(new import_lib3.ParseError(
+            node.message,
+            void 0,
+            // body
+            filename2,
+            line,
+            column,
+            offset
+          ));
+          return "";
+        }
+        if (node.$loc != null) {
+          const { token, $loc } = node;
+          updateSourceMap?.(token, $loc.pos);
+          return token;
         }
-        debugger;
-        throw new Error(`Unknown node ${stringify(node)}`);
+        if (!node.children) {
+          switch (node.type) {
+            case "Ref": {
+              throw new Error(`Unpopulated ref ${stringify(node)}`);
+            }
+          }
+          debugger;
+          throw new Error(`Unknown node ${stringify(node)}`);
+        }
+        return recurse(node.children);
       }
-      return gen(node.children, options);
+      debugger;
+      throw new Error(`Unknown node ${stringify(node)}`);
     }
-    debugger;
-    throw new Error(`Unknown node ${stringify(node)}`);
   }
   var generate_default = gen;
   function prune(node) {
@@ -4765,8 +4933,11 @@ ${js}`
       }
       if (results.length > 1) {
         return makeLeftHandSideExpression(results);
+      } else if (results.length) {
+        return results;
+      } else {
+        return ["void 0"];
       }
-      return results;
     } else {
       return blockOrExpression;
     }
@@ -4793,10 +4964,10 @@ ${js}`
       children.push(":void 0");
     }
     children.push(closeParen);
-    return {
+    return makeNode({
       type: "IfExpression",
       children
-    };
+    });
   }
   function expressionizeTypeIf([ws, ifOp, condition, t, e]) {
     const children = [
@@ -5293,7 +5464,8 @@ ${js}`
         while (expr.type === "ParenthesizedExpression") {
           expr = expr.expression;
         }
-        if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
+        let m;
+        if (m = expr.type, m === "AssignmentExpression" || m === "UpdateExpression") {
           if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
             pre.push("(");
             post.push([", ", lhs, ")"]);
@@ -5307,26 +5479,31 @@ ${js}`
         return;
       }
       const pre = [], post = [];
+      let ref4;
       switch (exp.type) {
-        case "AssignmentExpression":
+        case "AssignmentExpression": {
           if (!exp.lhs)
             return;
           exp.lhs.forEach((lhsPart, i) => {
-            let newLhs2 = extractAssignment(lhsPart[1]);
-            if (newLhs2) {
-              return lhsPart[1] = newLhs2;
+            let ref5;
+            if (ref5 = extractAssignment(lhsPart[1])) {
+              const newLhs = ref5;
+              return lhsPart[1] = newLhs;
             }
             ;
             return;
           });
           break;
-        case "UpdateExpression":
-          let newLhs = extractAssignment(exp.assigned);
-          if (newLhs) {
+        }
+        case "UpdateExpression": {
+          if (ref4 = extractAssignment(exp.assigned)) {
+            const newLhs = ref4;
             const i = exp.children.indexOf(exp.assigned);
             exp.assigned = exp.children[i] = newLhs;
           }
+          ;
           break;
+        }
       }
       if (pre.length)
         exp.children.unshift(...pre);
@@ -5336,13 +5513,7 @@ ${js}`
         const { assigned } = exp;
         const ref = makeRef();
         const newMemberExp = unchainOptionalMemberExpression(assigned, ref, (children) => {
-          return exp.children.map((c) => {
-            if (c === assigned) {
-              return children;
-            } else {
-              return c;
-            }
-          });
+          return exp.children.map(($) => $ === assigned ? children : $);
         });
         if (newMemberExp !== assigned) {
           if (newMemberExp.usesRef) {
@@ -5364,38 +5535,34 @@ ${js}`
       statements,
       (n) => n.type === "AssignmentExpression" && n.names === null,
       (exp) => {
-        let { lhs: $1, expression: $2 } = exp, tail = [], i = 0, len3 = $1.length;
+        let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length;
         let block;
-        let ref4;
-        if (exp.parent?.type === "BlockStatement" && !(ref4 = $1[$1.length - 1])?.[ref4.length - 1]?.special) {
+        let ref6;
+        if (exp.parent?.type === "BlockStatement" && !(ref6 = $1[$1.length - 1])?.[ref6.length - 1]?.special) {
           block = makeBlockFragment();
-          let ref5;
-          if (ref5 = prependStatementExpressionBlock(
+          let ref7;
+          if (ref7 = prependStatementExpressionBlock(
             { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
             block
           )) {
-            const ref = ref5;
-            exp.children = exp.children.map(function(c) {
-              if (c === $2)
-                return ref;
-              else
-                return c;
-            });
+            const ref = ref7;
+            exp.children = exp.children.map(($3) => $3 === $2 ? ref : $3);
             $2 = ref;
           } else {
             block = void 0;
           }
         }
-        if ($1.some((left) => left[left.length - 1].special)) {
+        let ref8;
+        if ($1.some(($4) => (ref8 = $4)[ref8.length - 1].special)) {
           if ($1.length !== 1)
             throw new Error("Only one assignment with id= is allowed");
           const [, lhs, , op] = $1[0];
           const { call, omitLhs } = op;
-          const index2 = exp.children.indexOf($2);
-          if (index2 < 0)
+          const index = exp.children.indexOf($2);
+          if (index < 0)
             throw new Error("Assertion error: exp not in AssignmentExpression");
           exp.children.splice(
-            index2,
+            index,
             1,
             exp.expression = $2 = [call, "(", lhs, ", ", $2, ")"]
           );
@@ -5404,12 +5571,15 @@ ${js}`
           }
         }
         let wrapped = false;
+        let i = 0;
         while (i < len3) {
           const lastAssignment = $1[i++];
           const [, lhs, , op] = lastAssignment;
-          if (op.token !== "=")
+          if (!(op.token === "=")) {
             continue;
-          if (lhs.type === "ObjectExpression" || lhs.type === "ObjectBindingPattern") {
+          }
+          let m1;
+          if (m1 = lhs.type, m1 === "ObjectExpression" || m1 === "ObjectBindingPattern") {
             if (!wrapped) {
               wrapped = true;
               lhs.children.splice(0, 0, "(");
@@ -5422,6 +5592,7 @@ ${js}`
           const lastAssignment = $1[i];
           if (lastAssignment[3].token === "=") {
             const lhs = lastAssignment[1];
+            let m2;
             if (lhs.type === "MemberExpression") {
               const members = lhs.children;
               const lastMember = members[members.length - 1];
@@ -5445,9 +5616,9 @@ ${js}`
                 }
                 exp.children = [$1];
                 exp.names = [];
-                return exp;
+                break;
               }
-            } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
+            } else if (m2 = lhs.type, m2 === "ObjectBindingPattern" || m2 === "ArrayBindingPattern") {
               processBindingPatternLHS(lhs, tail);
             }
           }
@@ -5480,10 +5651,12 @@ ${js}`
           i--;
         }
         exp.names = $1.flatMap(([, l]) => l.names || []);
-        const index = exp.children.indexOf($2);
-        if (index < 0)
-          throw new Error("Assertion error: exp not in AssignmentExpression");
-        exp.children.splice(index + 1, 0, ...tail);
+        if (tail.length) {
+          const index = exp.children.indexOf($2);
+          if (index < 0)
+            throw new Error("Assertion error: exp not in AssignmentExpression");
+          exp.children.splice(index + 1, 0, ...tail);
+        }
         if (block) {
           block.parent = exp.parent;
           block.expressions.push(["", exp]);
@@ -5542,9 +5715,9 @@ ${js}`
       }
       j++;
     }
-    let ref6;
-    if (ref6 = conditions.length) {
-      const l = ref6;
+    let ref9;
+    if (ref9 = conditions.length) {
+      const l = ref9;
       const cs = flatJoin(conditions, " && ");
       return {
         ...exp,
@@ -5581,8 +5754,8 @@ ${js}`
     return gatherRecursiveAll(node, (n) => n.type === "UnaryType").forEach((unary) => {
       let last;
       let count = 0;
-      let ref7;
-      while (unary.suffix.length && (ref7 = unary.suffix)[ref7.length - 1]?.token === "?") {
+      let ref10;
+      while (unary.suffix.length && (ref10 = unary.suffix)[ref10.length - 1]?.token === "?") {
         last = unary.suffix.pop();
         count++;
       }
@@ -5613,14 +5786,14 @@ ${js}`
     });
   }
   function processStatementExpressions(statements) {
-    gatherRecursiveAll(statements, ($) => $.type === "StatementExpression").forEach((_exp) => {
+    gatherRecursiveAll(statements, ($5) => $5.type === "StatementExpression").forEach((_exp) => {
       const exp = _exp;
       const { statement } = exp;
-      let ref8;
+      let ref11;
       switch (statement.type) {
         case "IfStatement": {
-          if (ref8 = expressionizeIfStatement(statement)) {
-            const expression = ref8;
+          if (ref11 = expressionizeIfStatement(statement)) {
+            const expression = ref11;
             return replaceNode(statement, expression, exp);
           } else {
             return replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -5662,7 +5835,7 @@ ${js}`
         }
       } else if (index > start + 1) {
         ref = makeRef();
-        subexp = children.splice(start, index);
+        subexp = children.splice(start, index - start);
       } else {
         throw new Error("Invalid parse tree for negative index access");
       }
@@ -5671,7 +5844,7 @@ ${js}`
         exp.hoistDec = hoistDec;
         children.splice(start, 0, makeLeftHandSideExpression(refAssignment));
       }
-      return exp.len.children = [
+      exp.len.children = [
         ref,
         ".length"
       ];
@@ -5743,11 +5916,11 @@ ${js}`
   function processPlaceholders(statements) {
     const placeholderMap = /* @__PURE__ */ new Map();
     const liftedIfs = /* @__PURE__ */ new Set();
-    gatherRecursiveAll(statements, ($3) => $3.type === "Placeholder").forEach((_exp) => {
+    gatherRecursiveAll(statements, ($6) => $6.type === "Placeholder").forEach((_exp) => {
       const exp = _exp;
       let ancestor;
       if (exp.subtype === ".") {
-        ({ ancestor } = findAncestor(exp, ($4) => $4.type === "Call"));
+        ({ ancestor } = findAncestor(exp, ($7) => $7.type === "Call"));
         ancestor = ancestor?.parent;
         while (ancestor?.parent?.type === "UnaryExpression" || ancestor?.parent?.type === "NewExpression") {
           ancestor = ancestor.parent;
@@ -5766,10 +5939,10 @@ ${js}`
           if (type === "IfStatement") {
             liftedIfs.add(ancestor2);
           }
-          let m;
-          let m1;
+          let m3;
+          let m4;
           return type === "Call" || // Block, except for if/else blocks when condition already lifted
-          type === "BlockStatement" && !((m = ancestor2.parent, typeof m === "object" && m != null && "type" in m && m.type === "IfStatement") && liftedIfs.has(ancestor2.parent)) && !((m1 = ancestor2.parent, typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "ElseClause" && "parent" in m1 && typeof m1.parent === "object" && m1.parent != null && "type" in m1.parent && m1.parent.type === "IfStatement") && liftedIfs.has(ancestor2.parent.parent)) || type === "PipelineExpression" || // Declaration
+          type === "BlockStatement" && !((m3 = ancestor2.parent, typeof m3 === "object" && m3 != null && "type" in m3 && m3.type === "IfStatement") && liftedIfs.has(ancestor2.parent)) && !((m4 = ancestor2.parent, typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "ElseClause" && "parent" in m4 && typeof m4.parent === "object" && m4.parent != null && "type" in m4.parent && m4.parent.type === "IfStatement") && liftedIfs.has(ancestor2.parent.parent)) || type === "PipelineExpression" || // Declaration
           type === "Initializer" || // Right-hand side of assignment
           type === "AssignmentExpression" && findChildIndex(ancestor2, child2) === ancestor2.children.indexOf(ancestor2.expression) || type === "ReturnStatement" || type === "YieldExpression";
         }));
@@ -5848,8 +6021,8 @@ ${js}`
       for (let i4 = 0, len3 = placeholders.length; i4 < len3; i4++) {
         const placeholder = placeholders[i4];
         typeSuffix ??= placeholder.typeSuffix;
-        let ref9;
-        replaceNode((ref9 = placeholder.children)[ref9.length - 1], ref);
+        let ref12;
+        replaceNode((ref12 = placeholder.children)[ref12.length - 1], ref);
       }
       const { parent } = ancestor;
       const body = maybeUnwrap(ancestor);
@@ -5880,9 +6053,9 @@ ${js}`
         fnExp = makeLeftHandSideExpression(fnExp);
       }
       replaceNode(ancestor, fnExp, parent);
-      let ref10;
-      if (ref10 = getTrimmingSpace(body)) {
-        const ws = ref10;
+      let ref13;
+      if (ref13 = getTrimmingSpace(body)) {
+        const ws = ref13;
         inplaceInsertTrimmingSpace(body, "");
         inplacePrepend(ws, fnExp);
       }
@@ -5907,43 +6080,39 @@ ${js}`
         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 { delim: restDelim } = rest, lastAfterProp = after[after.length - 1], { delim: lastDelim, children: lastAfterChildren } = lastAfterProp;
-        rest = {
-          ...rest,
-          delim: lastDelim,
-          children: [...rest.children.slice(0, -1), lastDelim]
-        };
-        after = [
-          ...after.slice(0, -1),
-          {
-            ...lastAfterProp,
-            delim: restDelim,
-            children: [...lastAfterChildren.slice(0, -1), restDelim]
-          }
-        ];
-      }
-      let ref11;
-      if (Array.isArray(rest.delim) && (ref11 = rest.delim)[ref11.length - 1]?.token === ",") {
-        rest.delim = rest.delim.slice(0, -1);
-        rest.children = [...rest.children.slice(0, -1), rest.delim];
-      }
-      const children = [...props, ...after, rest];
-      return {
-        children,
-        names
+    }
+    let after = props.slice(restIndex + 1);
+    let rest = props[restIndex];
+    props = props.slice(0, restIndex);
+    if (after.length) {
+      const { delim: restDelim } = rest, lastAfterProp = after[after.length - 1], { delim: lastDelim, children: lastAfterChildren } = lastAfterProp;
+      rest = {
+        ...rest,
+        delim: lastDelim,
+        children: [...rest.children.slice(0, -1), lastDelim]
       };
+      after = [
+        ...after.slice(0, -1),
+        {
+          ...lastAfterProp,
+          delim: restDelim,
+          children: [...lastAfterChildren.slice(0, -1), restDelim]
+        }
+      ];
     }
-    return {
-      children: [{
+    let ref14;
+    if (Array.isArray(rest.delim) && (ref14 = rest.delim)[ref14.length - 1]?.token === ",") {
+      rest.delim = rest.delim.slice(0, -1);
+      rest.children = [...rest.children.slice(0, -1), rest.delim];
+    }
+    const children = [...props, ...after, rest];
+    if (restCount > 1) {
+      children.push({
         type: "Error",
         message: "Multiple rest properties in object pattern"
-      }, props]
-    };
+      });
+    }
+    return { children, names };
   }
   function replaceNodes(root, predicate, replacer) {
     if (!(root != null)) {
@@ -6126,6 +6295,7 @@ ${js}`
     YieldExpression,
     ArrowFunction,
     FatArrow,
+    FatArrowToken,
     TrailingDeclaration,
     TrailingPipe,
     FatArrowBody,
@@ -6246,9 +6416,11 @@ ${js}`
     NoCommaBracedOrEmptyBlock,
     NoPostfixBracedOrEmptyBlock,
     EmptyBlock,
+    BlockOrEmptyStatement,
     BlockOrEmpty,
-    EmptyBareBlock,
     EmptyStatementBareBlock,
+    EmptyBareBlock,
+    NoBlock,
     BracedBlock,
     NoPostfixBracedBlock,
     NoCommaBracedBlock,
@@ -7267,13 +7439,14 @@ ${js}`
   }
   var StatementExpression$0 = DebuggerStatement;
   var StatementExpression$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(IfStatement), function($skip, $loc, $0, $1) {
-    if (!$1.else && isEmptyBareBlock($1.then))
+    if (!$1.else && $1.then.implicit)
       return $skip;
     return $1;
   });
   var StatementExpression$2 = (0, import_lib3.$TS)((0, import_lib3.$S)(IterationExpression), function($skip, $loc, $0, $1) {
-    if (isEmptyBareBlock($1.block))
+    if ($1.block.implicit && $1.subtype !== "DoStatement" && $1.subtype !== "ComptimeStatement") {
       return $skip;
+    }
     return $1;
   });
   var StatementExpression$3 = SwitchStatement;
@@ -7364,7 +7537,7 @@ ${js}`
       return $0;
     return $skip;
   });
-  var ForbiddenImplicitCalls$7 = (0, import_lib3.$S)(PostfixStatement, EmptyStatementBareBlock);
+  var ForbiddenImplicitCalls$7 = (0, import_lib3.$S)(PostfixStatement, NoBlock);
   var ForbiddenImplicitCalls$8 = (0, import_lib3.$EXPECT)($L5, 'ForbiddenImplicitCalls "... "');
   var ForbiddenImplicitCalls$$ = [ForbiddenImplicitCalls$0, ForbiddenImplicitCalls$1, ForbiddenImplicitCalls$2, ForbiddenImplicitCalls$3, ForbiddenImplicitCalls$4, ForbiddenImplicitCalls$5, ForbiddenImplicitCalls$6, ForbiddenImplicitCalls$7, ForbiddenImplicitCalls$8];
   function ForbiddenImplicitCalls(ctx, state2) {
@@ -7589,11 +7762,10 @@ ${js}`
     var post = $3;
     return processUnaryExpression(pre, exp, post);
   });
-  var UnaryExpression$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(CoffeeDoEnabled, Do, __, (0, import_lib3.$C)((0, import_lib3.$S)(LeftHandSideExpression, (0, import_lib3.$N)((0, import_lib3.$S)(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var UnaryExpression$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(CoffeeDoEnabled, Do, __, (0, import_lib3.$C)(ArrowFunction, (0, import_lib3.$S)(LeftHandSideExpression, (0, import_lib3.$N)((0, import_lib3.$S)(__, AssignmentOpSymbol))), ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
     var ws = $3;
     var exp = $4;
-    ws = insertTrimmingSpace(ws, "");
-    return ["(", ...ws, exp, ")()"];
+    return processCoffeeDo(ws, exp);
   });
   var UnaryExpression$$ = [UnaryExpression$0, UnaryExpression$1];
   function UnaryExpression(ctx, state2) {
@@ -7815,17 +7987,10 @@ ${js}`
     var async = $1;
     var parameters = $2;
     var suffix = $3;
+    var arrow = $4;
     var expOrBlock = $5;
-    if (hasAwait(expOrBlock) && !async) {
-      async = "async ";
-    }
-    let error;
-    if (hasYield(expOrBlock)) {
-      error = {
-        type: "Error",
-        message: "Can't use yield inside of => arrow function"
-      };
-    }
+    if (!async)
+      async = [];
     return {
       type: "ArrowFunction",
       signature: {
@@ -7836,25 +8001,31 @@ ${js}`
       },
       parameters,
       returnType: suffix,
-      ts: false,
       async,
       block: expOrBlock,
-      children: [async, $0.slice(1), error]
+      children: [async, parameters, suffix, arrow, expOrBlock]
     };
   });
   var ArrowFunction$$ = [ArrowFunction$0, ArrowFunction$1];
   function ArrowFunction(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "ArrowFunction", ArrowFunction$$);
   }
-  var FatArrow$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(_), (0, import_lib3.$C)((0, import_lib3.$EXPECT)($L13, 'FatArrow "=>"'), (0, import_lib3.$EXPECT)($L14, 'FatArrow "\u21D2"'))), function($skip, $loc, $0, $1, $2) {
+  var FatArrow$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(_), FatArrowToken), function($skip, $loc, $0, $1, $2) {
     var ws = $1;
+    var arrow = $2;
     if (!ws)
-      return " =>";
-    return [$1, "=>"];
+      ws = " ";
+    return [ws, arrow];
   });
   function FatArrow(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "FatArrow", FatArrow$0);
   }
+  var FatArrowToken$0 = (0, import_lib3.$TV)((0, import_lib3.$C)((0, import_lib3.$EXPECT)($L13, 'FatArrowToken "=>"'), (0, import_lib3.$EXPECT)($L14, 'FatArrowToken "\u21D2"')), function($skip, $loc, $0, $1) {
+    return { $loc, token: "=>" };
+  });
+  function FatArrowToken(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "FatArrowToken", FatArrowToken$0);
+  }
   var TrailingDeclaration$0 = (0, import_lib3.$S)((0, import_lib3.$E)(_), (0, import_lib3.$C)(ConstAssignment, LetAssignment));
   function TrailingDeclaration(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "TrailingDeclaration", TrailingDeclaration$0);
@@ -8366,7 +8537,13 @@ ${js}`
       children: [at, {
         type: "PropertyAccess",
         name: id,
-        children: [".", id]
+        children: [".", {
+          $loc: {
+            pos: $loc.pos + 1,
+            length: $loc.length - 1
+          },
+          token: id
+        }]
       }],
       thisShorthand: true
     };
@@ -9038,11 +9215,17 @@ ${js}`
   var ParameterElement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(_), (0, import_lib3.$E)(AccessModifier), (0, import_lib3.$E)(_), (0, import_lib3.$C)(NWBindingIdentifier, BindingPattern), (0, import_lib3.$E)(TypeSuffix), (0, import_lib3.$E)(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
     var accessModifier = $2;
     var binding = $4;
+    var typeSuffix = $5;
+    var initializer = $6;
+    var delim = $7;
     return {
       type: "Parameter",
       children: $0,
       names: binding.names,
-      accessModifier
+      typeSuffix,
+      accessModifier,
+      initializer,
+      delim
     };
   });
   function ParameterElement(ctx, state2) {
@@ -9457,7 +9640,6 @@ ${js}`
       name: id?.name,
       parameters,
       returnType: suffix,
-      ts: false,
       async,
       generator,
       modifier: {
@@ -9483,14 +9665,6 @@ ${js}`
         ts: true
       };
     }
-    if (hasAwait(block) && !signature.async.length) {
-      signature.async.push("async ");
-      signature.modifier.async = true;
-    }
-    if (hasYield(block) && !signature.generator.length) {
-      signature.generator.push("*");
-      signature.modifier.generator = true;
-    }
     return {
       ...signature,
       type: "FunctionExpression",
@@ -9662,15 +9836,21 @@ ${js}`
   function OperatorDeclaration(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "OperatorDeclaration", OperatorDeclaration$$);
   }
-  var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Operator, (0, import_lib3.$E)((0, import_lib3.$S)(_, Function2)), _, Identifier, (0, import_lib3.$E)(OperatorBehavior), (0, import_lib3.$E)(_), NonEmptyParameters, (0, import_lib3.$E)(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
-    var op = $1;
-    var func = $2;
-    var w1 = $3;
-    var id = $4;
-    var behavior = $5;
-    var w2 = $6;
-    var parameters = $7;
-    var suffix = $8;
+  var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)((0, import_lib3.$S)(Async, _)), Operator, (0, import_lib3.$E)((0, import_lib3.$S)(_, Function2)), (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), Star)), _, Identifier, (0, import_lib3.$E)(OperatorBehavior), (0, import_lib3.$E)(_), NonEmptyParameters, (0, import_lib3.$E)(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
+    var async = $1;
+    var op = $2;
+    var func = $3;
+    var generator = $4;
+    var w1 = $5;
+    var id = $6;
+    var behavior = $7;
+    var w2 = $8;
+    var parameters = $9;
+    var suffix = $10;
+    if (!async)
+      async = [];
+    if (!generator)
+      generator = [];
     if (!func) {
       func = { $loc: op.$loc, token: "function" };
     } else {
@@ -9679,12 +9859,17 @@ ${js}`
     return {
       type: "FunctionSignature",
       id,
-      modifier: {},
+      name: id.name,
       parameters,
       returnType: suffix,
-      ts: false,
+      async,
+      generator,
+      modifier: {
+        async: !!async.length,
+        generator: !!generator.length
+      },
       block: null,
-      children: [func, w1, id, w2, parameters, suffix],
+      children: [async, func, generator, w1, id, w2, parameters, suffix],
       behavior
     };
   });
@@ -9734,27 +9919,24 @@ ${js}`
     var suffix = $3;
     var arrow = $5;
     var block = $6;
-    if (hasAwait(block) && !async) {
-      async = "async ";
-    }
-    let generator;
-    if (hasYield(block)) {
-      generator = "*";
-    }
+    if (!async)
+      async = [];
+    const generator = [];
     return {
       type: "FunctionExpression",
       id: void 0,
       parameters,
       returnType: suffix,
-      ts: false,
       async,
       generator,
       block,
       signature: {
         name: void 0,
+        async,
+        generator,
         modifier: {
-          async: !!async,
-          generator: !!generator
+          async: !!async.length,
+          generator: !!generator.length
         },
         returnType: suffix
       },
@@ -9904,43 +10086,62 @@ ${js}`
       expressions,
       children: [$1, expressions, $2],
       bare: false,
-      empty: true
+      empty: true,
+      implicit: true
     };
   });
   function EmptyBlock(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "EmptyBlock", EmptyBlock$0);
   }
+  var BlockOrEmptyStatement$0 = Block;
+  var BlockOrEmptyStatement$1 = (0, import_lib3.$T)((0, import_lib3.$S)(NoBlock, EmptyStatementBareBlock), function(value) {
+    return value[1];
+  });
+  var BlockOrEmptyStatement$$ = [BlockOrEmptyStatement$0, BlockOrEmptyStatement$1];
+  function BlockOrEmptyStatement(ctx, state2) {
+    return (0, import_lib3.$EVENT_C)(ctx, state2, "BlockOrEmptyStatement", BlockOrEmptyStatement$$);
+  }
   var BlockOrEmpty$0 = Block;
-  var BlockOrEmpty$1 = EmptyStatementBareBlock;
+  var BlockOrEmpty$1 = (0, import_lib3.$T)((0, import_lib3.$S)(NoBlock, EmptyBlock), function(value) {
+    return value[1];
+  });
   var BlockOrEmpty$$ = [BlockOrEmpty$0, BlockOrEmpty$1];
   function BlockOrEmpty(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "BlockOrEmpty", BlockOrEmpty$$);
   }
-  var EmptyBareBlock$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
-    const expressions = [];
+  var EmptyStatementBareBlock$0 = (0, import_lib3.$TV)(InsertEmptyStatement, function($skip, $loc, $0, $1) {
+    var s = $0;
+    const expressions = [["", s]];
     return {
       type: "BlockStatement",
       expressions,
       children: [expressions],
-      bare: true
+      bare: true,
+      empty: true,
+      implicit: true,
+      semicolon: s.children[0]
     };
   });
-  function EmptyBareBlock(ctx, state2) {
-    return (0, import_lib3.$EVENT)(ctx, state2, "EmptyBareBlock", EmptyBareBlock$0);
+  function EmptyStatementBareBlock(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "EmptyStatementBareBlock", EmptyStatementBareBlock$0);
   }
-  var EmptyStatementBareBlock$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$Y)(EOS), (0, import_lib3.$N)(IndentedFurther), InsertEmptyStatement), function($skip, $loc, $0, $1, $2, $3) {
-    var s = $3;
-    const expressions = [["", s]];
+  var EmptyBareBlock$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
+    const expressions = [];
     return {
       type: "BlockStatement",
       expressions,
       children: [expressions],
       bare: true,
-      semicolon: s.children[0]
+      empty: true,
+      implicit: true
     };
   });
-  function EmptyStatementBareBlock(ctx, state2) {
-    return (0, import_lib3.$EVENT)(ctx, state2, "EmptyStatementBareBlock", EmptyStatementBareBlock$0);
+  function EmptyBareBlock(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "EmptyBareBlock", EmptyBareBlock$0);
+  }
+  var NoBlock$0 = (0, import_lib3.$S)((0, import_lib3.$Y)(EOS), (0, import_lib3.$N)(IndentedFurther));
+  function NoBlock(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "NoBlock", NoBlock$0);
   }
   var BracedBlock$0 = NonSingleBracedBlock;
   var BracedBlock$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(InsertOpenBrace, (0, import_lib3.$N)(EOS), PostfixedSingleLineStatements, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
@@ -11792,7 +11993,7 @@ ${js}`
   function IterationExpression(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "IterationExpression", IterationExpression$0);
   }
-  var LoopStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(LoopClause, BlockOrEmpty), function($skip, $loc, $0, $1, $2) {
+  var LoopStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(LoopClause, BlockOrEmptyStatement), function($skip, $loc, $0, $1, $2) {
     var clause = $1;
     var block = $2;
     return {
@@ -11870,7 +12071,7 @@ ${js}`
   function ComptimeStatement(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "ComptimeStatement", ComptimeStatement$0);
   }
-  var WhileStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(WhileClause, BlockOrEmpty), function($skip, $loc, $0, $1, $2) {
+  var WhileStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(WhileClause, BlockOrEmptyStatement), function($skip, $loc, $0, $1, $2) {
     var clause = $1;
     var block = $2;
     return {
@@ -11901,7 +12102,7 @@ ${js}`
   function WhileClause(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "WhileClause", WhileClause$0);
   }
-  var ForStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ForClause, BlockOrEmpty), function($skip, $loc, $0, $1, $2) {
+  var ForStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ForClause, BlockOrEmptyStatement), function($skip, $loc, $0, $1, $2) {
     var clause = $1;
     var block = $2;
     block = blockWithPrefix(clause.blockPrefix, block);
@@ -16479,34 +16680,22 @@ ${js}`
     }
   }
 
-  // source/util.civet
-  var util_exports = {};
-  __export(util_exports, {
+  // source/sourcemap.civet
+  var sourcemap_exports = {};
+  __export(sourcemap_exports, {
     SourceMap: () => SourceMap,
     base64Encode: () => base64Encode,
     locationTable: () => locationTable,
     lookupLineColumn: () => lookupLineColumn
   });
-  var smRegexp;
-  var prettySourceExcerpt;
-  var VLQ_SHIFT;
-  var VLQ_CONTINUATION_BIT;
-  var VLQ_VALUE_MASK;
-  var encodeVlq;
-  var BASE64_CHARS;
-  var encodeBase64;
-  var vlqTable;
-  var vlqChars;
-  var decodeError;
-  var decodeVLQ;
-  var remapPosition;
   var locationTable = function(input) {
-    var linesRe, lines, line, pos, result;
-    linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
-    lines = [];
-    line = 0;
-    pos = 0;
-    while (result = linesRe.exec(input)) {
+    const linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
+    const lines = [];
+    let line = 0;
+    let pos = 0;
+    let ref;
+    while (ref = linesRe.exec(input)) {
+      const result = ref;
       pos += result[0].length;
       lines[line++] = pos;
       if (pos === input.length) {
@@ -16516,39 +16705,39 @@ ${js}`
     return lines;
   };
   var lookupLineColumn = function(table, pos) {
-    var l, prevEnd;
-    l = 0;
-    prevEnd = 0;
+    let l = 0;
+    let prevEnd = 0;
     while (table[l] <= pos) {
       prevEnd = table[l++];
     }
     return [l, pos - prevEnd];
   };
   var SourceMap = function(sourceString) {
-    var srcTable, sm, EOL2;
-    srcTable = locationTable(sourceString);
-    sm = {
+    const srcTable = locationTable(sourceString);
+    const sm = {
       lines: [[]],
-      lineNum: 0,
+      line: 0,
       colOffset: 0,
+      // relative to previous entry
+      srcLine: 0,
+      srcColumn: 0,
+      srcOffset: 0,
       srcTable
     };
-    EOL2 = /\r?\n|\r/;
+    const EOL2 = /\r?\n|\r/;
     return {
       data: sm,
       source: function() {
         return sourceString;
       },
       renderMappings: function() {
-        var lastSourceLine, lastSourceColumn;
-        lastSourceLine = 0;
-        lastSourceColumn = 0;
-        return sm.lines.map(function(line) {
-          return line.map(function(entry) {
-            var colDelta, sourceFileIndex, srcLine, srcCol, lineDelta;
+        let lastSourceLine = 0;
+        let lastSourceColumn = 0;
+        return sm.lines.map((line) => {
+          return line.map((entry) => {
             if (entry.length === 4) {
-              [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
-              lineDelta = srcLine - lastSourceLine;
+              let [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
+              const lineDelta = srcLine - lastSourceLine;
               colDelta = srcCol - lastSourceColumn;
               lastSourceLine = srcLine;
               lastSourceColumn = srcCol;
@@ -16572,102 +16761,69 @@ ${js}`
           }
         };
       },
-      updateSourceMap: function(outputStr, inputPos) {
-        var outLines, srcLine, srcCol;
-        outLines = outputStr.split(EOL2);
+      updateSourceMap: function(outputStr, inputPos, colOffset = 0) {
+        const outLines = outputStr.split(EOL2);
+        let srcLine, srcCol;
         if (inputPos != null) {
           [srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
+          srcCol += colOffset;
+          sm.srcLine = srcLine;
+          sm.srcColumn = srcCol;
+          sm.srcOffset = inputPos + outputStr.length;
         }
-        outLines.forEach(function(line, i) {
-          var l;
+        for (let i1 = 0, len3 = outLines.length; i1 < len3; i1++) {
+          const i = i1;
+          const line = outLines[i1];
           if (i > 0) {
-            sm.lineNum++;
+            sm.line++;
+            sm.srcLine++;
             sm.colOffset = 0;
-            sm.lines[sm.lineNum] = [];
-            srcCol = 0;
+            sm.lines[sm.line] = [];
+            sm.srcColumn = srcCol = colOffset;
           }
-          l = sm.colOffset;
+          const l = sm.colOffset;
           sm.colOffset = line.length;
+          sm.srcColumn += line.length;
           if (inputPos != null) {
-            return sm.lines[sm.lineNum].push([l, 0, srcLine + i, srcCol]);
-          } else if (l !== 0) {
-            return sm.lines[sm.lineNum].push([l]);
+            sm.lines[sm.line].push([l, 0, srcLine + i, srcCol]);
+          } else if (l != 0) {
+            sm.lines[sm.line].push([l]);
           }
-          ;
-          return;
-        });
+        }
         return;
       }
     };
   };
-  SourceMap.parseWithLines = function(base64encodedJSONstr) {
-    var json, sourceLine, sourceColumn, lines;
-    json = JSON.parse(Buffer.from(base64encodedJSONstr, "base64").toString("utf8"));
-    sourceLine = 0;
-    sourceColumn = 0;
-    lines = json.mappings.split(";").map(function(line) {
-      if (line.length === 0) {
-        return [];
-      }
-      return line.split(",").map(function(entry) {
-        var result;
-        result = decodeVLQ(entry);
-        switch (result.length) {
-          case 1: {
-            return [result[0]];
-          }
-          case 4: {
-            return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3]];
-          }
-          case 5: {
-            return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3], result[4]];
-          }
-          default: {
-            throw new Error("Unknown source map entry", result);
-          }
-        }
-      });
+  var smRegexp = /\n\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,([+a-zA-Z0-9\/]*=?=?)$/;
+  var remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
+    let sourceMapText;
+    const codeWithoutSourceMap = codeWithSourceMap.replace(smRegexp, (match, sm) => {
+      sourceMapText = sm;
+      return "";
     });
-    json.lines = lines;
-    return json;
-  };
-  smRegexp = /\n\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,([+a-zA-Z0-9\/]*=?=?)$/;
-  SourceMap.remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
-    var sourceMapText, codeWithoutSourceMap, remappedSourceMapJSON, newSourceMap, remappedCodeWithSourceMap, parsed, composedLines;
-    sourceMapText = null;
-    codeWithoutSourceMap = codeWithSourceMap.replace(
-      smRegexp,
-      (match, sm) => {
-        sourceMapText = sm;
-        return "";
-      }
-    );
     if (sourceMapText) {
-      parsed = SourceMap.parseWithLines(sourceMapText);
-      composedLines = SourceMap.composeLines(upstreamMap.data.lines, parsed.lines);
+      const parsed = parseWithLines(sourceMapText);
+      const composedLines = composeLines(upstreamMap.data.lines, parsed.lines);
       upstreamMap.data.lines = composedLines;
     }
-    remappedSourceMapJSON = upstreamMap.json(sourcePath, targetPath);
-    newSourceMap = `${"sourceMapping"}URL=data:application/json;charset=utf-8;base64,${base64Encode(JSON.stringify(remappedSourceMapJSON))}`;
-    remappedCodeWithSourceMap = `${codeWithoutSourceMap}
+    const remappedSourceMapJSON = upstreamMap.json(sourcePath, targetPath);
+    const newSourceMap = `${"sourceMapping"}URL=data:application/json;charset=utf-8;base64,${base64Encode(JSON.stringify(remappedSourceMapJSON))}`;
+    const remappedCodeWithSourceMap = `${codeWithoutSourceMap}
 //# ${newSourceMap}`;
     return remappedCodeWithSourceMap;
   };
-  SourceMap.composeLines = function(upstreamMapping, lines) {
-    return lines.map(function(line, l) {
-      return line.map(function(entry) {
-        var colDelta, sourceFileIndex, srcLine, srcCol, srcPos, upstreamLine, upstreamCol;
+  var composeLines = function(upstreamMapping, lines) {
+    return lines.map((line) => {
+      return line.map((entry) => {
         if (entry.length === 1) {
           return entry;
         }
-        ;
-        [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
-        srcPos = remapPosition([srcLine, srcCol], upstreamMapping);
+        const [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
+        const srcPos = remapPosition([srcLine, srcCol], upstreamMapping);
         if (!srcPos) {
           return [entry[0]];
         }
-        ;
-        [upstreamLine, upstreamCol] = srcPos;
+        const [upstreamLine, upstreamCol] = srcPos;
         if (entry.length === 4) {
           return [colDelta, sourceFileIndex, upstreamLine, upstreamCol];
         }
@@ -16675,44 +16831,50 @@ ${js}`
       });
     });
   };
-  prettySourceExcerpt = function(source, location, length) {
-    var lines, lineNum, colNum, i, line, lineNumStr;
-    lines = source.split(/\r?\n|\r/);
-    lineNum = location.line;
-    colNum = location.column;
-    for (let start = lineNum - 2, end = lineNum + 2, i1 = i = start, asc = start <= end; asc ? i1 <= end : i1 >= end; i = asc ? ++i1 : --i1) {
-      if (i < 0 || i >= lines.length) {
-        continue;
-      }
-      line = lines[i];
-      lineNumStr = (i + 1).toString();
-      while (lineNumStr.length < 4) {
-        lineNumStr = " " + lineNumStr;
-      }
-      if (i === lineNum) {
-        console.log(`${lineNumStr}: ${line}`);
-        console.log(" ".repeat(lineNumStr.length + 2 + colNum) + "^".repeat(length));
-      } else {
-        console.log(`${lineNumStr}: ${line}`);
+  var parseWithLines = function(base64encodedJSONstr) {
+    const json = JSON.parse(Buffer.from(base64encodedJSONstr, "base64").toString("utf8"));
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    const lines = json.mappings.split(";").map((line) => {
+      if (line.length === 0) {
+        return [];
       }
-    }
-    return;
+      return line.split(",").map((entry) => {
+        const result = decodeVLQ(entry);
+        switch (result.length) {
+          case 1: {
+            return [result[0]];
+          }
+          case 4: {
+            return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3]];
+          }
+          case 5: {
+            return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3], result[4]];
+          }
+          default: {
+            throw new Error("Unknown source map entry", result);
+          }
+        }
+      });
+    });
+    json.lines = lines;
+    return json;
   };
-  VLQ_SHIFT = 5;
-  VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
-  VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
-  encodeVlq = function(value) {
-    var answer, valueToEncode, signBit, nextChunk;
-    answer = "";
-    let ref;
+  Object.assign(SourceMap, { remap, parseWithLines, composeLines });
+  var VLQ_SHIFT = 5;
+  var VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
+  var VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
+  var encodeVlq = function(value) {
+    let answer = "";
+    let ref1;
     if (value < 0)
-      ref = 1;
+      ref1 = 1;
     else
-      ref = 0;
-    signBit = ref;
-    valueToEncode = (Math.abs(value) << 1) + signBit;
+      ref1 = 0;
+    const signBit = ref1;
+    let valueToEncode = (Math.abs(value) << 1) + signBit;
     while (valueToEncode || !answer) {
-      nextChunk = valueToEncode & VLQ_VALUE_MASK;
+      let nextChunk = valueToEncode & VLQ_VALUE_MASK;
       valueToEncode = valueToEncode >> VLQ_SHIFT;
       if (valueToEncode) {
         nextChunk |= VLQ_CONTINUATION_BIT;
@@ -16721,57 +16883,53 @@ ${js}`
     }
     return answer;
   };
-  BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  encodeBase64 = function(value) {
+  var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var encodeBase64 = function(value) {
     return BASE64_CHARS[value] || (() => {
-      throw new Error(`Cannot Base64 encode value: ${value}`);
+      throw new Error("Cannot Base64 encode value: ${value}");
     })();
   };
   var base64Encode = function(src) {
     return Buffer.from(src).toString("base64");
   };
-  vlqTable = new Uint8Array(128);
-  vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  (function() {
-    var i, l;
-    i = 0;
-    l = vlqTable.length;
+  var vlqTable = new Uint8Array(128);
+  var vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  {
+    let i = 0;
+    let l = vlqTable.length;
     while (i < l) {
       vlqTable[i] = 255;
       i++;
     }
     i = 0;
     l = vlqChars.length;
-    const results = [];
     while (i < l) {
       vlqTable[vlqChars.charCodeAt(i)] = i;
-      results.push(i++);
+      i++;
     }
-    ;
-    return results;
-  })();
-  decodeError = function(message) {
+  }
+  var decodeError = function(message) {
     throw new Error(message);
   };
-  decodeVLQ = function(mapping) {
-    var i, l, result, shift, vlq, c, index, v;
-    i = 0;
-    l = mapping.length;
-    result = [];
+  var decodeVLQ = function(mapping) {
+    let i = 0;
+    let l = mapping.length;
+    let result = [];
     while (i < l) {
-      shift = 0;
-      vlq = 0;
+      let shift = 0;
+      let vlq = 0;
+      let v = 0;
       while (true) {
         if (i >= l) {
           decodeError("Unexpected early end of mapping data");
         }
-        c = mapping.charCodeAt(i);
-        if ((c & 127) !== c) {
-          decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
+        const c = mapping.charCodeAt(i);
+        if ((c & 127) != c) {
+          decodeError("Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}");
         }
-        index = vlqTable[c & 127];
+        const index = vlqTable[c & 127];
         if (index === 255) {
-          decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
+          decodeError("Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}");
         }
         i++;
         vlq |= (index & 31) << shift;
@@ -16789,20 +16947,19 @@ ${js}`
     }
     return result;
   };
-  remapPosition = function(position, sourcemapLines) {
-    var line, character, textLine, i, p, l, lastMapping, lastMappingPosition, mapping;
-    [line, character] = position;
-    textLine = sourcemapLines[line];
+  var remapPosition = function(position, sourcemapLines) {
+    const [line, character] = position;
+    const textLine = sourcemapLines[line];
     if (!textLine?.length) {
       return void 0;
     }
-    i = 0;
-    p = 0;
-    l = textLine.length;
-    lastMapping = void 0;
-    lastMappingPosition = 0;
+    let i = 0;
+    let p = 0;
+    const l = textLine.length;
+    let lastMapping = void 0;
+    let lastMappingPosition = 0;
     while (i < l) {
-      mapping = textLine[i];
+      const mapping = textLine[i];
       p += mapping[0];
       if (mapping.length === 4) {
         lastMapping = mapping;
@@ -16813,7 +16970,7 @@ ${js}`
       }
       i++;
     }
-    if (character - lastMappingPosition !== 0) {
+    if (character - lastMappingPosition != 0) {
       return void 0;
     }
     if (lastMapping) {
@@ -16864,20 +17021,15 @@ ${js}`
   };
 
   // source/main.civet
-  var { SourceMap: SourceMap2 } = util_exports;
+  var { SourceMap: SourceMap2 } = sourcemap_exports;
   var ParseErrors = class extends Error {
     name = "ParseErrors";
-    filename;
-    line;
-    column;
-    offset;
-    constructor(message, filename1, line1, column1, offset1) {
-      super(message);
-      this.filename = filename1;
-      this.line = line1;
-      this.column = column1;
-      this.offset = offset1;
+    errors;
+    constructor(errors) {
+      const message = errors.map(($) => $.message).join("\n");
+      super(errors.map(($1) => $1.message).join("\n"));
       this.message = message;
+      this.errors = errors;
     }
   };
   var uncacheable = /* @__PURE__ */ new Set([
@@ -16979,6 +17131,7 @@ ${counts}`;
         });
       }
     }
+    const throwOnErrors = options.errors == null;
     function rest(ast2) {
       options = options;
       if (!(options.ast === "raw")) {
@@ -16988,28 +17141,36 @@ ${counts}`;
         return ast2;
       }
       function checkErrors() {
+        if (!throwOnErrors) {
+          return;
+        }
+        options = options;
         if (options.errors?.length) {
-          throw new ParseErrors(options.errors.map(($) => $.message).join("\n"));
+          throw new ParseErrors(options.errors);
         }
         ;
         return;
       }
       if (options.sourceMap || options.inlineMap) {
-        const sm = SourceMap2(src);
-        options.updateSourceMap = sm.updateSourceMap;
+        options.sourceMap = SourceMap2(src);
         const code = generate_default(ast2, options);
         checkErrors();
         if (options.inlineMap) {
-          return SourceMap2.remap(code, sm, filename2, filename2 + ".tsx");
+          return SourceMap2.remap(code, options.sourceMap, filename2, filename2 + ".tsx");
         } else {
           return {
             code,
-            sourceMap: sm
+            sourceMap: options.sourceMap
           };
         }
       }
       const result = generate_default(ast2, options);
-      checkErrors();
+      if (options.errors?.length) {
+        delete options.errors;
+        options.sourceMap = SourceMap2(src);
+        generate_default(ast2, options);
+        checkErrors();
+      }
       return result;
     }
     if (ast.then != null) {
@@ -17081,9 +17242,8 @@ ${counts}`;
     return events;
   };
   var isCompileError = function(err) {
-    return err instanceof Error && //@ts-ignore
-    [err.message, err.name, err.filename, err.line, err.column, err.offset].every(($1) => $1 !== void 0);
+    return err instanceof import_lib3.ParseError || err instanceof ParseErrors;
   };
-  var main_default = { parse, parseProgram, generate: generate_default, util: util_exports, compile, isCompileError };
+  var main_default = { parse, parseProgram, ParseError: import_lib3.ParseError, ParseErrors, generate: generate_default, sourcemap: sourcemap_exports, SourceMap: SourceMap2, compile, isCompileError };
   return __toCommonJS(main_exports);
 })();