@danielx/civet 0.9.2 → 0.9.3

package/dist/browser.js

@@ -1,4 +1,3 @@
-"use strict";
 var Civet = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
@@ -401,37 +400,38 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     }
   });
 
-  // source/browser.civet
-  var browser_exports = {};
-  __export(browser_exports, {
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\browser.civet.jsx
+  var browser_civet_exports = {};
+  __export(browser_civet_exports, {
     ParseError: () => import_lib2.ParseError,
     ParseErrors: () => ParseErrors,
     SourceMap: () => SourceMap2,
     autoRunScripts: () => autoRunScripts,
     compile: () => compile,
-    generate: () => generate_default,
+    generate: () => generate_civet_default,
     isCompileError: () => isCompileError,
-    lib: () => lib_exports,
+    lib: () => lib_civet_exports,
     parse: () => parse,
     parseProgram: () => parseProgram,
     prune: () => prune,
     runScript: () => runScript,
     runScripts: () => runScripts,
-    sourcemap: () => sourcemap_exports
+    sourcemap: () => sourcemap_civet_exports
   });
 
   // source/parser.hera
   var import_lib2 = __toESM(require_machine());
 
-  // source/parser/lib.civet
-  var lib_exports = {};
-  __export(lib_exports, {
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\lib.civet.jsx
+  var lib_civet_exports = {};
+  __export(lib_civet_exports, {
     addPostfixStatement: () => addPostfixStatement,
     adjustBindingElements: () => adjustBindingElements,
     adjustIndexAccess: () => adjustIndexAccess,
     append: () => append,
     attachPostfixStatementAsExpression: () => attachPostfixStatementAsExpression,
     blockWithPrefix: () => blockWithPrefix,
+    braceBlock: () => braceBlock,
     convertNamedImportsToObject: () => convertNamedImportsToObject,
     convertObjectToJSXAttributes: () => convertObjectToJSXAttributes,
     convertWithClause: () => convertWithClause,
@@ -499,7 +499,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     wrapTypeInPromise: () => wrapTypeInPromise
   });
 
-  // source/parser/util.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\util.civet.jsx
   function len(arr, length) {
     return arr.length === length;
   }
@@ -793,6 +793,49 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
         throw new Error("Unrecognized literal " + JSON.stringify(literal));
     }
   }
+  function literalType(literal) {
+    let t;
+    switch (literal.type) {
+      case "RegularExpressionLiteral": {
+        t = "RegExp";
+        break;
+      }
+      case "TemplateLiteral": {
+        t = "string";
+        break;
+      }
+      case "Literal": {
+        switch (literal.subtype) {
+          case "NullLiteral": {
+            t = "null";
+            break;
+          }
+          case "BooleanLiteral": {
+            t = "boolean";
+            break;
+          }
+          case "NumericLiteral": {
+            literal.raw.endsWith("n") ? t = "bigint" : t = "number";
+            break;
+          }
+          case "StringLiteral": {
+            t = "string";
+            break;
+          }
+          default:
+            throw new Error(`unknown literal subtype ${literal.subtype}`);
+        }
+        break;
+      }
+      default:
+        throw new Error(`unknown literal type ${literal.type}`);
+    }
+    return {
+      type: "TypeLiteral",
+      t,
+      children: [t]
+    };
+  }
   function makeNumericLiteral(n) {
     let s = n.toString();
     return {
@@ -1013,7 +1056,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       return target;
   }
   function spliceChild(node, child, del, ...replacements) {
-    let children = node?.children ?? node;
+    let children = Array.isArray(node) ? node : node.children;
     if (!Array.isArray(children))
       throw new Error("spliceChild: non-array node has no children field");
     let index = children.indexOf(child);
@@ -1153,7 +1196,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     return result;
   }
 
-  // source/parser/traversal.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\traversal.civet.jsx
   function gatherRecursiveWithinFunction(node, predicate) {
     return gatherRecursive(node, predicate, isFunction);
   }
@@ -1227,7 +1270,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     return predicate(node) && nodes.push(node), nodes;
   }
 
-  // source/parser/ref.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\ref.civet.jsx
   function makeRef(base = "ref", id = base) {
     return {
       type: "Ref",
@@ -1278,7 +1321,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     return ref === exp ? { ref, refAssignmentComma: [] } : { ref, ...makeRefAssignment(ref, exp) };
   }
 
-  // source/parser/binding.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\binding.civet.jsx
   function adjustAtBindings(statements, asThis = !1) {
     for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "AtBindingProperty"), i1 = 0, len3 = ref1.length; i1 < len3; i1++) {
       let binding = ref1[i1], { ref } = binding;
@@ -1342,13 +1385,30 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
   function gatherBindingCode(statements, opts) {
     let thisAssignments = [], splices = [];
     function insertRestSplices(s, p, thisAssignments2) {
-      for (let ref2 = gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding"), i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
+      let m;
+      for (let ref2 = gatherRecursiveAll(
+        s,
+        (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding" || opts?.assignPins && (m = n.type, m === "PinPattern" || m === "PinProperty")
+      ), i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
         let n = ref2[i3];
         if (n.type === "AtBinding") {
           let { ref } = n, { id } = ref;
           thisAssignments2.push([`this.${id} = `, ref]);
           continue;
         }
+        if (opts?.assignPins && (n.type === "PinProperty" && (n.children = n.children.flatMap(($2) => $2 === n.name ? [n.name, ": ", n.value] : $2), updateParentPointers(n), n = n.value), n.type === "PinPattern")) {
+          n.ref = makeRef(
+            n.expression.type === "Identifier" ? n.expression.name : "pin"
+          ), n.children = [n.ref], updateParentPointers(n), thisAssignments2.push({
+            type: "AssignmentExpression",
+            children: [n.expression, " = ", n.ref],
+            names: [],
+            lhs: n.expression,
+            assigned: n.expression,
+            expression: n.ref
+          });
+          continue;
+        }
         if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
           for (let ref3 = n.names, i4 = 0, len3 = ref3.length; i4 < len3; i4++) {
             let id = ref3[i4];
@@ -1440,12 +1500,12 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     return pattern;
   }
 
-  // source/parser/comptime.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\comptime.civet.jsx
   init_browser_shim();
   init_browser_shim();
   init_browser_shim();
 
-  // source/parser/helper.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\helper.civet.jsx
   var preludeVar = "var ";
   function ts(children) {
     return {
@@ -1698,7 +1758,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     return helpers = new Set(gatherRecursive(node, helpers.has.bind(helpers))), state.prelude.filter((s) => gatherRecursive(s, helpers.has.bind(helpers)).length);
   }
 
-  // source/generate.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\generate.civet.jsx
   function stringify(node) {
     try {
       return JSON.stringify(removeParentPointers(node));
@@ -1755,7 +1815,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
       throw new Error(`Unknown node ${stringify(node)}`);
     }
   }
-  var generate_default = gen;
+  var generate_civet_default = gen;
   function prune(node) {
     if (node != null && !(typeof node == "string" && node.length === 0)) {
       if (node.parent != null && delete node.parent, Array.isArray(node)) {
@@ -1766,7 +1826,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
     }
   }
 
-  // source/parser/comptime.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\comptime.civet.jsx
   function expressionizeComptime(statement) {
     let { expressions } = statement.block, expression = wrapIIFE(expressions, hasAwait(expressions));
     return makeNode({
@@ -1795,7 +1855,7 @@ ${body}`), super(message), this.header = header, this.body = body, this.filename
         ...extractPreludeFor(content),
         content
       ];
-      let options = { js: !0 }, js = generate_default(prune(content), options);
+      let options = { js: !0 }, js = generate_civet_default(prune(content), options);
       if (js = `"use strict";${js}`, options.errors != null)
         return;
       let output, context, contextGlobal;
@@ -2000,7 +2060,7 @@ ${js}`
     return recurse(value);
   }
 
-  // source/parser/function.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\function.civet.jsx
   var concatAssign = (lhs, rhs) => (rhs?.[Symbol.isConcatSpreadable] ?? Array.isArray(rhs) ? lhs.push.apply(lhs, rhs) : lhs.push(rhs), lhs);
   function getTypeArguments(args) {
     for (; typeof args == "object" && args != null && "args" in args; )
@@ -2684,7 +2744,7 @@ ${js}`
           names
         });
         if (rest.typeSuffix) {
-          let optionalType2 = function(typeSuffix3, fallback) {
+          let optionalType = function(typeSuffix3, fallback) {
             let t2 = typeSuffix3?.t ?? fallback;
             return typeSuffix3?.optional ? [
               t2,
@@ -2693,9 +2753,7 @@ ${js}`
                 message: "Optional parameter not allowed in/after rest parameter"
               }
             ] : t2;
-          };
-          var optionalType = optionalType2;
-          let ref = makeRef("rest"), restRef = [
+          }, ref = makeRef("rest"), restRef = [
             { children: [ref], ts: !0 },
             { children: [restIdentifier], js: !0 }
           ];
@@ -2715,10 +2773,10 @@ ${js}`
             children: [ref],
             ts: !0
           });
-          let oldSuffix = rest.typeSuffix, colon = oldSuffix.colon ?? ": ", afterTypes = after.flatMap((p) => [",", optionalType2(p.typeSuffix, " unknown")]), t = [
+          let oldSuffix = rest.typeSuffix, colon = oldSuffix.colon ?? ": ", afterTypes = after.flatMap((p) => [",", optionalType(p.typeSuffix, " unknown")]), t = [
             "[",
             "...",
-            optionalType2(oldSuffix, "unknown[]"),
+            optionalType(oldSuffix, "unknown[]"),
             ...afterTypes,
             "]"
           ], typeSuffix2 = makeNode({
@@ -2751,17 +2809,18 @@ ${js}`
     let indent;
     expressions.length ? indent = expressions[0][0] : indent = "";
     let [splices, thisAssignments] = gatherBindingCode(parameters, {
-      injectParamProps: isConstructor
+      injectParamProps: isConstructor,
+      assignPins: !0
     });
     if (isConstructor) {
       let { ancestor } = findAncestor(f, ($9) => $9.type === "ClassExpression");
       if (ancestor != null) {
-        let fields = new Set(gatherRecursiveWithinFunction(ancestor, ($10) => $10.type === "FieldDefinition").map(($11) => $11.id).filter((a3) => typeof a3 == "object" && a3 != null && "type" in a3 && a3.type === "Identifier").map(($12) => $12.name)), classExpressions = ancestor.body.expressions, index = findChildIndex(classExpressions, f);
-        assert.notEqual(index, -1, "Could not find constructor in class");
+        let fields = new Set(gatherRecursiveWithinFunction(ancestor, ($10) => $10.type === "FieldDefinition").map(($11) => $11.id).filter((a3) => typeof a3 == "object" && a3 != null && "type" in a3 && a3.type === "Identifier").map(($12) => $12.name)), classExpressions = ancestor.body.expressions, index2 = findChildIndex(classExpressions, f);
+        assert.notEqual(index2, -1, "Could not find constructor in class");
         let m4;
-        for (; m4 = classExpressions[index - 1]?.[1], typeof m4 == "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor"; )
-          index--;
-        let fStatement = classExpressions[index];
+        for (; m4 = classExpressions[index2 - 1]?.[1], typeof m4 == "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor"; )
+          index2--;
+        let fStatement = classExpressions[index2];
         for (let ref18 = gatherRecursive(parameters, ($13) => $13.type === "Parameter"), i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
           let parameter = ref18[i9], { accessModifier } = parameter;
           if (accessModifier || parameter.typeSuffix)
@@ -2771,7 +2830,7 @@ ${js}`
                 continue;
               parameter.accessModifier && (replaceNode(parameter.accessModifier, void 0), parameter.accessModifier = void 0);
               let id = binding.ref.id;
-              fields.has(id) || (classExpressions.splice(index++, 0, [fStatement[0], {
+              fields.has(id) || (classExpressions.splice(index2++, 0, [fStatement[0], {
                 type: "FieldDefinition",
                 id,
                 typeSuffix,
@@ -2800,22 +2859,23 @@ ${js}`
       // TODO: figure out how to get JS only statement tuples
       ...s,
       children: [indent, ...s.children, delimiter]
-    })] : [indent, s, delimiter]), !!prefix.length) {
-      if (isConstructor) {
-        let superCalls = gatherNodes(
-          expressions,
-          (a4) => typeof a4 == "object" && a4 != null && "type" in a4 && a4.type === "CallExpression" && "children" in a4 && Array.isArray(a4.children) && a4.children.length >= 1 && typeof a4.children[0] == "object" && a4.children[0] != null && "token" in a4.children[0] && a4.children[0].token === "super"
-        );
-        if (superCalls.length) {
-          let { child } = findAncestor(superCalls[0], (a5) => a5 === block), index = findChildIndex(expressions, child);
-          if (index < 0)
-            throw new Error("Could not find super call within top-level expressions");
-          expressions.splice(index + 1, 0, ...prefix);
-          return;
-        }
-      }
-      expressions.unshift(...prefix), updateParentPointers(block), braceBlock(block);
-    }
+    })] : [indent, s, delimiter]), !prefix.length)
+      return;
+    let index = -1;
+    isConstructor && (index = findSuperCall(block)), expressions.splice(index + 1, 0, ...prefix), updateParentPointers(block), braceBlock(block);
+  }
+  function findSuperCall(block) {
+    let { expressions } = block, superCalls = gatherNodes(
+      expressions,
+      (a4) => typeof a4 == "object" && a4 != null && "type" in a4 && a4.type === "CallExpression" && "children" in a4 && Array.isArray(a4.children) && a4.children.length >= 1 && typeof a4.children[0] == "object" && a4.children[0] != null && "token" in a4.children[0] && a4.children[0].token === "super"
+    );
+    if (superCalls.length) {
+      let { child } = findAncestor(superCalls[0], (a5) => a5 === block), index = findChildIndex(expressions, child);
+      if (index < 0)
+        throw new Error("Could not find super call within top-level expressions");
+      return index;
+    } else
+      return -1;
   }
   function processSignature(f) {
     let { block, signature } = f;
@@ -2990,7 +3050,7 @@ ${js}`
     ).length > 1 && (fn.ampersandBlock = !1), fn;
   }
 
-  // source/parser/block.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\block.civet.jsx
   function blockWithPrefix(prefixStatements, block) {
     if (prefixStatements && prefixStatements.length) {
       let expressions = [...prefixStatements, ...block.expressions];
@@ -3137,7 +3197,7 @@ ${js}`
       };
   }
 
-  // source/parser/op.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\op.civet.jsx
   var precedenceOrder = [
     ["||", "??"],
     ["^^"],
@@ -3188,7 +3248,7 @@ ${js}`
     for (; i < expandedOps.length; ) {
       let op = expandedOps[i];
       if (op.special) {
-        let advanceLeft2 = function(allowEqual) {
+        let advanceLeft = function(allowEqual) {
           for (; start >= 4; ) {
             let prevPrec = getPrecedence(expandedOps[start - 2]);
             if (!(prevPrec > prec || allowEqual && prevPrec === prec))
@@ -3196,7 +3256,7 @@ ${js}`
             start -= 4;
           }
           return !1;
-        }, advanceRight2 = function(allowEqual) {
+        }, advanceRight = function(allowEqual) {
           for (; end + 4 < expandedOps.length; ) {
             let nextPrec = getPrecedence(expandedOps[end + 2]);
             if (!(nextPrec > prec || allowEqual && nextPrec === prec))
@@ -3204,31 +3264,29 @@ ${js}`
             end += 4;
           }
           return !1;
-        };
-        var advanceLeft = advanceLeft2, advanceRight = advanceRight2;
-        let start = i - 2, end = i + 2, prec = getPrecedence(op), error;
+        }, start = i - 2, end = i + 2, prec = getPrecedence(op), error;
         switch (op.assoc) {
           case "left":
           case void 0: {
-            advanceLeft2(!0), advanceRight2(!1);
+            advanceLeft(!0), advanceRight(!1);
             break;
           }
           case "right": {
-            advanceLeft2(!1), advanceRight2(!0);
+            advanceLeft(!1), advanceRight(!0);
             break;
           }
           case "non": {
-            (advanceLeft2(!1) || advanceRight2(!1)) && (error = {
+            (advanceLeft(!1) || advanceRight(!1)) && (error = {
               type: "Error",
               message: `non-associative operator ${op.token} used at same precedence level without parenthesization`
             });
             break;
           }
           case "arguments": {
-            advanceLeft2(!1) && (error = {
+            advanceLeft(!1) && (error = {
               type: "Error",
               message: `arguments operator ${op.token} used at same precedence level as ${expandedOps[start - 2].token} to the left`
-            }), advanceRight2(!0);
+            }), advanceRight(!0);
             break;
           }
           default:
@@ -3333,7 +3391,7 @@ ${js}`
     }
   }
 
-  // source/parser/pattern-matching.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\pattern-matching.civet.jsx
   function processPatternTest(lhs, patterns) {
     let { ref, refAssignmentComma } = maybeRefAssignment(lhs, "m"), conditionExpression = flatJoin(patterns.map(($1) => getPatternConditions($1, ref)).map(($2) => flatJoin($2, " && ")), " || ");
     return makeLeftHandSideExpression(makeNode({
@@ -3698,7 +3756,7 @@ ${js}`
     }
   }
 
-  // source/parser/declaration.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\declaration.civet.jsx
   function len2(arr, length) {
     return arr.length === length;
   }
@@ -3740,13 +3798,36 @@ ${js}`
   function processDeclarations(statements) {
     for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "Declaration"), i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
       let declaration = ref1[i1], { bindings } = declaration;
-      bindings?.forEach((binding) => {
-        let { typeSuffix } = binding;
-        typeSuffix && typeSuffix.optional && typeSuffix.t && convertOptionalType(typeSuffix);
-        let { initializer } = binding;
-        if (initializer)
-          return prependStatementExpressionBlock(initializer, declaration);
-      });
+      if (bindings != null)
+        for (let i2 = 0, len22 = bindings.length; i2 < len22; i2++) {
+          let binding = bindings[i2], { typeSuffix, initializer } = binding;
+          if (typeSuffix && typeSuffix.optional) {
+            if (initializer && !typeSuffix.t) {
+              let expression = trimFirstSpace(initializer.expression), m;
+              if (m = expression.type, m === "Identifier" || m === "MemberExpression")
+                typeSuffix.children.push(": ", typeSuffix.t = {
+                  type: "TypeTypeof",
+                  children: ["typeof ", expression],
+                  expression
+                });
+              else if (expression.type === "Literal" || expression.type === "RegularExpressionLiteral" || expression.type === "TemplateLiteral")
+                typeSuffix.children.push(": ", typeSuffix.t = literalType(expression));
+              else {
+                spliceChild(binding, typeSuffix, 1, {
+                  type: "Error",
+                  message: `Optional type can only be inferred from literals or member expressions, not ${expression.type}`
+                });
+                continue;
+              }
+            }
+            typeSuffix.t ? convertOptionalType(typeSuffix) : (spliceChild(binding, typeSuffix, 1), binding.children.push(initializer = binding.initializer = {
+              type: "Initializer",
+              expression: "undefined",
+              children: [" = ", "undefined"]
+            }));
+          }
+          initializer && prependStatementExpressionBlock(initializer, declaration);
+        }
     }
   }
   function prependStatementExpressionBlock(initializer, statement) {
@@ -3863,14 +3944,14 @@ ${js}`
       if (conditions.length) {
         let children = condition.children;
         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) && Array.isArray(m.children[0]) && len2(m.children[0], 1) && m.children[0][0] === "!" && typeof m.children[1] == "object" && m.children[1] != null && "type" in m.children[1] && m.children[1].type === "ParenthesizedExpression"))
+          let m1;
+          if (m1 = condition.expression, !(typeof m1 == "object" && m1 != null && "type" in m1 && m1.type === "UnaryExpression" && "children" in m1 && Array.isArray(m1.children) && len2(m1.children, 2) && Array.isArray(m1.children[0]) && len2(m1.children[0], 1) && m1.children[0][0] === "!" && typeof m1.children[1] == "object" && m1.children[1] != null && "type" in m1.children[1] && m1.children[1].type === "ParenthesizedExpression"))
             throw new Error("Unsupported negated condition");
           ({ children } = condition.expression.children[1]);
         }
         children.unshift("(");
-        for (let i2 = 0, len22 = conditions.length; i2 < len22; i2++) {
-          let c = conditions[i2];
+        for (let i3 = 0, len3 = conditions.length; i3 < len3; i3++) {
+          let c = conditions[i3];
           children.push(" && ", c);
         }
         children.push(")");
@@ -4067,7 +4148,7 @@ ${js}`
     return [extendsToken, insertTrimmingSpace(ws, " "), wrapped];
   }
 
-  // source/parser/unary.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\unary.civet.jsx
   function processUnaryExpression(pre, exp, post) {
     if (!(pre.length || post))
       return exp;
@@ -4178,7 +4259,7 @@ ${js}`
     return processUnaryExpression(pre, args, post);
   }
 
-  // source/parser/pipe.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\pipe.civet.jsx
   function constructInvocation(fn, arg) {
     let expr = fn.expr;
     for (; expr.type === "ParenthesizedExpression"; )
@@ -4340,7 +4421,7 @@ ${js}`
     });
   }
 
-  // source/parser/for.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\for.civet.jsx
   function processRangeExpression(start, ws1, range, end) {
     ws1 = [ws1, range.children[0]];
     let ws2 = range.children[1], comma = { $loc: range.$loc, token: "," }, ref;
@@ -4618,7 +4699,7 @@ ${js}`
     };
   }
 
-  // source/parser/auto-dec.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\auto-dec.civet.jsx
   var concatAssign2 = (lhs, rhs) => (rhs?.[Symbol.isConcatSpreadable] ?? Array.isArray(rhs) ? lhs.push.apply(lhs, rhs) : lhs.push(rhs), lhs);
   function findDecs(statements) {
     let declarationNames = gatherNodes(statements, ($) => $.type === "Declaration").flatMap((d) => d.names), globals = getConfig().globals || [];
@@ -4681,9 +4762,7 @@ ${js}`
         findAssignments(assignmentStatements2.map((s) => s.children), decs2)
       ), assignmentStatements2;
     }
-    pushVar || (pushVar = function(name) {
-      return varIds.push(name), decs.add(name);
-    });
+    pushVar ??= (name) => (varIds.push(name), decs.add(name));
     let { expressions: statements } = block, decs = findDecs(statements);
     scopes.push(decs);
     let varIds = [];
@@ -4702,7 +4781,7 @@ ${js}`
     scopes.pop();
   }
 
-  // source/parser/string.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\string.civet.jsx
   function getIndentLevel(str, tab) {
     if (tab != null && tab != 1) {
       let tabs = str.match(/\t/g), numTabs = tabs ? tabs.length : 0;
@@ -4812,7 +4891,7 @@ ${js}`
     return JSON.stringify(str);
   }
 
-  // source/parser/lib.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\lib.civet.jsx
   var xor = (a, b) => a ? !b && a : b;
   function addPostfixStatement(statement, ws, post) {
     let expressions = [
@@ -5430,16 +5509,14 @@ ${js}`
   }
   function processAssignments(statements) {
     for (let ref7 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len3 = ref7.length; i5 < len3; i5++) {
-      let extractAssignment2 = function(lhs) {
+      let extractAssignment = function(lhs) {
         let expr = lhs;
         for (; expr.type === "ParenthesizedExpression"; )
           expr = expr.expression;
         let m1;
         if (m1 = expr.type, m1 === "AssignmentExpression" || m1 === "UpdateExpression")
           return expr.type === "UpdateExpression" && expr.children[0] === expr.assigned ? (pre.push("("), post.push([", ", lhs, ")"])) : (pre.push(["(", lhs, ", "]), post.push(")")), expr.assigned;
-      };
-      var extractAssignment = extractAssignment2;
-      let exp = ref7[i5];
+      }, exp = ref7[i5];
       checkValidLHS(exp.assigned);
       let pre = [], post = [], ref8;
       switch (exp.type) {
@@ -5448,7 +5525,7 @@ ${js}`
             continue;
           for (let ref9 = exp.lhs, i6 = 0, len4 = ref9.length; i6 < len4; i6++) {
             let lhsPart = ref9[i6], ref10;
-            if (ref10 = extractAssignment2(lhsPart[1])) {
+            if (ref10 = extractAssignment(lhsPart[1])) {
               let newLhs = ref10;
               lhsPart[1] = newLhs;
             }
@@ -5456,7 +5533,7 @@ ${js}`
           break;
         }
         case "UpdateExpression": {
-          if (ref8 = extractAssignment2(exp.assigned)) {
+          if (ref8 = extractAssignment(exp.assigned)) {
             let newLhs = ref8, i = exp.children.indexOf(exp.assigned);
             exp.assigned = exp.children[i] = newLhs;
           }
@@ -5834,6 +5911,80 @@ ${js}`
       label.children.push(label.name = parent.label.name), delete label.special;
     }
   }
+  function processCoffeeClasses(statements) {
+    for (let ref21 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
+      let ce = ref21[i11], { expressions } = ce.body, indent = expressions[0]?.[0] ?? `
+`, autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
+      if (autoBinds.length) {
+        let construct;
+        for (let [, c] of expressions)
+          if (typeof c == "object" && c != null && "type" in c && c.type === "MethodDefinition" && "name" in c && c.name === "constructor" && c.block) {
+            construct = c;
+            break;
+          }
+        if (!construct) {
+          let parametersList = [], parameters = {
+            type: "Parameters",
+            children: [parametersList],
+            parameters: parametersList,
+            names: []
+          }, signature = {
+            type: "MethodSignature",
+            children: ["constructor(", parameters, ")"],
+            parameters,
+            modifier: {},
+            returnType: void 0
+          }, block = makeEmptyBlock();
+          construct = {
+            ...signature,
+            type: "MethodDefinition",
+            name: "constructor",
+            block,
+            signature,
+            children: [...signature.children, block]
+          }, expressions.unshift([indent, construct]);
+        }
+        let index = findSuperCall(construct.block);
+        construct.block.expressions.splice(
+          index + 1,
+          0,
+          ...(() => {
+            let results3 = [];
+            for (let i12 = 0, len10 = autoBinds.length; i12 < len10; i12++) {
+              let [, a] = autoBinds[i12];
+              results3.push([indent, ["this.", a.name, " = this.", a.name, ".bind(this)"], ";"]);
+            }
+            return results3;
+          })()
+        );
+      }
+      let privates = expressions.filter(($15) => $15[1]?.type === "CoffeeClassPrivate");
+      if (!privates.length)
+        continue;
+      let { parent } = ce;
+      for (let i13 = expressions.length + -1; i13 >= 0; --i13) {
+        let i = i13;
+        expressions[i][1]?.type === "CoffeeClassPrivate" && expressions.splice(i, 1);
+      }
+      let wrapped = wrapIIFE([
+        ...privates,
+        [indent, wrapWithReturn(ce)]
+      ]);
+      if (ce && typeof ce == "object" && "binding" in ce) {
+        let { binding } = ce;
+        binding = trimFirstSpace(binding), wrapped = makeNode({
+          type: "AssignmentExpression",
+          children: [binding, " = ", wrapped],
+          lhs: binding,
+          // TODO: incorrect shape
+          assigned: binding,
+          expression: wrapped,
+          names: [ce.name]
+        });
+      }
+      replaceNode(ce, wrapped, parent);
+    }
+  }
   function processProgram(root) {
     let state2 = getState(), config2 = getConfig();
     assert.equal(state2.forbidBracedApplication.length, 1, "forbidBracedApplication"), assert.equal(state2.forbidClassImplicitCall.length, 1, "forbidClassImplicitCall"), assert.equal(state2.forbidIndentedApplication.length, 1, "forbidIndentedApplication"), assert.equal(state2.forbidNestedBinaryOp.length, 1, "forbidNestedBinaryOp"), assert.equal(state2.forbidNewlineBinaryOp.length, 1, "forbidNewlineBinaryOp"), assert.equal(state2.forbidTrailingMemberProperty.length, 1, "forbidTrailingMemberProperty"), assert.equal(state2.JSXTagStack.length, 1, "JSXTagStack");
@@ -5841,33 +5992,33 @@ ${js}`
     if (config2.iife || config2.repl) {
       rootIIFE = wrapIIFE(root.expressions, root.topLevelAwait);
       let newExpressions = [["", rootIIFE]];
-      root.children = root.children.map(($13) => $13 === root.expressions ? newExpressions : $13), root.expressions = newExpressions;
+      root.children = root.children.map(($16) => $16 === root.expressions ? newExpressions : $16), root.expressions = newExpressions;
     }
     addParentPointers(root);
     let { expressions: statements } = root;
-    processPlaceholders(statements), processNegativeIndexAccess(statements), processTypes(statements), processDeclarationConditions(statements), processPipelineExpressions(statements), processDeclarations(statements), processAssignments(statements), processStatementExpressions(statements), processPatternMatching(statements), processIterationExpressions(statements), processFinallyClauses(statements), processBreaksContinues(statements), hoistRefDecs(statements), processFunctions(statements, config2), statements.unshift(...state2.prelude), config2.autoLet ? createConstLetDecs(statements, [], "let") : config2.autoConst ? createConstLetDecs(statements, [], "const") : config2.autoVar && createVarDecs(root, []), config2.repl && processRepl(root, rootIIFE), processBlocks(statements), populateRefs(statements), adjustAtBindings(statements), getSync() && processComptime(statements);
+    processPlaceholders(statements), processNegativeIndexAccess(statements), processTypes(statements), processDeclarationConditions(statements), processPipelineExpressions(statements), processDeclarations(statements), processAssignments(statements), processStatementExpressions(statements), processPatternMatching(statements), processIterationExpressions(statements), processFinallyClauses(statements), processBreaksContinues(statements), hoistRefDecs(statements), processFunctions(statements, config2), config2.coffeeClasses && processCoffeeClasses(statements), statements.unshift(...state2.prelude), config2.autoLet ? createConstLetDecs(statements, [], "let") : config2.autoConst ? createConstLetDecs(statements, [], "const") : config2.autoVar && createVarDecs(root, []), config2.repl && processRepl(root, rootIIFE), processBlocks(statements), populateRefs(statements), adjustAtBindings(statements), getSync() && processComptime(statements);
   }
   async function processProgramAsync(root) {
     let { expressions: statements } = root;
     await processComptime(statements);
   }
   function processRepl(root, rootIIFE) {
-    let topBlock = gatherRecursive(rootIIFE, ($14) => $14.type === "BlockStatement")[0], i = 0;
-    for (let ref21 = gatherRecursiveWithinFunction(topBlock, ($15) => $15.type === "Declaration"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
-      let decl = ref21[i11];
+    let topBlock = gatherRecursive(rootIIFE, ($17) => $17.type === "BlockStatement")[0], i = 0;
+    for (let ref22 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref22.length; i14 < len11; i14++) {
+      let decl = ref22[i14];
       decl.names?.length && (decl.parent === topBlock || decl.decl === "var") && (decl.children.shift(), decl.bindings[0]?.pattern?.type === "ObjectBindingPattern" && (decl.children.unshift("("), decl.children.push(")")), root.expressions.splice(i++, 0, ["", `var ${decl.names.join(",")}`, ";"]));
     }
-    for (let ref22 = gatherRecursive(topBlock, ($16) => $16.type === "FunctionExpression"), i12 = 0, len10 = ref22.length; i12 < len10; i12++) {
-      let func = ref22[i12];
+    for (let ref23 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref23.length; i15 < len12; i15++) {
+      let func = ref23[i15];
       func.name && func.parent?.type === "BlockStatement" && (func.parent === topBlock ? (replaceNode(func, void 0), root.expressions.splice(i++, 0, ["", func]), func.parent = root) : (func.children.unshift(func.name, "="), root.expressions.splice(i++, 0, ["", `var ${func.name}`, ";"])));
     }
-    for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($17) => $17.type === "ClassExpression"), i13 = 0, len11 = ref23.length; i13 < len11; i13++) {
-      let classExp = ref23[i13], m8;
+    for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref24.length; i16 < len13; i16++) {
+      let classExp = ref24[i16], m8;
       (classExp.name && classExp.parent === topBlock || (m8 = classExp.parent, typeof m8 == "object" && m8 != null && "type" in m8 && m8.type === "ReturnStatement" && "parent" in m8 && m8.parent === topBlock)) && (classExp.children.unshift(classExp.name, "="), root.expressions.splice(i++, 0, ["", `var ${classExp.name}`, ";"]));
     }
   }
   function populateRefs(statements) {
-    let refNodes = gatherRecursive(statements, ($18) => $18.type === "Ref");
+    let refNodes = gatherRecursive(statements, ($21) => $21.type === "Ref");
     if (refNodes.length) {
       let ids = gatherRecursive(statements, (s) => s.type === "Identifier"), names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
       refNodes.forEach((ref) => {
@@ -5883,8 +6034,8 @@ ${js}`
   }
   function processPlaceholders(statements) {
     let placeholderMap = /* @__PURE__ */ new Map(), liftedIfs = /* @__PURE__ */ new Set();
-    for (let ref24 = gatherRecursiveAll(statements, ($19) => $19.type === "Placeholder"), i14 = 0, len12 = ref24.length; i14 < len12; i14++) {
-      let exp = ref24[i14], ancestor;
+    for (let ref25 = gatherRecursiveAll(statements, ($22) => $22.type === "Placeholder"), i17 = 0, len14 = ref25.length; i17 < len14; i17++) {
+      let exp = ref25[i17], ancestor;
       if (exp.subtype === ".") {
         ({ ancestor } = findAncestor(
           exp,
@@ -5953,11 +6104,11 @@ ${js}`
     }
     for (let [ancestor, placeholders] of placeholderMap) {
       let ref = makeRef("$"), typeSuffix;
-      for (let i15 = 0, len13 = placeholders.length; i15 < len13; i15++) {
-        let placeholder = placeholders[i15];
+      for (let i18 = 0, len15 = placeholders.length; i18 < len15; i18++) {
+        let placeholder = placeholders[i18];
         typeSuffix ??= placeholder.typeSuffix;
-        let ref25;
-        (ref25 = placeholder.children)[ref25.length - 1] = ref;
+        let ref26;
+        (ref26 = placeholder.children)[ref26.length - 1] = ref;
       }
       let { parent } = ancestor, body = maybeUnwrap(ancestor), fnExp = makeAmpersandFunction({ ref, typeSuffix, body }), outer;
       switch (parent?.type) {
@@ -5974,8 +6125,8 @@ ${js}`
           break;
         }
         case "PipelineExpression": {
-          let i = findChildIndex(parent, ancestor), ref26;
-          i === 1 ? ref26 = ancestor === parent.children[i] : i === 2 ? ref26 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3] : ref26 = void 0, outer = ref26;
+          let i = findChildIndex(parent, ancestor), ref27;
+          i === 1 ? ref27 = ancestor === parent.children[i] : i === 2 ? ref27 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3] : ref27 = void 0, outer = ref27;
           break;
         }
         case "AssignmentExpression":
@@ -5987,9 +6138,9 @@ ${js}`
         }
       }
       outer || (fnExp = makeLeftHandSideExpression(fnExp)), replaceNode(ancestor, fnExp, parent);
-      let ref27;
-      if (ref27 = getTrimmingSpace(body)) {
-        let ws = ref27;
+      let ref28;
+      if (ref28 = getTrimmingSpace(body)) {
+        let ws = ref28;
         inplaceInsertTrimmingSpace(body, ""), inplacePrepend(ws, fnExp);
       }
     }
@@ -6020,8 +6171,8 @@ ${js}`
         }
       ];
     }
-    let ref28;
-    Array.isArray(rest.delim) && (ref28 = rest.delim)[ref28.length - 1]?.token === "," && (rest.delim = rest.delim.slice(0, -1), rest.children = [...rest.children.slice(0, -1), rest.delim]);
+    let ref29;
+    Array.isArray(rest.delim) && (ref29 = rest.delim)[ref29.length - 1]?.token === "," && (rest.delim = rest.delim.slice(0, -1), rest.children = [...rest.children.slice(0, -1), rest.delim]);
     let children = [...props, ...after, rest];
     return restCount > 1 && children.push({
       type: "Error",
@@ -7878,13 +8029,28 @@ ${js}`
   var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEnabled, ClassElementName, (0, import_lib2.$E)(_), Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
     var id = $2, exp = $6;
     switch (exp.type) {
-      // TODO: => functions
-      case "FunctionExpression":
+      case "FunctionExpression": {
         let fnTokenIndex = exp.children.findIndex((c) => c?.token?.startsWith("function")), children = exp.children.slice();
         return exp.generator ? children.splice(fnTokenIndex, 2, children[fnTokenIndex + 1], id) : children.splice(fnTokenIndex, 1, id), {
           ...exp,
+          type: "MethodDefinition",
+          name: id.name,
+          signature: { ...exp.signature, id, name: id.name },
           children
         };
+      }
+      case "ArrowFunction": {
+        let block = { ...exp.block }, children = exp.children.filter((c) => !(Array.isArray(c) && c[c.length - 1]?.token?.includes("=>"))).map((c) => c === exp.block ? block : c);
+        return children.unshift(id), exp = {
+          ...exp,
+          type: "MethodDefinition",
+          name: id.name,
+          signature: { ...exp.signature, id, name: id.name },
+          block,
+          children,
+          autoBind: !0
+        }, block.parent = exp, braceBlock(block), exp;
+      }
       default:
         return {
           type: "FieldDefinition",
@@ -7893,26 +8059,37 @@ ${js}`
         };
     }
   }), FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly, ClassElementName, (0, import_lib2.$E)(TypeSuffix), __, ConstAssignment, MaybeNestedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-    var r = $1, id = $2, typeSuffix = $3, ca = $5;
-    return r.children[0].$loc = {
+    var readonly = $1, id = $2, typeSuffix = $3, ca = $5;
+    return readonly.children[0].$loc = {
       pos: ca.$loc.pos - 1,
       length: ca.$loc.length + 1
     }, {
       type: "FieldDefinition",
       id,
       typeSuffix,
-      children: $0
+      children: $0,
+      readonly
     };
-  }), FieldDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Abstract, (0, import_lib2.$E)(_))), (0, import_lib2.$E)((0, import_lib2.$S)(Readonly, (0, import_lib2.$E)(_))), ClassElementName, (0, import_lib2.$E)(TypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-    var id = $3, typeSuffix = $4;
+  }), FieldDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEnabled, ActualAssignment), function($skip, $loc, $0, $1, $2) {
+    var assignment = $2;
+    return {
+      type: "CoffeeClassPrivate",
+      children: [assignment],
+      assignment
+    };
+  }), FieldDefinition$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Abstract, (0, import_lib2.$E)(_))), (0, import_lib2.$E)((0, import_lib2.$S)(Readonly, (0, import_lib2.$E)(_))), ClassElementName, (0, import_lib2.$E)(TypeSuffix), (0, import_lib2.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var abstract = $1, readonly = $2, id = $3, typeSuffix = $4, initializer = $5;
     return {
       type: "FieldDefinition",
       children: $0,
-      ts: $1 ? !0 : void 0,
+      ts: abstract ? !0 : void 0,
       id,
-      typeSuffix
+      typeSuffix,
+      abstract,
+      readonly,
+      initializer
     };
-  }), FieldDefinition$$ = [FieldDefinition$0, FieldDefinition$1, FieldDefinition$2];
+  }), FieldDefinition$$ = [FieldDefinition$0, FieldDefinition$1, FieldDefinition$2, FieldDefinition$3];
   function FieldDefinition(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "FieldDefinition", FieldDefinition$$);
   }
@@ -8524,7 +8701,7 @@ ${js}`
     var expression = $2;
     return {
       type: "PinPattern",
-      children: $0,
+      children: [expression],
       expression
     };
   }), PinPattern$1 = (0, import_lib2.$TV)(ActualMemberExpression, function($skip, $loc, $0, $1) {
@@ -8683,6 +8860,7 @@ ${js}`
       name: binding,
       value: {
         type: "PinPattern",
+        children: [binding],
         expression: binding
       }
     }) : {
@@ -9360,7 +9538,7 @@ ${js}`
     return (0, import_lib2.$EVENT_C)(ctx, state2, "LiteralContent", LiteralContent$$);
   }
   var NullLiteral$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L38, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-    return { $loc, token: $1 };
+    return { type: "NullLiteral", $loc, token: $1 };
   });
   function NullLiteral(ctx, state2) {
     return (0, import_lib2.$EVENT)(ctx, state2, "NullLiteral", NullLiteral$0);
@@ -9374,15 +9552,15 @@ ${js}`
   var _BooleanLiteral$0 = (0, import_lib2.$T)((0, import_lib2.$S)(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
     return value[1];
   }), _BooleanLiteral$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L39, '_BooleanLiteral "true"'), (0, import_lib2.$EXPECT)($L40, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-    return { $loc, token: $1 };
+    return { type: "BooleanLiteral", $loc, token: $1 };
   }), _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
   function _BooleanLiteral(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "_BooleanLiteral", _BooleanLiteral$$);
   }
   var CoffeeScriptBooleanLiteral$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L41, 'CoffeeScriptBooleanLiteral "yes"'), (0, import_lib2.$EXPECT)($L42, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-    return { $loc, token: "true" };
+    return { type: "BooleanLiteral", $loc, token: "true" };
   }), CoffeeScriptBooleanLiteral$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L43, 'CoffeeScriptBooleanLiteral "no"'), (0, import_lib2.$EXPECT)($L44, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-    return { $loc, token: "false" };
+    return { type: "BooleanLiteral", $loc, token: "false" };
   }), CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
   function CoffeeScriptBooleanLiteral(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
@@ -12391,7 +12569,12 @@ ${js}`
     return (0, import_lib2.$EVENT)(ctx, state2, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
   }
   var RegularExpressionLiteral$0 = HeregexLiteral, RegularExpressionLiteral$1 = (0, import_lib2.$TV)((0, import_lib2.$TEXT)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($L77, 'RegularExpressionLiteral "/"'), RegularExpressionBody, (0, import_lib2.$EXPECT)($L77, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
-    return { type: "RegularExpressionLiteral", $loc, token: $1 };
+    var raw = $0;
+    return {
+      type: "RegularExpressionLiteral",
+      raw,
+      children: [{ $loc, token: raw }]
+    };
   }), RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
   function RegularExpressionLiteral(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "RegularExpressionLiteral", RegularExpressionLiteral$$);
@@ -14371,9 +14554,11 @@ ${js}`
     return (0, import_lib2.$EVENT)(ctx, state2, "UnknownAlias", UnknownAlias$0);
   }
   var TypePrimary$0 = (0, import_lib2.$S)((0, import_lib2.$E)(_), Infer, (0, import_lib2.$E)(_), IdentifierName, (0, import_lib2.$E)((0, import_lib2.$S)(NotDedented, ExtendsToken, Type))), TypePrimary$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), Typeof, (0, import_lib2.$E)(_), UnaryExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var expression = $4;
     return {
-      type: "TypeofType",
-      children: $0
+      type: "TypeTypeof",
+      children: $0,
+      expression
     };
   }), TypePrimary$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), TypeTuple), function($skip, $loc, $0, $1, $2) {
     return prepend($1, $2);
@@ -15484,9 +15669,9 @@ ${js}`
     "unscopables"
   ];
 
-  // source/sourcemap.civet
-  var sourcemap_exports = {};
-  __export(sourcemap_exports, {
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\sourcemap.civet.jsx
+  var sourcemap_civet_exports = {};
+  __export(sourcemap_civet_exports, {
     SourceMap: () => SourceMap,
     base64Encode: () => base64Encode,
     locationTable: () => locationTable,
@@ -15643,7 +15828,7 @@ ${js}`
       return [lastMapping[2], lastMapping[3]];
   };
 
-  // source/state-cache.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\state-cache.civet.jsx
   var StateCache = class {
     cache = /* @__PURE__ */ new Map();
     get(key) {
@@ -15666,8 +15851,8 @@ ${js}`
     }
   };
 
-  // source/main.civet
-  var { SourceMap: SourceMap2 } = sourcemap_exports;
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\main.civet.jsx
+  var { SourceMap: SourceMap2 } = sourcemap_civet_exports;
   var ParseErrors = class extends Error {
     name = "ParseErrors";
     errors;
@@ -15772,14 +15957,14 @@ ${counts}`;
       }
       if (options.sourceMap || options.inlineMap) {
         options.sourceMap = SourceMap2(src);
-        let code = generate_default(ast2, options);
+        let code = generate_civet_default(ast2, options);
         return checkErrors(), options.inlineMap ? SourceMap2.remap(code, options.sourceMap, filename2, filename2 + ".tsx") : {
           code,
           sourceMap: options.sourceMap
         };
       }
-      let result = generate_default(ast2, options);
-      return options.errors?.length && (delete options.errors, options.sourceMap = SourceMap2(src), generate_default(ast2, options), checkErrors()), result;
+      let result = generate_civet_default(ast2, options);
+      return options.errors?.length && (delete options.errors, options.sourceMap = SourceMap2(src), generate_civet_default(ast2, options), checkErrors()), result;
     }
     return ast.then != null ? ast.then(rest) : rest(ast);
   }
@@ -15816,7 +16001,7 @@ ${counts}`;
     return err instanceof import_lib2.ParseError || err instanceof ParseErrors;
   };
 
-  // source/browser.civet
+  // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\browser.civet.jsx
   async function runScripts(type = "text/civet") {
     let scripts = window.document.querySelectorAll(`script[type=${JSON.stringify(type)}]`);
     for (let i1 = 0, len3 = scripts.length; i1 < len3; i1++) {
@@ -15862,5 +16047,5 @@ ${counts}`;
         return autoRunScripts([document.head, document.body]);
     });
   }
-  return __toCommonJS(browser_exports);
+  return __toCommonJS(browser_civet_exports);
 })();