@danielx/civet 0.8.4 → 0.8.5

package/dist/browser.js

@@ -1067,6 +1067,9 @@ ${body}`;
       expression = item;
     }
     if (isASTNodeObject(expression)) {
+      if (expression.token) {
+        return expression;
+      }
       if (expression.parenthesized) {
         return expression;
       }
@@ -1589,86 +1592,90 @@ ${body}`;
     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;
@@ -1753,6 +1760,34 @@ ${body}`;
         "\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]
@@ -1879,6 +1914,9 @@ ${body}`;
     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)));
@@ -5825,7 +5863,131 @@ ${js}`
     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 = {
@@ -5924,8 +6086,9 @@ ${js}`
         }
       }
     }
-    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 = [];
@@ -5996,14 +6159,14 @@ ${js}`
             });
           }
         }
-        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,
@@ -6045,6 +6208,33 @@ ${js}`
             ...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;
@@ -6055,9 +6245,9 @@ ${js}`
       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;
@@ -6149,8 +6339,8 @@ ${js}`
         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,
@@ -6160,7 +6350,7 @@ ${js}`
         };
       }
     });
-    let ref3;
+    let ref5;
     return {
       type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
       names: node.names,
@@ -6169,7 +6359,7 @@ ${js}`
         node.children[0],
         // {
         properties,
-        (ref3 = node.children)[ref3.length - 1]
+        (ref5 = node.children)[ref5.length - 1]
         // }
       ]
     };
@@ -6275,8 +6465,8 @@ ${js}`
         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, ")"]);
@@ -6290,15 +6480,15 @@ ${js}`
         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;
             }
             ;
@@ -6307,8 +6497,8 @@ ${js}`
           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;
           }
@@ -6324,7 +6514,7 @@ ${js}`
         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) {
@@ -6348,23 +6538,23 @@ ${js}`
       (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];
@@ -6389,8 +6579,8 @@ ${js}`
           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, "(");
@@ -6404,10 +6594,17 @@ ${js}`
           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(";
@@ -6430,9 +6627,9 @@ ${js}`
                 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--;
@@ -6465,7 +6662,7 @@ ${js}`
         }
         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",
@@ -6539,9 +6736,9 @@ ${js}`
       }
       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,
@@ -6580,27 +6777,27 @@ ${js}`
       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);
@@ -6626,14 +6823,14 @@ ${js}`
             ]
           });
         }
-      } 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(
@@ -6659,14 +6856,14 @@ ${js}`
     });
   }
   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);
@@ -6735,7 +6932,7 @@ ${js}`
     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);
@@ -6775,17 +6972,17 @@ ${js}`
     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);
@@ -6797,17 +6994,17 @@ ${js}`
         }
       }
     }
-    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 || []));
@@ -6830,11 +7027,11 @@ ${js}`
   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;
@@ -6853,10 +7050,10 @@ ${js}`
           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";
         }));
@@ -6932,11 +7129,11 @@ ${js}`
     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);
@@ -6957,16 +7154,16 @@ ${js}`
         }
         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":
@@ -6981,9 +7178,9 @@ ${js}`
         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);
       }
@@ -7028,8 +7225,8 @@ ${js}`
         }
       ];
     }
-    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];
     }
@@ -7054,9 +7251,9 @@ ${js}`
         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;
       }
@@ -7080,9 +7277,9 @@ ${js}`
         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;
       }
@@ -7500,7 +7697,7 @@ ${js}`
     IgnoreColon,
     TryStatement,
     CatchClause,
-    CatchBind,
+    CatchBinding,
     FinallyClause,
     CatchParameter,
     Condition,
@@ -7844,6 +8041,7 @@ ${js}`
     TypeSuffix,
     MaybeNestedType,
     MaybeNestedTypePrimary,
+    MaybeNestedTypeUnary,
     ReturnTypeSuffix,
     ReturnType,
     TypePredicate,
@@ -9902,11 +10100,12 @@ ${js}`
     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,
@@ -9923,78 +10122,57 @@ ${js}`
   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;
@@ -11663,6 +11841,7 @@ ${js}`
       left: { inclusive: true, raw: "" },
       right: { inclusive: false, raw: "." },
       increasing: void 0,
+      triple: true,
       children: []
     };
   });
@@ -13940,12 +14119,14 @@ ${js}`
     };
   });
   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];
@@ -14016,36 +14197,56 @@ ${js}`
   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;
@@ -14058,9 +14259,34 @@ ${js}`
   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$$);
   }
@@ -17466,6 +17692,19 @@ ${js}`
   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;
@@ -17520,7 +17759,7 @@ ${js}`
   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;