@danielx/civet 0.7.9 → 0.7.10

package/dist/main.js

@@ -30,9 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 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"(exports2, module2) {
+  "node_modules/@danielx/hera/dist/machine.js"(exports2, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -71,6 +71,7 @@ var require_machine = __commonJS({
       $TS: () => $TS2,
       $TV: () => $TV2,
       $Y: () => $Y2,
+      ParseError: () => ParseError2,
       Validator: () => Validator2
     });
     module2.exports = __toCommonJS2(machine_exports);
@@ -437,11 +438,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) {
@@ -464,15 +464,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;
       }
     };
   }
@@ -481,7 +487,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,
@@ -490,7 +498,7 @@ __export(main_exports, {
   parse: () => parse,
   parseProgram: () => parseProgram,
   prune: () => prune,
-  util: () => util_exports
+  sourcemap: () => sourcemap_exports
 });
 module.exports = __toCommonJS(main_exports);
 
@@ -546,6 +554,7 @@ __export(lib_exports, {
   processAssignmentDeclaration: () => processAssignmentDeclaration,
   processBinaryOpExpression: () => processBinaryOpExpression,
   processCallMemberExpression: () => processCallMemberExpression,
+  processCoffeeDo: () => processCoffeeDo,
   processCoffeeInterpolation: () => processCoffeeInterpolation,
   processForInOf: () => processForInOf,
   processProgram: () => processProgram,
@@ -1247,6 +1256,56 @@ 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 ref6 = parameters.children, i1 = 0, len3 = ref6.length; i1 < len3; i1++) {
+          let parameter = ref6[i1];
+          if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
+            let ref7;
+            if (ref7 = parameter.initializer) {
+              const initializer = ref7;
+              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(($) => $ === parameters ? newParameters : $)
+    };
+  }
+  return {
+    type: "CallExpression",
+    children: [
+      makeLeftHandSideExpression(expression),
+      {
+        type: "Call",
+        args,
+        children: ["(", args, ")"]
+      }
+    ]
+  };
+}
 
 // source/parser/block.civet
 function blockWithPrefix(prefixStatements, block) {
@@ -1407,6 +1466,9 @@ function needsPrecedingSemicolon(exp) {
     }
     return false;
   }
+  if (isToken(exp)) {
+    exp = exp.token;
+  }
   if (typeof exp === "string") {
     return /^\s*[\(\[\`\+\-\/]/.test(exp);
   }
@@ -1842,24 +1904,29 @@ function makeAmpersandFunction(rhs) {
   }
   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",
@@ -3232,7 +3299,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];
@@ -4125,49 +4191,71 @@ 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;
+      }
+      if (!node.children) {
+        switch (node.type) {
+          case "Ref": {
+            throw new Error(`Unpopulated ref ${stringify(node)}`);
+          }
         }
+        debugger;
+        throw new Error(`Unknown node ${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)}`);
+  ;
+  return recurse;
 }
 var generate_default = gen;
 function prune(node) {
@@ -5271,7 +5359,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, ")"]);
@@ -5285,26 +5374,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);
@@ -5314,13 +5408,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) {
@@ -5342,38 +5430,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, ")"]
         );
@@ -5382,12 +5466,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, "(");
@@ -5400,6 +5487,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];
@@ -5423,9 +5511,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);
           }
         }
@@ -5458,10 +5546,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]);
@@ -5520,9 +5610,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,
@@ -5559,8 +5649,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++;
     }
@@ -5591,14 +5681,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);
@@ -5640,7 +5730,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");
     }
@@ -5649,7 +5739,7 @@ function processNegativeIndexAccess(statements) {
       exp.hoistDec = hoistDec;
       children.splice(start, 0, makeLeftHandSideExpression(refAssignment));
     }
-    return exp.len.children = [
+    exp.len.children = [
       ref,
       ".length"
     ];
@@ -5721,11 +5811,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;
@@ -5744,10 +5834,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";
       }));
@@ -5826,8 +5916,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);
@@ -5858,9 +5948,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);
     }
@@ -5885,43 +5975,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)) {
@@ -6104,6 +6190,7 @@ var grammar = {
   YieldExpression,
   ArrowFunction,
   FatArrow,
+  FatArrowToken,
   TrailingDeclaration,
   TrailingPipe,
   FatArrowBody,
@@ -6224,9 +6311,11 @@ var grammar = {
   NoCommaBracedOrEmptyBlock,
   NoPostfixBracedOrEmptyBlock,
   EmptyBlock,
+  BlockOrEmptyStatement,
   BlockOrEmpty,
-  EmptyBareBlock,
   EmptyStatementBareBlock,
+  EmptyBareBlock,
+  NoBlock,
   BracedBlock,
   NoPostfixBracedBlock,
   NoCommaBracedBlock,
@@ -7245,13 +7334,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;
@@ -7342,7 +7432,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) {
@@ -7567,11 +7657,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) {
@@ -7793,6 +7882,7 @@ 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 ";
@@ -7817,22 +7907,29 @@ var ArrowFunction$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$
     ts: false,
     async,
     block: expOrBlock,
-    children: [async, $0.slice(1), error]
+    children: [async, parameters, suffix, arrow, error, 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);
@@ -8344,7 +8441,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
   };
@@ -9016,11 +9119,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) {
@@ -9882,43 +9991,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) {
@@ -11770,7 +11898,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 {
@@ -11848,7 +11976,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 {
@@ -11879,7 +12007,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);
@@ -16457,33 +16585,20 @@ 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;
+  const linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
+  const lines = [];
+  let line = 0;
+  let pos = 0;
+  let result;
   while (result = linesRe.exec(input)) {
     pos += result[0].length;
     lines[line++] = pos;
@@ -16494,39 +16609,35 @@ 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,
-    colOffset: 0,
+    line: 0,
+    column: 0,
+    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;
+      let lastSourceLine = 0;
+      let lastSourceColumn = 0;
       return sm.lines.map(function(line) {
         return line.map(function(entry) {
-          var colDelta, sourceFileIndex, srcLine, srcCol, lineDelta;
           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;
@@ -16550,26 +16661,31 @@ 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;
         if (i > 0) {
-          sm.lineNum++;
-          sm.colOffset = 0;
-          sm.lines[sm.lineNum] = [];
-          srcCol = 0;
+          sm.line++;
+          sm.srcLine++;
+          sm.column = 0;
+          sm.lines[sm.line] = [];
+          sm.srcColumn = srcCol = colOffset;
         }
-        l = sm.colOffset;
-        sm.colOffset = line.length;
+        const l = sm.column;
+        sm.column += 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]);
+          return sm.lines[sm.line].push([l, 0, srcLine + i, srcCol]);
+        } else if (l != 0) {
+          return sm.lines[sm.line].push([l]);
         }
         ;
         return;
@@ -16578,74 +16694,36 @@ var SourceMap = function(sourceString) {
     }
   };
 };
-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) {
+var composeLines = function(upstreamMapping, lines) {
+  return lines.map(function(line) {
     return line.map(function(entry) {
-      var colDelta, sourceFileIndex, srcLine, srcCol, srcPos, upstreamLine, upstreamCol;
       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];
       }
@@ -16653,44 +16731,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(function(line) {
+    if (line.length === 0) {
+      return [];
     }
-  }
-  return;
+    return line.split(",").map(function(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 = "";
+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 ref;
   if (value < 0)
     ref = 1;
   else
     ref = 0;
-  signBit = ref;
-  valueToEncode = (Math.abs(value) << 1) + signBit;
+  const signBit = ref;
+  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;
@@ -16699,21 +16783,20 @@ 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+/";
+var vlqTable = new Uint8Array(128);
+var vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 (function() {
-  var i, l;
-  i = 0;
-  l = vlqTable.length;
+  let i = 0;
+  let l = vlqTable.length;
   while (i < l) {
     vlqTable[i] = 255;
     i++;
@@ -16728,28 +16811,28 @@ vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   ;
   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;
@@ -16767,20 +16850,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;
@@ -16791,7 +16873,7 @@ remapPosition = function(position, sourcemapLines) {
     }
     i++;
   }
-  if (character - lastMappingPosition !== 0) {
+  if (character - lastMappingPosition != 0) {
     return void 0;
   }
   if (lastMapping) {
@@ -16842,20 +16924,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([
@@ -16957,6 +17034,7 @@ ${counts}`;
       });
     }
   }
+  const throwOnErrors = options.errors == null;
   function rest(ast2) {
     options = options;
     if (!(options.ast === "raw")) {
@@ -16966,28 +17044,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) {
@@ -17059,13 +17145,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 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ParseError,
   ParseErrors,
+  SourceMap,
   compile,
   generate,
   isCompileError,
@@ -17073,5 +17160,5 @@ var main_default = { parse, parseProgram, generate: generate_default, util: util
   parse,
   parseProgram,
   prune,
-  util
+  sourcemap
 });