@danielx/civet 0.6.89 → 0.6.91

package/dist/browser.js

@@ -41,213 +41,596 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // source/parser/util.civet
-  function addParentPointers(node, parent) {
-    if (node == null)
-      return;
-    if (typeof node !== "object")
-      return;
-    if (Array.isArray(node)) {
-      for (const child of node) {
-        addParentPointers(child, parent);
-      }
-      return;
+  // source/parser/op.civet
+  function getPrecedence(op) {
+    if (typeof op === "string") {
+      return precedenceMap.get(op) ?? (() => {
+        throw new Error(`Unknown operator: ${op}`);
+      })();
+    } else if (typeof op.prec === "number") {
+      return op.prec;
+    } else {
+      return precedenceMap.get(op.prec ?? op.token) ?? (op.relational ? precedenceRelational : precedenceCustomDefault);
     }
-    node = node;
-    node.parent = parent;
-    if (node.children) {
-      for (const child of node.children) {
-        addParentPointers(child, node);
+  }
+  function processBinaryOpExpression($0) {
+    return recurse(expandChainedComparisons($0));
+    function recurse(expandedOps) {
+      let i = 2;
+      while (i < expandedOps.length) {
+        let op = expandedOps[i];
+        if (op.special) {
+          let advanceLeft2 = function(allowEqual) {
+            while (start >= 4) {
+              const prevPrec = getPrecedence(expandedOps[start - 2]);
+              if (!(prevPrec > prec || allowEqual && prevPrec === prec)) {
+                return prevPrec === prec;
+              }
+              start -= 4;
+            }
+            return false;
+          }, advanceRight2 = function(allowEqual) {
+            while (end + 4 < expandedOps.length) {
+              const nextPrec = getPrecedence(expandedOps[end + 2]);
+              if (!(nextPrec > prec || allowEqual && nextPrec === prec)) {
+                return nextPrec === prec;
+              }
+              end += 4;
+            }
+            return false;
+          };
+          var advanceLeft = advanceLeft2, advanceRight = advanceRight2;
+          let start = i - 2, end = i + 2;
+          const prec = getPrecedence(op);
+          let error;
+          switch (op.assoc) {
+            case "left":
+            case void 0: {
+              advanceLeft2(true);
+              advanceRight2(false);
+              break;
+            }
+            case "right": {
+              advanceLeft2(false);
+              advanceRight2(true);
+              break;
+            }
+            case "non": {
+              if (advanceLeft2(false) || advanceRight2(false)) {
+                error = {
+                  type: "Error",
+                  message: `non-associative operator ${op.token} used at same precedence level without parenthesization`
+                };
+              }
+              ;
+              break;
+            }
+            case "arguments": {
+              if (advanceLeft2(false)) {
+                error = {
+                  type: "Error",
+                  message: `arguments operator ${op.token} used at same precedence level as ${expandedOps[start - 2].token} to the left`
+                };
+              }
+              advanceRight2(true);
+              break;
+            }
+            default: {
+              throw new Error(`Unsupported associativity: ${op.assoc}`);
+            }
+          }
+          let a = start === i - 2 ? expandedOps[start] : expandedOps.slice(start, i - 1);
+          let wsOp = expandedOps[i - 1];
+          let wsB = expandedOps[i + 1];
+          let b = end === i + 2 ? expandedOps[i + 2] : expandedOps.slice(i + 2, end + 1);
+          if (op.assoc === "arguments") {
+            let i2 = 2;
+            while (i2 < b.length) {
+              if (prec === getPrecedence(b[i2])) {
+                if (!(b[i2].token === op.token)) {
+                  error ??= {
+                    type: "Error",
+                    message: `arguments operator ${op.token} used at same precedence level as ${b[i2].token} to the right`
+                  };
+                }
+                b[i2] = ",";
+              }
+              i2 += 4;
+            }
+          } else {
+            b = recurse(b);
+          }
+          if (op.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
+            a = ["typeof ", makeLeftHandSideExpression(a)];
+            if (op.negated) {
+              op = { ...op, token: "!==", negated: false };
+            } else {
+              op = { ...op, token: "===" };
+            }
+          }
+          if (op.asConst) {
+            a = makeAsConst(a);
+            b = makeAsConst(b);
+          }
+          let children;
+          if (op.call) {
+            wsOp = insertTrimmingSpace(wsOp, "");
+            if (op.reversed) {
+              wsB = insertTrimmingSpace(wsB, "");
+              children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix];
+            } else {
+              children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix];
+            }
+          } else if (op.method) {
+            wsOp = insertTrimmingSpace(wsOp, "");
+            wsB = insertTrimmingSpace(wsB, "");
+            if (op.reversed) {
+              if (end !== i + 2)
+                b = makeLeftHandSideExpression(b);
+              b = dotNumericLiteral(b);
+              children = [wsB, b, wsOp, ".", op.method, "(", a, ")"];
+            } else {
+              if (start !== i - 2 || a.type === "NumericLiteral") {
+                a = makeLeftHandSideExpression(a);
+              }
+              a = dotNumericLiteral(a);
+              children = [a, wsOp, ".", op.method, "(", wsB, b, ")"];
+            }
+          } else if (op.token) {
+            children = [a, wsOp, op, wsB, b];
+            if (op.negated)
+              children = ["(", ...children, ")"];
+          } else {
+            throw new Error("Unknown operator: " + JSON.stringify(op));
+          }
+          if (op.negated)
+            children.unshift("!");
+          if (error != null) {
+            children.push(error);
+          }
+          expandedOps.splice(start, end - start + 1, {
+            children
+          });
+          i = start + 2;
+        } else {
+          i += 4;
+        }
       }
+      return expandedOps;
     }
+    ;
+    return recurse;
   }
-  function clone(node) {
-    removeParentPointers(node);
-    return deepCopy(node);
+  function dotNumericLiteral(literal) {
+    if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
+      literal.children.push(".");
+      literal.raw += ".";
+    }
+    return literal;
   }
-  function removeParentPointers(node) {
-    if (node == null)
-      return;
-    if (typeof node !== "object")
-      return;
-    if (Array.isArray(node)) {
-      for (const child of node) {
-        removeParentPointers(child);
-      }
-      return;
+  function makeAsConst(node) {
+    if (Array.isArray(node) && node.length === 1) {
+      node = node[0];
     }
-    node.parent = null;
-    if (node.children) {
-      for (const child of node.children) {
-        removeParentPointers(child);
-      }
+    if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
+      return { ...node, children: [...node.children, asConst] };
+    } else {
+      return node;
     }
   }
-  function isEmptyBareBlock(node) {
-    if (node?.type !== "BlockStatement")
-      return false;
-    const { bare, expressions } = node;
-    return bare && (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
-  }
-  function isFunction(node) {
-    const { type } = node;
-    return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || !!node.async;
-  }
-  function isWhitespaceOrEmpty(node) {
-    if (!node)
-      return true;
-    if (node.type === "Ref")
-      return false;
-    if (node.token)
-      return node.token.match(/^\s*$/);
-    if (node.children)
-      node = node.children;
-    if (!node.length)
-      return true;
-    if (typeof node === "string")
-      return node.match(/^\s*$/);
-    if (Array.isArray(node))
-      return node.every(isWhitespaceOrEmpty);
-    return;
-  }
-  function isExit(node) {
-    return [
-      "ReturnStatement",
-      "ThrowStatement",
-      "BreakStatement",
-      "ContinueStatement"
-    ].includes(node?.type);
-  }
-  function isComma(node) {
-    if (node?.token === ",") {
-      return node;
-    } else if (Array.isArray(node) && node.at(-1)?.token === ",") {
-      return node.at(-1);
+  function isExistence(exp) {
+    if (exp?.type === "ParenthesizedExpression" && exp.implicit) {
+      exp = exp.expression;
+    }
+    if (exp?.type === "Existence") {
+      return exp;
     }
     ;
     return;
   }
-  function insertTrimmingSpace(target, c) {
-    if (!target) {
-      return target;
+  function isRelationalOp(op) {
+    return op.relational || getPrecedence(op) === precedenceRelational;
+  }
+  function expandChainedComparisons([first, binops]) {
+    if (!binops.length) {
+      return [first];
     }
-    if (Array.isArray(target)) {
-      if (target.length === 0) {
-        return c;
+    const results = [];
+    let start = 0;
+    const chains = [];
+    var i = 0;
+    for (let i3 = 0, len2 = binops.length; i3 < len2; i3++) {
+      var i = i3;
+      var [, op] = binops[i3];
+      if (isRelationalOp(op)) {
+        chains.push(i);
+      } else if (getPrecedence(op) < precedenceRelational) {
+        processChains();
+        first = results.pop();
       }
-      return target.map((e, i) => {
-        if (i === 0) {
-          return insertTrimmingSpace(e, c);
-        }
-        return e;
-      });
     }
-    if (target.children) {
-      return {
-        ...target,
-        children: insertTrimmingSpace(target.children, c)
-      };
+    processChains();
+    return results;
+    function processChains() {
+      if (chains.length > 0) {
+        first = expandExistence(first);
+        for (let i4 = 0, len3 = chains.length; i4 < len3; i4++) {
+          const k = i4;
+          const index = chains[i4];
+          if (k > 0) {
+            results.push(" ", "&&", " ");
+          }
+          const binop = binops[index];
+          const exp = binop[3] = expandExistence(binop[3]);
+          results.push(first);
+          const endIndex = chains[k + 1] ?? i + 1;
+          results.push(...binops.slice(start, endIndex).flat());
+          first = [exp].concat(binops.slice(index + 1, endIndex));
+          start = endIndex;
+        }
+      } else {
+        results.push(first);
+        results.push(...binops.slice(start, i + 1).flat());
+        start = i + 1;
+      }
+      chains.length = 0;
     }
-    if (target.token) {
-      return {
-        ...target,
-        token: target.token.replace(/^ ?/, c)
-      };
+    function expandExistence(exp) {
+      let ref;
+      if (ref = isExistence(exp)) {
+        const existence = ref;
+        results.push(existence, " ", "&&", " ");
+        return existence.expression;
+      } else {
+        return exp;
+      }
     }
-    return target;
-  }
-  function getTrimmingSpace(target) {
-    if (!target)
-      return;
-    if (Array.isArray(target))
-      return getTrimmingSpace(target[0]);
-    if (target.children)
-      return getTrimmingSpace(target.children[0]);
-    if (target.token)
-      return target.token.match(/^ ?/)[0];
-    return;
+    ;
   }
-  function literalValue(literal) {
-    let { raw } = literal;
-    switch (raw) {
-      case "null":
-        return null;
-      case "true":
-        return true;
-      case "false":
-        return false;
-    }
-    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-      return raw.slice(1, -1);
+  var precedenceOrder, precedenceMap, precedenceStep, precedenceRelational, precedenceCustomDefault, asConst;
+  var init_op = __esm({
+    "source/parser/op.civet"() {
+      "use strict";
+      init_util();
+      precedenceOrder = [
+        ["||", "??"],
+        ["^^"],
+        ["&&"],
+        ["|"],
+        ["^"],
+        ["&"],
+        // NOTE: Equality and inequality merged because of relational chaining
+        [
+          "==",
+          "!=",
+          "===",
+          "!==",
+          "<",
+          "<=",
+          ">",
+          ">=",
+          "in",
+          "instanceof"
+        ],
+        // NOTE: Extra in-between level for default custom operators
+        ["custom"],
+        ["<<", ">>", ">>>"],
+        ["+", "-"],
+        ["*", "/", "%"],
+        ["**"]
+      ];
+      precedenceMap = /* @__PURE__ */ new Map();
+      for (let i1 = 0, len = precedenceOrder.length; i1 < len; i1++) {
+        const prec = i1;
+        const ops = precedenceOrder[i1];
+        for (let i2 = 0, len1 = ops.length; i2 < len1; i2++) {
+          const op = ops[i2];
+          precedenceMap.set(op, prec);
+        }
+      }
+      precedenceStep = 1 / 64;
+      precedenceRelational = precedenceMap.get("==");
+      precedenceCustomDefault = precedenceMap.get("custom");
+      asConst = {
+        ts: true,
+        children: [" as const"]
+      };
     }
-    const numeric = literal.children.find(
-      (child) => child.type === "NumericLiteral"
-    );
-    if (numeric) {
-      raw = raw.replace(/_/g, "");
-      const { token } = numeric;
-      if (token.endsWith("n")) {
-        return BigInt(raw.slice(0, -1));
-      } else if (token.match(/[\.eE]/)) {
-        return parseFloat(raw);
-      } else if (token.startsWith("0")) {
-        switch (token.charAt(1).toLowerCase()) {
-          case "x":
-            return parseInt(raw.replace(/0[xX]/, ""), 16);
-          case "b":
-            return parseInt(raw.replace(/0[bB]/, ""), 2);
-          case "o":
-            return parseInt(raw.replace(/0[oO]/, ""), 8);
+  });
+
+  // source/parser/unary.civet
+  function processUnaryExpression(pre, exp, post) {
+    if (!(pre.length || post))
+      return exp;
+    if (post?.token === "?") {
+      post = {
+        $loc: post.$loc,
+        token: " != null"
+      };
+      if (pre.length) {
+        const lastPre = pre.at(-1);
+        if (lastPre.token === "!") {
+          post.token = " == null";
+          pre = pre.slice(0, -1);
+        } else if (lastPre.length === 2 && lastPre[0].token === "!") {
+          post.token = " == null";
+          pre = pre.slice(0, -1);
         }
       }
-      return parseInt(raw, 10);
+      const existence = {
+        type: "Existence",
+        expression: exp,
+        children: [exp, post],
+        parent: void 0
+      };
+      exp = makeLeftHandSideExpression(existence);
+      if (pre.length) {
+        return {
+          type: "UnaryExpression",
+          children: [...pre, exp]
+        };
+      }
+      return exp;
     }
-    throw new Error("Unrecognized literal " + JSON.stringify(literal));
-  }
-  function startsWith(target, value) {
-    if (!target)
-      return;
-    if (Array.isArray(target)) {
-      let i = 0;
-      let l = target.length;
-      while (i < l) {
-        const t = target[i];
-        if (t && (t.length || t.token || t.children)) {
-          break;
+    if (exp.type === "Literal") {
+      if (pre.length === 1) {
+        const { token } = pre[0];
+        if (token === "-" || token === "+") {
+          const children = [pre[0], ...exp.children];
+          if (post)
+            exp.children.push(post);
+          return {
+            type: "Literal",
+            children,
+            raw: `${token}${exp.raw}`
+          };
         }
-        i++;
       }
-      if (i < l) {
-        return startsWith(target[i], value);
+    }
+    let ref;
+    while (ref = pre.length) {
+      const l = ref;
+      const last = pre[l - 1];
+      if (last.type === "Await") {
+        if (last.op) {
+          if (exp.type !== "ParenthesizedExpression") {
+            exp = ["(", exp, ")"];
+          }
+          exp = {
+            type: "CallExpression",
+            children: [...last.children, "Promise", last.op, exp]
+          };
+          pre = pre.slice(0, -1);
+        } else {
+          exp = {
+            type: "AwaitExpression",
+            children: [...last.children, exp]
+          };
+          pre = pre.slice(0, -1);
+        }
+      } else {
+        break;
       }
     }
-    if (target.children)
-      return startsWith(target.children, value);
-    if (target.token)
-      return value.test(target.token);
-    if (typeof target === "string")
-      return value.test(target);
-    return;
-  }
-  function hasAwait(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
-  }
-  function hasYield(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
-  }
-  function hasImportDeclaration(exp) {
-    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "ImportDeclaration").length > 0;
+    return {
+      type: "UnaryExpression",
+      children: [...pre, exp, post]
+    };
   }
-  function deepCopy(node) {
+  var init_unary = __esm({
+    "source/parser/unary.civet"() {
+      "use strict";
+      init_util();
+    }
+  });
+
+  // source/parser/util.civet
+  function addParentPointers(node, parent) {
     if (node == null)
-      return node;
+      return;
     if (typeof node !== "object")
-      return node;
+      return;
     if (Array.isArray(node)) {
-      return node.map(deepCopy);
+      for (const child of node) {
+        addParentPointers(child, parent);
+      }
+      return;
     }
-    return Object.fromEntries(
-      Object.entries(node).map(([key, value]) => {
+    node = node;
+    node.parent = parent;
+    if (node.children) {
+      for (const child of node.children) {
+        addParentPointers(child, node);
+      }
+    }
+  }
+  function clone(node) {
+    removeParentPointers(node);
+    return deepCopy(node);
+  }
+  function removeParentPointers(node) {
+    if (node == null)
+      return;
+    if (typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        removeParentPointers(child);
+      }
+      return;
+    }
+    node.parent = null;
+    if (node.children) {
+      for (const child of node.children) {
+        removeParentPointers(child);
+      }
+    }
+  }
+  function isEmptyBareBlock(node) {
+    if (node?.type !== "BlockStatement")
+      return false;
+    const { bare, expressions } = node;
+    return bare && (expressions.length === 0 || expressions.length === 1 && expressions[0][1]?.type === "EmptyStatement");
+  }
+  function isFunction(node) {
+    const { type } = node;
+    return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || !!node.async;
+  }
+  function isWhitespaceOrEmpty(node) {
+    if (!node)
+      return true;
+    if (node.type === "Ref")
+      return false;
+    if (node.token)
+      return node.token.match(/^\s*$/);
+    if (node.children)
+      node = node.children;
+    if (!node.length)
+      return true;
+    if (typeof node === "string")
+      return node.match(/^\s*$/);
+    if (Array.isArray(node))
+      return node.every(isWhitespaceOrEmpty);
+    return;
+  }
+  function isExit(node) {
+    return [
+      "ReturnStatement",
+      "ThrowStatement",
+      "BreakStatement",
+      "ContinueStatement"
+    ].includes(node?.type);
+  }
+  function isComma(node) {
+    if (node?.token === ",") {
+      return node;
+    } else if (Array.isArray(node) && node.at(-1)?.token === ",") {
+      return node.at(-1);
+    }
+    ;
+    return;
+  }
+  function insertTrimmingSpace(target, c) {
+    if (!target) {
+      return target;
+    }
+    if (Array.isArray(target)) {
+      if (target.length === 0) {
+        return c;
+      }
+      return target.map((e, i) => {
+        if (i === 0) {
+          return insertTrimmingSpace(e, c);
+        }
+        return e;
+      });
+    }
+    if (target.children) {
+      return {
+        ...target,
+        children: insertTrimmingSpace(target.children, c)
+      };
+    }
+    if (target.token) {
+      return {
+        ...target,
+        token: target.token.replace(/^ ?/, c)
+      };
+    }
+    return target;
+  }
+  function getTrimmingSpace(target) {
+    if (!target)
+      return;
+    if (Array.isArray(target))
+      return getTrimmingSpace(target[0]);
+    if (target.children)
+      return getTrimmingSpace(target.children[0]);
+    if (target.token)
+      return target.token.match(/^ ?/)[0];
+    return;
+  }
+  function literalValue(literal) {
+    let { raw } = literal;
+    switch (raw) {
+      case "null":
+        return null;
+      case "true":
+        return true;
+      case "false":
+        return false;
+    }
+    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+      return raw.slice(1, -1);
+    }
+    const numeric = literal.children.find(
+      (child) => child.type === "NumericLiteral"
+    );
+    if (numeric) {
+      raw = raw.replace(/_/g, "");
+      const { token } = numeric;
+      if (token.endsWith("n")) {
+        return BigInt(raw.slice(0, -1));
+      } else if (token.match(/[\.eE]/)) {
+        return parseFloat(raw);
+      } else if (token.startsWith("0")) {
+        switch (token.charAt(1).toLowerCase()) {
+          case "x":
+            return parseInt(raw.replace(/0[xX]/, ""), 16);
+          case "b":
+            return parseInt(raw.replace(/0[bB]/, ""), 2);
+          case "o":
+            return parseInt(raw.replace(/0[oO]/, ""), 8);
+        }
+      }
+      return parseInt(raw, 10);
+    }
+    throw new Error("Unrecognized literal " + JSON.stringify(literal));
+  }
+  function startsWith(target, value) {
+    if (!target)
+      return;
+    if (Array.isArray(target)) {
+      let i = 0;
+      let l = target.length;
+      while (i < l) {
+        const t = target[i];
+        if (t && (t.length || t.token || t.children)) {
+          break;
+        }
+        i++;
+      }
+      if (i < l) {
+        return startsWith(target[i], value);
+      }
+    }
+    if (target.children)
+      return startsWith(target.children, value);
+    if (target.token)
+      return value.test(target.token);
+    if (typeof target === "string")
+      return value.test(target);
+    return;
+  }
+  function hasAwait(exp) {
+    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
+  }
+  function hasYield(exp) {
+    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
+  }
+  function hasImportDeclaration(exp) {
+    return gatherRecursiveWithinFunction(exp, ({ type }) => type === "ImportDeclaration").length > 0;
+  }
+  function deepCopy(node) {
+    if (node == null)
+      return node;
+    if (typeof node !== "object")
+      return node;
+    if (Array.isArray(node)) {
+      return node.map(deepCopy);
+    }
+    return Object.fromEntries(
+      Object.entries(node).map(([key, value]) => {
         return [key, deepCopy(value)];
       })
     );
@@ -276,6 +659,92 @@ var Civet = (() => {
       parameters
     };
   }
+  function makeAmpersandFunctionExpression(prefix, rhs) {
+    let ref, body, typeSuffix;
+    if (!rhs) {
+      body = ref = makeRef("$");
+    } else {
+      ({ ref, typeSuffix } = rhs);
+      if (!ref) {
+        throw new Error("Could not find ref in ampersand shorthand block");
+      }
+      body = rhs;
+    }
+    if (prefix.length) {
+      body = {
+        type: "UnaryExpression",
+        children: [processUnaryExpression(prefix, body, void 0)]
+      };
+    }
+    const parameters = {
+      type: "Parameters",
+      children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
+      names: []
+    };
+    const expressions = [body];
+    const block = {
+      bare: true,
+      expressions,
+      children: [expressions]
+    };
+    const children = [parameters, " => ", block];
+    const async = hasAwait(body);
+    if (async) {
+      children.unshift("async ");
+    }
+    return {
+      type: "ArrowFunction",
+      signature: {
+        modifier: {
+          async
+        }
+      },
+      children,
+      ref,
+      body,
+      ampersandBlock: true,
+      block,
+      parameters
+    };
+  }
+  function makeAmpersandBlockRHSBody(typeSuffix, callExpRest, unaryPostfix, assign, binopRHS) {
+    const ref = makeRef("$");
+    let exp = {
+      type: "AmpersandRef",
+      children: [ref],
+      names: [],
+      ref
+    };
+    if (callExpRest) {
+      exp.children.push(...callExpRest[1]);
+    }
+    if (unaryPostfix) {
+      exp = processUnaryExpression([], exp, unaryPostfix);
+    }
+    if (assign) {
+      const [op1, more, rhs] = assign;
+      const lhs = [
+        [void 0, exp, ...op1],
+        ...more.map((x) => [x[0], x[1], ...x[2]])
+      ];
+      exp = {
+        type: "AssignmentExpression",
+        children: [lhs, rhs],
+        names: null,
+        lhs,
+        assigned: exp,
+        exp: rhs
+      };
+    }
+    if (binopRHS) {
+      exp = {
+        children: processBinaryOpExpression([exp, binopRHS[1]])
+      };
+    }
+    exp.ref = ref;
+    exp.typeSuffix = typeSuffix;
+    return exp;
+  }
   function makeLeftHandSideExpression(expression) {
     if (expression.parenthesized) {
       return expression;
@@ -453,7 +922,9 @@ var Civet = (() => {
     const children = expression ? ["return ", expression] : ["return"];
     return makeNode({
       type: "ReturnStatement",
-      children
+      children,
+      expression,
+      parent: expression?.parent
     });
   }
   var assert, typeNeedsNoParens;
@@ -461,6 +932,8 @@ var Civet = (() => {
     "source/parser/util.civet"() {
       "use strict";
       init_traversal();
+      init_op();
+      init_unary();
       assert = {
         equal(a, b, msg) {
           if (a !== b) {
@@ -694,503 +1167,200 @@ var Civet = (() => {
     const index = expressions.findIndex((exp) => {
       return exp === node || Array.isArray(exp) && exp[1] === node;
     });
-    if (index < 0) {
-      throw new Error("Couldn't find expression in block for hoistable declaration.");
-    }
-    const statement = [expressions[index][0], dec, ";"];
-    expressions[index][0] = "";
-    expressions.splice(index, 0, statement);
-    addParentPointers(dec, block);
-  }
-  function processBlocks(statements) {
-    insertSemicolon(statements);
-    gatherRecursive(statements, ($) => $.type === "BlockStatement").forEach(function({ expressions }) {
-      return processBlocks(expressions);
-    });
-  }
-  function insertSemicolon(statements) {
-    const l = statements.length;
-    for (let i1 = 0, len = statements.length; i1 < len; i1++) {
-      const i = i1;
-      const s = statements[i1];
-      if (i < l - 1) {
-        if (needsPrecedingSemicolon(statements[i + 1])) {
-          const delim = s[2];
-          if (!delim) {
-            s[2] = ";";
-          } else if (typeof delim === "string" && !delim.match(/;/)) {
-            s[2] = `;${delim}`;
-          }
-        }
-      }
-    }
-  }
-  function needsPrecedingSemicolon(exp) {
-    let following;
-    if (Array.isArray(exp)) {
-      [, following] = exp;
-    } else {
-      following = exp;
-    }
-    if (!following) {
-      return false;
-    }
-    if (Array.isArray(following)) {
-      return needsPrecedingSemicolon(following[0]);
-    }
-    switch (following.type) {
-      case "ParenthesizedExpression":
-      case "ArrayExpression":
-      case "ArrowFunction":
-      case "TemplateLiteral":
-      case "RegularExpressionLiteral":
-      case "RangeExpression": {
-        return true;
-      }
-      case "AssignmentExpression": {
-        return startsWith(following, /^(\[|\()/);
-      }
-      case "Literal": {
-        return following.raw?.startsWith("-") || following.raw?.startsWith("+");
-      }
-      case "PipelineExpression":
-      case "UnwrappedExpression": {
-        return needsPrecedingSemicolon(following.children[1]);
-      }
-      default: {
-        if (following.children) {
-          return needsPrecedingSemicolon(following.children[0]);
-        }
-        ;
-        return;
-      }
-    }
-  }
-  var init_block = __esm({
-    "source/parser/block.civet"() {
-      "use strict";
-      init_util();
-      init_traversal();
-    }
-  });
-
-  // source/parser/binding.civet
-  function adjustAtBindings(statements, asThis = false) {
-    gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
-      const { ref } = binding;
-      if (asThis) {
-        const atBinding = binding.binding;
-        atBinding.children.pop();
-        atBinding.type = void 0;
-        binding.children.unshift(ref.id, ": this.", ref.base);
-        binding.type = "Property";
-        binding.ref = void 0;
-        return;
-      }
-      if (ref.names[0] !== ref.base) {
-        return binding.children.unshift(ref.base, ": ");
-      }
-      ;
-      return;
-    });
-  }
-  function adjustBindingElements(elements) {
-    const names = elements.flatMap((p) => p.names || []), { length } = elements;
-    let blockPrefix, restIndex = -1, restCount = 0;
-    elements.forEach(({ type }, i) => {
-      if (type === "BindingRestElement") {
-        if (restIndex < 0)
-          restIndex = i;
-        return restCount++;
-      }
-      ;
-      return;
-    });
-    if (restCount === 0) {
-      return {
-        children: elements,
-        names,
-        blockPrefix,
-        length
-      };
-    } else if (restCount === 1) {
-      const rest = elements[restIndex];
-      const after = elements.slice(restIndex + 1);
-      const restIdentifier = rest.binding.ref || rest.binding;
-      names.push(...rest.names || []);
-      let l = after.length;
-      if (l) {
-        if (arrayElementHasTrailingComma(after[l - 1]))
-          l++;
-        blockPrefix = {
-          type: "PostRestBindingElements",
-          children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", l.toString(), ")"],
-          names: after.flatMap((p) => p.names)
-        };
-      }
-      return {
-        names,
-        children: [...elements.slice(0, restIndex), {
-          ...rest,
-          children: rest.children.slice(0, -1)
-          // remove trailing comma
-        }],
-        blockPrefix,
-        length
-      };
-    }
-    const err = {
-      type: "Error",
-      children: ["Multiple rest elements in array pattern"]
-    };
-    return {
-      names,
-      children: [...elements, err],
-      blockPrefix,
-      length
-    };
-  }
-  function gatherBindingCode(statements, opts) {
-    const thisAssignments = [];
-    const splices = [];
-    function insertRestSplices(s, p, thisAssignments2) {
-      gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
-        if (n.type === "AtBinding") {
-          const { ref } = n;
-          const { id } = ref;
-          thisAssignments2.push([`this.${id} = `, ref]);
-          return;
-        }
-        if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-          n.names.forEach((id) => ({
-            push: thisAssignments2.push({
-              type: "AssignmentExpression",
-              children: [`this.${id} = `, id],
-              js: true
-            })
-          }));
-          return;
-        }
-        const { blockPrefix } = n;
-        p.push(blockPrefix);
-        return insertRestSplices(blockPrefix, p, thisAssignments2);
-      });
-    }
-    insertRestSplices(statements, splices, thisAssignments);
-    return [splices, thisAssignments];
-  }
-  function arrayElementHasTrailingComma(elementNode) {
-    const lastChild = elementNode.children.at(-1);
-    return lastChild && lastChild[lastChild.length - 1]?.token === ",";
-  }
-  var init_binding = __esm({
-    "source/parser/binding.civet"() {
-      "use strict";
-      init_traversal();
-      init_util();
-    }
-  });
-
-  // source/parser/op.civet
-  function getPrecedence(op) {
-    if (typeof op === "string") {
-      return precedenceMap.get(op) ?? (() => {
-        throw new Error(`Unknown operator: ${op}`);
-      })();
-    } else if (typeof op.prec === "number") {
-      return op.prec;
-    } else {
-      return precedenceMap.get(op.prec ?? op.token) ?? (op.relational ? precedenceRelational : precedenceCustomDefault);
-    }
-  }
-  function processBinaryOpExpression($0) {
-    return recurse(expandChainedComparisons($0));
-    function recurse(expandedOps) {
-      let i = 2;
-      while (i < expandedOps.length) {
-        let op = expandedOps[i];
-        if (op.special) {
-          let advanceLeft2 = function(allowEqual) {
-            while (start >= 4) {
-              const prevPrec = getPrecedence(expandedOps[start - 2]);
-              if (!(prevPrec > prec || allowEqual && prevPrec === prec)) {
-                return prevPrec === prec;
-              }
-              start -= 4;
-            }
-            return false;
-          }, advanceRight2 = function(allowEqual) {
-            while (end + 4 < expandedOps.length) {
-              const nextPrec = getPrecedence(expandedOps[end + 2]);
-              if (!(nextPrec > prec || allowEqual && nextPrec === prec)) {
-                return nextPrec === prec;
-              }
-              end += 4;
-            }
-            return false;
-          };
-          var advanceLeft = advanceLeft2, advanceRight = advanceRight2;
-          let start = i - 2, end = i + 2;
-          const prec = getPrecedence(op);
-          let error;
-          switch (op.assoc) {
-            case "left":
-            case void 0: {
-              advanceLeft2(true);
-              advanceRight2(false);
-              break;
-            }
-            case "right": {
-              advanceLeft2(false);
-              advanceRight2(true);
-              break;
-            }
-            case "non": {
-              if (advanceLeft2(false) || advanceRight2(false)) {
-                error = {
-                  type: "Error",
-                  message: `non-associative operator ${op.token} used at same precedence level without parenthesization`
-                };
-              }
-              ;
-              break;
-            }
-            case "arguments": {
-              if (advanceLeft2(false)) {
-                error = {
-                  type: "Error",
-                  message: `arguments operator ${op.token} used at same precedence level as ${expandedOps[start - 2].token} to the left`
-                };
-              }
-              advanceRight2(true);
-              break;
-            }
-            default: {
-              throw new Error(`Unsupported associativity: ${op.assoc}`);
-            }
-          }
-          let a = start === i - 2 ? expandedOps[start] : expandedOps.slice(start, i - 1);
-          let wsOp = expandedOps[i - 1];
-          let wsB = expandedOps[i + 1];
-          let b = end === i + 2 ? expandedOps[i + 2] : expandedOps.slice(i + 2, end + 1);
-          if (op.assoc === "arguments") {
-            let i2 = 2;
-            while (i2 < b.length) {
-              if (prec === getPrecedence(b[i2])) {
-                if (!(b[i2].token === op.token)) {
-                  error ??= {
-                    type: "Error",
-                    message: `arguments operator ${op.token} used at same precedence level as ${b[i2].token} to the right`
-                  };
-                }
-                b[i2] = ",";
-              }
-              i2 += 4;
-            }
-          } else {
-            b = recurse(b);
-          }
-          if (op.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
-            a = ["typeof ", makeLeftHandSideExpression(a)];
-            if (op.negated) {
-              op = { ...op, token: "!==", negated: false };
-            } else {
-              op = { ...op, token: "===" };
-            }
-          }
-          if (op.asConst) {
-            a = makeAsConst(a);
-            b = makeAsConst(b);
-          }
-          let children;
-          if (op.call) {
-            wsOp = insertTrimmingSpace(wsOp, "");
-            if (op.reversed) {
-              wsB = insertTrimmingSpace(wsB, "");
-              children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix];
-            } else {
-              children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix];
-            }
-          } else if (op.method) {
-            wsOp = insertTrimmingSpace(wsOp, "");
-            wsB = insertTrimmingSpace(wsB, "");
-            if (op.reversed) {
-              if (end !== i + 2)
-                b = makeLeftHandSideExpression(b);
-              b = dotNumericLiteral(b);
-              children = [wsB, b, wsOp, ".", op.method, "(", a, ")"];
-            } else {
-              if (start !== i - 2 || a.type === "NumericLiteral") {
-                a = makeLeftHandSideExpression(a);
-              }
-              a = dotNumericLiteral(a);
-              children = [a, wsOp, ".", op.method, "(", wsB, b, ")"];
-            }
-          } else if (op.token) {
-            children = [a, wsOp, op, wsB, b];
-            if (op.negated)
-              children = ["(", ...children, ")"];
-          } else {
-            throw new Error("Unknown operator: " + JSON.stringify(op));
-          }
-          if (op.negated)
-            children.unshift("!");
-          if (error != null) {
-            children.push(error);
+    if (index < 0) {
+      throw new Error("Couldn't find expression in block for hoistable declaration.");
+    }
+    const statement = [expressions[index][0], dec, ";"];
+    expressions[index][0] = "";
+    expressions.splice(index, 0, statement);
+    addParentPointers(dec, block);
+  }
+  function processBlocks(statements) {
+    insertSemicolon(statements);
+    gatherRecursive(statements, ($) => $.type === "BlockStatement").forEach(function({ expressions }) {
+      return processBlocks(expressions);
+    });
+  }
+  function insertSemicolon(statements) {
+    const l = statements.length;
+    for (let i1 = 0, len = statements.length; i1 < len; i1++) {
+      const i = i1;
+      const s = statements[i1];
+      if (i < l - 1) {
+        if (needsPrecedingSemicolon(statements[i + 1])) {
+          const delim = s[2];
+          if (!delim) {
+            s[2] = ";";
+          } else if (typeof delim === "string" && !delim.match(/;/)) {
+            s[2] = `;${delim}`;
           }
-          expandedOps.splice(start, end - start + 1, {
-            children
-          });
-          i = start + 2;
-        } else {
-          i += 4;
         }
       }
-      return expandedOps;
-    }
-    ;
-    return recurse;
-  }
-  function dotNumericLiteral(literal) {
-    if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
-      literal.children.push(".");
-      literal.raw += ".";
     }
-    return literal;
   }
-  function makeAsConst(node) {
-    if (Array.isArray(node) && node.length === 1) {
-      node = node[0];
-    }
-    if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
-      return { ...node, children: [...node.children, asConst] };
+  function needsPrecedingSemicolon(exp) {
+    let following;
+    if (Array.isArray(exp)) {
+      [, following] = exp;
     } else {
-      return node;
+      following = exp;
     }
-  }
-  function isExistence(exp) {
-    if (exp.type === "ParenthesizedExpression" && exp.implicit) {
-      exp = exp.expression;
+    if (!following) {
+      return false;
     }
-    if (exp.type === "Existence") {
-      return exp;
+    if (Array.isArray(following)) {
+      return needsPrecedingSemicolon(following[0]);
     }
-    ;
-    return;
-  }
-  function isRelationalOp(op) {
-    return op.relational || getPrecedence(op) === precedenceRelational;
-  }
-  function expandChainedComparisons([first, binops]) {
-    const results = [];
-    let i = 0;
-    const l = binops.length;
-    let start = 0;
-    let chains = [];
-    let op;
-    while (i < l) {
-      [, op] = binops[i];
-      if (isRelationalOp(op)) {
-        chains.push(i);
-      } else if (getPrecedence(op) < precedenceRelational) {
-        processChains(op);
-        first = void 0;
+    switch (following.type) {
+      case "ParenthesizedExpression":
+      case "ArrayExpression":
+      case "ArrowFunction":
+      case "TemplateLiteral":
+      case "RegularExpressionLiteral":
+      case "RangeExpression": {
+        return true;
       }
-      i++;
-    }
-    if (op != null) {
-      processChains(op);
-    }
-    return results;
-    function processChains(op2) {
-      if (first && isRelationalOp(op2)) {
-        first = expandExistence(first);
+      case "AssignmentExpression": {
+        return startsWith(following, /^(\[|\()/);
       }
-      if (chains.length > 1) {
-        chains.forEach((index, k) => {
-          if (k > 0) {
-            results.push(" ", "&&", " ");
-          }
-          const binop = binops[index];
-          let [, , , exp] = binop;
-          exp = binop[3] = expandExistence(exp);
-          let endIndex;
-          if (k < chains.length - 1) {
-            endIndex = chains[k + 1];
-          } else {
-            endIndex = i + 1;
-          }
-          results.push(first, ...binops.slice(start, endIndex).flat());
-          first = [exp].concat(binops.slice(index + 1, endIndex));
-          return start = endIndex;
-        });
-      } else {
-        if (first) {
-          results.push(first);
-        }
-        results.push(...binops.slice(start, i + 1).flat());
-        start = i + 1;
+      case "Literal": {
+        return following.raw?.startsWith("-") || following.raw?.startsWith("+");
       }
-      chains.length = 0;
-    }
-    function expandExistence(exp) {
-      const existence = isExistence(exp);
-      if (existence) {
-        results.push(existence, " ", "&&", " ");
-        return existence.expression;
+      case "PipelineExpression":
+      case "UnwrappedExpression": {
+        return needsPrecedingSemicolon(following.children[1]);
+      }
+      default: {
+        if (following.children) {
+          return needsPrecedingSemicolon(following.children[0]);
+        }
+        ;
+        return;
       }
-      return exp;
     }
-    ;
   }
-  var precedenceOrder, precedenceMap, precedenceStep, precedenceRelational, precedenceCustomDefault, asConst;
-  var init_op = __esm({
-    "source/parser/op.civet"() {
+  var init_block = __esm({
+    "source/parser/block.civet"() {
       "use strict";
       init_util();
-      precedenceOrder = [
-        ["||", "??"],
-        ["^^"],
-        ["&&"],
-        ["|"],
-        ["^"],
-        ["&"],
-        // NOTE: Equality and inequality merged because of relational chaining
-        [
-          "==",
-          "!=",
-          "===",
-          "!==",
-          "<",
-          "<=",
-          ">",
-          ">=",
-          "in",
-          "instanceof"
-        ],
-        // NOTE: Extra in-between level for default custom operators
-        ["custom"],
-        ["<<", ">>", ">>>"],
-        ["+", "-"],
-        ["*", "/", "%"],
-        ["**"]
-      ];
-      precedenceMap = /* @__PURE__ */ new Map();
-      for (let i1 = 0, len = precedenceOrder.length; i1 < len; i1++) {
-        const prec = i1;
-        const ops = precedenceOrder[i1];
-        for (let i2 = 0, len1 = ops.length; i2 < len1; i2++) {
-          const op = ops[i2];
-          precedenceMap.set(op, prec);
+      init_traversal();
+    }
+  });
+
+  // source/parser/binding.civet
+  function adjustAtBindings(statements, asThis = false) {
+    gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
+      const { ref } = binding;
+      if (asThis) {
+        const atBinding = binding.binding;
+        atBinding.children.pop();
+        atBinding.type = void 0;
+        binding.children.unshift(ref.id, ": this.", ref.base);
+        binding.type = "Property";
+        binding.ref = void 0;
+        return;
+      }
+      if (ref.names[0] !== ref.base) {
+        return binding.children.unshift(ref.base, ": ");
+      }
+      ;
+      return;
+    });
+  }
+  function adjustBindingElements(elements) {
+    const names = elements.flatMap((p) => p.names || []), { length } = elements;
+    let blockPrefix, restIndex = -1, restCount = 0;
+    elements.forEach(({ type }, i) => {
+      if (type === "BindingRestElement") {
+        if (restIndex < 0)
+          restIndex = i;
+        return restCount++;
+      }
+      ;
+      return;
+    });
+    if (restCount === 0) {
+      return {
+        children: elements,
+        names,
+        blockPrefix,
+        length
+      };
+    } else if (restCount === 1) {
+      const rest = elements[restIndex];
+      const after = elements.slice(restIndex + 1);
+      const restIdentifier = rest.binding.ref || rest.binding;
+      names.push(...rest.names || []);
+      let l = after.length;
+      if (l) {
+        if (arrayElementHasTrailingComma(after[l - 1]))
+          l++;
+        blockPrefix = {
+          type: "PostRestBindingElements",
+          children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", l.toString(), ")"],
+          names: after.flatMap((p) => p.names)
+        };
+      }
+      return {
+        names,
+        children: [...elements.slice(0, restIndex), {
+          ...rest,
+          children: rest.children.slice(0, -1)
+          // remove trailing comma
+        }],
+        blockPrefix,
+        length
+      };
+    }
+    const err = {
+      type: "Error",
+      children: ["Multiple rest elements in array pattern"]
+    };
+    return {
+      names,
+      children: [...elements, err],
+      blockPrefix,
+      length
+    };
+  }
+  function gatherBindingCode(statements, opts) {
+    const thisAssignments = [];
+    const splices = [];
+    function insertRestSplices(s, p, thisAssignments2) {
+      gatherRecursiveAll(s, (n) => n.blockPrefix || opts?.injectParamProps && n.accessModifier || n.type === "AtBinding").forEach((n) => {
+        if (n.type === "AtBinding") {
+          const { ref } = n;
+          const { id } = ref;
+          thisAssignments2.push([`this.${id} = `, ref]);
+          return;
+        }
+        if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
+          n.names.forEach((id) => ({
+            push: thisAssignments2.push({
+              type: "AssignmentExpression",
+              children: [`this.${id} = `, id],
+              js: true
+            })
+          }));
+          return;
         }
-      }
-      precedenceStep = 1 / 64;
-      precedenceRelational = precedenceMap.get("==");
-      precedenceCustomDefault = precedenceMap.get("custom");
-      asConst = {
-        ts: true,
-        children: [" as const"]
-      };
+        const { blockPrefix } = n;
+        p.push(blockPrefix);
+        return insertRestSplices(blockPrefix, p, thisAssignments2);
+      });
+    }
+    insertRestSplices(statements, splices, thisAssignments);
+    return [splices, thisAssignments];
+  }
+  function arrayElementHasTrailingComma(elementNode) {
+    const lastChild = elementNode.children.at(-1);
+    return lastChild && lastChild[lastChild.length - 1]?.token === ",";
+  }
+  var init_binding = __esm({
+    "source/parser/binding.civet"() {
+      "use strict";
+      init_traversal();
+      init_util();
     }
   });
 
@@ -1900,7 +2070,7 @@ var Civet = (() => {
         return;
       case "IfStatement":
         insertReturn(exp.then);
-        if (exp.else)
+        if (exp.else && exp.else.length !== 0)
           insertReturn(exp.else[2]);
         else
           exp.children.push(["", {
@@ -2193,7 +2363,8 @@ var Civet = (() => {
     }
     const { decl, bindings } = condition.declaration;
     const binding = bindings[0];
-    const { pattern, suffix, initializer, splices, thisAssignments } = binding;
+    let { pattern, suffix, initializer, splices, thisAssignments } = binding;
+    const nullCheck = suffix?.optional && !suffix.t && !suffix.nonnull;
     let ref = prependStatementExpressionBlock(initializer, parent);
     if (ref) {
       Object.assign(condition, {
@@ -2207,11 +2378,16 @@ var Civet = (() => {
       ref = makeRef();
       const grandparent = condition.parent?.parent;
       const children = (
-        // Check that the declaration is a plain assignment (no pattern-matching) and the immediate grandchild of an `if` or `while`
+        // Wrap declaration that is a plain assignment (no pattern-matching) and the immediate grandchild of an `if` or `while`
+        // to satisfy eslint's no-cond-assign rule
         // More complex conditions (triggered by pattern matching or `until`/`unless`) don't need double parens
-        // @ts-ignore Just because pattern might not have a type at runtime doesn't mean it's unsafe
-        pattern.type === "Identifier" && (grandparent?.type === "IfStatement" || grandparent?.type === "WhileStatement") ? ["(", ref, initializer, ")"] : [ref, initializer]
+        pattern.type === "Identifier" && (grandparent?.type === "IfStatement" || grandparent?.type === "IterationStatement") && !nullCheck ? ["(", ref, initializer, ")"] : [ref, initializer]
       );
+      if (nullCheck) {
+        children.unshift("(");
+        children.push(") != null");
+        suffix = void 0;
+      }
       Object.assign(condition, {
         type: "AssignmentExpression",
         children,
@@ -2450,91 +2626,6 @@ var Civet = (() => {
     }
   });
 
-  // source/parser/unary.civet
-  function processUnaryExpression(pre, exp, post) {
-    if (!(pre.length || post))
-      return exp;
-    if (post?.token === "?") {
-      post = {
-        $loc: post.$loc,
-        token: " != null"
-      };
-      if (pre.length) {
-        const lastPre = pre[pre.length - 1];
-        if (lastPre.token === "!") {
-          post.token = " == null";
-          pre = pre.slice(0, -1);
-        } else if (lastPre.length === 2 && lastPre[0].token === "!") {
-          post.token = " == null";
-          pre = pre.slice(0, -1);
-        }
-      }
-      const existence = {
-        type: "Existence",
-        expression: exp,
-        children: [exp, post]
-      };
-      exp = makeLeftHandSideExpression(existence);
-      if (pre.length) {
-        return {
-          type: "UnaryExpression",
-          children: [...pre, exp]
-        };
-      }
-      return exp;
-    }
-    if (exp.type === "Literal") {
-      if (pre.length === 1) {
-        const { token } = pre[0];
-        if (token === "-" || token === "+") {
-          const children = [pre[0], ...exp.children];
-          if (post)
-            exp.children.push(post);
-          return {
-            type: "Literal",
-            children,
-            raw: `${token}${exp.raw}`
-          };
-        }
-      }
-    }
-    let ref;
-    while (ref = pre.length) {
-      const l = ref;
-      const last = pre[l - 1];
-      if (last.type === "Await") {
-        if (last.op) {
-          if (exp.type !== "ParenthesizedExpression") {
-            exp = ["(", exp, ")"];
-          }
-          exp = {
-            type: "CallExpression",
-            children: [...last.children, "Promise", last.op, exp]
-          };
-          pre = pre.slice(0, -1);
-        } else {
-          exp = {
-            type: "AwaitExpression",
-            children: [...last.children, exp]
-          };
-          pre = pre.slice(0, -1);
-        }
-      } else {
-        break;
-      }
-    }
-    return {
-      type: "UnaryExpression",
-      children: [...pre, exp, post]
-    };
-  }
-  var init_unary = __esm({
-    "source/parser/unary.civet"() {
-      "use strict";
-      init_util();
-    }
-  });
-
   // source/parser/pipe.civet
   function constructInvocation(fn, arg) {
     const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
@@ -2751,10 +2842,13 @@ var Civet = (() => {
   function forRange(open, forDeclaration, range, stepExp, close) {
     const { start, end, inclusive } = range;
     const counterRef = makeRef("i");
+    const infinite = end.type === "Identifier" && end.name === "Infinity";
     let stepRef;
     if (stepExp) {
       stepExp = insertTrimmingSpace(stepExp, "");
       stepRef = maybeRef(stepExp, "step");
+    } else if (infinite) {
+      stepExp = stepRef = "1";
     }
     let startRef = maybeRef(start, "start");
     let endRef = maybeRef(end, "end");
@@ -2784,7 +2878,7 @@ var Civet = (() => {
       } else {
         const value = "StringLiteral" === start.subtype ? ["String.fromCharCode(", counterRef, ")"] : counterRef;
         blockPrefix = [
-          ["", forDeclaration, " = ", value, ";"]
+          ["", [forDeclaration, " = ", value], ";"]
         ];
       }
     } else if (forDeclaration) {
@@ -2796,8 +2890,8 @@ var Civet = (() => {
       names: forDeclaration?.names
     };
     const counterPart = inclusive ? [counterRef, " <= ", endRef, " : ", counterRef, " >= ", endRef] : [counterRef, " < ", endRef, " : ", counterRef, " > ", endRef];
-    const condition = stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ascRef ? [ascRef, " ? ", ...counterPart] : asc ? counterPart.slice(0, 3) : counterPart.slice(4);
-    const increment = stepRef ? [...varAssign, counterRef, " += ", stepRef] : ascRef ? [...varAssign, ascRef, " ? ++", counterRef, " : --", counterRef] : [...varAssign, asc ? "++" : "--", counterRef];
+    const condition = infinite ? [] : stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ascRef ? [ascRef, " ? ", ...counterPart] : asc ? counterPart.slice(0, 3) : counterPart.slice(4);
+    const increment = infinite ? [...varAssign, "++", counterRef] : stepRef ? [...varAssign, counterRef, " += ", stepRef] : ascRef ? [...varAssign, ascRef, " ? ++", counterRef, " : --", counterRef] : [...varAssign, asc ? "++" : "--", counterRef];
     return {
       declaration,
       children: [open, declaration, "; ", ...condition, "; ", ...increment, close],
@@ -3288,7 +3382,9 @@ var Civet = (() => {
     isWhitespaceOrEmpty: () => isWhitespaceOrEmpty,
     lastAccessInCallExpression: () => lastAccessInCallExpression,
     literalValue: () => literalValue,
+    makeAmpersandBlockRHSBody: () => makeAmpersandBlockRHSBody,
     makeAmpersandFunction: () => makeAmpersandFunction,
+    makeAmpersandFunctionExpression: () => makeAmpersandFunctionExpression,
     makeEmptyBlock: () => makeEmptyBlock,
     makeExpressionStatement: () => makeExpressionStatement,
     makeGetterMethod: () => makeGetterMethod,
@@ -4251,6 +4347,7 @@ var Civet = (() => {
     assert.equal(m.JSXTagStack.length, 1, "JSXTagStack");
     addParentPointers(root);
     const { expressions: statements } = root;
+    processPartialPlaceholders(statements);
     processNegativeIndexAccess(statements);
     processTypes(statements);
     processDeclarationConditions(statements, m.getRef);
@@ -4295,6 +4392,43 @@ var Civet = (() => {
       });
     }
   }
+  function processPartialPlaceholders(statements) {
+    const partialMap = /* @__PURE__ */ new Map();
+    gatherRecursiveAll(statements, ($3) => $3.type === "PartialPlaceholder").forEach((_exp) => {
+      const exp = _exp;
+      let { ancestor } = findAncestor(exp, ($4) => $4?.type === "Call");
+      ancestor = ancestor?.parent;
+      while (ancestor?.parent?.type === "UnaryExpression") {
+        ancestor = ancestor.parent;
+      }
+      if (ancestor) {
+        if (partialMap.has(ancestor)) {
+          return partialMap.get(ancestor).push(exp);
+        } else {
+          return partialMap.set(ancestor, [exp]);
+        }
+      } else {
+        return replaceNode(exp, {
+          type: "Error",
+          message: "Partial placeholder outside of call expression",
+          parent: exp.parent
+        });
+      }
+    });
+    for (const [ancestor, placeholders] of partialMap) {
+      let ref = makeRef("$");
+      placeholders.forEach((exp) => {
+        return replaceNode(exp.children.at(-1), ref);
+      });
+      const rhs = {
+        ref,
+        children: [ancestor]
+      };
+      const fnExp = makeAmpersandFunctionExpression([], rhs);
+      replaceNode(ancestor, fnExp);
+    }
+    return;
+  }
   function reorderBindingRestProperty(props) {
     const names = props.flatMap((p) => p.names);
     let restIndex = -1;
@@ -5005,11 +5139,11 @@ ${input.slice(result.pos)}
         WRHS,
         SingleLineBinaryOpRHS,
         RHS,
-        ParenthesizedAssignment,
         UnaryExpression,
         UnaryWithoutParenthesizedAssignment,
         UnaryBody,
         UnaryWithoutParenthesizedAssignmentBody,
+        ParenthesizedAssignment,
         UnaryPostfix,
         TypePostfix,
         Tuple,
@@ -5037,6 +5171,7 @@ ${input.slice(result.pos)}
         PipelineTailItem,
         PrimaryExpression,
         ParenthesizedExpression,
+        PartialPlaceholder,
         ClassDeclaration,
         ClassExpression,
         ClassBinding,
@@ -5081,6 +5216,7 @@ ${input.slice(result.pos)}
         MemberBracketContent,
         SliceParameters,
         AccessStart,
+        ImplicitAccessStart,
         PropertyAccessModifier,
         PropertyAccess,
         PropertyGlob,
@@ -5215,6 +5351,7 @@ ${input.slice(result.pos)}
         BinaryOp,
         _BinaryOp,
         BinaryOpSymbol,
+        ActualIn,
         CoffeeOfOp,
         NotOp,
         Xor,
@@ -5495,6 +5632,7 @@ ${input.slice(result.pos)}
         TripleTick,
         Try,
         Typeof,
+        Undefined,
         Unless,
         Until,
         Using,
@@ -5895,123 +6033,126 @@ ${input.slice(result.pos)}
       var $L199 = $L("```");
       var $L200 = $L("try");
       var $L201 = $L("typeof");
-      var $L202 = $L("unless");
-      var $L203 = $L("until");
-      var $L204 = $L("using");
-      var $L205 = $L("var");
-      var $L206 = $L("void");
-      var $L207 = $L("when");
-      var $L208 = $L("while");
-      var $L209 = $L("yield");
-      var $L210 = $L("/>");
-      var $L211 = $L("</");
-      var $L212 = $L("<>");
-      var $L213 = $L("</>");
-      var $L214 = $L("<!--");
-      var $L215 = $L("-->");
-      var $L216 = $L("type");
-      var $L217 = $L("enum");
-      var $L218 = $L("interface");
-      var $L219 = $L("global");
-      var $L220 = $L("module");
-      var $L221 = $L("namespace");
-      var $L222 = $L("asserts");
-      var $L223 = $L("keyof");
-      var $L224 = $L("???");
-      var $L225 = $L("[]");
-      var $L226 = $L("civet");
+      var $L202 = $L("undefined");
+      var $L203 = $L("unless");
+      var $L204 = $L("until");
+      var $L205 = $L("using");
+      var $L206 = $L("var");
+      var $L207 = $L("void");
+      var $L208 = $L("when");
+      var $L209 = $L("while");
+      var $L210 = $L("yield");
+      var $L211 = $L("/>");
+      var $L212 = $L("</");
+      var $L213 = $L("<>");
+      var $L214 = $L("</>");
+      var $L215 = $L("<!--");
+      var $L216 = $L("-->");
+      var $L217 = $L("type");
+      var $L218 = $L("enum");
+      var $L219 = $L("interface");
+      var $L220 = $L("global");
+      var $L221 = $L("module");
+      var $L222 = $L("namespace");
+      var $L223 = $L("asserts");
+      var $L224 = $L("keyof");
+      var $L225 = $L("???");
+      var $L226 = $L("[]");
+      var $L227 = $L("civet");
       var $R0 = $R(new RegExp("(?=async|debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
       var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
       var $R2 = $R(new RegExp("[0-9]", "suy"));
       var $R3 = $R(new RegExp("(?!\\p{ID_Start}|[_$0-9(\\[{])", "suy"));
       var $R4 = $R(new RegExp("[ \\t]", "suy"));
-      var $R5 = $R(new RegExp("(?=['\"`])", "suy"));
-      var $R6 = $R(new RegExp("(?=[\\/?])", "suy"));
-      var $R7 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
-      var $R8 = $R(new RegExp("[)}]", "suy"));
-      var $R9 = $R(new RegExp("\\+\\+|--|[\\+-]\\S", "suy"));
-      var $R10 = $R(new RegExp("[&]", "suy"));
-      var $R11 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
-      var $R12 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
-      var $R13 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
-      var $R14 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
-      var $R15 = $R(new RegExp("(?=\\[)", "suy"));
-      var $R16 = $R(new RegExp("[!+-]?", "suy"));
-      var $R17 = $R(new RegExp("[+-]", "suy"));
-      var $R18 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])", "suy"));
-      var $R19 = $R(new RegExp("!\\^\\^?", "suy"));
-      var $R20 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s)", "suy"));
-      var $R21 = $R(new RegExp("[:.]", "suy"));
-      var $R22 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
-      var $R23 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
-      var $R24 = $R(new RegExp("(?=[\\s\\),])", "suy"));
-      var $R25 = $R(new RegExp('[^;"\\s]+', "suy"));
-      var $R26 = $R(new RegExp("(?=[0-9.])", "suy"));
-      var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
-      var $R28 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
-      var $R29 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
-      var $R30 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
-      var $R31 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
-      var $R32 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
-      var $R33 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
-      var $R34 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
-      var $R35 = $R(new RegExp("(?=[0-9])", "suy"));
-      var $R36 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
-      var $R37 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
-      var $R38 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
-      var $R39 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
-      var $R40 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
-      var $R41 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
-      var $R42 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
-      var $R43 = $R(new RegExp("(?:\\\\.)", "suy"));
-      var $R44 = $R(new RegExp("[\\s]+", "suy"));
-      var $R45 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
-      var $R46 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
-      var $R47 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
-      var $R48 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
-      var $R49 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
-      var $R50 = $R(new RegExp("(?=[`'\"])", "suy"));
-      var $R51 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
-      var $R52 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
-      var $R53 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
-      var $R54 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
-      var $R55 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
-      var $R56 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
-      var $R57 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
-      var $R58 = $R(new RegExp("(?=\\/|#)", "suy"));
-      var $R59 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
-      var $R60 = $R(new RegExp(".", "suy"));
-      var $R61 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
-      var $R62 = $R(new RegExp("[^]*?###", "suy"));
-      var $R63 = $R(new RegExp("###(?!#)", "suy"));
-      var $R64 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
-      var $R65 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
-      var $R66 = $R(new RegExp("[ \\t]+", "suy"));
-      var $R67 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
-      var $R68 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
-      var $R69 = $R(new RegExp("['\u2019]s", "suy"));
-      var $R70 = $R(new RegExp("\\s", "suy"));
-      var $R71 = $R(new RegExp("(?=[<])", "suy"));
-      var $R72 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
-      var $R73 = $R(new RegExp("[!+-]", "suy"));
-      var $R74 = $R(new RegExp("[\\s>]|\\/>", "suy"));
-      var $R75 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
-      var $R76 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
-      var $R77 = $R(new RegExp("[<>]", "suy"));
-      var $R78 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
-      var $R79 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
-      var $R80 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
-      var $R81 = $R(new RegExp("[+-]?", "suy"));
-      var $R82 = $R(new RegExp("(?=if|unless)", "suy"));
-      var $R83 = $R(new RegExp("#![^\\r\\n]*", "suy"));
-      var $R84 = $R(new RegExp("[\\t ]*", "suy"));
-      var $R85 = $R(new RegExp("[ \\t]*", "suy"));
-      var $R86 = $R(new RegExp("[\\s]*", "suy"));
-      var $R87 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
-      var $R88 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
-      var $R89 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
-      var $R90 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
-      var $R91 = $R(new RegExp("[^]*", "suy"));
+      var $R5 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$.])", "suy"));
+      var $R6 = $R(new RegExp("(?=['\"`])", "suy"));
+      var $R7 = $R(new RegExp("(?=[\\/?])", "suy"));
+      var $R8 = $R(new RegExp("(?=[\\/\\[{?.!@#'\u2019:])", "suy"));
+      var $R9 = $R(new RegExp("[)}]", "suy"));
+      var $R10 = $R(new RegExp("[+-]", "suy"));
+      var $R11 = $R(new RegExp("\\+\\+|--|[\\+-]\\S", "suy"));
+      var $R12 = $R(new RegExp("[&]", "suy"));
+      var $R13 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
+      var $R14 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
+      var $R15 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
+      var $R16 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
+      var $R17 = $R(new RegExp("(?=\\[)", "suy"));
+      var $R18 = $R(new RegExp("[!+-]?", "suy"));
+      var $R19 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])", "suy"));
+      var $R20 = $R(new RegExp("!\\^\\^?", "suy"));
+      var $R21 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s)", "suy"));
+      var $R22 = $R(new RegExp("[:.]", "suy"));
+      var $R23 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
+      var $R24 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
+      var $R25 = $R(new RegExp("(?=[\\s\\),])", "suy"));
+      var $R26 = $R(new RegExp('[^;"\\s]+', "suy"));
+      var $R27 = $R(new RegExp("(?=[0-9.])", "suy"));
+      var $R28 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
+      var $R29 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
+      var $R30 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
+      var $R31 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
+      var $R32 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
+      var $R33 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
+      var $R34 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
+      var $R35 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
+      var $R36 = $R(new RegExp("(?=[0-9])", "suy"));
+      var $R37 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
+      var $R38 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
+      var $R39 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
+      var $R40 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
+      var $R41 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
+      var $R42 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
+      var $R43 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
+      var $R44 = $R(new RegExp("(?:\\\\.)", "suy"));
+      var $R45 = $R(new RegExp("[\\s]+", "suy"));
+      var $R46 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
+      var $R47 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
+      var $R48 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
+      var $R49 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
+      var $R50 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
+      var $R51 = $R(new RegExp("(?=[`'\"])", "suy"));
+      var $R52 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
+      var $R53 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
+      var $R54 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
+      var $R55 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
+      var $R56 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
+      var $R57 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
+      var $R58 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
+      var $R59 = $R(new RegExp("(?=\\/|#)", "suy"));
+      var $R60 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
+      var $R61 = $R(new RegExp(".", "suy"));
+      var $R62 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
+      var $R63 = $R(new RegExp("[^]*?###", "suy"));
+      var $R64 = $R(new RegExp("###(?!#)", "suy"));
+      var $R65 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
+      var $R66 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
+      var $R67 = $R(new RegExp("[ \\t]+", "suy"));
+      var $R68 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
+      var $R69 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
+      var $R70 = $R(new RegExp("[=:]", "suy"));
+      var $R71 = $R(new RegExp("['\u2019]s", "suy"));
+      var $R72 = $R(new RegExp("\\s", "suy"));
+      var $R73 = $R(new RegExp("(?=[<])", "suy"));
+      var $R74 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
+      var $R75 = $R(new RegExp("[!+-]", "suy"));
+      var $R76 = $R(new RegExp("[\\s>]|\\/>", "suy"));
+      var $R77 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
+      var $R78 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
+      var $R79 = $R(new RegExp("[<>]", "suy"));
+      var $R80 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
+      var $R81 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
+      var $R82 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
+      var $R83 = $R(new RegExp("[+-]?", "suy"));
+      var $R84 = $R(new RegExp("(?=if|unless)", "suy"));
+      var $R85 = $R(new RegExp("#![^\\r\\n]*", "suy"));
+      var $R86 = $R(new RegExp("[\\t ]*", "suy"));
+      var $R87 = $R(new RegExp("[ \\t]*", "suy"));
+      var $R88 = $R(new RegExp("[\\s]*", "suy"));
+      var $R89 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
+      var $R90 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
+      var $R91 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
+      var $R92 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+      var $R93 = $R(new RegExp("[^]*", "suy"));
       var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var statements = $4;
         processProgram({
@@ -6424,17 +6565,12 @@ ${input.slice(result.pos)}
       function SingleLineBinaryOpRHS(ctx, state) {
         return $EVENT(ctx, state, "SingleLineBinaryOpRHS", SingleLineBinaryOpRHS$0);
       }
-      var RHS$0 = ParenthesizedAssignment;
-      var RHS$1 = UnaryExpression;
-      var RHS$2 = ExpressionizedStatementWithTrailingCallExpressions;
-      var RHS$$ = [RHS$0, RHS$1, RHS$2];
+      var RHS$0 = UnaryExpression;
+      var RHS$1 = ExpressionizedStatementWithTrailingCallExpressions;
+      var RHS$$ = [RHS$0, RHS$1];
       function RHS(ctx, state) {
         return $EVENT_C(ctx, state, "RHS", RHS$$);
       }
-      var ParenthesizedAssignment$0 = $S(InsertOpenParen, ActualAssignment, InsertCloseParen);
-      function ParenthesizedAssignment(ctx, state) {
-        return $EVENT(ctx, state, "ParenthesizedAssignment", ParenthesizedAssignment$0);
-      }
       var UnaryExpression$0 = AmpersandFunctionExpression;
       var UnaryExpression$1 = $TS($S($Q(UnaryOp), UnaryBody, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
         var pre = $1;
@@ -6476,6 +6612,10 @@ ${input.slice(result.pos)}
       function UnaryWithoutParenthesizedAssignmentBody(ctx, state) {
         return $EVENT_C(ctx, state, "UnaryWithoutParenthesizedAssignmentBody", UnaryWithoutParenthesizedAssignmentBody$$);
       }
+      var ParenthesizedAssignment$0 = $S(InsertOpenParen, $C(ActualAssignment, ArrowFunction), InsertCloseParen);
+      function ParenthesizedAssignment(ctx, state) {
+        return $EVENT(ctx, state, "ParenthesizedAssignment", ParenthesizedAssignment$0);
+      }
       var UnaryPostfix$0 = QuestionMark;
       var UnaryPostfix$1 = $P(TypePostfix);
       var UnaryPostfix$$ = [UnaryPostfix$0, UnaryPostfix$1];
@@ -6788,8 +6928,9 @@ ${input.slice(result.pos)}
       var PrimaryExpression$7 = ClassExpression;
       var PrimaryExpression$8 = RegularExpressionLiteral;
       var PrimaryExpression$9 = ParenthesizedExpression;
-      var PrimaryExpression$10 = JSXImplicitFragment;
-      var PrimaryExpression$$ = [PrimaryExpression$0, PrimaryExpression$1, PrimaryExpression$2, PrimaryExpression$3, PrimaryExpression$4, PrimaryExpression$5, PrimaryExpression$6, PrimaryExpression$7, PrimaryExpression$8, PrimaryExpression$9, PrimaryExpression$10];
+      var PrimaryExpression$10 = PartialPlaceholder;
+      var PrimaryExpression$11 = JSXImplicitFragment;
+      var PrimaryExpression$$ = [PrimaryExpression$0, PrimaryExpression$1, PrimaryExpression$2, PrimaryExpression$3, PrimaryExpression$4, PrimaryExpression$5, PrimaryExpression$6, PrimaryExpression$7, PrimaryExpression$8, PrimaryExpression$9, PrimaryExpression$10, PrimaryExpression$11];
       function PrimaryExpression(ctx, state) {
         return $EVENT_C(ctx, state, "PrimaryExpression", PrimaryExpression$$);
       }
@@ -6823,6 +6964,16 @@ ${input.slice(result.pos)}
       function ParenthesizedExpression(ctx, state) {
         return $EVENT(ctx, state, "ParenthesizedExpression", ParenthesizedExpression$0);
       }
+      var PartialPlaceholder$0 = $TS($S(Dot, $N($EXPECT($R5, "PartialPlaceholder /(?:\\p{ID_Continue}|[\\u200C\\u200D$.])/"))), function($skip, $loc, $0, $1, $2) {
+        var dot = $1;
+        return {
+          type: "PartialPlaceholder",
+          children: [dot]
+        };
+      });
+      function PartialPlaceholder(ctx, state) {
+        return $EVENT(ctx, state, "PartialPlaceholder", PartialPlaceholder$0);
+      }
       var ClassDeclaration$0 = $TS($S(ClassExpression), function($skip, $loc, $0, $1) {
         if ($1.id)
           return $1;
@@ -7127,7 +7278,8 @@ ${input.slice(result.pos)}
         return $EVENT_C(ctx, state, "FieldDefinition", FieldDefinition$$);
       }
       var ThisLiteral$0 = This;
-      var ThisLiteral$1 = $TS($S(AtThis, $TEXT($S($E(Hash), IdentifierName))), function($skip, $loc, $0, $1, $2) {
+      var ThisLiteral$1 = HashThis;
+      var ThisLiteral$2 = $TS($S(AtThis, $TEXT($S($E(Hash), IdentifierName))), function($skip, $loc, $0, $1, $2) {
         var at = $1;
         var id = $2;
         return {
@@ -7140,20 +7292,20 @@ ${input.slice(result.pos)}
           thisShorthand: true
         };
       });
-      var ThisLiteral$2 = AtThis;
-      var ThisLiteral$3 = HashThis;
+      var ThisLiteral$3 = AtThis;
       var ThisLiteral$$ = [ThisLiteral$0, ThisLiteral$1, ThisLiteral$2, ThisLiteral$3];
       function ThisLiteral(ctx, state) {
         return $EVENT_C(ctx, state, "ThisLiteral", ThisLiteral$$);
       }
-      var HashThis$0 = $TS($S(LengthShorthand, $E($S($Y($S($P(_), $C($S(Not, __, In), In))), $EXPECT($L0, 'HashThis ""')))), function($skip, $loc, $0, $1, $2) {
-        var id = $1;
-        var beforeIn = $2;
-        if (beforeIn != null)
+      var HashThis$0 = $TS($S($E(AtThis), LengthShorthand, $E($S($Y($S(_, $E($S(Not, __)), ActualIn)), $EXPECT($L0, 'HashThis ""')))), function($skip, $loc, $0, $1, $2, $3) {
+        var at = $1;
+        var id = $2;
+        var beforeIn = $3;
+        if (beforeIn != null && at == null)
           return ['"', id.name, '"'];
         return {
           type: "MemberExpression",
-          children: ["this", {
+          children: [at ?? "this", {
             type: "PropertyAccess",
             name: id.name,
             children: [".", id]
@@ -7161,7 +7313,7 @@ ${input.slice(result.pos)}
           thisShorthand: true
         };
       });
-      var HashThis$1 = $TS($S(PrivateIdentifier, $Y($S($P(_), $C($S(Not, __, In), In)))), function($skip, $loc, $0, $1, $2) {
+      var HashThis$1 = $TS($S(PrivateIdentifier, $Y($S(_, $E($S(Not, __)), ActualIn))), function($skip, $loc, $0, $1, $2) {
         var id = $1;
         return id;
       });
@@ -7255,7 +7407,7 @@ ${input.slice(result.pos)}
       var CallExpressionRest$1 = $T($S(TypeArguments, $N($C(IdentifierName, NumericLiteral))), function(value) {
         return value[0];
       });
-      var CallExpressionRest$2 = $TS($S($EXPECT($R5, "CallExpressionRest /(?=['\"`])/"), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
+      var CallExpressionRest$2 = $TS($S($EXPECT($R6, "CallExpressionRest /(?=['\"`])/"), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
         var literal = $2;
         if (literal.type === "StringLiteral") {
           literal = "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
@@ -7278,7 +7430,7 @@ ${input.slice(result.pos)}
       function CallExpressionRest(ctx, state) {
         return $EVENT_C(ctx, state, "CallExpressionRest", CallExpressionRest$$);
       }
-      var OptionalShorthand$0 = $TS($S($EXPECT($R6, "OptionalShorthand /(?=[\\/?])/"), $Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var OptionalShorthand$0 = $TS($S($EXPECT($R7, "OptionalShorthand /(?=[\\/?])/"), $Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3, $4) {
         var comments = $2;
         var q = $3;
         var d = $4;
@@ -7332,7 +7484,7 @@ ${input.slice(result.pos)}
       function MemberBase(ctx, state) {
         return $EVENT_C(ctx, state, "MemberBase", MemberBase$$);
       }
-      var MemberExpressionRest$0 = $TS($S($EXPECT($R7, "MemberExpressionRest /(?=[\\/\\[{?.!@'\u2019:])/"), $Q(InlineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2, $3) {
+      var MemberExpressionRest$0 = $TS($S($EXPECT($R8, "MemberExpressionRest /(?=[\\/\\[{?.!@#'\u2019:])/"), $Q(InlineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2, $3) {
         var comments = $2;
         var body = $3;
         if (Array.isArray(body))
@@ -7465,16 +7617,27 @@ ${input.slice(result.pos)}
       var AccessStart$0 = $TS($S($E(PropertyAccessModifier), Dot, $N(Dot)), function($skip, $loc, $0, $1, $2, $3) {
         var modifier = $1;
         var dot = $2;
-        let children = modifier ? [modifier, dot] : [dot];
         return {
           type: "AccessStart",
-          children,
+          children: modifier ? [modifier, dot] : [dot],
           optional: modifier?.token === "?"
         };
       });
       function AccessStart(ctx, state) {
         return $EVENT(ctx, state, "AccessStart", AccessStart$0);
       }
+      var ImplicitAccessStart$0 = $TS($S($E(PropertyAccessModifier), InsertDot, $N(Dot)), function($skip, $loc, $0, $1, $2, $3) {
+        var modifier = $1;
+        var dot = $2;
+        return {
+          type: "AccessStart",
+          children: modifier ? [modifier, dot] : [dot],
+          optional: modifier?.token === "?"
+        };
+      });
+      function ImplicitAccessStart(ctx, state) {
+        return $EVENT(ctx, state, "ImplicitAccessStart", ImplicitAccessStart$0);
+      }
       var PropertyAccessModifier$0 = QuestionMark;
       var PropertyAccessModifier$1 = NonNullAssertion;
       var PropertyAccessModifier$$ = [PropertyAccessModifier$0, PropertyAccessModifier$1];
@@ -7516,15 +7679,24 @@ ${input.slice(result.pos)}
         var dot = $1;
         var comments = $2;
         var id = $3;
-        const children = [dot, ...comments, ...id.children];
         return {
           type: "PropertyAccess",
           name: id.name,
           dot,
-          children
+          children: [dot, ...comments, ...id.children]
+        };
+      });
+      var PropertyAccess$3 = $TS($S(ImplicitAccessStart, $C(PrivateIdentifier, LengthShorthand)), function($skip, $loc, $0, $1, $2) {
+        var dot = $1;
+        var id = $2;
+        return {
+          type: "PropertyAccess",
+          name: id.name,
+          dot,
+          children: [dot, ...id.children]
         };
       });
-      var PropertyAccess$3 = $TS($S(CoffeePrototypeEnabled, DoubleColon, $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyAccess$4 = $TS($S(CoffeePrototypeEnabled, DoubleColon, $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
         var p = $2;
         var id = $3;
         if (id) {
@@ -7545,7 +7717,7 @@ ${input.slice(result.pos)}
           };
         }
       });
-      var PropertyAccess$$ = [PropertyAccess$0, PropertyAccess$1, PropertyAccess$2, PropertyAccess$3];
+      var PropertyAccess$$ = [PropertyAccess$0, PropertyAccess$1, PropertyAccess$2, PropertyAccess$3, PropertyAccess$4];
       function PropertyAccess(ctx, state) {
         return $EVENT_C(ctx, state, "PropertyAccess", PropertyAccess$$);
       }
@@ -7796,7 +7968,7 @@ ${input.slice(result.pos)}
         return $EVENT(ctx, state, "ParameterElement", ParameterElement$0);
       }
       var ParameterElementDelimiter$0 = $S($E(_), Comma);
-      var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($R8, "ParameterElementDelimiter /[)}]/"))));
+      var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($R9, "ParameterElementDelimiter /[)}]/"))));
       var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
         return value[1];
       });
@@ -7865,7 +8037,23 @@ ${input.slice(result.pos)}
           expression
         };
       });
-      var PinPattern$$ = [PinPattern$0, PinPattern$1];
+      var PinPattern$2 = $TV($S($EXPECT($R10, "PinPattern /[+-]/"), NumericLiteral), function($skip, $loc, $0, $1) {
+        var expression = $0;
+        return {
+          type: "PinPattern",
+          children: [expression],
+          expression
+        };
+      });
+      var PinPattern$3 = $TV(Undefined, function($skip, $loc, $0, $1) {
+        var expression = $0;
+        return {
+          type: "PinPattern",
+          children: [expression],
+          expression
+        };
+      });
+      var PinPattern$$ = [PinPattern$0, PinPattern$1, PinPattern$2, PinPattern$3];
       function PinPattern(ctx, state) {
         return $EVENT_C(ctx, state, "PinPattern", PinPattern$$);
       }
@@ -8300,7 +8488,7 @@ ${input.slice(result.pos)}
           parameters
         };
       });
-      var FunctionExpression$4 = $TS($S(OpenParen, __, $N($EXPECT($R9, "FunctionExpression /\\+\\+|--|[\\+-]\\S/")), BinaryOp, __, NonPipelineAssignmentExpression, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+      var FunctionExpression$4 = $TS($S(OpenParen, __, $N($EXPECT($R11, "FunctionExpression /\\+\\+|--|[\\+-]\\S/")), BinaryOp, __, NonPipelineAssignmentExpression, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
         var open = $1;
         var ws1 = $2;
         var op = $4;
@@ -8343,52 +8531,7 @@ ${input.slice(result.pos)}
         var rhs = $3;
         if (!prefix.length && !rhs)
           return $skip;
-        let body, ref, typeSuffix;
-        if (!rhs) {
-          body = ref = makeRef("$");
-        } else {
-          ({ ref, typeSuffix } = rhs);
-          if (!ref) {
-            throw new Error("Could not find ref in ampersand shorthand block");
-          }
-          body = rhs;
-        }
-        if (prefix.length) {
-          body = {
-            type: "UnaryExpression",
-            children: [processUnaryExpression(prefix, body, void 0)]
-          };
-        }
-        const parameters = {
-          type: "Parameters",
-          children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
-          names: []
-        };
-        const expressions = [body];
-        const block = {
-          bare: true,
-          expressions,
-          children: [expressions]
-        };
-        const children = [parameters, " => ", block];
-        const async = hasAwait(body);
-        if (async) {
-          children.unshift("async ");
-        }
-        return {
-          type: "ArrowFunction",
-          signature: {
-            modifier: {
-              async
-            }
-          },
-          children,
-          ref,
-          body,
-          ampersandBlock: true,
-          block,
-          parameters
-        };
+        return makeAmpersandFunctionExpression(prefix, rhs);
       });
       function AmpersandFunctionExpression(ctx, state) {
         return $EVENT(ctx, state, "AmpersandFunctionExpression", AmpersandFunctionExpression$0);
@@ -8514,7 +8657,7 @@ ${input.slice(result.pos)}
       function AmpersandTypeSuffix(ctx, state) {
         return $EVENT(ctx, state, "AmpersandTypeSuffix", AmpersandTypeSuffix$0);
       }
-      var AmpersandBlockRHSBody$0 = $TS($S($E(AmpersandTypeSuffix), $E($S($N(_), $P(CallExpressionRest))), $E(UnaryPostfix), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($R10, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var AmpersandBlockRHSBody$0 = $TS($S($E(AmpersandTypeSuffix), $E($S($N(_), $P(CallExpressionRest))), $E(UnaryPostfix), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($R12, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var typeSuffix = $1;
         var callExpRest = $2;
         var unaryPostfix = $3;
@@ -8522,42 +8665,7 @@ ${input.slice(result.pos)}
         var binopRHS = $5;
         if (!typeSuffix && !callExpRest && !binopRHS && !unaryPostfix)
           return $skip;
-        const ref = makeRef("$");
-        let exp = {
-          type: "AmpersandRef",
-          children: [ref],
-          names: [],
-          ref
-        };
-        if (callExpRest) {
-          exp.children.push(...callExpRest[1]);
-        }
-        if (unaryPostfix) {
-          exp = processUnaryExpression([], exp, unaryPostfix);
-        }
-        if (assign) {
-          const [op1, more, rhs] = assign;
-          const lhs = [
-            [void 0, exp, ...op1],
-            ...more.map((x) => [x[0], x[1], ...x[2]])
-          ];
-          exp = {
-            type: "AssignmentExpression",
-            children: [lhs, rhs],
-            names: null,
-            lhs,
-            assigned: exp,
-            exp: rhs
-          };
-        }
-        if (binopRHS) {
-          exp = {
-            children: processBinaryOpExpression([exp, binopRHS[1]])
-          };
-        }
-        exp.ref = ref;
-        exp.typeSuffix = typeSuffix;
-        return exp;
+        return makeAmpersandBlockRHSBody(typeSuffix, callExpRest, unaryPostfix, assign, binopRHS);
       });
       function AmpersandBlockRHSBody(ctx, state) {
         return $EVENT(ctx, state, "AmpersandBlockRHSBody", AmpersandBlockRHSBody$0);
@@ -8958,7 +9066,7 @@ ${input.slice(result.pos)}
       function BlockStatementPart(ctx, state) {
         return $EVENT(ctx, state, "BlockStatementPart", BlockStatementPart$0);
       }
-      var Literal$0 = $TS($S($EXPECT($R11, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
+      var Literal$0 = $TS($S($EXPECT($R13, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
         var literal = $2;
         return {
           type: "Literal",
@@ -8984,7 +9092,7 @@ ${input.slice(result.pos)}
       function NullLiteral(ctx, state) {
         return $EVENT(ctx, state, "NullLiteral", NullLiteral$0);
       }
-      var BooleanLiteral$0 = $T($S($EXPECT($R12, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
+      var BooleanLiteral$0 = $T($S($EXPECT($R14, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
         return value[1];
       });
       function BooleanLiteral(ctx, state) {
@@ -9010,14 +9118,14 @@ ${input.slice(result.pos)}
       function CoffeeScriptBooleanLiteral(ctx, state) {
         return $EVENT_C(ctx, state, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
       }
-      var Identifier$0 = $T($S($EXPECT($R13, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
+      var Identifier$0 = $T($S($EXPECT($R15, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
         var id = value[2];
         return id;
       });
       function Identifier(ctx, state) {
         return $EVENT(ctx, state, "Identifier", Identifier$0);
       }
-      var IdentifierName$0 = $TR($EXPECT($R14, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var IdentifierName$0 = $TR($EXPECT($R16, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return {
           type: "Identifier",
           name: $0,
@@ -9039,7 +9147,7 @@ ${input.slice(result.pos)}
       function UpcomingAssignment(ctx, state) {
         return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
       }
-      var ArrayLiteral$0 = $T($S($EXPECT($R15, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
+      var ArrayLiteral$0 = $T($S($EXPECT($R17, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
         return value[1];
       });
       function ArrayLiteral(ctx, state) {
@@ -9140,8 +9248,26 @@ ${input.slice(result.pos)}
           end: e
         };
       });
+      var RangeExpression$1 = $TS($S(ExtendedExpression, __, DotDot, $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var s = $1;
+        var ws = $2;
+        return {
+          type: "RangeExpression",
+          children: ["[]", {
+            type: "Error",
+            message: "Infinite range [x..] is only valid in for loops"
+          }],
+          start: s,
+          end: {
+            type: "Identifier",
+            name: "Infinity",
+            children: ["Infinity"]
+          }
+        };
+      });
+      var RangeExpression$$ = [RangeExpression$0, RangeExpression$1];
       function RangeExpression(ctx, state) {
-        return $EVENT(ctx, state, "RangeExpression", RangeExpression$0);
+        return $EVENT_C(ctx, state, "RangeExpression", RangeExpression$$);
       }
       var ArrayLiteralContent$0 = RangeExpression;
       var ArrayLiteralContent$1 = $S(NestedElementList, $Y($S(__, CloseBracket)));
@@ -9237,7 +9363,7 @@ ${input.slice(result.pos)}
       var ArrayElementExpression$1 = $T($S(ImplicitObjectLiteral, $Y(ArrayElementDelimiter)), function(value) {
         return value[0];
       });
-      var ArrayElementExpression$2 = $TS($S($E(ExtendedExpression), __, DotDotDot, $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ArrayElementExpression$2 = $TS($S(ExtendedExpression, $E(_), DotDotDot, $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var exp = $1;
         var ws = $2;
         var dots = $3;
@@ -9246,7 +9372,7 @@ ${input.slice(result.pos)}
         }
         return {
           type: "SpreadElement",
-          children: [...ws, dots, exp],
+          children: [ws, dots, exp],
           names: exp.names
         };
       });
@@ -9463,7 +9589,7 @@ ${input.slice(result.pos)}
           children: [ws, ...prop.children]
         };
       });
-      var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R16, "PropertyDefinition /[!+-]?/")), PropertyName, $Y(ObjectPropertyDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R18, "PropertyDefinition /[!+-]?/")), PropertyName, $Y(ObjectPropertyDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var ws = $1;
         var toggle = $2;
         var id = $3;
@@ -9648,7 +9774,7 @@ ${input.slice(result.pos)}
           implicit: true
         };
       });
-      var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($R17, "ComputedPropertyName /[+-]/"), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($R10, "ComputedPropertyName /[+-]/"), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
         const expression = [$2, $3];
         return {
           type: "ComputedPropertyName",
@@ -9657,7 +9783,18 @@ ${input.slice(result.pos)}
           implicit: true
         };
       });
-      var ComputedPropertyName$$ = [ComputedPropertyName$0, ComputedPropertyName$1, ComputedPropertyName$2];
+      var ComputedPropertyName$3 = $TS($S(InsertOpenBracket, PartialPlaceholder, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3) {
+        var open = $1;
+        var expression = $2;
+        var close = $3;
+        return {
+          type: "ComputedPropertyName",
+          expression,
+          children: [open, expression, close],
+          implicit: true
+        };
+      });
+      var ComputedPropertyName$$ = [ComputedPropertyName$0, ComputedPropertyName$1, ComputedPropertyName$2, ComputedPropertyName$3];
       function ComputedPropertyName(ctx, state) {
         return $EVENT_C(ctx, state, "ComputedPropertyName", ComputedPropertyName$$);
       }
@@ -10027,7 +10164,7 @@ ${input.slice(result.pos)}
       function IdentifierBinaryOp(ctx, state) {
         return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
       }
-      var BinaryOp$0 = $T($S($EXPECT($R18, "BinaryOp /(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])/"), _BinaryOp), function(value) {
+      var BinaryOp$0 = $T($S($EXPECT($R19, "BinaryOp /(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])/"), _BinaryOp), function(value) {
         var op = value[1];
         return op;
       });
@@ -10162,7 +10299,7 @@ ${input.slice(result.pos)}
           prec: "^^"
         };
       });
-      var BinaryOpSymbol$35 = $TV($C($EXPECT($R19, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L101, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
+      var BinaryOpSymbol$35 = $TV($C($EXPECT($R20, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L101, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
         return {
           call: module.getRef("xnor"),
           special: true,
@@ -10256,6 +10393,16 @@ ${input.slice(result.pos)}
       function BinaryOpSymbol(ctx, state) {
         return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
       }
+      var ActualIn$0 = $T($S(CoffeeOfEnabled, Of), function(value) {
+        return value[1];
+      });
+      var ActualIn$1 = $T($S($N(CoffeeOfEnabled), In), function(value) {
+        return value[1];
+      });
+      var ActualIn$$ = [ActualIn$0, ActualIn$1];
+      function ActualIn(ctx, state) {
+        return $EVENT_C(ctx, state, "ActualIn", ActualIn$$);
+      }
       var CoffeeOfOp$0 = $T($S(Of), function(value) {
         return "in";
       });
@@ -10316,24 +10463,24 @@ ${input.slice(result.pos)}
       function Xor(ctx, state) {
         return $EVENT_C(ctx, state, "Xor", Xor$$);
       }
-      var Xnor$0 = $R$0($EXPECT($R19, "Xnor /!\\^\\^?/"));
+      var Xnor$0 = $R$0($EXPECT($R20, "Xnor /!\\^\\^?/"));
       var Xnor$1 = $EXPECT($L101, 'Xnor "xnor"');
       var Xnor$$ = [Xnor$0, Xnor$1];
       function Xnor(ctx, state) {
         return $EVENT_C(ctx, state, "Xnor", Xnor$$);
       }
-      var UnaryOp$0 = $TR($EXPECT($R20, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var UnaryOp$0 = $TR($EXPECT($R21, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       var UnaryOp$1 = AwaitOp;
-      var UnaryOp$2 = $TS($S($C(Delete, Void, Typeof), $N($EXPECT($R21, "UnaryOp /[:.]/")), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
+      var UnaryOp$2 = $TS($S($C(Delete, Void, Typeof), $N($EXPECT($R22, "UnaryOp /[:.]/")), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
         var op = $1;
         var ws = $3;
         if (!ws)
           return [op, [" "]];
         return [op, ws];
       });
-      var UnaryOp$3 = $T($S(Not, $N($EXPECT($R21, "UnaryOp /[:.]/")), $E($EXPECT($L16, 'UnaryOp " "')), $E(_)), function(value) {
+      var UnaryOp$3 = $T($S(Not, $N($EXPECT($R22, "UnaryOp /[:.]/")), $E($EXPECT($L16, 'UnaryOp " "')), $E(_)), function(value) {
         return [value[0], value[3]];
       });
       var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
@@ -10428,7 +10575,7 @@ ${input.slice(result.pos)}
       function NonPipelinePostfixedExpression(ctx, state) {
         return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
       }
-      var PostfixStatement$0 = $T($S($EXPECT($R22, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
+      var PostfixStatement$0 = $T($S($EXPECT($R23, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
         return value[1];
       });
       function PostfixStatement(ctx, state) {
@@ -10561,7 +10708,7 @@ ${input.slice(result.pos)}
       function UnlessClause(ctx, state) {
         return $EVENT(ctx, state, "UnlessClause", UnlessClause$0);
       }
-      var IterationStatement$0 = $T($S($EXPECT($R23, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
+      var IterationStatement$0 = $T($S($EXPECT($R24, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
         return value[1];
       });
       function IterationStatement(ctx, state) {
@@ -10914,7 +11061,7 @@ ${input.slice(result.pos)}
           names: binding.names
         };
       });
-      var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R24, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
+      var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R25, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
         var c = $1;
         var binding = $2;
         return {
@@ -11743,7 +11890,7 @@ ${input.slice(result.pos)}
       function UnprocessedModuleSpecifier(ctx, state) {
         return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
       }
-      var UnquotedSpecifier$0 = $TV($EXPECT($R25, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
+      var UnquotedSpecifier$0 = $TV($EXPECT($R26, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
         var spec = $0;
         return { $loc, token: `"${spec}"` };
       });
@@ -11996,7 +12143,7 @@ ${input.slice(result.pos)}
       function VariableDeclarationList(ctx, state) {
         return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
       }
-      var NumericLiteral$0 = $TS($S($EXPECT($R26, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
+      var NumericLiteral$0 = $TS($S($EXPECT($R27, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
         var token = $2;
         return { type: "NumericLiteral", $loc, token };
       });
@@ -12012,36 +12159,36 @@ ${input.slice(result.pos)}
       function NumericLiteralKind(ctx, state) {
         return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
       }
-      var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R27, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
+      var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R28, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
       function DecimalBigIntegerLiteral(ctx, state) {
         return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
       }
-      var DecimalLiteral$0 = $TV($TEXT($EXPECT($R28, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
+      var DecimalLiteral$0 = $TV($TEXT($EXPECT($R29, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
         return $1 + ".";
       });
-      var DecimalLiteral$1 = $TEXT($S($EXPECT($R29, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
-      var DecimalLiteral$2 = $TEXT($S($EXPECT($R30, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
+      var DecimalLiteral$1 = $TEXT($S($EXPECT($R30, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
+      var DecimalLiteral$2 = $TEXT($S($EXPECT($R31, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
       var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
       function DecimalLiteral(ctx, state) {
         return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
       }
-      var ExponentPart$0 = $R$0($EXPECT($R31, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
+      var ExponentPart$0 = $R$0($EXPECT($R32, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
       function ExponentPart(ctx, state) {
         return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
       }
-      var BinaryIntegerLiteral$0 = $R$0($EXPECT($R32, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
+      var BinaryIntegerLiteral$0 = $R$0($EXPECT($R33, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
       function BinaryIntegerLiteral(ctx, state) {
         return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
       }
-      var OctalIntegerLiteral$0 = $R$0($EXPECT($R33, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
+      var OctalIntegerLiteral$0 = $R$0($EXPECT($R34, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
       function OctalIntegerLiteral(ctx, state) {
         return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
       }
-      var HexIntegerLiteral$0 = $R$0($EXPECT($R34, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
+      var HexIntegerLiteral$0 = $R$0($EXPECT($R35, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
       function HexIntegerLiteral(ctx, state) {
         return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
       }
-      var IntegerLiteral$0 = $TS($S($EXPECT($R35, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
+      var IntegerLiteral$0 = $TS($S($EXPECT($R36, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
         var token = $2;
         return { $loc, token };
       });
@@ -12057,7 +12204,7 @@ ${input.slice(result.pos)}
       function IntegerLiteralKind(ctx, state) {
         return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
       }
-      var DecimalIntegerLiteral$0 = $R$0($EXPECT($R36, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
+      var DecimalIntegerLiteral$0 = $R$0($EXPECT($R37, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
       function DecimalIntegerLiteral(ctx, state) {
         return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
       }
@@ -12081,25 +12228,25 @@ ${input.slice(result.pos)}
       function StringLiteral(ctx, state) {
         return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
       }
-      var DoubleStringCharacters$0 = $TR($EXPECT($R37, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var DoubleStringCharacters$0 = $TR($EXPECT($R38, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function DoubleStringCharacters(ctx, state) {
         return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
       }
-      var SingleStringCharacters$0 = $TR($EXPECT($R38, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var SingleStringCharacters$0 = $TR($EXPECT($R39, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function SingleStringCharacters(ctx, state) {
         return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
       }
-      var TripleDoubleStringCharacters$0 = $TR($EXPECT($R39, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var TripleDoubleStringCharacters$0 = $TR($EXPECT($R40, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function TripleDoubleStringCharacters(ctx, state) {
         return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
       }
-      var TripleSingleStringCharacters$0 = $TR($EXPECT($R40, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var TripleSingleStringCharacters$0 = $TR($EXPECT($R41, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function TripleSingleStringCharacters(ctx, state) {
@@ -12122,7 +12269,7 @@ ${input.slice(result.pos)}
       function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
         return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
       }
-      var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R41, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R42, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function CoffeeDoubleQuotedStringCharacters(ctx, state) {
@@ -12142,7 +12289,7 @@ ${input.slice(result.pos)}
       function RegularExpressionClass(ctx, state) {
         return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
       }
-      var RegularExpressionClassCharacters$0 = $TR($EXPECT($R42, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var RegularExpressionClassCharacters$0 = $TR($EXPECT($R43, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function RegularExpressionClassCharacters(ctx, state) {
@@ -12199,7 +12346,7 @@ ${input.slice(result.pos)}
       var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
         return { "type": "Substitution", "children": value[0] };
       });
-      var HeregexPart$3 = $TR($EXPECT($R43, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var HeregexPart$3 = $TR($EXPECT($R44, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         let token = $0;
         switch ($0[1]) {
           case "\n":
@@ -12217,13 +12364,13 @@ ${input.slice(result.pos)}
       var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
         return { $loc, token: "" };
       });
-      var HeregexPart$5 = $TR($EXPECT($R44, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var HeregexPart$5 = $TR($EXPECT($R45, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: "" };
       });
-      var HeregexPart$6 = $TR($EXPECT($R45, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var HeregexPart$6 = $TR($EXPECT($R46, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: "\\/" };
       });
-      var HeregexPart$7 = $TR($EXPECT($R46, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var HeregexPart$7 = $TR($EXPECT($R47, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
@@ -12236,7 +12383,7 @@ ${input.slice(result.pos)}
       function HeregexComment(ctx, state) {
         return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
       }
-      var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R47, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
+      var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R48, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
       function RegularExpressionBody(ctx, state) {
         return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
       }
@@ -12246,15 +12393,15 @@ ${input.slice(result.pos)}
       function RegExpPart(ctx, state) {
         return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
       }
-      var RegExpCharacter$0 = $R$0($EXPECT($R48, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
+      var RegExpCharacter$0 = $R$0($EXPECT($R49, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
       function RegExpCharacter(ctx, state) {
         return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
       }
-      var RegularExpressionFlags$0 = $R$0($EXPECT($R49, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
+      var RegularExpressionFlags$0 = $R$0($EXPECT($R50, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
       function RegularExpressionFlags(ctx, state) {
         return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
       }
-      var TemplateLiteral$0 = $T($S($EXPECT($R50, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
+      var TemplateLiteral$0 = $T($S($EXPECT($R51, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
         return value[1];
       });
       function TemplateLiteral(ctx, state) {
@@ -12294,28 +12441,28 @@ ${input.slice(result.pos)}
       function TemplateSubstitution(ctx, state) {
         return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
       }
-      var TemplateCharacters$0 = $TR($EXPECT($R51, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var TemplateCharacters$0 = $TR($EXPECT($R52, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function TemplateCharacters(ctx, state) {
         return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
       }
-      var TemplateBlockCharacters$0 = $TR($EXPECT($R52, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var TemplateBlockCharacters$0 = $TR($EXPECT($R53, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function TemplateBlockCharacters(ctx, state) {
         return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
       }
-      var ReservedWord$0 = $S($R$0($EXPECT($R53, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
-      var ReservedWord$1 = $S($R$0($EXPECT($R54, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
-      var ReservedWord$2 = $S($R$0($EXPECT($R55, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
-      var ReservedWord$3 = $S($R$0($EXPECT($R56, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
-      var ReservedWord$4 = $R$0($EXPECT($R57, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
+      var ReservedWord$0 = $S($R$0($EXPECT($R54, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
+      var ReservedWord$1 = $S($R$0($EXPECT($R55, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
+      var ReservedWord$2 = $S($R$0($EXPECT($R56, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
+      var ReservedWord$3 = $S($R$0($EXPECT($R57, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
+      var ReservedWord$4 = $R$0($EXPECT($R58, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
       var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
       function ReservedWord(ctx, state) {
         return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
       }
-      var Comment$0 = $T($S($EXPECT($R58, "Comment /(?=\\/|#)/"), _Comment), function(value) {
+      var Comment$0 = $T($S($EXPECT($R59, "Comment /(?=\\/|#)/"), _Comment), function(value) {
         return value[1];
       });
       function Comment(ctx, state) {
@@ -12333,7 +12480,7 @@ ${input.slice(result.pos)}
       function SingleLineComment(ctx, state) {
         return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
       }
-      var JSSingleLineComment$0 = $TR($EXPECT($R59, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var JSSingleLineComment$0 = $TR($EXPECT($R60, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { type: "Comment", $loc, token: $0 };
       });
       function JSSingleLineComment(ctx, state) {
@@ -12345,30 +12492,30 @@ ${input.slice(result.pos)}
       function MultiLineComment(ctx, state) {
         return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
       }
-      var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L123, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L124, 'JSMultiLineComment "*/"')), $EXPECT($R60, "JSMultiLineComment /./"))), $EXPECT($L124, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
+      var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L123, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L124, 'JSMultiLineComment "*/"')), $EXPECT($R61, "JSMultiLineComment /./"))), $EXPECT($L124, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
         return { type: "Comment", $loc, token: $1 };
       });
       function JSMultiLineComment(ctx, state) {
         return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
       }
-      var CoffeeSingleLineComment$0 = $TR($EXPECT($R61, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var CoffeeSingleLineComment$0 = $TR($EXPECT($R62, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { type: "Comment", $loc, token: `//${$1}` };
       });
       function CoffeeSingleLineComment(ctx, state) {
         return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
       }
-      var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R62, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
+      var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R63, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
         $2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
         return { type: "Comment", $loc, token: `/*${$2}*/` };
       });
       function CoffeeMultiLineComment(ctx, state) {
         return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
       }
-      var CoffeeHereCommentStart$0 = $R$0($EXPECT($R63, "CoffeeHereCommentStart /###(?!#)/"));
+      var CoffeeHereCommentStart$0 = $R$0($EXPECT($R64, "CoffeeHereCommentStart /###(?!#)/"));
       function CoffeeHereCommentStart(ctx, state) {
         return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
       }
-      var InlineComment$0 = $TR($EXPECT($R64, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var InlineComment$0 = $TR($EXPECT($R65, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function InlineComment(ctx, state) {
@@ -12382,13 +12529,13 @@ ${input.slice(result.pos)}
       function TrailingComment(ctx, state) {
         return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
       }
-      var _$0 = $T($S($EXPECT($R65, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
+      var _$0 = $T($S($EXPECT($R66, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
         return value[1];
       });
       function _(ctx, state) {
         return $EVENT(ctx, state, "_", _$0);
       }
-      var NonNewlineWhitespace$0 = $TR($EXPECT($R66, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var NonNewlineWhitespace$0 = $TR($EXPECT($R67, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       var NonNewlineWhitespace$1 = $T($S($EXPECT($L125, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
@@ -12405,7 +12552,7 @@ ${input.slice(result.pos)}
       function Trimmed_(ctx, state) {
         return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
       }
-      var __$0 = $T($S($EXPECT($R67, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
+      var __$0 = $T($S($EXPECT($R68, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
         return value[1];
       });
       var __$1 = $EXPECT($L0, '__ ""');
@@ -12413,7 +12560,7 @@ ${input.slice(result.pos)}
       function __(ctx, state) {
         return $EVENT_C(ctx, state, "__", __$$);
       }
-      var Whitespace$0 = $TR($EXPECT($R44, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var Whitespace$0 = $TR($EXPECT($R45, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function Whitespace(ctx, state) {
@@ -12451,7 +12598,7 @@ ${input.slice(result.pos)}
       function SemicolonDelimiter(ctx, state) {
         return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
       }
-      var NonIdContinue$0 = $R$0($EXPECT($R68, "NonIdContinue /(?!\\p{ID_Continue})/"));
+      var NonIdContinue$0 = $R$0($EXPECT($R69, "NonIdContinue /(?!\\p{ID_Continue})/"));
       function NonIdContinue(ctx, state) {
         return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
       }
@@ -12569,7 +12716,7 @@ ${input.slice(result.pos)}
       function CoffeeSubstitutionStart(ctx, state) {
         return $EVENT(ctx, state, "CoffeeSubstitutionStart", CoffeeSubstitutionStart$0);
       }
-      var Colon$0 = $TS($S($EXPECT($L15, 'Colon ":"'), $N($EXPECT($L3, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
+      var Colon$0 = $TS($S($EXPECT($L15, 'Colon ":"'), $N($EXPECT($R70, "Colon /[=:]/"))), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Colon(ctx, state) {
@@ -12614,7 +12761,7 @@ ${input.slice(result.pos)}
       var Dot$0 = $TV($EXPECT($L7, 'Dot "."'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
-      var Dot$1 = $TS($S($EXPECT($R69, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
+      var Dot$1 = $TS($S($EXPECT($R71, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
         var ws = $2;
         return [
           { $loc, token: "." },
@@ -12735,7 +12882,7 @@ ${input.slice(result.pos)}
       function If(ctx, state) {
         return $EVENT(ctx, state, "If", If$0);
       }
-      var Import$0 = $TS($S($EXPECT($L20, 'Import "import"'), $Y($EXPECT($R70, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
+      var Import$0 = $TS($S($EXPECT($L20, 'Import "import"'), $Y($EXPECT($R72, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Import(ctx, state) {
@@ -13004,49 +13151,55 @@ ${input.slice(result.pos)}
       function Typeof(ctx, state) {
         return $EVENT(ctx, state, "Typeof", Typeof$0);
       }
-      var Unless$0 = $TS($S($EXPECT($L202, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Undefined$0 = $TS($S($EXPECT($L202, 'Undefined "undefined"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function Undefined(ctx, state) {
+        return $EVENT(ctx, state, "Undefined", Undefined$0);
+      }
+      var Unless$0 = $TS($S($EXPECT($L203, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, negated: true };
       });
       function Unless(ctx, state) {
         return $EVENT(ctx, state, "Unless", Unless$0);
       }
-      var Until$0 = $TS($S($EXPECT($L203, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Until$0 = $TS($S($EXPECT($L204, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Until(ctx, state) {
         return $EVENT(ctx, state, "Until", Until$0);
       }
-      var Using$0 = $TS($S($EXPECT($L204, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Using$0 = $TS($S($EXPECT($L205, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Using(ctx, state) {
         return $EVENT(ctx, state, "Using", Using$0);
       }
-      var Var$0 = $TS($S($EXPECT($L205, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Var$0 = $TS($S($EXPECT($L206, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Var(ctx, state) {
         return $EVENT(ctx, state, "Var", Var$0);
       }
-      var Void$0 = $TS($S($EXPECT($L206, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Void$0 = $TS($S($EXPECT($L207, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Void(ctx, state) {
         return $EVENT(ctx, state, "Void", Void$0);
       }
-      var When$0 = $TS($S($EXPECT($L207, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var When$0 = $TS($S($EXPECT($L208, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: "case" };
       });
       function When(ctx, state) {
         return $EVENT(ctx, state, "When", When$0);
       }
-      var While$0 = $TS($S($EXPECT($L208, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var While$0 = $TS($S($EXPECT($L209, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function While(ctx, state) {
         return $EVENT(ctx, state, "While", While$0);
       }
-      var Yield$0 = $TS($S($EXPECT($L209, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Yield$0 = $TS($S($EXPECT($L210, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1, type: "Yield" };
       });
       function Yield(ctx, state) {
@@ -13075,7 +13228,7 @@ ${input.slice(result.pos)}
       function JSXImplicitFragment(ctx, state) {
         return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
       }
-      var JSXTag$0 = $T($S($EXPECT($R71, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
+      var JSXTag$0 = $T($S($EXPECT($R73, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
         return value[1];
       });
       function JSXTag(ctx, state) {
@@ -13125,7 +13278,7 @@ ${input.slice(result.pos)}
       function JSXElement(ctx, state) {
         return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
       }
-      var JSXSelfClosingElement$0 = $TS($S($EXPECT($L17, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L210, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var JSXSelfClosingElement$0 = $TS($S($EXPECT($L17, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L211, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         return { type: "JSXElement", children: $0, tag: $2 };
       });
       function JSXSelfClosingElement(ctx, state) {
@@ -13159,7 +13312,7 @@ ${input.slice(result.pos)}
       function JSXOptionalClosingElement(ctx, state) {
         return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
       }
-      var JSXClosingElement$0 = $S($EXPECT($L211, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L45, 'JSXClosingElement ">"'));
+      var JSXClosingElement$0 = $S($EXPECT($L212, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L45, 'JSXClosingElement ">"'));
       function JSXClosingElement(ctx, state) {
         return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
       }
@@ -13180,7 +13333,7 @@ ${input.slice(result.pos)}
         ];
         return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
       });
-      var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L212, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L213, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var children = $3;
         $0 = $0.slice(1);
         return {
@@ -13193,7 +13346,7 @@ ${input.slice(result.pos)}
       function JSXFragment(ctx, state) {
         return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
       }
-      var PushJSXOpeningFragment$0 = $TV($EXPECT($L212, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
+      var PushJSXOpeningFragment$0 = $TV($EXPECT($L213, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
         module.JSXTagStack.push("");
         return $1;
       });
@@ -13210,7 +13363,7 @@ ${input.slice(result.pos)}
       function JSXOptionalClosingFragment(ctx, state) {
         return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
       }
-      var JSXClosingFragment$0 = $EXPECT($L213, 'JSXClosingFragment "</>"');
+      var JSXClosingFragment$0 = $EXPECT($L214, 'JSXClosingFragment "</>"');
       function JSXClosingFragment(ctx, state) {
         return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
       }
@@ -13222,7 +13375,7 @@ ${input.slice(result.pos)}
       function JSXElementName(ctx, state) {
         return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
       }
-      var JSXIdentifierName$0 = $R$0($EXPECT($R72, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
+      var JSXIdentifierName$0 = $R$0($EXPECT($R74, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
       function JSXIdentifierName(ctx, state) {
         return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
       }
@@ -13401,7 +13554,7 @@ ${input.slice(result.pos)}
           class: $2
         };
       });
-      var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R73, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
+      var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R75, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
         var toggle = $1;
         var id = $2;
         const value = toggle === "+" ? "true" : "false";
@@ -13411,11 +13564,11 @@ ${input.slice(result.pos)}
       function JSXAttribute(ctx, state) {
         return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
       }
-      var JSXAttributeSpace$0 = $R$0($EXPECT($R74, "JSXAttributeSpace /[\\s>]|\\/>/"));
+      var JSXAttributeSpace$0 = $R$0($EXPECT($R76, "JSXAttributeSpace /[\\s>]|\\/>/"));
       function JSXAttributeSpace(ctx, state) {
         return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
       }
-      var JSXShorthandString$0 = $TR($EXPECT($R75, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var JSXShorthandString$0 = $TR($EXPECT($R77, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return quoteString($0);
       });
       var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
@@ -13449,7 +13602,7 @@ ${input.slice(result.pos)}
         }
         return [open, value, close];
       });
-      var JSXAttributeValue$4 = $R$0($EXPECT($R76, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
+      var JSXAttributeValue$4 = $R$0($EXPECT($R78, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
       var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
       function JSXAttributeValue(ctx, state) {
         return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
@@ -13462,7 +13615,7 @@ ${input.slice(result.pos)}
       function InlineJSXAttributeValue(ctx, state) {
         return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
       }
-      var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R77, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
+      var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R79, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
         var op = $2;
         var rhs = $3;
         return [[], op, [], rhs];
@@ -13479,7 +13632,7 @@ ${input.slice(result.pos)}
       function InlineJSXUnaryExpression(ctx, state) {
         return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
       }
-      var InlineJSXUnaryOp$0 = $TR($EXPECT($R78, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var InlineJSXUnaryOp$0 = $TR($EXPECT($R80, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function InlineJSXUnaryOp(ctx, state) {
@@ -13689,19 +13842,19 @@ ${input.slice(result.pos)}
       function JSXChild(ctx, state) {
         return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
       }
-      var JSXComment$0 = $TS($S($EXPECT($L214, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L215, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
+      var JSXComment$0 = $TS($S($EXPECT($L215, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L216, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
         return ["{/*", $2, "*/}"];
       });
       function JSXComment(ctx, state) {
         return $EVENT(ctx, state, "JSXComment", JSXComment$0);
       }
-      var JSXCommentContent$0 = $TR($EXPECT($R79, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var JSXCommentContent$0 = $TR($EXPECT($R81, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0.replace(/\*\//g, "* /") };
       });
       function JSXCommentContent(ctx, state) {
         return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
       }
-      var JSXText$0 = $TR($EXPECT($R80, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var JSXText$0 = $TR($EXPECT($R82, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return {
           type: "JSXText",
           token: $0,
@@ -13876,37 +14029,37 @@ ${input.slice(result.pos)}
       function InterfaceExtendsTarget(ctx, state) {
         return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
       }
-      var TypeKeyword$0 = $TS($S($EXPECT($L216, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var TypeKeyword$0 = $TS($S($EXPECT($L217, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function TypeKeyword(ctx, state) {
         return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
       }
-      var Enum$0 = $TS($S($EXPECT($L217, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Enum$0 = $TS($S($EXPECT($L218, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Enum(ctx, state) {
         return $EVENT(ctx, state, "Enum", Enum$0);
       }
-      var Interface$0 = $TS($S($EXPECT($L218, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Interface$0 = $TS($S($EXPECT($L219, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Interface(ctx, state) {
         return $EVENT(ctx, state, "Interface", Interface$0);
       }
-      var Global$0 = $TS($S($EXPECT($L219, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Global$0 = $TS($S($EXPECT($L220, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Global(ctx, state) {
         return $EVENT(ctx, state, "Global", Global$0);
       }
-      var Module$0 = $TS($S($EXPECT($L220, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Module$0 = $TS($S($EXPECT($L221, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Module(ctx, state) {
         return $EVENT(ctx, state, "Module", Module$0);
       }
-      var Namespace$0 = $TS($S($EXPECT($L221, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Namespace$0 = $TS($S($EXPECT($L222, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Namespace(ctx, state) {
@@ -14122,7 +14275,7 @@ ${input.slice(result.pos)}
       function TypeProperty(ctx, state) {
         return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
       }
-      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R81, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R17, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
+      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R83, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R10, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
       function TypeIndexSignature(ctx, state) {
         return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
       }
@@ -14142,11 +14295,13 @@ ${input.slice(result.pos)}
         return { "type": "TypeSuffix", "ts": true, "optional": optional, "children": value };
       });
       var TypeSuffix$2 = $TS($S(NonNullAssertion, $E(_), $E($S(Colon, MaybeIndentedType))), function($skip, $loc, $0, $1, $2, $3) {
+        var nonnull = $1;
         var ct = $3;
         const [colon, t] = ct ?? [];
         return {
           type: "TypeSuffix",
           ts: true,
+          nonnull,
           t,
           children: [$1, $2, colon, t]
         };
@@ -14180,7 +14335,7 @@ ${input.slice(result.pos)}
       function ReturnTypeSuffix(ctx, state) {
         return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
       }
-      var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L222, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+      var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L223, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
         var asserts = $1;
         var t = $2;
         if (asserts) {
@@ -14259,7 +14414,7 @@ ${input.slice(result.pos)}
       function TypeUnarySuffix(ctx, state) {
         return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
       }
-      var TypeUnaryOp$0 = $S($EXPECT($L223, 'TypeUnaryOp "keyof"'), NonIdContinue);
+      var TypeUnaryOp$0 = $S($EXPECT($L224, 'TypeUnaryOp "keyof"'), NonIdContinue);
       var TypeUnaryOp$1 = $S($EXPECT($L184, 'TypeUnaryOp "readonly"'), NonIdContinue);
       var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1];
       function TypeUnaryOp(ctx, state) {
@@ -14290,7 +14445,7 @@ ${input.slice(result.pos)}
       function TypeIndexedAccess(ctx, state) {
         return $EVENT_C(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$$);
       }
-      var UnknownAlias$0 = $TV($EXPECT($L224, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
+      var UnknownAlias$0 = $TV($EXPECT($L225, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "unknown" };
       });
       function UnknownAlias(ctx, state) {
@@ -14416,7 +14571,7 @@ ${input.slice(result.pos)}
       function NestedType(ctx, state) {
         return $EVENT(ctx, state, "NestedType", NestedType$0);
       }
-      var TypeConditional$0 = $TS($S($E(_), $EXPECT($R82, "TypeConditional /(?=if|unless)/"), TypeIfThenElse), function($skip, $loc, $0, $1, $2, $3) {
+      var TypeConditional$0 = $TS($S($E(_), $EXPECT($R84, "TypeConditional /(?=if|unless)/"), TypeIfThenElse), function($skip, $loc, $0, $1, $2, $3) {
         return [$1, expressionizeTypeIf($3)];
       });
       var TypeConditional$1 = $TS($S(TypeCondition, NotDedented, QuestionMark, Type, __, Colon, Type), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
@@ -14496,17 +14651,17 @@ ${input.slice(result.pos)}
       }
       var TypeLiteral$0 = TypeTemplateLiteral;
       var TypeLiteral$1 = Literal;
-      var TypeLiteral$2 = $TS($S($EXPECT($R17, "TypeLiteral /[+-]/"), NumericLiteral), function($skip, $loc, $0, $1, $2) {
+      var TypeLiteral$2 = $TS($S($EXPECT($R10, "TypeLiteral /[+-]/"), NumericLiteral), function($skip, $loc, $0, $1, $2) {
         var sign = $1;
         var num = $2;
         if (sign[0] === "+")
           return num;
         return $0;
       });
-      var TypeLiteral$3 = $TS($S($EXPECT($L206, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var TypeLiteral$3 = $TS($S($EXPECT($L207, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { type: "VoidType", $loc, token: $1 };
       });
-      var TypeLiteral$4 = $TV($EXPECT($L225, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
+      var TypeLiteral$4 = $TV($EXPECT($L226, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "[]" };
       });
       var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3, TypeLiteral$4];
@@ -14616,15 +14771,15 @@ ${input.slice(result.pos)}
       function ThisType(ctx, state) {
         return $EVENT(ctx, state, "ThisType", ThisType$0);
       }
-      var Shebang$0 = $S($R$0($EXPECT($R83, "Shebang /#![^\\r\\n]*/")), EOL);
+      var Shebang$0 = $S($R$0($EXPECT($R85, "Shebang /#![^\\r\\n]*/")), EOL);
       function Shebang(ctx, state) {
         return $EVENT(ctx, state, "Shebang", Shebang$0);
       }
-      var CivetPrologue$0 = $T($S($EXPECT($R84, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R85, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
+      var CivetPrologue$0 = $T($S($EXPECT($R86, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R87, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
         var content = value[2];
         return content;
       });
-      var CivetPrologue$1 = $T($S($EXPECT($R84, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R85, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
+      var CivetPrologue$1 = $T($S($EXPECT($R86, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R87, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
         var content = value[2];
         return content;
       });
@@ -14632,7 +14787,7 @@ ${input.slice(result.pos)}
       function CivetPrologue(ctx, state) {
         return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
       }
-      var CivetPrologueContent$0 = $TS($S($EXPECT($L226, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R86, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var CivetPrologueContent$0 = $TS($S($EXPECT($L227, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R88, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
         var options = $3;
         return {
           type: "CivetPrologue",
@@ -14643,7 +14798,7 @@ ${input.slice(result.pos)}
       function CivetPrologueContent(ctx, state) {
         return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
       }
-      var CivetOption$0 = $TR($EXPECT($R87, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var CivetOption$0 = $TR($EXPECT($R89, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
           if (l)
             return l.toUpperCase();
@@ -14660,11 +14815,11 @@ ${input.slice(result.pos)}
       function CivetOption(ctx, state) {
         return $EVENT(ctx, state, "CivetOption", CivetOption$0);
       }
-      var UnknownPrologue$0 = $S($R$0($EXPECT($R84, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
+      var UnknownPrologue$0 = $S($R$0($EXPECT($R86, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
       function UnknownPrologue(ctx, state) {
         return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
       }
-      var TripleSlashDirective$0 = $S($R$0($EXPECT($R88, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
+      var TripleSlashDirective$0 = $S($R$0($EXPECT($R90, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
       function TripleSlashDirective(ctx, state) {
         return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
       }
@@ -14680,13 +14835,13 @@ ${input.slice(result.pos)}
       function PrologueString(ctx, state) {
         return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
       }
-      var EOS$0 = $T($S($EXPECT($R89, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
+      var EOS$0 = $T($S($EXPECT($R91, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
         return value[1];
       });
       function EOS(ctx, state) {
         return $EVENT(ctx, state, "EOS", EOS$0);
       }
-      var EOL$0 = $TR($EXPECT($R90, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var EOL$0 = $TR($EXPECT($R92, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function EOL(ctx, state) {
@@ -15258,11 +15413,11 @@ ${input.slice(result.pos)}
       function Prologue(ctx, state) {
         return $EVENT(ctx, state, "Prologue", Prologue$0);
       }
-      var ProloguePrefix$0 = $S(Prologue, $R$0($EXPECT($R91, "ProloguePrefix /[^]*/")));
+      var ProloguePrefix$0 = $S(Prologue, $R$0($EXPECT($R93, "ProloguePrefix /[^]*/")));
       function ProloguePrefix(ctx, state) {
         return $EVENT(ctx, state, "ProloguePrefix", ProloguePrefix$0);
       }
-      var Indent$0 = $TR($EXPECT($R85, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var Indent$0 = $TR($EXPECT($R87, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         const level = getIndentLevel($0, module.config.tab);
         return {
           $loc,
@@ -15410,11 +15565,11 @@ ${input.slice(result.pos)}
       exports.WRHS = WRHS;
       exports.SingleLineBinaryOpRHS = SingleLineBinaryOpRHS;
       exports.RHS = RHS;
-      exports.ParenthesizedAssignment = ParenthesizedAssignment;
       exports.UnaryExpression = UnaryExpression;
       exports.UnaryWithoutParenthesizedAssignment = UnaryWithoutParenthesizedAssignment;
       exports.UnaryBody = UnaryBody;
       exports.UnaryWithoutParenthesizedAssignmentBody = UnaryWithoutParenthesizedAssignmentBody;
+      exports.ParenthesizedAssignment = ParenthesizedAssignment;
       exports.UnaryPostfix = UnaryPostfix;
       exports.TypePostfix = TypePostfix;
       exports.Tuple = Tuple;
@@ -15442,6 +15597,7 @@ ${input.slice(result.pos)}
       exports.PipelineTailItem = PipelineTailItem;
       exports.PrimaryExpression = PrimaryExpression;
       exports.ParenthesizedExpression = ParenthesizedExpression;
+      exports.PartialPlaceholder = PartialPlaceholder;
       exports.ClassDeclaration = ClassDeclaration;
       exports.ClassExpression = ClassExpression;
       exports.ClassBinding = ClassBinding;
@@ -15486,6 +15642,7 @@ ${input.slice(result.pos)}
       exports.MemberBracketContent = MemberBracketContent;
       exports.SliceParameters = SliceParameters;
       exports.AccessStart = AccessStart;
+      exports.ImplicitAccessStart = ImplicitAccessStart;
       exports.PropertyAccessModifier = PropertyAccessModifier;
       exports.PropertyAccess = PropertyAccess;
       exports.PropertyGlob = PropertyGlob;
@@ -15620,6 +15777,7 @@ ${input.slice(result.pos)}
       exports.BinaryOp = BinaryOp;
       exports._BinaryOp = _BinaryOp;
       exports.BinaryOpSymbol = BinaryOpSymbol;
+      exports.ActualIn = ActualIn;
       exports.CoffeeOfOp = CoffeeOfOp;
       exports.NotOp = NotOp;
       exports.Xor = Xor;
@@ -15900,6 +16058,7 @@ ${input.slice(result.pos)}
       exports.TripleTick = TripleTick;
       exports.Try = Try;
       exports.Typeof = Typeof;
+      exports.Undefined = Undefined;
       exports.Unless = Unless;
       exports.Until = Until;
       exports.Using = Using;
@@ -16116,6 +16275,13 @@ ${input.slice(result.pos)}
   var import_parser = __toESM(require_parser());
 
   // source/generate.civet
+  function stringify(node) {
+    try {
+      return JSON.stringify(node);
+    } catch (e) {
+      return `${node}`;
+    }
+  }
   function gen(node, options) {
     if (node === null || node === void 0) {
       return "";
@@ -16149,16 +16315,16 @@ ${input.slice(result.pos)}
       if (!node.children) {
         switch (node.type) {
           case "Ref": {
-            throw new Error(`Unpopulated ref ${JSON.stringify(node)}`);
+            throw new Error(`Unpopulated ref ${stringify(node)}`);
           }
         }
         debugger;
-        throw new Error(`Unknown node ${JSON.stringify(node)}`);
+        throw new Error(`Unknown node ${stringify(node)}`);
       }
       return gen(node.children, options);
     }
     debugger;
-    throw new Error(`Unknown node ${JSON.stringify(node)}`);
+    throw new Error(`Unknown node ${stringify(node)}`);
   }
   var generate_default = gen;
   function prune(node) {