@danielx/civet 0.6.90 → 0.6.91

package/dist/browser.js

@@ -41,6 +41,389 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // 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);
+          }
+          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] };
+    } else {
+      return node;
+    }
+  }
+  function isExistence(exp) {
+    if (exp?.type === "ParenthesizedExpression" && exp.implicit) {
+      exp = exp.expression;
+    }
+    if (exp?.type === "Existence") {
+      return exp;
+    }
+    ;
+    return;
+  }
+  function isRelationalOp(op) {
+    return op.relational || getPrecedence(op) === precedenceRelational;
+  }
+  function expandChainedComparisons([first, binops]) {
+    if (!binops.length) {
+      return [first];
+    }
+    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();
+      }
+    }
+    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;
+    }
+    function expandExistence(exp) {
+      let ref;
+      if (ref = isExistence(exp)) {
+        const existence = ref;
+        results.push(existence, " ", "&&", " ");
+        return existence.expression;
+      } else {
+        return exp;
+      }
+    }
+    ;
+  }
+  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"]
+      };
+    }
+  });
+
+  // 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);
+        }
+      }
+      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;
+    }
+    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/util.civet
   function addParentPointers(node, parent) {
     if (node == null)
@@ -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) {
@@ -872,325 +1345,22 @@ var Civet = (() => {
           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);
-          }
-          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] };
-    } else {
-      return node;
-    }
-  }
-  function isExistence(exp) {
-    if (exp.type === "ParenthesizedExpression" && exp.implicit) {
-      exp = exp.expression;
-    }
-    if (exp.type === "Existence") {
-      return exp;
-    }
-    ;
-    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;
-      }
-      i++;
-    }
-    if (op != null) {
-      processChains(op);
-    }
-    return results;
-    function processChains(op2) {
-      if (first && isRelationalOp(op2)) {
-        first = expandExistence(first);
-      }
-      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;
-      }
-      chains.length = 0;
-    }
-    function expandExistence(exp) {
-      const existence = isExistence(exp);
-      if (existence) {
-        results.push(existence, " ", "&&", " ");
-        return existence.expression;
-      }
-      return exp;
+        p.push(blockPrefix);
+        return insertRestSplices(blockPrefix, p, thisAssignments2);
+      });
     }
-    ;
+    insertRestSplices(statements, splices, thisAssignments);
+    return [splices, thisAssignments];
   }
-  var precedenceOrder, precedenceMap, precedenceStep, precedenceRelational, precedenceCustomDefault, asConst;
-  var init_op = __esm({
-    "source/parser/op.civet"() {
+  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();
-      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"]
-      };
     }
   });
 
@@ -2456,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];
@@ -2757,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");
@@ -2790,7 +2878,7 @@ var Civet = (() => {
       } else {
         const value = "StringLiteral" === start.subtype ? ["String.fromCharCode(", counterRef, ")"] : counterRef;
         blockPrefix = [
-          ["", forDeclaration, " = ", value, ";"]
+          ["", [forDeclaration, " = ", value], ";"]
         ];
       }
     } else if (forDeclaration) {
@@ -2802,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],
@@ -3294,7 +3382,9 @@ var Civet = (() => {
     isWhitespaceOrEmpty: () => isWhitespaceOrEmpty,
     lastAccessInCallExpression: () => lastAccessInCallExpression,
     literalValue: () => literalValue,
+    makeAmpersandBlockRHSBody: () => makeAmpersandBlockRHSBody,
     makeAmpersandFunction: () => makeAmpersandFunction,
+    makeAmpersandFunctionExpression: () => makeAmpersandFunctionExpression,
     makeEmptyBlock: () => makeEmptyBlock,
     makeExpressionStatement: () => makeExpressionStatement,
     makeGetterMethod: () => makeGetterMethod,
@@ -4257,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);
@@ -4301,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;
@@ -5011,11 +5139,11 @@ ${input.slice(result.pos)}
         WRHS,
         SingleLineBinaryOpRHS,
         RHS,
-        ParenthesizedAssignment,
         UnaryExpression,
         UnaryWithoutParenthesizedAssignment,
         UnaryBody,
         UnaryWithoutParenthesizedAssignmentBody,
+        ParenthesizedAssignment,
         UnaryPostfix,
         TypePostfix,
         Tuple,
@@ -5043,6 +5171,7 @@ ${input.slice(result.pos)}
         PipelineTailItem,
         PrimaryExpression,
         ParenthesizedExpression,
+        PartialPlaceholder,
         ClassDeclaration,
         ClassExpression,
         ClassBinding,
@@ -5503,6 +5632,7 @@ ${input.slice(result.pos)}
         TripleTick,
         Try,
         Typeof,
+        Undefined,
         Unless,
         Until,
         Using,
@@ -5903,124 +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("[=:]", "suy"));
-      var $R70 = $R(new RegExp("['\u2019]s", "suy"));
-      var $R71 = $R(new RegExp("\\s", "suy"));
-      var $R72 = $R(new RegExp("(?=[<])", "suy"));
-      var $R73 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
-      var $R74 = $R(new RegExp("[!+-]", "suy"));
-      var $R75 = $R(new RegExp("[\\s>]|\\/>", "suy"));
-      var $R76 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
-      var $R77 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
-      var $R78 = $R(new RegExp("[<>]", "suy"));
-      var $R79 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
-      var $R80 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
-      var $R81 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
-      var $R82 = $R(new RegExp("[+-]?", "suy"));
-      var $R83 = $R(new RegExp("(?=if|unless)", "suy"));
-      var $R84 = $R(new RegExp("#![^\\r\\n]*", "suy"));
-      var $R85 = $R(new RegExp("[\\t ]*", "suy"));
-      var $R86 = $R(new RegExp("[ \\t]*", "suy"));
-      var $R87 = $R(new RegExp("[\\s]*", "suy"));
-      var $R88 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
-      var $R89 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
-      var $R90 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
-      var $R91 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
-      var $R92 = $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({
@@ -6433,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;
@@ -6485,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];
@@ -6797,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$$);
       }
@@ -6832,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;
@@ -7265,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") + "`";
@@ -7288,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;
@@ -7342,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))
@@ -7826,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];
       });
@@ -7895,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$$);
       }
@@ -8330,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;
@@ -8373,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);
@@ -8544,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;
@@ -8552,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);
@@ -8988,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",
@@ -9014,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) {
@@ -9040,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,
@@ -9069,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) {
@@ -9170,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)));
@@ -9493,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;
@@ -9678,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",
@@ -9687,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$$);
       }
@@ -10057,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;
       });
@@ -10192,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,
@@ -10356,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];
@@ -10468,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) {
@@ -10601,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) {
@@ -10954,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 {
@@ -11783,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}"` };
       });
@@ -12036,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 };
       });
@@ -12052,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 };
       });
@@ -12097,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);
       }
@@ -12121,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) {
@@ -12162,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) {
@@ -12182,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) {
@@ -12239,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":
@@ -12257,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];
@@ -12276,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);
       }
@@ -12286,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) {
@@ -12334,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) {
@@ -12373,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) {
@@ -12385,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) {
@@ -12422,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) {
@@ -12445,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, '__ ""');
@@ -12453,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) {
@@ -12491,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);
       }
@@ -12609,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($R69, "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) {
@@ -12654,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($R70, "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: "." },
@@ -12775,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($R71, "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) {
@@ -13044,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) {
@@ -13115,7 +13228,7 @@ ${input.slice(result.pos)}
       function JSXImplicitFragment(ctx, state) {
         return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
       }
-      var JSXTag$0 = $T($S($EXPECT($R72, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
+      var JSXTag$0 = $T($S($EXPECT($R73, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
         return value[1];
       });
       function JSXTag(ctx, state) {
@@ -13165,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) {
@@ -13199,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);
       }
@@ -13220,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 {
@@ -13233,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;
       });
@@ -13250,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);
       }
@@ -13262,7 +13375,7 @@ ${input.slice(result.pos)}
       function JSXElementName(ctx, state) {
         return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
       }
-      var JSXIdentifierName$0 = $R$0($EXPECT($R73, "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);
       }
@@ -13441,7 +13554,7 @@ ${input.slice(result.pos)}
           class: $2
         };
       });
-      var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R74, "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";
@@ -13451,11 +13564,11 @@ ${input.slice(result.pos)}
       function JSXAttribute(ctx, state) {
         return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
       }
-      var JSXAttributeSpace$0 = $R$0($EXPECT($R75, "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($R76, "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) {
@@ -13489,7 +13602,7 @@ ${input.slice(result.pos)}
         }
         return [open, value, close];
       });
-      var JSXAttributeValue$4 = $R$0($EXPECT($R77, `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$$);
@@ -13502,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($R78, "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];
@@ -13519,7 +13632,7 @@ ${input.slice(result.pos)}
       function InlineJSXUnaryExpression(ctx, state) {
         return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
       }
-      var InlineJSXUnaryOp$0 = $TR($EXPECT($R79, "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) {
@@ -13729,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($R80, "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($R81, "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,
@@ -13916,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) {
@@ -14162,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($R82, "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);
       }
@@ -14222,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) {
@@ -14301,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) {
@@ -14332,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) {
@@ -14458,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($R83, "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) {
@@ -14538,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];
@@ -14658,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($R84, "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($R85, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R86, "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($R85, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R86, "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;
       });
@@ -14674,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($R87, "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",
@@ -14685,7 +14798,7 @@ ${input.slice(result.pos)}
       function CivetPrologueContent(ctx, state) {
         return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
       }
-      var CivetOption$0 = $TR($EXPECT($R88, "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();
@@ -14702,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($R85, "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($R89, "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);
       }
@@ -14722,13 +14835,13 @@ ${input.slice(result.pos)}
       function PrologueString(ctx, state) {
         return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
       }
-      var EOS$0 = $T($S($EXPECT($R90, "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($R91, "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) {
@@ -15300,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($R92, "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($R86, "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,
@@ -15452,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;
@@ -15484,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;
@@ -15944,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;
@@ -16160,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 "";
@@ -16193,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) {