@danielx/civet 0.8.4 → 0.8.5

package/dist/main.mjs

@@ -1038,6 +1038,9 @@ function makeLeftHandSideExpression(expression) {
     expression = item;
   }
   if (isASTNodeObject(expression)) {
+    if (expression.token) {
+      return expression;
+    }
     if (expression.parenthesized) {
       return expression;
     }
@@ -1560,86 +1563,90 @@ function gatherBindingPatternTypeSuffix(pattern) {
   let count = 0;
   switch (pattern.type) {
     case "ArrayBindingPattern": {
-      const results = [];
-      for (let ref2 = pattern.elements, i2 = 0, len1 = ref2.length; i2 < len1; i2++) {
-        const elem = ref2[i2];
-        let { typeSuffix } = elem;
-        typeSuffix ??= elem.binding?.typeSuffix;
-        if (typeSuffix) {
-          count++;
-        }
-        let typeElement = [typeSuffix?.t, elem.delim];
-        if (typeSuffix?.optional) {
-          typeElement[0] = parenthesizeType(typeElement[0]);
-          typeElement.unshift("undefined |");
+      {
+        const results = [];
+        for (let ref2 = pattern.elements, i2 = 0, len1 = ref2.length; i2 < len1; i2++) {
+          const elem = ref2[i2];
+          let { typeSuffix } = elem;
+          typeSuffix ??= elem.binding?.typeSuffix;
+          if (typeSuffix) {
+            count++;
+          }
+          let typeElement = [typeSuffix?.t, elem.delim];
+          if (typeSuffix?.optional) {
+            typeElement[0] = parenthesizeType(typeElement[0]);
+            typeElement.unshift("undefined |");
+          }
+          if (elem.type === "BindingRestElement") {
+            typeElement[0] ??= "unknown[]";
+            typeElement.unshift(elem.dots);
+          } else {
+            typeElement[0] ??= "unknown";
+          }
+          results.push(typeElement);
         }
-        if (elem.type === "BindingRestElement") {
-          typeElement[0] ??= "unknown[]";
-          typeElement.unshift(elem.dots);
-        } else {
-          typeElement[0] ??= "unknown";
+        ;
+        const types = results;
+        if (count) {
+          const t = [": [", types, "]"];
+          pattern.typeSuffix = {
+            type: "TypeSuffix",
+            ts: true,
+            t,
+            children: [t]
+          };
         }
-        results.push(typeElement);
-      }
-      ;
-      const types = results;
-      if (count) {
-        const t = [": [", types, "]"];
-        pattern.typeSuffix = {
-          type: "TypeSuffix",
-          ts: true,
-          t,
-          children: [t]
-        };
       }
       ;
       break;
     }
     case "ObjectBindingPattern": {
-      let restType;
-      const results1 = [];
-      for (let ref3 = pattern.properties, i3 = 0, len22 = ref3.length; i3 < len22; i3++) {
-        const prop = ref3[i3];
-        let { typeSuffix } = prop;
-        typeSuffix ??= prop.value?.typeSuffix;
-        if (typeSuffix) {
-          count++;
-        }
-        typeSuffix ??= {
-          type: "TypeSuffix",
-          ts: true,
-          children: [": unknown"]
-        };
-        switch (prop.type) {
-          case "BindingProperty": {
-            const ws = prop.children.slice(0, prop.children.indexOf(prop.name));
-            results1.push([...ws, prop.name, typeSuffix, prop.delim]);
-            break;
-          }
-          case "AtBindingProperty": {
-            const ws = prop.children.slice(0, prop.children.indexOf(prop.binding));
-            results1.push([...ws, prop.ref.id, typeSuffix, prop.delim]);
-            break;
+      {
+        let restType;
+        const results1 = [];
+        for (let ref3 = pattern.properties, i3 = 0, len22 = ref3.length; i3 < len22; i3++) {
+          const prop = ref3[i3];
+          let { typeSuffix } = prop;
+          typeSuffix ??= prop.value?.typeSuffix;
+          if (typeSuffix) {
+            count++;
           }
-          case "BindingRestProperty": {
-            restType = prop.typeSuffix?.t;
-            continue;
+          typeSuffix ??= {
+            type: "TypeSuffix",
+            ts: true,
+            children: [": unknown"]
+          };
+          switch (prop.type) {
+            case "BindingProperty": {
+              const ws = prop.children.slice(0, prop.children.indexOf(prop.name));
+              results1.push([...ws, prop.name, typeSuffix, prop.delim]);
+              break;
+            }
+            case "AtBindingProperty": {
+              const ws = prop.children.slice(0, prop.children.indexOf(prop.binding));
+              results1.push([...ws, prop.ref.id, typeSuffix, prop.delim]);
+              break;
+            }
+            case "BindingRestProperty": {
+              restType = prop.typeSuffix?.t;
+              continue;
+            }
           }
         }
-      }
-      ;
-      const types = results1;
-      if (count) {
-        const t = ["{", types, "}"];
-        if (restType != null) {
-          t.push(" & ", parenthesizeType(trimFirstSpace(restType)));
+        ;
+        const types = results1;
+        if (count) {
+          const t = ["{", types, "}"];
+          if (restType != null) {
+            t.push(" & ", parenthesizeType(trimFirstSpace(restType)));
+          }
+          pattern.typeSuffix = {
+            type: "TypeSuffix",
+            ts: true,
+            t,
+            children: [": ", t]
+          };
         }
-        pattern.typeSuffix = {
-          type: "TypeSuffix",
-          ts: true,
-          t,
-          children: [": ", t]
-        };
       }
       ;
       break;
@@ -1709,6 +1716,34 @@ var declareHelper = {
       "\n"
     ]]);
   },
+  rslice(rsliceRef) {
+    const RSliceable = makeRef("RSliceable");
+    state.prelude.push(["", [
+      ts(["type ", RSliceable, "<R> = string | {length: number; slice(start: number, end: number): {reverse(): R}}\n"]),
+      preludeVar,
+      rsliceRef,
+      ts([": <R, T extends string | ", RSliceable, "<R>>(a: T, start?: number, end?: number) => T extends string ? string : T extends ", RSliceable, "<infer R> ? R : never"]),
+      " = ((a, start, end) => {\n",
+      "  const l = a.length\n",
+      "  start = ",
+      getHelperRef("modulo"),
+      "(start ?? -1, l)\n",
+      "  end = ",
+      getHelperRef("modulo"),
+      "((end ?? -1) + 1, l)\n",
+      "  if (typeof a === 'string') {\n",
+      `    let r = ""
+`,
+      "    for (let i = start; i >= end; --i) r += a[i]\n",
+      "    return r",
+      asAny,
+      "\n",
+      "  } else {\n",
+      "    return a.slice(end, start + 1).reverse()\n",
+      "  }\n",
+      "});\n"
+    ]]);
+  },
   div(divRef) {
     state.prelude.push(["", [
       // [indent, statement]
@@ -1835,6 +1870,9 @@ function getHelperRef(base) {
   declareHelper[base](ref);
   return state.helperRefs[base] = ref;
 }
+function peekHelperRef(base) {
+  return state.helperRefs[base];
+}
 function extractPreludeFor(node) {
   let helpers = new Set(Object.values(state.helperRefs));
   helpers = new Set(gatherRecursive(node, helpers.has.bind(helpers)));
@@ -5781,7 +5819,131 @@ function handleThisPrivateShorthands(value) {
   return [value, value.thisShorthand];
 }
 function processTryBlock($0) {
-  let [t, , b, c, e, f] = $0;
+  let [t, , b, cs, e, f] = $0;
+  let c;
+  let m;
+  if (cs.some(($) => (m = $.binding?.parameter, typeof m === "object" && m != null && "type" in m && m.type === "CatchPattern"))) {
+    const ref = makeRef("e");
+    const binding = {
+      type: "CatchBinding",
+      children: ["(", ref, ")"],
+      parameter: ref
+    };
+    const condition = {
+      type: "ParenthesizedExpression",
+      children: ["(", ref, ")"],
+      expression: ref
+    };
+    let defaultClause = false;
+    const clauses = cs.map((clause) => {
+      let ref1;
+      if ((ref1 = clause.binding?.parameter) && typeof ref1 === "object" && "type" in ref1 && ref1.type === "CatchPattern" && "patterns" in ref1) {
+        const { type, patterns } = ref1;
+        return {
+          type: "PatternClause",
+          patterns,
+          block: clause.block,
+          children: [patterns, clause.block]
+        };
+      } else {
+        defaultClause = true;
+        const parameter = clause.binding?.parameter;
+        if (parameter != null) {
+          assert.equal(
+            parameter.type,
+            "CatchParameter",
+            `Invalid catch parameter ${parameter.type}`
+          );
+          const { binding: pattern, typeSuffix } = parameter;
+          const initializer = {
+            type: "Initializer",
+            expression: ref,
+            children: ["", " = ", ref]
+          };
+          const bindings = [{
+            type: "Binding",
+            names: pattern.names,
+            pattern,
+            typeSuffix,
+            initializer,
+            children: [pattern, typeSuffix, initializer],
+            splices: [],
+            thisAssignments: []
+          }];
+          clause.block.expressions.unshift(["", {
+            type: "Declaration",
+            children: ["let", " ", bindings],
+            bindings,
+            names: bindings[0].names,
+            decl: "let"
+          }, ";"]);
+        }
+        return {
+          type: "DefaultClause",
+          block: clause.block,
+          children: ["default: ", clause.block]
+        };
+      }
+    });
+    if (!defaultClause) {
+      const expressions = [[
+        "",
+        {
+          type: "ThrowStatement",
+          children: ["throw", " ", ref]
+        }
+      ]];
+      const block2 = {
+        type: "BlockStatement",
+        expressions,
+        children: [" {", expressions, "}"],
+        bare: false
+      };
+      clauses.push({
+        type: "DefaultClause",
+        block: block2,
+        children: ["default: ", block2]
+      });
+    }
+    const caseBlock = {
+      type: "CaseBlock",
+      clauses,
+      children: [" {", clauses, "}"]
+    };
+    const patternSwitch = {
+      type: "SwitchStatement",
+      condition,
+      caseBlock,
+      children: ["switch", condition, caseBlock]
+    };
+    const block = {
+      type: "BlockStatement",
+      bare: false,
+      expressions: [["", patternSwitch]],
+      children: [" {", patternSwitch, "}"]
+    };
+    c = makeNode({
+      type: "CatchClause",
+      children: [
+        cs[0].children[0],
+        // whitespace
+        cs[0].children[1],
+        // catch token
+        binding,
+        block
+      ],
+      binding,
+      block
+    });
+  } else {
+    c = cs[0];
+    if (cs.length > 1) {
+      c = append(c, {
+        type: "Error",
+        message: "Only one catch clause allowed unless using pattern matching"
+      });
+    }
+  }
   if (!c && (e || !f)) {
     const emptyCatchBlock = makeEmptyBlock();
     c = {
@@ -5880,8 +6042,9 @@ function processCallMemberExpression(node) {
       }
     }
   }
-  for (let i = 0; i < children.length; i++) {
-    const glob = children[i];
+  for (let i3 = 0, len22 = children.length; i3 < len22; i3++) {
+    const i = i3;
+    const glob = children[i3];
     if (glob?.type === "PropertyGlob") {
       let prefix = children.slice(0, i);
       const parts = [];
@@ -5952,14 +6115,14 @@ function processCallMemberExpression(node) {
           });
         }
       }
-      let ref1;
+      let ref2;
       let object = {
         type: "ObjectExpression",
         children: [
           glob.object.children[0],
           // {
           ...parts,
-          (ref1 = glob.object.children)[ref1.length - 1]
+          (ref2 = glob.object.children)[ref2.length - 1]
           // whitespace and }
         ],
         properties: parts,
@@ -6001,6 +6164,33 @@ function processCallMemberExpression(node) {
           ...children.slice(i + 1)
         ]
       });
+    } else if (typeof glob === "object" && glob != null && "type" in glob && glob.type === "SliceExpression" && "reversed" in glob && glob.reversed === true) {
+      const args = [
+        { ...node, children: node.children.slice(0, i) },
+        { ...glob.children[0], token: ", " },
+        ...glob.children.slice(1, -1)
+      ];
+      let ref3;
+      return makeNode({
+        ...node,
+        children: [
+          {
+            type: "CallExpression",
+            children: [
+              getHelperRef("rslice"),
+              makeNode({
+                type: "Call",
+                args,
+                children: [
+                  "(",
+                  args,
+                  (ref3 = glob.children)[ref3.length - 1]
+                ]
+              })
+            ]
+          }
+        ]
+      });
     }
   }
   return node;
@@ -6011,9 +6201,9 @@ function replaceNode(node, newNode, parent) {
     throw new Error("replaceNode failed: node has no parent");
   }
   function recurse(children) {
-    for (let i3 = 0, len22 = children.length; i3 < len22; i3++) {
-      const i = i3;
-      const child = children[i3];
+    for (let i4 = 0, len3 = children.length; i4 < len3; i4++) {
+      const i = i4;
+      const child = children[i4];
       if (child === node) {
         children[i] = newNode;
         return true;
@@ -6105,8 +6295,8 @@ function convertNamedImportsToObject(node, pattern) {
       return { type: "Error", message: "cannot use `type` in dynamic import" };
     } else {
       const { source, binding } = specifier;
-      let ref2;
-      const delim = (ref2 = specifier.children)[ref2.length - 1];
+      let ref4;
+      const delim = (ref4 = specifier.children)[ref4.length - 1];
       return {
         type: pattern ? "BindingProperty" : "Property",
         name: source,
@@ -6116,7 +6306,7 @@ function convertNamedImportsToObject(node, pattern) {
       };
     }
   });
-  let ref3;
+  let ref5;
   return {
     type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
     names: node.names,
@@ -6125,7 +6315,7 @@ function convertNamedImportsToObject(node, pattern) {
       node.children[0],
       // {
       properties,
-      (ref3 = node.children)[ref3.length - 1]
+      (ref5 = node.children)[ref5.length - 1]
       // }
     ]
   };
@@ -6231,8 +6421,8 @@ function processAssignments(statements) {
       while (expr.type === "ParenthesizedExpression") {
         expr = expr.expression;
       }
-      let m;
-      if (m = expr.type, m === "AssignmentExpression" || m === "UpdateExpression") {
+      let m1;
+      if (m1 = expr.type, m1 === "AssignmentExpression" || m1 === "UpdateExpression") {
         if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
           pre.push("(");
           post.push([", ", lhs, ")"]);
@@ -6246,15 +6436,15 @@ function processAssignments(statements) {
       return;
     }
     const pre = [], post = [];
-    let ref4;
+    let ref6;
     switch (exp.type) {
       case "AssignmentExpression": {
         if (!exp.lhs)
           return;
         exp.lhs.forEach((lhsPart, i) => {
-          let ref5;
-          if (ref5 = extractAssignment(lhsPart[1])) {
-            const newLhs = ref5;
+          let ref7;
+          if (ref7 = extractAssignment(lhsPart[1])) {
+            const newLhs = ref7;
             return lhsPart[1] = newLhs;
           }
           ;
@@ -6263,8 +6453,8 @@ function processAssignments(statements) {
         break;
       }
       case "UpdateExpression": {
-        if (ref4 = extractAssignment(exp.assigned)) {
-          const newLhs = ref4;
+        if (ref6 = extractAssignment(exp.assigned)) {
+          const newLhs = ref6;
           const i = exp.children.indexOf(exp.assigned);
           exp.assigned = exp.children[i] = newLhs;
         }
@@ -6280,7 +6470,7 @@ function processAssignments(statements) {
       const { assigned } = exp;
       const ref = makeRef();
       const newMemberExp = unchainOptionalMemberExpression(assigned, ref, (children) => {
-        return exp.children.map(($) => $ === assigned ? children : $);
+        return exp.children.map(($3) => $3 === assigned ? children : $3);
       });
       if (newMemberExp !== assigned) {
         if (newMemberExp.usesRef) {
@@ -6304,23 +6494,23 @@ function processAssignments(statements) {
     (exp) => {
       let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length;
       let block;
-      let ref6;
-      if (exp.parent?.type === "BlockStatement" && !(ref6 = $1[$1.length - 1])?.[ref6.length - 1]?.special) {
+      let ref8;
+      if (exp.parent?.type === "BlockStatement" && !(ref8 = $1[$1.length - 1])?.[ref8.length - 1]?.special) {
         block = makeBlockFragment();
-        let ref7;
-        if (ref7 = prependStatementExpressionBlock(
+        let ref9;
+        if (ref9 = prependStatementExpressionBlock(
           { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
           block
         )) {
-          const ref = ref7;
-          exp.children = exp.children.map(($3) => $3 === $2 ? ref : $3);
+          const ref = ref9;
+          exp.children = exp.children.map(($4) => $4 === $2 ? ref : $4);
           $2 = ref;
         } else {
           block = void 0;
         }
       }
-      let ref8;
-      if ($1.some(($4) => (ref8 = $4)[ref8.length - 1].special)) {
+      let ref10;
+      if ($1.some(($5) => (ref10 = $5)[ref10.length - 1].special)) {
         if ($1.length !== 1)
           throw new Error("Only one assignment with id= is allowed");
         const [, lhs, , op] = $1[0];
@@ -6345,8 +6535,8 @@ function processAssignments(statements) {
         if (!(op.token === "=")) {
           continue;
         }
-        let m1;
-        if (m1 = lhs.type, m1 === "ObjectExpression" || m1 === "ObjectBindingPattern") {
+        let m2;
+        if (m2 = lhs.type, m2 === "ObjectExpression" || m2 === "ObjectBindingPattern") {
           if (!wrapped) {
             wrapped = true;
             lhs.children.splice(0, 0, "(");
@@ -6360,10 +6550,17 @@ function processAssignments(statements) {
         const lastAssignment = $1[i];
         if (lastAssignment[3].token === "=") {
           const lhs = lastAssignment[1];
-          let m2;
+          let m3;
           if (lhs.type === "MemberExpression") {
             const members = lhs.children;
             const lastMember = members[members.length - 1];
+            if (typeof lastMember === "object" && lastMember != null && "type" in lastMember && lastMember.type === "CallExpression" && "children" in lastMember && Array.isArray(lastMember.children) && lastMember.children.length >= 1 && lastMember.children[0] === peekHelperRef("rslice")) {
+              lastMember.children.push({
+                type: "Error",
+                message: "Slice range cannot be decreasing in assignment"
+              });
+              break;
+            }
             if (lastMember.type === "SliceExpression") {
               const { start, end, children: c } = lastMember;
               c[0].token = ".splice(";
@@ -6386,9 +6583,9 @@ function processAssignments(statements) {
               exp.names = [];
               break;
             }
-          } else if (m2 = lhs.type, m2 === "ObjectBindingPattern" || m2 === "ArrayBindingPattern") {
+          } else if (m3 = lhs.type, m3 === "ObjectBindingPattern" || m3 === "ArrayBindingPattern") {
             processBindingPatternLHS(lhs, tail);
-            gatherRecursiveAll(lhs, ($5) => $5.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare));
+            gatherRecursiveAll(lhs, ($6) => $6.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare));
           }
         }
         i--;
@@ -6421,7 +6618,7 @@ function processAssignments(statements) {
       }
       if (refsToDeclare.size) {
         if (exp.hoistDec) {
-          exp.hoistDec.children.push([...refsToDeclare].map(($6) => [",", $6]));
+          exp.hoistDec.children.push([...refsToDeclare].map(($7) => [",", $7]));
         } else {
           exp.hoistDec = {
             type: "Declaration",
@@ -6495,9 +6692,9 @@ function unchainOptionalMemberExpression(exp, ref, innerExp) {
     }
     j++;
   }
-  let ref9;
-  if (ref9 = conditions.length) {
-    const l = ref9;
+  let ref11;
+  if (ref11 = conditions.length) {
+    const l = ref11;
     const cs = flatJoin(conditions, " && ");
     return {
       ...exp,
@@ -6536,27 +6733,27 @@ function processTypes(node) {
     if (!unary.suffix.length) {
       return;
     }
-    let ref10;
-    let m3;
-    if (m3 = (ref10 = unary.suffix)[ref10.length - 1], typeof m3 === "object" && m3 != null && "token" in m3 && m3.token === "?") {
-      const { token } = m3;
+    let ref12;
+    let m4;
+    if (m4 = (ref12 = unary.suffix)[ref12.length - 1], typeof m4 === "object" && m4 != null && "token" in m4 && m4.token === "?") {
+      const { token } = m4;
       let last;
       let count = 0;
-      let ref11;
-      while (unary.suffix.length && (ref11 = unary.suffix)[ref11.length - 1]?.token === "?") {
+      let ref13;
+      while (unary.suffix.length && (ref13 = unary.suffix)[ref13.length - 1]?.token === "?") {
         last = unary.suffix.pop();
         count++;
       }
-      let ref12;
-      while (unary.suffix.length && (ref12 = unary.suffix)[ref12.length - 1]?.type === "NonNullAssertion") {
+      let ref14;
+      while (unary.suffix.length && (ref14 = unary.suffix)[ref14.length - 1]?.type === "NonNullAssertion") {
         unary.suffix.pop();
       }
-      let ref13;
+      let ref15;
       if (unary.suffix.length || unary.prefix.length)
-        ref13 = unary;
+        ref15 = unary;
       else
-        ref13 = unary.t;
-      const t = ref13;
+        ref15 = unary.t;
+      const t = ref15;
       if (unary.parent?.type === "TypeTuple") {
         if (count === 1) {
           unary.suffix.push(last);
@@ -6582,14 +6779,14 @@ function processTypes(node) {
           ]
         });
       }
-    } else if (typeof m3 === "object" && m3 != null && "type" in m3 && m3.type === "NonNullAssertion") {
-      const { type } = m3;
-      let ref14;
-      while (unary.suffix.length && (ref14 = unary.suffix)[ref14.length - 1]?.type === "NonNullAssertion") {
+    } else if (typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "NonNullAssertion") {
+      const { type } = m4;
+      let ref16;
+      while (unary.suffix.length && (ref16 = unary.suffix)[ref16.length - 1]?.type === "NonNullAssertion") {
         unary.suffix.pop();
       }
-      let ref15;
-      while (unary.suffix.length && (ref15 = unary.suffix)[ref15.length - 1]?.token === "?") {
+      let ref17;
+      while (unary.suffix.length && (ref17 = unary.suffix)[ref17.length - 1]?.token === "?") {
         unary.suffix.pop();
       }
       const t = trimFirstSpace(
@@ -6615,14 +6812,14 @@ function processTypes(node) {
   });
 }
 function processStatementExpressions(statements) {
-  gatherRecursiveAll(statements, ($7) => $7.type === "StatementExpression").forEach((_exp) => {
+  gatherRecursiveAll(statements, ($8) => $8.type === "StatementExpression").forEach((_exp) => {
     const exp = _exp;
     const { statement } = exp;
-    let ref16;
+    let ref18;
     switch (statement.type) {
       case "IfStatement": {
-        if (ref16 = expressionizeIfStatement(statement)) {
-          const expression = ref16;
+        if (ref18 = expressionizeIfStatement(statement)) {
+          const expression = ref18;
           return replaceNode(statement, expression, exp);
         } else {
           return replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -6691,7 +6888,7 @@ function processProgram(root) {
   if (config2.iife || config2.repl) {
     rootIIFE = wrapIIFE(root.expressions, root.topLevelAwait);
     const newExpressions = [["", rootIIFE]];
-    root.children = root.children.map(($8) => $8 === root.expressions ? newExpressions : $8);
+    root.children = root.children.map(($9) => $9 === root.expressions ? newExpressions : $9);
     root.expressions = newExpressions;
   }
   addParentPointers(root);
@@ -6731,17 +6928,17 @@ async function processProgramAsync(root) {
   await processComptime(statements);
 }
 function processRepl(root, rootIIFE) {
-  const topBlock = gatherRecursive(rootIIFE, ($9) => $9.type === "BlockStatement")[0];
+  const topBlock = gatherRecursive(rootIIFE, ($10) => $10.type === "BlockStatement")[0];
   let i = 0;
-  for (let ref17 = gatherRecursiveWithinFunction(topBlock, ($10) => $10.type === "Declaration"), i4 = 0, len3 = ref17.length; i4 < len3; i4++) {
-    const decl = ref17[i4];
+  for (let ref19 = gatherRecursiveWithinFunction(topBlock, ($11) => $11.type === "Declaration"), i5 = 0, len4 = ref19.length; i5 < len4; i5++) {
+    const decl = ref19[i5];
     if (decl.parent === topBlock || decl.decl === "var") {
       decl.children.shift();
       root.expressions.splice(i++, 0, ["", `var ${decl.names.join(",")};`]);
     }
   }
-  for (let ref18 = gatherRecursive(topBlock, ($11) => $11.type === "FunctionExpression"), i5 = 0, len4 = ref18.length; i5 < len4; i5++) {
-    const func = ref18[i5];
+  for (let ref20 = gatherRecursive(topBlock, ($12) => $12.type === "FunctionExpression"), i6 = 0, len5 = ref20.length; i6 < len5; i6++) {
+    const func = ref20[i6];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
         replaceNode(func, void 0);
@@ -6753,17 +6950,17 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref19 = gatherRecursiveWithinFunction(topBlock, ($12) => $12.type === "ClassExpression"), i6 = 0, len5 = ref19.length; i6 < len5; i6++) {
-    const classExp = ref19[i6];
-    let m4;
-    if (classExp.name && classExp.parent === topBlock || (m4 = classExp.parent, typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "ReturnStatement" && "parent" in m4 && m4.parent === topBlock)) {
+  for (let ref21 = gatherRecursiveWithinFunction(topBlock, ($13) => $13.type === "ClassExpression"), i7 = 0, len6 = ref21.length; i7 < len6; i7++) {
+    const classExp = ref21[i7];
+    let m5;
+    if (classExp.name && classExp.parent === topBlock || (m5 = classExp.parent, typeof m5 === "object" && m5 != null && "type" in m5 && m5.type === "ReturnStatement" && "parent" in m5 && m5.parent === topBlock)) {
       classExp.children.unshift(classExp.name, "=");
       root.expressions.splice(i++, 0, ["", `var ${classExp.name};`]);
     }
   }
 }
 function populateRefs(statements) {
-  const refNodes = gatherRecursive(statements, ($13) => $13.type === "Ref");
+  const refNodes = gatherRecursive(statements, ($14) => $14.type === "Ref");
   if (refNodes.length) {
     const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
     const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
@@ -6786,11 +6983,11 @@ function populateRefs(statements) {
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
   const liftedIfs = /* @__PURE__ */ new Set();
-  gatherRecursiveAll(statements, ($14) => $14.type === "Placeholder").forEach((_exp) => {
+  gatherRecursiveAll(statements, ($15) => $15.type === "Placeholder").forEach((_exp) => {
     const exp = _exp;
     let ancestor;
     if (exp.subtype === ".") {
-      ({ ancestor } = findAncestor(exp, ($15) => $15.type === "Call"));
+      ({ ancestor } = findAncestor(exp, ($16) => $16.type === "Call"));
       ancestor = ancestor?.parent;
       while (ancestor?.parent?.type === "UnaryExpression" || ancestor?.parent?.type === "NewExpression") {
         ancestor = ancestor.parent;
@@ -6809,10 +7006,10 @@ function processPlaceholders(statements) {
         if (type === "IfStatement") {
           liftedIfs.add(ancestor2);
         }
-        let m5;
         let m6;
+        let m7;
         return type === "Call" || // Block, except for if/else blocks when condition already lifted
-        type === "BlockStatement" && !((m5 = ancestor2.parent, typeof m5 === "object" && m5 != null && "type" in m5 && m5.type === "IfStatement") && liftedIfs.has(ancestor2.parent)) && !((m6 = ancestor2.parent, typeof m6 === "object" && m6 != null && "type" in m6 && m6.type === "ElseClause" && "parent" in m6 && typeof m6.parent === "object" && m6.parent != null && "type" in m6.parent && m6.parent.type === "IfStatement") && liftedIfs.has(ancestor2.parent.parent)) || type === "PipelineExpression" || // Declaration
+        type === "BlockStatement" && !((m6 = ancestor2.parent, typeof m6 === "object" && m6 != null && "type" in m6 && m6.type === "IfStatement") && liftedIfs.has(ancestor2.parent)) && !((m7 = ancestor2.parent, typeof m7 === "object" && m7 != null && "type" in m7 && m7.type === "ElseClause" && "parent" in m7 && typeof m7.parent === "object" && m7.parent != null && "type" in m7.parent && m7.parent.type === "IfStatement") && liftedIfs.has(ancestor2.parent.parent)) || type === "PipelineExpression" || // Declaration
         type === "Initializer" || // Right-hand side of assignment
         type === "AssignmentExpression" && findChildIndex(ancestor2, child2) === ancestor2.children.indexOf(ancestor2.expression) || type === "ReturnStatement" || type === "YieldExpression";
       }));
@@ -6888,11 +7085,11 @@ function processPlaceholders(statements) {
   for (const [ancestor, placeholders] of placeholderMap) {
     let ref = makeRef("$");
     let typeSuffix;
-    for (let i7 = 0, len6 = placeholders.length; i7 < len6; i7++) {
-      const placeholder = placeholders[i7];
+    for (let i8 = 0, len7 = placeholders.length; i8 < len7; i8++) {
+      const placeholder = placeholders[i8];
       typeSuffix ??= placeholder.typeSuffix;
-      let ref20;
-      replaceNode((ref20 = placeholder.children)[ref20.length - 1], ref);
+      let ref22;
+      replaceNode((ref22 = placeholder.children)[ref22.length - 1], ref);
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -6913,16 +7110,16 @@ function processPlaceholders(statements) {
       }
       case "PipelineExpression": {
         const i = findChildIndex(parent, ancestor);
-        let ref21;
+        let ref23;
         if (i === 1) {
-          ref21 = ancestor === parent.children[i];
+          ref23 = ancestor === parent.children[i];
         } else if (i === 2) {
-          ref21 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          ref23 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
         } else {
-          ref21 = void 0;
+          ref23 = void 0;
         }
         ;
-        outer = ref21;
+        outer = ref23;
         break;
       }
       case "AssignmentExpression":
@@ -6937,9 +7134,9 @@ function processPlaceholders(statements) {
       fnExp = makeLeftHandSideExpression(fnExp);
     }
     replaceNode(ancestor, fnExp, parent);
-    let ref22;
-    if (ref22 = getTrimmingSpace(body)) {
-      const ws = ref22;
+    let ref24;
+    if (ref24 = getTrimmingSpace(body)) {
+      const ws = ref24;
       inplaceInsertTrimmingSpace(body, "");
       inplacePrepend(ws, fnExp);
     }
@@ -6984,8 +7181,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  let ref23;
-  if (Array.isArray(rest.delim) && (ref23 = rest.delim)[ref23.length - 1]?.token === ",") {
+  let ref25;
+  if (Array.isArray(rest.delim) && (ref25 = rest.delim)[ref25.length - 1]?.token === ",") {
     rest.delim = rest.delim.slice(0, -1);
     rest.children = [...rest.children.slice(0, -1), rest.delim];
   }
@@ -7010,9 +7207,9 @@ function replaceNodes(root, predicate, replacer) {
       return root;
     }
   }
-  for (let i8 = 0, len7 = array.length; i8 < len7; i8++) {
-    const i = i8;
-    const node = array[i8];
+  for (let i9 = 0, len8 = array.length; i9 < len8; i9++) {
+    const i = i9;
+    const node = array[i9];
     if (!(node != null)) {
       return;
     }
@@ -7036,9 +7233,9 @@ function replaceNodesRecursive(root, predicate, replacer) {
       return root;
     }
   }
-  for (let i9 = 0, len8 = array.length; i9 < len8; i9++) {
-    const i = i9;
-    const node = array[i9];
+  for (let i10 = 0, len9 = array.length; i10 < len9; i10++) {
+    const i = i10;
+    const node = array[i10];
     if (!(node != null)) {
       continue;
     }
@@ -7456,7 +7653,7 @@ var grammar = {
   IgnoreColon,
   TryStatement,
   CatchClause,
-  CatchBind,
+  CatchBinding,
   FinallyClause,
   CatchParameter,
   Condition,
@@ -7800,6 +7997,7 @@ var grammar = {
   TypeSuffix,
   MaybeNestedType,
   MaybeNestedTypePrimary,
+  MaybeNestedTypeUnary,
   ReturnTypeSuffix,
   ReturnType,
   TypePredicate,
@@ -9858,11 +10056,12 @@ var MemberBracketContent$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(OpenBracke
   var ws = $3;
   var close = $4;
   if (expression.type === "SliceParameters") {
-    const { start, end, children } = expression;
+    const { start, end, reversed, children } = expression;
     return {
       type: "SliceExpression",
       start,
       end,
+      reversed,
       children: [
         { ...open, token: ".slice(" },
         ...children,
@@ -9879,78 +10078,57 @@ var MemberBracketContent$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(OpenBracke
 function MemberBracketContent(ctx, state2) {
   return (0, import_lib4.$EVENT)(ctx, state2, "MemberBracketContent", MemberBracketContent$0);
 }
-var SliceParameters$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(Expression, __, RangeDots, (0, import_lib4.$E)(Expression)), function($skip, $loc, $0, $1, $2, $3, $4) {
-  var start = $1;
-  var ws = $2;
-  var dots = $3;
-  var end = $4;
+var SliceParameters$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(Loc, (0, import_lib4.$E)(Expression), __, RangeDots, Loc, (0, import_lib4.$E)(Expression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+  var ls = $1;
+  var start = $2;
+  var ws = $3;
+  var dots = $4;
+  var le = $5;
+  var end = $6;
+  const reversed = dots.increasing === false;
+  const sign = reversed ? "-" : "+";
   let children;
+  start ??= {
+    $loc: ls.$loc,
+    token: reversed ? "-1" : "0"
+  };
+  if (!end) {
+    if (reversed) {
+      end = {
+        $loc: le.$loc,
+        token: "0"
+      };
+    } else if (!dots.right.inclusive && !dots.triple) {
+      end = {
+        $loc: le.$loc,
+        token: "-1"
+      };
+    }
+  }
   if (!dots.left.inclusive) {
-    start = ["1 + ", makeLeftHandSideExpression(start)];
+    start = [makeLeftHandSideExpression(start), ` ${sign} 1`];
   }
   if (end) {
     const inc = [];
     if (dots.right.inclusive) {
-      end = ["1 + ", makeLeftHandSideExpression(end)];
-      inc.push(" || 1/0");
+      end = [makeLeftHandSideExpression(end), ` ${sign} 1`];
+      if (!reversed)
+        inc.push(" || 1/0");
     }
     children = [start, [...ws, dots.children[0], { token: ", ", $loc: dots.$loc }], [dots.children[1], end, ...inc]];
   } else {
     children = [start, ws];
   }
-  if (dots.increasing === false) {
-    children.push({
-      type: "Error",
-      message: "Slice range cannot be decreasing",
-      $loc: dots.$loc
-    });
-  }
   return {
     type: "SliceParameters",
     start,
     end,
+    reversed,
     children
   };
 });
-var SliceParameters$1 = (0, import_lib4.$TS)((0, import_lib4.$S)(Loc, __, (0, import_lib4.$C)(DotDotDot, DotDot), Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
-  var l = $1;
-  var ws = $2;
-  var sep = $3;
-  var end = $4;
-  const inclusive = sep.token === "..";
-  const inc = [];
-  if (inclusive) {
-    end = ["1 + ", end];
-    inc.push(" || 1/0");
-  }
-  const start = {
-    $loc: l.$loc,
-    token: "0"
-  };
-  return {
-    type: "SliceParameters",
-    start,
-    end,
-    children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
-  };
-});
-var SliceParameters$2 = (0, import_lib4.$TS)((0, import_lib4.$S)(Loc, __, (0, import_lib4.$C)(DotDot, DotDotDot), (0, import_lib4.$Y)((0, import_lib4.$S)(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
-  var l = $1;
-  var ws = $2;
-  const start = {
-    $loc: l.$loc,
-    token: "0"
-  };
-  return {
-    type: "SliceParameters",
-    start,
-    end: void 0,
-    children: [start, ws]
-  };
-});
-var SliceParameters$$ = [SliceParameters$0, SliceParameters$1, SliceParameters$2];
 function SliceParameters(ctx, state2) {
-  return (0, import_lib4.$EVENT_C)(ctx, state2, "SliceParameters", SliceParameters$$);
+  return (0, import_lib4.$EVENT)(ctx, state2, "SliceParameters", SliceParameters$0);
 }
 var AccessStart$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$E)(PropertyAccessModifier), Dot, (0, import_lib4.$N)((0, import_lib4.$EXPECT)($R11, "AccessStart /[.\\s]/"))), function($skip, $loc, $0, $1, $2, $3) {
   var modifier = $1;
@@ -11619,6 +11797,7 @@ var RangeDots$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(DotDotDot), function(
     left: { inclusive: true, raw: "" },
     right: { inclusive: false, raw: "." },
     increasing: void 0,
+    triple: true,
     children: []
   };
 });
@@ -13896,12 +14075,14 @@ var CaseClause$3 = (0, import_lib4.$TS)((0, import_lib4.$S)(Default, ImpliedColo
   };
 });
 var CaseClause$4 = (0, import_lib4.$TS)((0, import_lib4.$S)(Else, ImpliedColon, (0, import_lib4.$C)(ThenClause, BracedBlock, EmptyBlock)), function($skip, $loc, $0, $1, $2, $3) {
+  var e = $1;
+  var colon = $2;
   var block = $3;
-  $1.token = "default";
+  e = { ...e, token: "default" };
   return {
     type: "DefaultClause",
     block,
-    children: $0
+    children: [e, colon, block]
   };
 });
 var CaseClause$$ = [CaseClause$0, CaseClause$1, CaseClause$2, CaseClause$3, CaseClause$4];
@@ -13972,36 +14153,56 @@ var IgnoreColon$0 = (0, import_lib4.$TV)((0, import_lib4.$E)((0, import_lib4.$S)
 function IgnoreColon(ctx, state2) {
   return (0, import_lib4.$EVENT)(ctx, state2, "IgnoreColon", IgnoreColon$0);
 }
-var TryStatement$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(Try, (0, import_lib4.$N)((0, import_lib4.$EXPECT)($L16, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, (0, import_lib4.$E)(CatchClause), (0, import_lib4.$E)(ElseClause), (0, import_lib4.$E)(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var TryStatement$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(Try, (0, import_lib4.$N)((0, import_lib4.$EXPECT)($L16, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, (0, import_lib4.$Q)(CatchClause), (0, import_lib4.$E)(ElseClause), (0, import_lib4.$E)(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   return processTryBlock($0);
 });
 function TryStatement(ctx, state2) {
   return (0, import_lib4.$EVENT)(ctx, state2, "TryStatement", TryStatement$0);
 }
-var CatchClause$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$C)(Nested, _), Catch, (0, import_lib4.$E)(CatchBind), (0, import_lib4.$C)(BracedThenClause, BracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4) {
+var CatchClause$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$C)(Nested, _), Catch, (0, import_lib4.$E)(CatchBinding), (0, import_lib4.$C)(BracedThenClause, BracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var binding = $3;
   var block = $4;
   return {
     type: "CatchClause",
     children: $0,
-    block
+    block,
+    binding
   };
 });
 function CatchClause(ctx, state2) {
   return (0, import_lib4.$EVENT)(ctx, state2, "CatchClause", CatchClause$0);
 }
-var CatchBind$0 = (0, import_lib4.$S)((0, import_lib4.$E)(_), OpenParen, __, CatchParameter, __, CloseParen);
-var CatchBind$1 = (0, import_lib4.$TS)((0, import_lib4.$S)(_, InsertOpenParen, (0, import_lib4.$N)(EOS), ForbidIndentedApplication, (0, import_lib4.$E)(CatchParameter), RestoreIndentedApplication, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+var CatchBinding$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$E)(_), OpenParen, __, AllowAll, (0, import_lib4.$E)(CatchParameter), RestoreAll, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+  var ws1 = $1;
+  var open = $2;
+  var ws2 = $3;
+  var parameter = $5;
+  var ws3 = $7;
+  var close = $8;
+  if (!parameter)
+    return $skip;
+  return {
+    type: "CatchBinding",
+    parameter,
+    children: [ws1, open, ws2, parameter, ws3, close]
+  };
+});
+var CatchBinding$1 = (0, import_lib4.$TS)((0, import_lib4.$S)(_, InsertOpenParen, (0, import_lib4.$N)(EOS), ForbidIndentedApplication, (0, import_lib4.$E)(CatchParameter), RestoreIndentedApplication, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var ws = $1;
   var open = $2;
-  var param = $5;
+  var parameter = $5;
   var close = $7;
-  if (!param)
+  if (!parameter)
     return $skip;
-  return [ws, open, param, close];
+  return {
+    type: "CatchBinding",
+    parameter,
+    children: [ws, open, parameter, close]
+  };
 });
-var CatchBind$$ = [CatchBind$0, CatchBind$1];
-function CatchBind(ctx, state2) {
-  return (0, import_lib4.$EVENT_C)(ctx, state2, "CatchBind", CatchBind$$);
+var CatchBinding$$ = [CatchBinding$0, CatchBinding$1];
+function CatchBinding(ctx, state2) {
+  return (0, import_lib4.$EVENT_C)(ctx, state2, "CatchBinding", CatchBinding$$);
 }
 var FinallyClause$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$C)(Nested, _), Finally, (0, import_lib4.$C)(BracedThenClause, BracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3) {
   var block = $3;
@@ -14014,9 +14215,34 @@ var FinallyClause$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$
 function FinallyClause(ctx, state2) {
   return (0, import_lib4.$EVENT)(ctx, state2, "FinallyClause", FinallyClause$0);
 }
-var CatchParameter$0 = (0, import_lib4.$S)(BindingIdentifier, (0, import_lib4.$E)(TypeSuffix));
-var CatchParameter$1 = (0, import_lib4.$S)(BindingPattern, (0, import_lib4.$E)(TypeSuffix));
-var CatchParameter$$ = [CatchParameter$0, CatchParameter$1];
+var CatchParameter$0 = (0, import_lib4.$TS)((0, import_lib4.$S)(BindingIdentifier, (0, import_lib4.$E)(TypeSuffix)), function($skip, $loc, $0, $1, $2) {
+  var binding = $1;
+  var typeSuffix = $2;
+  return {
+    type: "CatchParameter",
+    binding,
+    typeSuffix,
+    children: $0
+  };
+});
+var CatchParameter$1 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$C)(ObjectBindingPattern, ArrayBindingPattern), TypeSuffix), function($skip, $loc, $0, $1, $2) {
+  var binding = $1;
+  var typeSuffix = $2;
+  return {
+    type: "CatchParameter",
+    binding,
+    typeSuffix,
+    children: [binding, typeSuffix]
+  };
+});
+var CatchParameter$2 = (0, import_lib4.$TS)((0, import_lib4.$S)(PatternExpressionList), function($skip, $loc, $0, $1) {
+  return {
+    type: "CatchPattern",
+    children: $0,
+    patterns: $1
+  };
+});
+var CatchParameter$$ = [CatchParameter$0, CatchParameter$1, CatchParameter$2];
 function CatchParameter(ctx, state2) {
   return (0, import_lib4.$EVENT_C)(ctx, state2, "CatchParameter", CatchParameter$$);
 }
@@ -17422,6 +17648,19 @@ var MaybeNestedTypePrimary$$ = [MaybeNestedTypePrimary$0, MaybeNestedTypePrimary
 function MaybeNestedTypePrimary(ctx, state2) {
   return (0, import_lib4.$EVENT_C)(ctx, state2, "MaybeNestedTypePrimary", MaybeNestedTypePrimary$$);
 }
+var MaybeNestedTypeUnary$0 = NestedTypeBulletedTuple;
+var MaybeNestedTypeUnary$1 = NestedInterfaceBlock;
+var MaybeNestedTypeUnary$2 = NestedTypeBinaryChain;
+var MaybeNestedTypeUnary$3 = (0, import_lib4.$TS)((0, import_lib4.$S)(PushIndent, (0, import_lib4.$E)((0, import_lib4.$S)(Nested, Type)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+  if (!$2)
+    return $skip;
+  return $2;
+});
+var MaybeNestedTypeUnary$4 = (0, import_lib4.$S)(NotDedented, TypeUnary);
+var MaybeNestedTypeUnary$$ = [MaybeNestedTypeUnary$0, MaybeNestedTypeUnary$1, MaybeNestedTypeUnary$2, MaybeNestedTypeUnary$3, MaybeNestedTypeUnary$4];
+function MaybeNestedTypeUnary(ctx, state2) {
+  return (0, import_lib4.$EVENT_C)(ctx, state2, "MaybeNestedTypeUnary", MaybeNestedTypeUnary$$);
+}
 var ReturnTypeSuffix$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$E)(_), (0, import_lib4.$E)(QuestionMark), (0, import_lib4.$E)(_), Colon, ReturnType), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var optional = $2;
   var t = $5;
@@ -17476,7 +17715,7 @@ var Type$0 = TypeWithPostfix;
 function Type(ctx, state2) {
   return (0, import_lib4.$EVENT)(ctx, state2, "Type", Type$0);
 }
-var TypeBinary$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$E)((0, import_lib4.$S)(NotDedented, TypeBinaryOp, __)), TypeUnary, (0, import_lib4.$Q)((0, import_lib4.$S)(NotDedented, TypeBinaryOp, __, TypeUnary))), function($skip, $loc, $0, $1, $2, $3) {
+var TypeBinary$0 = (0, import_lib4.$TS)((0, import_lib4.$S)((0, import_lib4.$E)((0, import_lib4.$S)(NotDedented, TypeBinaryOp, __)), TypeUnary, (0, import_lib4.$Q)((0, import_lib4.$S)(NotDedented, TypeBinaryOp, MaybeNestedTypeUnary))), function($skip, $loc, $0, $1, $2, $3) {
   var optionalPrefix = $1;
   var t = $2;
   var ops = $3;