@danielx/civet 0.7.9 → 0.7.11

package/dist/main.mjs

@@ -28,9 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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;
@@ -69,6 +69,7 @@ var require_machine = __commonJS({
       $TS: () => $TS2,
       $TV: () => $TV2,
       $Y: () => $Y2,
+      ParseError: () => ParseError2,
       Validator: () => Validator2
     });
     module.exports = __toCommonJS(machine_exports);
@@ -435,11 +436,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) {
@@ -462,15 +462,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;
       }
     };
   }
@@ -528,6 +534,7 @@ __export(lib_exports, {
   processAssignmentDeclaration: () => processAssignmentDeclaration,
   processBinaryOpExpression: () => processBinaryOpExpression,
   processCallMemberExpression: () => processCallMemberExpression,
+  processCoffeeDo: () => processCoffeeDo,
   processCoffeeInterpolation: () => processCoffeeInterpolation,
   processForInOf: () => processForInOf,
   processProgram: () => processProgram,
@@ -933,27 +940,49 @@ function assignResults(node, collect) {
     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 = ";");
@@ -961,18 +990,22 @@ function assignResults(node, collect) {
       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;
@@ -983,7 +1016,7 @@ function insertReturn(node, outerNode = node) {
   if (!node)
     return;
   switch (node.type) {
-    case "BlockStatement":
+    case "BlockStatement": {
       if (node.expressions.length) {
         if (node.expressions.some(([, exp2]) => isExit(exp2))) {
           return;
@@ -996,7 +1029,8 @@ function insertReturn(node, outerNode = node) {
         }
       }
       return;
-    case "WhenClause":
+    }
+    case "WhenClause": {
       if (node.break) {
         node.children.splice(node.children.indexOf(node.break), 1);
       }
@@ -1006,9 +1040,11 @@ function insertReturn(node, outerNode = node) {
         node.block.expressions.push(wrapWithReturn());
       }
       return;
-    case "DefaultClause":
+    }
+    case "DefaultClause": {
       insertReturn(node.block);
       return;
+    }
   }
   if (!Array.isArray(node))
     return;
@@ -1028,23 +1064,36 @@ function insertReturn(node, outerNode = node) {
     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([
           "",
@@ -1057,16 +1106,19 @@ function insertReturn(node, outerNode = node) {
         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);
@@ -1078,18 +1130,23 @@ function insertReturn(node, outerNode = node) {
           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);
 }
@@ -1178,10 +1235,33 @@ function processParams(f) {
   }
   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);
   });
@@ -1229,6 +1309,102 @@ function skipImplicitArguments(args) {
   }
   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) {
@@ -1389,6 +1565,9 @@ function needsPrecedingSemicolon(exp) {
     }
     return false;
   }
+  if (isToken(exp)) {
+    exp = exp.token;
+  }
   if (typeof exp === "string") {
     return /^\s*[\(\[\`\+\-\/]/.test(exp);
   }
@@ -1449,8 +1628,8 @@ function addParentPointers(node, parent) {
     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);
     }
   }
@@ -1732,13 +1911,13 @@ function startsWith(target, value) {
   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)
@@ -1776,72 +1955,29 @@ function removeHoistDecs(node) {
     }
   }
 }
-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",
@@ -1869,8 +2005,8 @@ function updateParentPointers(node, parent, depth = 1) {
     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);
     }
   }
@@ -1941,11 +2077,11 @@ function parenthesizeType(type) {
 }
 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 "]
@@ -1956,8 +2092,7 @@ function wrapIIFE(expressions, asyncFlag) {
     expressions,
     children: ["{", expressions, "}"],
     bare: false,
-    root: false,
-    parent: void 0
+    root: false
   });
   const parameters = {
     type: "Parameters",
@@ -1966,7 +2101,7 @@ function wrapIIFE(expressions, asyncFlag) {
   };
   const signature = {
     modifier: {
-      async: !!async
+      async: !!async.length
     },
     returnType: void 0
   };
@@ -2309,8 +2444,6 @@ function processBinaryOpExpression($0) {
     }
     return expandedOps;
   }
-  ;
-  return recurse;
 }
 function dotNumericLiteral(literal) {
   if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
@@ -2827,7 +2960,13 @@ function getPatternBlockPrefix(pattern, ref, decl = "const ", suffix) {
   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, ";"])
   ];
@@ -2975,9 +3114,18 @@ function aggregateDuplicateBindings(bindings) {
       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;
 }
@@ -3214,7 +3362,6 @@ function processDeclarationConditionStatement(s) {
       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];
@@ -3469,8 +3616,7 @@ function processUnaryExpression(pre, exp, post) {
       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);
@@ -3514,9 +3660,9 @@ function processUnaryExpression(pre, exp, post) {
       }
     }
   }
-  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) {
@@ -4107,49 +4253,69 @@ function stringify(node) {
     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) {
@@ -4725,8 +4891,11 @@ function expressionizeBlock(blockOrExpression) {
     }
     if (results.length > 1) {
       return makeLeftHandSideExpression(results);
+    } else if (results.length) {
+      return results;
+    } else {
+      return ["void 0"];
     }
-    return results;
   } else {
     return blockOrExpression;
   }
@@ -4753,10 +4922,10 @@ function expressionizeIfStatement(statement) {
     children.push(":void 0");
   }
   children.push(closeParen);
-  return {
+  return makeNode({
     type: "IfExpression",
     children
-  };
+  });
 }
 function expressionizeTypeIf([ws, ifOp, condition, t, e]) {
   const children = [
@@ -5253,7 +5422,8 @@ function processAssignments(statements) {
       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, ")"]);
@@ -5267,26 +5437,31 @@ function processAssignments(statements) {
       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);
@@ -5296,13 +5471,7 @@ function processAssignments(statements) {
       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) {
@@ -5324,38 +5493,34 @@ function processAssignments(statements) {
     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, ")"]
         );
@@ -5364,12 +5529,15 @@ function processAssignments(statements) {
         }
       }
       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, "(");
@@ -5382,6 +5550,7 @@ function processAssignments(statements) {
         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];
@@ -5405,9 +5574,9 @@ function processAssignments(statements) {
               }
               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);
           }
         }
@@ -5440,10 +5609,12 @@ function processAssignments(statements) {
         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]);
@@ -5502,9 +5673,9 @@ function unchainOptionalMemberExpression(exp, ref, innerExp) {
     }
     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,
@@ -5541,8 +5712,8 @@ function processTypes(node) {
   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++;
     }
@@ -5573,14 +5744,14 @@ function processTypes(node) {
   });
 }
 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);
@@ -5622,7 +5793,7 @@ function processNegativeIndexAccess(statements) {
       }
     } 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");
     }
@@ -5631,7 +5802,7 @@ function processNegativeIndexAccess(statements) {
       exp.hoistDec = hoistDec;
       children.splice(start, 0, makeLeftHandSideExpression(refAssignment));
     }
-    return exp.len.children = [
+    exp.len.children = [
       ref,
       ".length"
     ];
@@ -5703,11 +5874,11 @@ function populateRefs(statements) {
 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;
@@ -5726,10 +5897,10 @@ function processPlaceholders(statements) {
         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";
       }));
@@ -5808,8 +5979,8 @@ function processPlaceholders(statements) {
     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);
@@ -5840,9 +6011,9 @@ function processPlaceholders(statements) {
       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);
     }
@@ -5867,43 +6038,39 @@ function reorderBindingRestProperty(props) {
       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)) {
@@ -6086,6 +6253,7 @@ var grammar = {
   YieldExpression,
   ArrowFunction,
   FatArrow,
+  FatArrowToken,
   TrailingDeclaration,
   TrailingPipe,
   FatArrowBody,
@@ -6206,9 +6374,11 @@ var grammar = {
   NoCommaBracedOrEmptyBlock,
   NoPostfixBracedOrEmptyBlock,
   EmptyBlock,
+  BlockOrEmptyStatement,
   BlockOrEmpty,
-  EmptyBareBlock,
   EmptyStatementBareBlock,
+  EmptyBareBlock,
+  NoBlock,
   BracedBlock,
   NoPostfixBracedBlock,
   NoCommaBracedBlock,
@@ -7227,13 +7397,14 @@ function ExpressionizedStatement(ctx, state2) {
 }
 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;
@@ -7324,7 +7495,7 @@ var ForbiddenImplicitCalls$6 = (0, import_lib3.$TS)((0, import_lib3.$S)(OmittedN
     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) {
@@ -7549,11 +7720,10 @@ var UnaryExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3
   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) {
@@ -7775,17 +7945,10 @@ var ArrowFunction$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$
   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: {
@@ -7796,25 +7959,31 @@ var ArrowFunction$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$
     },
     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);
@@ -8326,7 +8495,13 @@ var ThisLiteral$2 = (0, import_lib3.$TS)((0, import_lib3.$S)(AtThis, (0, import_
     children: [at, {
       type: "PropertyAccess",
       name: id,
-      children: [".", id]
+      children: [".", {
+        $loc: {
+          pos: $loc.pos + 1,
+          length: $loc.length - 1
+        },
+        token: id
+      }]
     }],
     thisShorthand: true
   };
@@ -8998,11 +9173,17 @@ function FunctionRestParameter(ctx, state2) {
 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) {
@@ -9417,7 +9598,6 @@ var FunctionSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
     name: id?.name,
     parameters,
     returnType: suffix,
-    ts: false,
     async,
     generator,
     modifier: {
@@ -9443,14 +9623,6 @@ var FunctionExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(FunctionSign
       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",
@@ -9622,15 +9794,21 @@ var OperatorDeclaration$$ = [OperatorDeclaration$0, OperatorDeclaration$1, Opera
 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 {
@@ -9639,12 +9817,17 @@ var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Operator, (0,
   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
   };
 });
@@ -9694,27 +9877,24 @@ var ThinArrowFunction$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
   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
     },
@@ -9864,43 +10044,62 @@ var EmptyBlock$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(InsertOpenBrace, Ins
     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) {
@@ -11752,7 +11951,7 @@ var IterationExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_
 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 {
@@ -11830,7 +12029,7 @@ var ComptimeStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Comptime, NoP
 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 {
@@ -11861,7 +12060,7 @@ var WhileClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)
 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);
@@ -16439,34 +16638,22 @@ function parseProgram(input, options) {
   }
 }
 
-// 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) {
@@ -16476,39 +16663,39 @@ var locationTable = function(input) {
   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;
@@ -16532,102 +16719,69 @@ var SourceMap = function(sourceString) {
         }
       };
     },
-    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];
       }
@@ -16635,44 +16789,50 @@ SourceMap.composeLines = function(upstreamMapping, lines) {
     });
   });
 };
-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;
@@ -16681,57 +16841,53 @@ encodeVlq = function(value) {
   }
   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;
@@ -16749,20 +16905,19 @@ decodeVLQ = function(mapping) {
   }
   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;
@@ -16773,7 +16928,7 @@ remapPosition = function(position, sourcemapLines) {
     }
     i++;
   }
-  if (character - lastMappingPosition !== 0) {
+  if (character - lastMappingPosition != 0) {
     return void 0;
   }
   if (lastMapping) {
@@ -16824,20 +16979,15 @@ var StateCache = class {
 };
 
 // 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([
@@ -16939,6 +17089,7 @@ ${counts}`;
       });
     }
   }
+  const throwOnErrors = options.errors == null;
   function rest(ast2) {
     options = options;
     if (!(options.ast === "raw")) {
@@ -16948,28 +17099,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) {
@@ -17041,12 +17200,14 @@ var makeCache = function({ hits, trace } = {}) {
   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 };
+var export_ParseError = import_lib3.ParseError;
 export {
+  export_ParseError as ParseError,
   ParseErrors,
+  SourceMap2 as SourceMap,
   compile,
   main_default as default,
   generate_default as generate,
@@ -17055,5 +17216,5 @@ export {
   parse,
   parseProgram,
   prune,
-  util_exports as util
+  sourcemap_exports as sourcemap
 };