@danielx/civet 0.9.2 → 0.9.3

package/dist/main.js

@@ -513,6 +513,7 @@ __export(lib_civet_exports, {
   append: () => append,
   attachPostfixStatementAsExpression: () => attachPostfixStatementAsExpression,
   blockWithPrefix: () => blockWithPrefix,
+  braceBlock: () => braceBlock,
   convertNamedImportsToObject: () => convertNamedImportsToObject,
   convertObjectToJSXAttributes: () => convertObjectToJSXAttributes,
   convertWithClause: () => convertWithClause,
@@ -993,6 +994,57 @@ function literalValue(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": {
+          if (literal.raw.endsWith("n")) {
+            t = "bigint";
+          } else {
+            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) {
   const s = n.toString();
   return {
@@ -1305,7 +1357,7 @@ function skipIfOnlyWS(target) {
   return target;
 }
 function spliceChild(node, child, del, ...replacements) {
-  const children = node?.children ?? node;
+  const children = Array.isArray(node) ? node : node.children;
   if (!Array.isArray(children)) {
     throw new Error("spliceChild: non-array node has no children field");
   }
@@ -1740,14 +1792,41 @@ function gatherBindingCode(statements, opts) {
   const thisAssignments = [];
   const 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++) {
-      const n = ref2[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") {
         const { ref } = n;
         const { id } = ref;
         thisAssignments2.push([`this.${id} = `, ref]);
         continue;
       }
+      if (opts?.assignPins) {
+        if (n.type === "PinProperty") {
+          n.children = n.children.flatMap(($2) => $2 === n.name ? [n.name, ": ", n.value] : $2);
+          updateParentPointers(n);
+          n = n.value;
+        }
+        if (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++) {
           const id = ref3[i4];
@@ -3583,20 +3662,21 @@ function processParams(f) {
     indent = expressions[0][0];
   }
   const [splices, thisAssignments] = gatherBindingCode(parameters, {
-    injectParamProps: isConstructor
+    injectParamProps: isConstructor,
+    assignPins: true
   });
   if (isConstructor) {
     const { ancestor } = findAncestor(f, ($9) => $9.type === "ClassExpression");
     if (ancestor != null) {
       const 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));
       const classExpressions = ancestor.body.expressions;
-      let index = findChildIndex(classExpressions, f);
-      assert.notEqual(index, -1, "Could not find constructor in class");
+      let index2 = findChildIndex(classExpressions, f);
+      assert.notEqual(index2, -1, "Could not find constructor in class");
       let m4;
-      while (m4 = classExpressions[index - 1]?.[1], typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor") {
-        index--;
+      while (m4 = classExpressions[index2 - 1]?.[1], typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "MethodDefinition" && "name" in m4 && m4.name === "constructor") {
+        index2--;
       }
-      const fStatement = classExpressions[index];
+      const fStatement = classExpressions[index2];
       for (let ref18 = gatherRecursive(parameters, ($13) => $13.type === "Parameter"), i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
         const parameter = ref18[i9];
         const { accessModifier } = parameter;
@@ -3617,7 +3697,7 @@ function processParams(f) {
           if (fields.has(id)) {
             continue;
           }
-          classExpressions.splice(index++, 0, [fStatement[0], {
+          classExpressions.splice(index2++, 0, [fStatement[0], {
             type: "FieldDefinition",
             id,
             typeSuffix,
@@ -3654,25 +3734,31 @@ function processParams(f) {
   if (!prefix.length) {
     return;
   }
+  let index = -1;
   if (isConstructor) {
-    const 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) {
-      const { child } = findAncestor(superCalls[0], (a5) => a5 === block);
-      const 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;
-    }
+    index = findSuperCall(block);
   }
-  expressions.unshift(...prefix);
+  expressions.splice(index + 1, 0, ...prefix);
   updateParentPointers(block);
   braceBlock(block);
 }
+function findSuperCall(block) {
+  const { expressions } = block;
+  const 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) {
+    const { child } = findAncestor(superCalls[0], (a5) => a5 === block);
+    const 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) {
   const { block, signature } = f;
   if (!f.async?.length && hasAwait(block)) {
@@ -4965,18 +5051,47 @@ function processDeclarations(statements) {
   for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "Declaration"), i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
     const declaration = ref1[i1];
     const { bindings } = declaration;
-    bindings?.forEach((binding) => {
-      const { typeSuffix } = binding;
-      if (typeSuffix && typeSuffix.optional && typeSuffix.t) {
-        convertOptionalType(typeSuffix);
+    if (!(bindings != null)) {
+      continue;
+    }
+    for (let i2 = 0, len22 = bindings.length; i2 < len22; i2++) {
+      const binding = bindings[i2];
+      let { typeSuffix, initializer } = binding;
+      if (typeSuffix && typeSuffix.optional) {
+        if (initializer && !typeSuffix.t) {
+          const expression = trimFirstSpace(initializer.expression);
+          let 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;
+          }
+        }
+        if (typeSuffix.t) {
+          convertOptionalType(typeSuffix);
+        } else {
+          spliceChild(binding, typeSuffix, 1);
+          binding.children.push(initializer = binding.initializer = {
+            type: "Initializer",
+            expression: "undefined",
+            children: [" = ", "undefined"]
+          });
+        }
       }
-      const { initializer } = binding;
       if (initializer) {
-        return prependStatementExpressionBlock(initializer, declaration);
+        prependStatementExpressionBlock(initializer, declaration);
       }
-      ;
-      return;
-    });
+    }
   }
 }
 function prependStatementExpressionBlock(initializer, statement) {
@@ -5139,16 +5254,16 @@ function processDeclarationConditionStatement(s) {
     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++) {
-        const c = conditions[i2];
+      for (let i3 = 0, len3 = conditions.length; i3 < len3; i3++) {
+        const c = conditions[i3];
         children.push(" && ", c);
       }
       children.push(")");
@@ -5269,7 +5384,8 @@ function dynamizeFromClause(from) {
   if (ref3 = from[from.length - 1]?.assertion) {
     const assert2 = ref3;
     let ref4;
-    ref4 = from[from.length - 1], ref4.children = ref4.children.filter((a2) => a2 !== assert2);
+    ref4 = from[from.length - 1];
+    ref4.children = ref4.children.filter((a2) => a2 !== assert2);
     from.push(", {", assert2.keyword, ":", assert2.object, "}");
   }
   return ["(", ...from, ")"];
@@ -6303,12 +6419,10 @@ function createVarDecs(block, scopes, pushVar) {
     }
     return assignmentStatements2;
   }
-  if (!pushVar) {
-    pushVar = function(name) {
-      varIds.push(name);
-      return decs.add(name);
-    };
-  }
+  pushVar ??= (name) => {
+    varIds.push(name);
+    return decs.add(name);
+  };
   const { expressions: statements } = block;
   const decs = findDecs(statements);
   scopes.push(decs);
@@ -7908,6 +8022,91 @@ function processBreaksContinues(statements) {
     delete label.special;
   }
 }
+function processCoffeeClasses(statements) {
+  for (let ref21 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
+    const ce = ref21[i11];
+    const { expressions } = ce.body;
+    const indent = expressions[0]?.[0] ?? "\n";
+    const autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
+    if (autoBinds.length) {
+      let construct;
+      for (const [, 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) {
+        const parametersList = [];
+        const parameters = {
+          type: "Parameters",
+          children: [parametersList],
+          parameters: parametersList,
+          names: []
+        };
+        const signature = {
+          type: "MethodSignature",
+          children: ["constructor(", parameters, ")"],
+          parameters,
+          modifier: {},
+          returnType: void 0
+        };
+        const block = makeEmptyBlock();
+        construct = {
+          ...signature,
+          type: "MethodDefinition",
+          name: "constructor",
+          block,
+          signature,
+          children: [...signature.children, block]
+        };
+        expressions.unshift([indent, construct]);
+      }
+      const index = findSuperCall(construct.block);
+      construct.block.expressions.splice(
+        index + 1,
+        0,
+        ...(() => {
+          const results3 = [];
+          for (let i12 = 0, len10 = autoBinds.length; i12 < len10; i12++) {
+            const [, a] = autoBinds[i12];
+            results3.push([indent, ["this.", a.name, " = this.", a.name, ".bind(this)"], ";"]);
+          }
+          return results3;
+        })()
+      );
+    }
+    const privates = expressions.filter(($15) => $15[1]?.type === "CoffeeClassPrivate");
+    if (!privates.length) {
+      continue;
+    }
+    const { parent } = ce;
+    for (let i13 = expressions.length + -1; i13 >= 0; --i13) {
+      const i = i13;
+      if (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) {
   const state2 = getState();
   const config2 = getConfig();
@@ -7922,7 +8121,7 @@ function processProgram(root) {
   if (config2.iife || config2.repl) {
     rootIIFE = wrapIIFE(root.expressions, root.topLevelAwait);
     const newExpressions = [["", rootIIFE]];
-    root.children = root.children.map(($13) => $13 === root.expressions ? newExpressions : $13);
+    root.children = root.children.map(($16) => $16 === root.expressions ? newExpressions : $16);
     root.expressions = newExpressions;
   }
   addParentPointers(root);
@@ -7941,6 +8140,9 @@ function processProgram(root) {
   processBreaksContinues(statements);
   hoistRefDecs(statements);
   processFunctions(statements, config2);
+  if (config2.coffeeClasses) {
+    processCoffeeClasses(statements);
+  }
   statements.unshift(...state2.prelude);
   if (config2.autoLet) {
     createConstLetDecs(statements, [], "let");
@@ -7964,10 +8166,10 @@ async function processProgramAsync(root) {
   await processComptime(statements);
 }
 function processRepl(root, rootIIFE) {
-  const topBlock = gatherRecursive(rootIIFE, ($14) => $14.type === "BlockStatement")[0];
+  const topBlock = gatherRecursive(rootIIFE, ($17) => $17.type === "BlockStatement")[0];
   let i = 0;
-  for (let ref21 = gatherRecursiveWithinFunction(topBlock, ($15) => $15.type === "Declaration"), i11 = 0, len9 = ref21.length; i11 < len9; i11++) {
-    const decl = ref21[i11];
+  for (let ref22 = gatherRecursiveWithinFunction(topBlock, ($18) => $18.type === "Declaration"), i14 = 0, len11 = ref22.length; i14 < len11; i14++) {
+    const decl = ref22[i14];
     if (!decl.names?.length) {
       continue;
     }
@@ -7980,8 +8182,8 @@ function processRepl(root, rootIIFE) {
       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++) {
-    const func = ref22[i12];
+  for (let ref23 = gatherRecursive(topBlock, ($19) => $19.type === "FunctionExpression"), i15 = 0, len12 = ref23.length; i15 < len12; i15++) {
+    const func = ref23[i15];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
         replaceNode(func, void 0);
@@ -7993,8 +8195,8 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($17) => $17.type === "ClassExpression"), i13 = 0, len11 = ref23.length; i13 < len11; i13++) {
-    const classExp = ref23[i13];
+  for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($20) => $20.type === "ClassExpression"), i16 = 0, len13 = ref24.length; i16 < len13; i16++) {
+    const classExp = ref24[i16];
     let m8;
     if (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, "=");
@@ -8003,7 +8205,7 @@ function processRepl(root, rootIIFE) {
   }
 }
 function populateRefs(statements) {
-  const refNodes = gatherRecursive(statements, ($18) => $18.type === "Ref");
+  const refNodes = gatherRecursive(statements, ($21) => $21.type === "Ref");
   if (refNodes.length) {
     const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
     const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
@@ -8025,8 +8227,8 @@ function populateRefs(statements) {
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
   const liftedIfs = /* @__PURE__ */ new Set();
-  for (let ref24 = gatherRecursiveAll(statements, ($19) => $19.type === "Placeholder"), i14 = 0, len12 = ref24.length; i14 < len12; i14++) {
-    const exp = ref24[i14];
+  for (let ref25 = gatherRecursiveAll(statements, ($22) => $22.type === "Placeholder"), i17 = 0, len14 = ref25.length; i17 < len14; i17++) {
+    const exp = ref25[i17];
     let ancestor;
     if (exp.subtype === ".") {
       ({ ancestor } = findAncestor(
@@ -8135,11 +8337,11 @@ function processPlaceholders(statements) {
   for (const [ancestor, placeholders] of placeholderMap) {
     let ref = makeRef("$");
     let typeSuffix;
-    for (let i15 = 0, len13 = placeholders.length; i15 < len13; i15++) {
-      const placeholder = placeholders[i15];
+    for (let i18 = 0, len15 = placeholders.length; i18 < len15; i18++) {
+      const placeholder = placeholders[i18];
       typeSuffix ??= placeholder.typeSuffix;
-      let ref25;
-      (ref25 = placeholder.children)[ref25.length - 1] = ref;
+      let ref26;
+      (ref26 = placeholder.children)[ref26.length - 1] = ref;
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -8160,16 +8362,16 @@ function processPlaceholders(statements) {
       }
       case "PipelineExpression": {
         const i = findChildIndex(parent, ancestor);
-        let ref26;
+        let ref27;
         if (i === 1) {
-          ref26 = ancestor === parent.children[i];
+          ref27 = ancestor === parent.children[i];
         } else if (i === 2) {
-          ref26 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          ref27 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
         } else {
-          ref26 = void 0;
+          ref27 = void 0;
         }
         ;
-        outer = ref26;
+        outer = ref27;
         break;
       }
       case "AssignmentExpression":
@@ -8184,9 +8386,9 @@ function processPlaceholders(statements) {
       fnExp = makeLeftHandSideExpression(fnExp);
     }
     replaceNode(ancestor, fnExp, parent);
-    let ref27;
-    if (ref27 = getTrimmingSpace(body)) {
-      const ws = ref27;
+    let ref28;
+    if (ref28 = getTrimmingSpace(body)) {
+      const ws = ref28;
       inplaceInsertTrimmingSpace(body, "");
       inplacePrepend(ws, fnExp);
     }
@@ -8230,8 +8432,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  let ref28;
-  if (Array.isArray(rest.delim) && (ref28 = rest.delim)[ref28.length - 1]?.token === ",") {
+  let ref29;
+  if (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];
   }
@@ -10762,8 +10964,7 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
   var id = $2;
   var exp = $6;
   switch (exp.type) {
-    // TODO: => functions
-    case "FunctionExpression":
+    case "FunctionExpression": {
       const fnTokenIndex = exp.children.findIndex((c) => c?.token?.startsWith("function"));
       const children = exp.children.slice();
       if (exp.generator) {
@@ -10773,8 +10974,29 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
       }
       return {
         ...exp,
+        type: "MethodDefinition",
+        name: id.name,
+        signature: { ...exp.signature, id, name: id.name },
         children
       };
+    }
+    case "ArrowFunction": {
+      const block = { ...exp.block };
+      const children = exp.children.filter((c) => !(Array.isArray(c) && c[c.length - 1]?.token?.includes("=>"))).map((c) => c === exp.block ? block : c);
+      children.unshift(id);
+      exp = {
+        ...exp,
+        type: "MethodDefinition",
+        name: id.name,
+        signature: { ...exp.signature, id, name: id.name },
+        block,
+        children,
+        autoBind: true
+      };
+      block.parent = exp;
+      braceBlock(block);
+      return exp;
+    }
     default:
       return {
         type: "FieldDefinition",
@@ -10784,11 +11006,11 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
   }
 });
 var 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;
+  var readonly = $1;
   var id = $2;
   var typeSuffix = $3;
   var ca = $5;
-  r.children[0].$loc = {
+  readonly.children[0].$loc = {
     pos: ca.$loc.pos - 1,
     length: ca.$loc.length + 1
   };
@@ -10796,21 +11018,36 @@ var FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly,
     type: "FieldDefinition",
     id,
     typeSuffix,
-    children: $0
+    children: $0,
+    readonly
+  };
+});
+var 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
   };
 });
-var 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 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;
+  var readonly = $2;
   var id = $3;
   var typeSuffix = $4;
+  var initializer = $5;
   return {
     type: "FieldDefinition",
     children: $0,
-    ts: $1 ? true : void 0,
+    ts: abstract ? true : void 0,
     id,
-    typeSuffix
+    typeSuffix,
+    abstract,
+    readonly,
+    initializer
   };
 });
-var FieldDefinition$$ = [FieldDefinition$0, FieldDefinition$1, FieldDefinition$2];
+var FieldDefinition$$ = [FieldDefinition$0, FieldDefinition$1, FieldDefinition$2, FieldDefinition$3];
 function FieldDefinition(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "FieldDefinition", FieldDefinition$$);
 }
@@ -11617,7 +11854,7 @@ var PinPattern$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Caret, SingleLineExp
   var expression = $2;
   return {
     type: "PinPattern",
-    children: $0,
+    children: [expression],
     expression
   };
 });
@@ -11832,6 +12069,7 @@ var BindingProperty$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
       name: binding,
       value: {
         type: "PinPattern",
+        children: [binding],
         expression: binding
       }
     };
@@ -12700,7 +12938,7 @@ function LiteralContent(ctx, state2) {
   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);
@@ -12715,17 +12953,17 @@ var _BooleanLiteral$0 = (0, import_lib2.$T)((0, import_lib2.$S)(CoffeeBooleansEn
   return value[1];
 });
 var _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 };
 });
 var _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" };
 });
 var 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" };
 });
 var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
 function CoffeeScriptBooleanLiteral(ctx, state2) {
@@ -16611,7 +16849,12 @@ function CoffeeDoubleQuotedStringCharacters(ctx, state2) {
 }
 var RegularExpressionLiteral$0 = HeregexLiteral;
 var 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 }]
+  };
 });
 var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
 function RegularExpressionLiteral(ctx, state2) {
@@ -18999,9 +19242,11 @@ function UnknownAlias(ctx, state2) {
 }
 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)));
 var 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
   };
 });
 var TypePrimary$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), TypeTuple), function($skip, $loc, $0, $1, $2) {