@delance/builder 0.2.1 → 0.2.3

package/dist/index.js

@@ -12,10 +12,10 @@ var __export = (target, all) => {
 // transform/webcrack/index.ts
 import {getQuickJS, shouldInterruptAfterDeadline} from "quickjs-emscripten";
 
-// node_modules/webcrack/src/deobfuscate/index.ts
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/webcrack/src/deobfuscate/index.ts
 import debug3 from "debug";
 
-// node_modules/webcrack/src/ast-utils/ast.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/ast-utils/ast.ts
 import * as t from "@babel/types";
 function getPropName(node) {
   if (t.isIdentifier(node)) {
@@ -28,7 +28,7 @@ function getPropName(node) {
     return node.value.toString();
   }
 }
-// node_modules/webcrack/src/ast-utils/generator.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/ast-utils/generator.ts
 import babelGenerate from "@babel/generator";
 function generate(ast, options = defaultOptions) {
   return babelGenerate(ast, options).code;
@@ -45,37 +45,2125 @@ function codePreview(node) {
   return code;
 }
 var defaultOptions = { jsescOption: { minimal: true } };
-// node_modules/webcrack/src/ast-utils/inline.ts
-import traverse2 from "@babel/traverse";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/ast-utils/inline.ts
+import traverse4 from "@babel/traverse";
+import * as t13 from "@babel/types";
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/anyExpression.ts
+import * as t2 from "@babel/types";
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/Matcher.ts
+class Matcher {
+  match(value, keys = []) {
+    return this.matchValue(value, keys);
+  }
+  matchValue(value, keys) {
+    throw new Error(`${this.constructor.name}#matchValue is not implemented`);
+  }
+}
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/anyExpression.ts
+function anyExpression() {
+  return new AnyExpressionMatcher;
+}
+
+class AnyExpressionMatcher extends Matcher {
+  constructor() {
+    super(...arguments);
+  }
+  matchValue(value) {
+    return t2.isNode(value) && t2.isExpression(value);
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/utils/distributeAcrossSlices.ts
+function* distributeAcrossSlices(slices, available) {
+  if (slices.length === 0) {
+    yield [];
+  } else if (slices.length === 1) {
+    const spacer = slices[0];
+    if (spacer.min <= available && available <= spacer.max) {
+      yield [available];
+    }
+  } else {
+    const last = slices[slices.length - 1];
+    for (let allocateToLast = last.min;allocateToLast <= last.max && allocateToLast <= available; allocateToLast++) {
+      const allButLast = slices.slice(0, -1);
+      for (const allButLastAllocations of distributeAcrossSlices(allButLast, available - allocateToLast)) {
+        yield [...allButLastAllocations, allocateToLast];
+      }
+    }
+  }
+}
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/anything.ts
+function anything() {
+  return new AnythingMatcher;
+}
+
+class AnythingMatcher extends Matcher {
+  constructor() {
+    super(...arguments);
+  }
+  matchValue(value) {
+    return true;
+  }
+}
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/slice.ts
+function zeroOrMore(matcher = anything()) {
+  return new SliceMatcher(0, Infinity, matcher);
+}
+function oneOrMore(matcher = anything()) {
+  return new SliceMatcher(1, Infinity, matcher);
+}
+function slice(optionsOrLength, matcherOrUndefined) {
+  let min;
+  let max;
+  let matcher;
+  if (typeof optionsOrLength === "number") {
+    min = optionsOrLength;
+    max = optionsOrLength;
+    matcher = matcherOrUndefined ?? anything();
+  } else if (typeof optionsOrLength === "object" && typeof matcherOrUndefined === "undefined") {
+    min = optionsOrLength.min ?? 0;
+    max = optionsOrLength.max ?? Infinity;
+    matcher = optionsOrLength.matcher ?? anything();
+  } else {
+    throw new Error("Invalid arguments");
+  }
+  return new SliceMatcher(min, max, matcher);
+}
+class SliceMatcher extends Matcher {
+  min;
+  max;
+  matcher;
+  constructor(min, max, matcher) {
+    super();
+    this.min = min;
+    this.max = max;
+    this.matcher = matcher;
+  }
+  matchValue(value, keys) {
+    return this.matcher.matchValue(value, keys);
+  }
+}
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/anyList.ts
+function anyList(...elements) {
+  return new AnyListMatcher(elements);
+}
+
+class AnyListMatcher extends Matcher {
+  matchers;
+  sliceMatchers = [];
+  constructor(matchers) {
+    super();
+    this.matchers = matchers;
+    for (const matcher of matchers) {
+      if (matcher instanceof SliceMatcher) {
+        this.sliceMatchers.push(matcher);
+      }
+    }
+  }
+  matchValue(array, keys) {
+    if (!Array.isArray(array)) {
+      return false;
+    }
+    if (this.matchers.length === 0 && array.length === 0) {
+      return true;
+    }
+    const spacerAllocations = distributeAcrossSlices(this.sliceMatchers, array.length - this.matchers.length + this.sliceMatchers.length);
+    for (const allocations of spacerAllocations) {
+      const valuesToMatch = array.slice();
+      let matchedAll = true;
+      let key = 0;
+      for (const matcher of this.matchers) {
+        if (matcher instanceof SliceMatcher) {
+          let sliceValueCount = allocations.shift() || 0;
+          while (sliceValueCount > 0) {
+            const valueToMatch = valuesToMatch.shift();
+            if (!matcher.matchValue(valueToMatch, [...keys, key])) {
+              matchedAll = false;
+              break;
+            }
+            sliceValueCount--;
+            key++;
+          }
+        } else if (!matcher.matchValue(valuesToMatch.shift(), [...keys, key])) {
+          matchedAll = false;
+          break;
+        } else {
+          key++;
+        }
+      }
+      if (matchedAll) {
+        if (valuesToMatch.length > 0) {
+          throw new Error(`expected to consume all elements to match but ${valuesToMatch.length} remain!`);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/anyNode.ts
 import * as t3 from "@babel/types";
-import * as m2 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/anyStatement.ts
+import * as t4 from "@babel/types";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/anyString.ts
+function anyString() {
+  return new StringMatcher;
+}
+
+class StringMatcher extends Matcher {
+  constructor() {
+    super(...arguments);
+  }
+  matchValue(value) {
+    return typeof value === "string" || value instanceof String;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/arrayOf.ts
+function arrayOf(elementMatcher) {
+  return new ArrayOfMatcher(elementMatcher);
+}
+
+class ArrayOfMatcher extends Matcher {
+  elementMatcher;
+  constructor(elementMatcher) {
+    super();
+    this.elementMatcher = elementMatcher;
+  }
+  matchValue(value, keys) {
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    for (const [i, element] of value.entries()) {
+      if (!this.elementMatcher.matchValue(element, [...keys, i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/capture.ts
+function capture(matcher) {
+  return new CapturedMatcher(matcher);
+}
+
+class CapturedMatcher extends Matcher {
+  matcher;
+  _current;
+  _currentKeys;
+  constructor(matcher = anything()) {
+    super();
+    this.matcher = matcher;
+  }
+  get current() {
+    return this._current;
+  }
+  get currentKeys() {
+    return this._currentKeys;
+  }
+  matchValue(value, keys) {
+    if (this.matcher.matchValue(value, keys)) {
+      this.capture(value, keys);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  capture(value, keys) {
+    this._current = value;
+    this._currentKeys = keys;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/containerOf.ts
+import * as t5 from "@babel/types";
+function containerOf(containedMatcher) {
+  return new ContainerOfMatcher(containedMatcher);
+}
+
+class ContainerOfMatcher extends CapturedMatcher {
+  containedMatcher;
+  constructor(containedMatcher) {
+    super();
+    this.containedMatcher = containedMatcher;
+  }
+  matchValue(value, keys) {
+    if (!t5.isNode(value)) {
+      return false;
+    }
+    if (this.containedMatcher.matchValue(value, keys)) {
+      this.capture(value, keys);
+      return true;
+    }
+    for (const key in value) {
+      const valueAtKey = value[key];
+      if (Array.isArray(valueAtKey)) {
+        for (const [i, element] of valueAtKey.entries()) {
+          if (this.matchValue(element, [...keys, key, i])) {
+            return true;
+          }
+        }
+      } else if (this.matchValue(valueAtKey, [...keys, key])) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/@codemod/utils/src/index.ts
+import * as Babel from "@babel/core";
+import * as t9 from "@babel/types";
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@utils&commit=f7526b4223cf97415_ft7dhqwpjko62eotbauyrlhwiq/node_modules/@codemod/utils/src/NodeTypes.ts
+import * as t6 from "@babel/types";
+var { BUILDER_KEYS, NODE_FIELDS } = t6;
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@utils&commit=f7526b4223cf97415_ft7dhqwpjko62eotbauyrlhwiq/node_modules/@codemod/utils/src/builders.ts
+import traverse2 from "@babel/traverse";
+import * as t7 from "@babel/types";
+
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/@codemod/parser/src/index.ts
+import {
+parse as babelParse
+} from "@babel/parser";
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@parser&commit=f7526b4223cf9741_cvf6llk3hlbskhgvm7jwgnhrpm/node_modules/@codemod/parser/src/options.ts
+var DefaultParserPlugins = new Set([
+  "asyncGenerators",
+  "bigInt",
+  "classPrivateMethods",
+  "classPrivateProperties",
+  "classProperties",
+  "doExpressions",
+  "dynamicImport",
+  "exportDefaultFrom",
+  "exportNamespaceFrom",
+  "functionBind",
+  "functionSent",
+  "importAssertions",
+  "importMeta",
+  "jsx",
+  "logicalAssignment",
+  "nullishCoalescingOperator",
+  "numericSeparator",
+  "objectRestSpread",
+  "optionalCatchBinding",
+  "optionalChaining",
+  "partialApplication",
+  "throwExpressions",
+  "topLevelAwait",
+  ["decorators", { decoratorsBeforeExport: true }],
+  "decorators-legacy",
+  ["pipelineOperator", { proposal: "minimal" }],
+  ["recordAndTuple", { syntaxType: "hash" }]
+]);
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@utils&commit=f7526b4223cf97415_ft7dhqwpjko62eotbauyrlhwiq/node_modules/@codemod/utils/src/nodesEquivalent.ts
+import * as t8 from "@babel/types";
+function nodesEquivalent(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a.type !== b.type) {
+    return false;
+  }
+  const fields = NODE_FIELDS[a.type];
+  const aProps = a;
+  const bProps = b;
+  for (const [k, field] of Object.entries(fields)) {
+    const key = k;
+    if (field.optional && aProps[key] == null && bProps[key] == null) {
+      continue;
+    }
+    const aVal = aProps[key];
+    const bVal = bProps[key];
+    if (aVal === bVal) {
+      continue;
+    }
+    if (aVal == null || bVal == null) {
+      return false;
+    }
+    if (Array.isArray(aVal) && Array.isArray(bVal)) {
+      if (aVal.length !== bVal.length) {
+        return false;
+      }
+      for (let i = 0;i < aVal.length; i++) {
+        if (!nodesEquivalent(aVal[i], bVal[i])) {
+          return false;
+        }
+      }
+      continue;
+    }
+    if (t8.isNode(aVal) && t8.isNode(bVal)) {
+      if (!nodesEquivalent(aVal, bVal)) {
+        return false;
+      }
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/fromCapture.ts
+function fromCapture(capturedMatcher) {
+  return new FromCaptureMatcher(capturedMatcher);
+}
+
+class FromCaptureMatcher extends Matcher {
+  capturedMatcher;
+  constructor(capturedMatcher) {
+    super();
+    this.capturedMatcher = capturedMatcher;
+  }
+  matchValue(value) {
+    if (t9.isNode(this.capturedMatcher.current) && t9.isNode(value)) {
+      return nodesEquivalent(this.capturedMatcher.current, value);
+    }
+    return this.capturedMatcher.current === value;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/function.ts
+import * as t10 from "@babel/types";
+
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/tupleOf.ts
+function tupleOf(...matchers) {
+  return new TupleOfMatcher(...matchers);
+}
+
+class TupleOfMatcher extends Matcher {
+  matchers;
+  constructor(...matchers) {
+    super();
+    this.matchers = matchers;
+  }
+  matchValue(value, keys) {
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    if (value.length !== this.matchers.length) {
+      return false;
+    }
+    for (let i = 0;i < this.matchers.length; i++) {
+      const matcher = this.matchers[i];
+      const element = value[i];
+      if (!matcher.matchValue(element, [...keys, i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/generated.ts
+import * as t11 from "@babel/types";
+function arrayExpression(elements) {
+  return new ArrayExpressionMatcher(elements);
+}
+function arrayPattern(elements) {
+  return new ArrayPatternMatcher(elements);
+}
+function arrowFunctionExpression(params, body, async) {
+  return new ArrowFunctionExpressionMatcher(params, body, async);
+}
+function assignmentExpression(operator, left, right) {
+  return new AssignmentExpressionMatcher(operator, left, right);
+}
+function binaryExpression(operator, left, right) {
+  return new BinaryExpressionMatcher(operator, left, right);
+}
+function blockStatement(body, directives) {
+  return new BlockStatementMatcher(body, directives);
+}
+function booleanLiteral(value) {
+  return new BooleanLiteralMatcher(value);
+}
+function breakStatement(label) {
+  return new BreakStatementMatcher(label);
+}
+function callExpression(callee, _arguments) {
+  return new CallExpressionMatcher(callee, _arguments);
+}
+function classMethod(kind, key, params, body, computed, _static, generator2, async) {
+  return new ClassMethodMatcher(kind, key, params, body, computed, _static, generator2, async);
+}
+function classProperty(key, value, typeAnnotation, decorators, computed, _static) {
+  return new ClassPropertyMatcher(key, value, typeAnnotation, decorators, computed, _static);
+}
+function conditionalExpression(test, consequent, alternate) {
+  return new ConditionalExpressionMatcher(test, consequent, alternate);
+}
+function continueStatement(label) {
+  return new ContinueStatementMatcher(label);
+}
+function expressionStatement(expression) {
+  return new ExpressionStatementMatcher(expression);
+}
+function forInStatement(left, right, body) {
+  return new ForInStatementMatcher(left, right, body);
+}
+function forStatement(init, test, update, body) {
+  return new ForStatementMatcher(init, test, update, body);
+}
+function functionDeclaration(id, params, body, generator2, async) {
+  return new FunctionDeclarationMatcher(id, params, body, generator2, async);
+}
+function functionExpression(id, params, body, generator2, async) {
+  return new FunctionExpressionMatcher(id, params, body, generator2, async);
+}
+function identifier(name) {
+  return new IdentifierMatcher(name);
+}
+function ifStatement(test, consequent, alternate) {
+  return new IfStatementMatcher(test, consequent, alternate);
+}
+function logicalExpression(operator, left, right) {
+  return new LogicalExpressionMatcher(operator, left, right);
+}
+function memberExpression(object, property, computed, optional) {
+  return new MemberExpressionMatcher(object, property, computed, optional);
+}
+function nullLiteral() {
+  return new NullLiteralMatcher;
+}
+function numericLiteral(value) {
+  return new NumericLiteralMatcher(value);
+}
+function objectExpression(properties) {
+  return new ObjectExpressionMatcher(properties);
+}
+function objectMethod(kind, key, params, body, computed, generator2, async) {
+  return new ObjectMethodMatcher(kind, key, params, body, computed, generator2, async);
+}
+function objectPattern(properties) {
+  return new ObjectPatternMatcher(properties);
+}
+function objectProperty(key, value, computed, shorthand, decorators) {
+  return new ObjectPropertyMatcher(key, value, computed, shorthand, decorators);
+}
+function optionalMemberExpression(object, property, computed, optional) {
+  return new OptionalMemberExpressionMatcher(object, property, computed, optional);
+}
+function restElement(argument) {
+  return new RestElementMatcher(argument);
+}
+function returnStatement(argument) {
+  return new ReturnStatementMatcher(argument);
+}
+function sequenceExpression(expressions) {
+  return new SequenceExpressionMatcher(expressions);
+}
+function spreadElement(argument) {
+  return new SpreadElementMatcher(argument);
+}
+function stringLiteral(value) {
+  return new StringLiteralMatcher(value);
+}
+function switchCase(test, consequent) {
+  return new SwitchCaseMatcher(test, consequent);
+}
+function switchStatement(discriminant, cases) {
+  return new SwitchStatementMatcher(discriminant, cases);
+}
+function templateLiteral(quasis, expressions) {
+  return new TemplateLiteralMatcher(quasis, expressions);
+}
+function thisExpression() {
+  return new ThisExpressionMatcher;
+}
+function tryStatement(block, handler, finalizer) {
+  return new TryStatementMatcher(block, handler, finalizer);
+}
+function unaryExpression(operator, argument, prefix) {
+  return new UnaryExpressionMatcher(operator, argument, prefix);
+}
+function updateExpression(operator, argument, prefix) {
+  return new UpdateExpressionMatcher(operator, argument, prefix);
+}
+function variableDeclaration(kind, declarations) {
+  return new VariableDeclarationMatcher(kind, declarations);
+}
+function variableDeclarator(id, init) {
+  return new VariableDeclaratorMatcher(id, init);
+}
+function whileStatement(test, body) {
+  return new WhileStatementMatcher(test, body);
+}
+class ArrayExpressionMatcher extends Matcher {
+  elements;
+  constructor(elements) {
+    super();
+    this.elements = elements;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isArrayExpression(node)) {
+      return false;
+    }
+    if (typeof this.elements === "undefined") {
+    } else if (Array.isArray(this.elements)) {
+      if (!tupleOf(...this.elements).matchValue(node.elements, [
+        ...keys,
+        "elements"
+      ])) {
+        return false;
+      }
+    } else if (!this.elements.matchValue(node.elements, [...keys, "elements"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ArrayPatternMatcher extends Matcher {
+  elements;
+  constructor(elements) {
+    super();
+    this.elements = elements;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isArrayPattern(node)) {
+      return false;
+    }
+    if (typeof this.elements === "undefined") {
+    } else if (Array.isArray(this.elements)) {
+      if (!tupleOf(...this.elements).matchValue(node.elements, [
+        ...keys,
+        "elements"
+      ])) {
+        return false;
+      }
+    } else if (!this.elements.matchValue(node.elements, [...keys, "elements"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class ArrowFunctionExpressionMatcher extends Matcher {
+  params;
+  body;
+  async;
+  constructor(params, body, async) {
+    super();
+    this.params = params;
+    this.body = body;
+    this.async = async;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isArrowFunctionExpression(node)) {
+      return false;
+    }
+    if (typeof this.params === "undefined") {
+    } else if (Array.isArray(this.params)) {
+      if (!tupleOf(...this.params).matchValue(node.params, [
+        ...keys,
+        "params"
+      ])) {
+        return false;
+      }
+    } else if (!this.params.matchValue(node.params, [...keys, "params"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    if (typeof this.async === "undefined") {
+    } else if (typeof this.async === "boolean") {
+      if (this.async !== node.async) {
+        return false;
+      }
+    } else if (!this.async.matchValue(node.async, [...keys, "async"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class AssignmentExpressionMatcher extends Matcher {
+  operator;
+  left;
+  right;
+  constructor(operator, left, right) {
+    super();
+    this.operator = operator;
+    this.left = left;
+    this.right = right;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isAssignmentExpression(node)) {
+      return false;
+    }
+    if (typeof this.operator === "undefined") {
+    } else if (typeof this.operator === "string") {
+      if (this.operator !== node.operator) {
+        return false;
+      }
+    } else if (!this.operator.matchValue(node.operator, [...keys, "operator"])) {
+      return false;
+    }
+    if (typeof this.left === "undefined") {
+    } else if (!this.left.matchValue(node.left, [...keys, "left"])) {
+      return false;
+    }
+    if (typeof this.right === "undefined") {
+    } else if (!this.right.matchValue(node.right, [...keys, "right"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class BinaryExpressionMatcher extends Matcher {
+  operator;
+  left;
+  right;
+  constructor(operator, left, right) {
+    super();
+    this.operator = operator;
+    this.left = left;
+    this.right = right;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isBinaryExpression(node)) {
+      return false;
+    }
+    if (typeof this.operator === "undefined") {
+    } else if (typeof this.operator === "string") {
+      if (this.operator !== node.operator) {
+        return false;
+      }
+    } else if (!this.operator.matchValue(node.operator, [...keys, "operator"])) {
+      return false;
+    }
+    if (typeof this.left === "undefined") {
+    } else if (!this.left.matchValue(node.left, [...keys, "left"])) {
+      return false;
+    }
+    if (typeof this.right === "undefined") {
+    } else if (!this.right.matchValue(node.right, [...keys, "right"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class BlockStatementMatcher extends Matcher {
+  body;
+  directives;
+  constructor(body, directives) {
+    super();
+    this.body = body;
+    this.directives = directives;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isBlockStatement(node)) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (Array.isArray(this.body)) {
+      if (!tupleOf(...this.body).matchValue(node.body, [...keys, "body"])) {
+        return false;
+      }
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    if (typeof this.directives === "undefined") {
+    } else if (Array.isArray(this.directives)) {
+      if (!tupleOf(...this.directives).matchValue(node.directives, [
+        ...keys,
+        "directives"
+      ])) {
+        return false;
+      }
+    } else if (!this.directives.matchValue(node.directives, [...keys, "directives"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class BooleanLiteralMatcher extends Matcher {
+  value;
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isBooleanLiteral(node)) {
+      return false;
+    }
+    if (typeof this.value === "undefined") {
+    } else if (typeof this.value === "boolean") {
+      if (this.value !== node.value) {
+        return false;
+      }
+    } else if (!this.value.matchValue(node.value, [...keys, "value"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class BreakStatementMatcher extends Matcher {
+  label;
+  constructor(label) {
+    super();
+    this.label = label;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isBreakStatement(node)) {
+      return false;
+    }
+    if (typeof this.label === "undefined") {
+    } else if (this.label === null) {
+      if (node.label !== null) {
+        return false;
+      }
+    } else if (!this.label.matchValue(node.label, [...keys, "label"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class CallExpressionMatcher extends Matcher {
+  callee;
+  _arguments;
+  constructor(callee, _arguments) {
+    super();
+    this.callee = callee;
+    this._arguments = _arguments;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isCallExpression(node)) {
+      return false;
+    }
+    if (typeof this.callee === "undefined") {
+    } else if (!this.callee.matchValue(node.callee, [...keys, "callee"])) {
+      return false;
+    }
+    if (typeof this._arguments === "undefined") {
+    } else if (Array.isArray(this._arguments)) {
+      if (!tupleOf(...this._arguments).matchValue(node.arguments, [
+        ...keys,
+        "arguments"
+      ])) {
+        return false;
+      }
+    } else if (!this._arguments.matchValue(node.arguments, [...keys, "arguments"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class ClassMethodMatcher extends Matcher {
+  kind;
+  key;
+  params;
+  body;
+  computed;
+  _static;
+  generator2;
+  async;
+  constructor(kind, key, params, body, computed, _static, generator2, async) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.params = params;
+    this.body = body;
+    this.computed = computed;
+    this._static = _static;
+    this.generator = generator2;
+    this.async = async;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isClassMethod(node)) {
+      return false;
+    }
+    if (typeof this.kind === "undefined") {
+    } else if (typeof this.kind === "string") {
+      if (this.kind !== node.kind) {
+        return false;
+      }
+    } else if (!this.kind.matchValue(node.kind, [...keys, "kind"])) {
+      return false;
+    }
+    if (typeof this.key === "undefined") {
+    } else if (!this.key.matchValue(node.key, [...keys, "key"])) {
+      return false;
+    }
+    if (typeof this.params === "undefined") {
+    } else if (Array.isArray(this.params)) {
+      if (!tupleOf(...this.params).matchValue(node.params, [
+        ...keys,
+        "params"
+      ])) {
+        return false;
+      }
+    } else if (!this.params.matchValue(node.params, [...keys, "params"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    if (typeof this.computed === "undefined") {
+    } else if (typeof this.computed === "boolean") {
+      if (this.computed !== node.computed) {
+        return false;
+      }
+    } else if (!this.computed.matchValue(node.computed, [...keys, "computed"])) {
+      return false;
+    }
+    if (typeof this._static === "undefined") {
+    } else if (typeof this._static === "boolean") {
+      if (this._static !== node.static) {
+        return false;
+      }
+    } else if (!this._static.matchValue(node.static, [...keys, "static"])) {
+      return false;
+    }
+    if (typeof this.generator === "undefined") {
+    } else if (typeof this.generator === "boolean") {
+      if (this.generator !== node.generator) {
+        return false;
+      }
+    } else if (!this.generator.matchValue(node.generator, [...keys, "generator"])) {
+      return false;
+    }
+    if (typeof this.async === "undefined") {
+    } else if (typeof this.async === "boolean") {
+      if (this.async !== node.async) {
+        return false;
+      }
+    } else if (!this.async.matchValue(node.async, [...keys, "async"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class ClassPropertyMatcher extends Matcher {
+  key;
+  value;
+  typeAnnotation;
+  decorators;
+  computed;
+  _static;
+  constructor(key, value, typeAnnotation, decorators, computed, _static) {
+    super();
+    this.key = key;
+    this.value = value;
+    this.typeAnnotation = typeAnnotation;
+    this.decorators = decorators;
+    this.computed = computed;
+    this._static = _static;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isClassProperty(node)) {
+      return false;
+    }
+    if (typeof this.key === "undefined") {
+    } else if (!this.key.matchValue(node.key, [...keys, "key"])) {
+      return false;
+    }
+    if (typeof this.value === "undefined") {
+    } else if (this.value === null) {
+      if (node.value !== null) {
+        return false;
+      }
+    } else if (!this.value.matchValue(node.value, [...keys, "value"])) {
+      return false;
+    }
+    if (typeof this.typeAnnotation === "undefined") {
+    } else if (this.typeAnnotation === null) {
+      if (node.typeAnnotation !== null) {
+        return false;
+      }
+    } else if (!this.typeAnnotation.matchValue(node.typeAnnotation, [
+      ...keys,
+      "typeAnnotation"
+    ])) {
+      return false;
+    }
+    if (typeof this.decorators === "undefined") {
+    } else if (this.decorators === null) {
+      if (node.decorators !== null) {
+        return false;
+      }
+    } else if (Array.isArray(this.decorators)) {
+      if (!tupleOf(...this.decorators).matchValue(node.decorators, [
+        ...keys,
+        "decorators"
+      ])) {
+        return false;
+      }
+    } else if (!this.decorators.matchValue(node.decorators, [...keys, "decorators"])) {
+      return false;
+    }
+    if (typeof this.computed === "undefined") {
+    } else if (typeof this.computed === "boolean") {
+      if (this.computed !== node.computed) {
+        return false;
+      }
+    } else if (!this.computed.matchValue(node.computed, [...keys, "computed"])) {
+      return false;
+    }
+    if (typeof this._static === "undefined") {
+    } else if (typeof this._static === "boolean") {
+      if (this._static !== node.static) {
+        return false;
+      }
+    } else if (!this._static.matchValue(node.static, [...keys, "static"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ConditionalExpressionMatcher extends Matcher {
+  test;
+  consequent;
+  alternate;
+  constructor(test, consequent, alternate) {
+    super();
+    this.test = test;
+    this.consequent = consequent;
+    this.alternate = alternate;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isConditionalExpression(node)) {
+      return false;
+    }
+    if (typeof this.test === "undefined") {
+    } else if (!this.test.matchValue(node.test, [...keys, "test"])) {
+      return false;
+    }
+    if (typeof this.consequent === "undefined") {
+    } else if (!this.consequent.matchValue(node.consequent, [...keys, "consequent"])) {
+      return false;
+    }
+    if (typeof this.alternate === "undefined") {
+    } else if (!this.alternate.matchValue(node.alternate, [...keys, "alternate"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ContinueStatementMatcher extends Matcher {
+  label;
+  constructor(label) {
+    super();
+    this.label = label;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isContinueStatement(node)) {
+      return false;
+    }
+    if (typeof this.label === "undefined") {
+    } else if (this.label === null) {
+      if (node.label !== null) {
+        return false;
+      }
+    } else if (!this.label.matchValue(node.label, [...keys, "label"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class ExpressionStatementMatcher extends Matcher {
+  expression;
+  constructor(expression) {
+    super();
+    this.expression = expression;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isExpressionStatement(node)) {
+      return false;
+    }
+    if (typeof this.expression === "undefined") {
+    } else if (!this.expression.matchValue(node.expression, [...keys, "expression"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class ForInStatementMatcher extends Matcher {
+  left;
+  right;
+  body;
+  constructor(left, right, body) {
+    super();
+    this.left = left;
+    this.right = right;
+    this.body = body;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isForInStatement(node)) {
+      return false;
+    }
+    if (typeof this.left === "undefined") {
+    } else if (!this.left.matchValue(node.left, [...keys, "left"])) {
+      return false;
+    }
+    if (typeof this.right === "undefined") {
+    } else if (!this.right.matchValue(node.right, [...keys, "right"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class ForStatementMatcher extends Matcher {
+  init;
+  test;
+  update;
+  body;
+  constructor(init, test, update, body) {
+    super();
+    this.init = init;
+    this.test = test;
+    this.update = update;
+    this.body = body;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isForStatement(node)) {
+      return false;
+    }
+    if (typeof this.init === "undefined") {
+    } else if (this.init === null) {
+      if (node.init !== null) {
+        return false;
+      }
+    } else if (!this.init.matchValue(node.init, [...keys, "init"])) {
+      return false;
+    }
+    if (typeof this.test === "undefined") {
+    } else if (this.test === null) {
+      if (node.test !== null) {
+        return false;
+      }
+    } else if (!this.test.matchValue(node.test, [...keys, "test"])) {
+      return false;
+    }
+    if (typeof this.update === "undefined") {
+    } else if (this.update === null) {
+      if (node.update !== null) {
+        return false;
+      }
+    } else if (!this.update.matchValue(node.update, [...keys, "update"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class FunctionDeclarationMatcher extends Matcher {
+  id;
+  params;
+  body;
+  generator2;
+  async;
+  constructor(id, params, body, generator2, async) {
+    super();
+    this.id = id;
+    this.params = params;
+    this.body = body;
+    this.generator = generator2;
+    this.async = async;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isFunctionDeclaration(node)) {
+      return false;
+    }
+    if (typeof this.id === "undefined") {
+    } else if (this.id === null) {
+      if (node.id !== null) {
+        return false;
+      }
+    } else if (!this.id.matchValue(node.id, [...keys, "id"])) {
+      return false;
+    }
+    if (typeof this.params === "undefined") {
+    } else if (Array.isArray(this.params)) {
+      if (!tupleOf(...this.params).matchValue(node.params, [
+        ...keys,
+        "params"
+      ])) {
+        return false;
+      }
+    } else if (!this.params.matchValue(node.params, [...keys, "params"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    if (typeof this.generator === "undefined") {
+    } else if (typeof this.generator === "boolean") {
+      if (this.generator !== node.generator) {
+        return false;
+      }
+    } else if (!this.generator.matchValue(node.generator, [...keys, "generator"])) {
+      return false;
+    }
+    if (typeof this.async === "undefined") {
+    } else if (typeof this.async === "boolean") {
+      if (this.async !== node.async) {
+        return false;
+      }
+    } else if (!this.async.matchValue(node.async, [...keys, "async"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class FunctionExpressionMatcher extends Matcher {
+  id;
+  params;
+  body;
+  generator2;
+  async;
+  constructor(id, params, body, generator2, async) {
+    super();
+    this.id = id;
+    this.params = params;
+    this.body = body;
+    this.generator = generator2;
+    this.async = async;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isFunctionExpression(node)) {
+      return false;
+    }
+    if (typeof this.id === "undefined") {
+    } else if (this.id === null) {
+      if (node.id !== null) {
+        return false;
+      }
+    } else if (!this.id.matchValue(node.id, [...keys, "id"])) {
+      return false;
+    }
+    if (typeof this.params === "undefined") {
+    } else if (Array.isArray(this.params)) {
+      if (!tupleOf(...this.params).matchValue(node.params, [
+        ...keys,
+        "params"
+      ])) {
+        return false;
+      }
+    } else if (!this.params.matchValue(node.params, [...keys, "params"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    if (typeof this.generator === "undefined") {
+    } else if (typeof this.generator === "boolean") {
+      if (this.generator !== node.generator) {
+        return false;
+      }
+    } else if (!this.generator.matchValue(node.generator, [...keys, "generator"])) {
+      return false;
+    }
+    if (typeof this.async === "undefined") {
+    } else if (typeof this.async === "boolean") {
+      if (this.async !== node.async) {
+        return false;
+      }
+    } else if (!this.async.matchValue(node.async, [...keys, "async"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class IdentifierMatcher extends Matcher {
+  name;
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isIdentifier(node)) {
+      return false;
+    }
+    if (typeof this.name === "undefined") {
+    } else if (typeof this.name === "string") {
+      if (this.name !== node.name) {
+        return false;
+      }
+    } else if (!this.name.matchValue(node.name, [...keys, "name"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class IfStatementMatcher extends Matcher {
+  test;
+  consequent;
+  alternate;
+  constructor(test, consequent, alternate) {
+    super();
+    this.test = test;
+    this.consequent = consequent;
+    this.alternate = alternate;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isIfStatement(node)) {
+      return false;
+    }
+    if (typeof this.test === "undefined") {
+    } else if (!this.test.matchValue(node.test, [...keys, "test"])) {
+      return false;
+    }
+    if (typeof this.consequent === "undefined") {
+    } else if (!this.consequent.matchValue(node.consequent, [...keys, "consequent"])) {
+      return false;
+    }
+    if (typeof this.alternate === "undefined") {
+    } else if (this.alternate === null) {
+      if (node.alternate !== null) {
+        return false;
+      }
+    } else if (!this.alternate.matchValue(node.alternate, [...keys, "alternate"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class LogicalExpressionMatcher extends Matcher {
+  operator;
+  left;
+  right;
+  constructor(operator, left, right) {
+    super();
+    this.operator = operator;
+    this.left = left;
+    this.right = right;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isLogicalExpression(node)) {
+      return false;
+    }
+    if (typeof this.operator === "undefined") {
+    } else if (typeof this.operator === "string") {
+      if (this.operator !== node.operator) {
+        return false;
+      }
+    } else if (!this.operator.matchValue(node.operator, [...keys, "operator"])) {
+      return false;
+    }
+    if (typeof this.left === "undefined") {
+    } else if (!this.left.matchValue(node.left, [...keys, "left"])) {
+      return false;
+    }
+    if (typeof this.right === "undefined") {
+    } else if (!this.right.matchValue(node.right, [...keys, "right"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class MemberExpressionMatcher extends Matcher {
+  object;
+  property;
+  computed;
+  optional;
+  constructor(object, property, computed, optional) {
+    super();
+    this.object = object;
+    this.property = property;
+    this.computed = computed;
+    this.optional = optional;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isMemberExpression(node)) {
+      return false;
+    }
+    if (typeof this.object === "undefined") {
+    } else if (!this.object.matchValue(node.object, [...keys, "object"])) {
+      return false;
+    }
+    if (typeof this.property === "undefined") {
+    } else if (!this.property.matchValue(node.property, [...keys, "property"])) {
+      return false;
+    }
+    if (typeof this.computed === "undefined") {
+    } else if (typeof this.computed === "boolean") {
+      if (this.computed !== node.computed) {
+        return false;
+      }
+    } else if (!this.computed.matchValue(node.computed, [...keys, "computed"])) {
+      return false;
+    }
+    if (typeof this.optional === "undefined") {
+    } else if (typeof this.optional === "boolean") {
+      if (this.optional !== node.optional) {
+        return false;
+      }
+    } else if (this.optional === null) {
+      if (node.optional !== null) {
+        return false;
+      }
+    } else if (!this.optional.matchValue(node.optional, [...keys, "optional"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class NullLiteralMatcher extends Matcher {
+  constructor() {
+    super();
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isNullLiteral(node)) {
+      return false;
+    }
+    return true;
+  }
+}
+class NumericLiteralMatcher extends Matcher {
+  value;
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isNumericLiteral(node)) {
+      return false;
+    }
+    if (typeof this.value === "undefined") {
+    } else if (typeof this.value === "number") {
+      if (this.value !== node.value) {
+        return false;
+      }
+    } else if (!this.value.matchValue(node.value, [...keys, "value"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ObjectExpressionMatcher extends Matcher {
+  properties;
+  constructor(properties) {
+    super();
+    this.properties = properties;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isObjectExpression(node)) {
+      return false;
+    }
+    if (typeof this.properties === "undefined") {
+    } else if (Array.isArray(this.properties)) {
+      if (!tupleOf(...this.properties).matchValue(node.properties, [
+        ...keys,
+        "properties"
+      ])) {
+        return false;
+      }
+    } else if (!this.properties.matchValue(node.properties, [...keys, "properties"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ObjectMethodMatcher extends Matcher {
+  kind;
+  key;
+  params;
+  body;
+  computed;
+  generator2;
+  async;
+  constructor(kind, key, params, body, computed, generator2, async) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.params = params;
+    this.body = body;
+    this.computed = computed;
+    this.generator = generator2;
+    this.async = async;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isObjectMethod(node)) {
+      return false;
+    }
+    if (typeof this.kind === "undefined") {
+    } else if (typeof this.kind === "string") {
+      if (this.kind !== node.kind) {
+        return false;
+      }
+    } else if (!this.kind.matchValue(node.kind, [...keys, "kind"])) {
+      return false;
+    }
+    if (typeof this.key === "undefined") {
+    } else if (!this.key.matchValue(node.key, [...keys, "key"])) {
+      return false;
+    }
+    if (typeof this.params === "undefined") {
+    } else if (Array.isArray(this.params)) {
+      if (!tupleOf(...this.params).matchValue(node.params, [
+        ...keys,
+        "params"
+      ])) {
+        return false;
+      }
+    } else if (!this.params.matchValue(node.params, [...keys, "params"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    if (typeof this.computed === "undefined") {
+    } else if (typeof this.computed === "boolean") {
+      if (this.computed !== node.computed) {
+        return false;
+      }
+    } else if (!this.computed.matchValue(node.computed, [...keys, "computed"])) {
+      return false;
+    }
+    if (typeof this.generator === "undefined") {
+    } else if (typeof this.generator === "boolean") {
+      if (this.generator !== node.generator) {
+        return false;
+      }
+    } else if (!this.generator.matchValue(node.generator, [...keys, "generator"])) {
+      return false;
+    }
+    if (typeof this.async === "undefined") {
+    } else if (typeof this.async === "boolean") {
+      if (this.async !== node.async) {
+        return false;
+      }
+    } else if (!this.async.matchValue(node.async, [...keys, "async"])) {
+      return false;
+    }
+    return true;
+  }
+}
 
-// node_modules/webcrack/src/ast-utils/matcher.ts
-import * as t2 from "@babel/types";
-import * as m from "@codemod/matchers";
+class ObjectPatternMatcher extends Matcher {
+  properties;
+  constructor(properties) {
+    super();
+    this.properties = properties;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isObjectPattern(node)) {
+      return false;
+    }
+    if (typeof this.properties === "undefined") {
+    } else if (Array.isArray(this.properties)) {
+      if (!tupleOf(...this.properties).matchValue(node.properties, [
+        ...keys,
+        "properties"
+      ])) {
+        return false;
+      }
+    } else if (!this.properties.matchValue(node.properties, [...keys, "properties"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ObjectPropertyMatcher extends Matcher {
+  key;
+  value;
+  computed;
+  shorthand;
+  decorators;
+  constructor(key, value, computed, shorthand, decorators) {
+    super();
+    this.key = key;
+    this.value = value;
+    this.computed = computed;
+    this.shorthand = shorthand;
+    this.decorators = decorators;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isObjectProperty(node)) {
+      return false;
+    }
+    if (typeof this.key === "undefined") {
+    } else if (!this.key.matchValue(node.key, [...keys, "key"])) {
+      return false;
+    }
+    if (typeof this.value === "undefined") {
+    } else if (!this.value.matchValue(node.value, [...keys, "value"])) {
+      return false;
+    }
+    if (typeof this.computed === "undefined") {
+    } else if (typeof this.computed === "boolean") {
+      if (this.computed !== node.computed) {
+        return false;
+      }
+    } else if (!this.computed.matchValue(node.computed, [...keys, "computed"])) {
+      return false;
+    }
+    if (typeof this.shorthand === "undefined") {
+    } else if (typeof this.shorthand === "boolean") {
+      if (this.shorthand !== node.shorthand) {
+        return false;
+      }
+    } else if (!this.shorthand.matchValue(node.shorthand, [...keys, "shorthand"])) {
+      return false;
+    }
+    if (typeof this.decorators === "undefined") {
+    } else if (this.decorators === null) {
+      if (node.decorators !== null) {
+        return false;
+      }
+    } else if (Array.isArray(this.decorators)) {
+      if (!tupleOf(...this.decorators).matchValue(node.decorators, [
+        ...keys,
+        "decorators"
+      ])) {
+        return false;
+      }
+    } else if (!this.decorators.matchValue(node.decorators, [...keys, "decorators"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class OptionalMemberExpressionMatcher extends Matcher {
+  object;
+  property;
+  computed;
+  optional;
+  constructor(object, property, computed, optional) {
+    super();
+    this.object = object;
+    this.property = property;
+    this.computed = computed;
+    this.optional = optional;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isOptionalMemberExpression(node)) {
+      return false;
+    }
+    if (typeof this.object === "undefined") {
+    } else if (!this.object.matchValue(node.object, [...keys, "object"])) {
+      return false;
+    }
+    if (typeof this.property === "undefined") {
+    } else if (!this.property.matchValue(node.property, [...keys, "property"])) {
+      return false;
+    }
+    if (typeof this.computed === "undefined") {
+    } else if (typeof this.computed === "boolean") {
+      if (this.computed !== node.computed) {
+        return false;
+      }
+    } else if (!this.computed.matchValue(node.computed, [...keys, "computed"])) {
+      return false;
+    }
+    if (typeof this.optional === "undefined") {
+    } else if (typeof this.optional === "boolean") {
+      if (this.optional !== node.optional) {
+        return false;
+      }
+    } else if (!this.optional.matchValue(node.optional, [...keys, "optional"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class RestElementMatcher extends Matcher {
+  argument;
+  constructor(argument) {
+    super();
+    this.argument = argument;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isRestElement(node)) {
+      return false;
+    }
+    if (typeof this.argument === "undefined") {
+    } else if (!this.argument.matchValue(node.argument, [...keys, "argument"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ReturnStatementMatcher extends Matcher {
+  argument;
+  constructor(argument) {
+    super();
+    this.argument = argument;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isReturnStatement(node)) {
+      return false;
+    }
+    if (typeof this.argument === "undefined") {
+    } else if (this.argument === null) {
+      if (node.argument !== null) {
+        return false;
+      }
+    } else if (!this.argument.matchValue(node.argument, [...keys, "argument"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class SequenceExpressionMatcher extends Matcher {
+  expressions;
+  constructor(expressions) {
+    super();
+    this.expressions = expressions;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isSequenceExpression(node)) {
+      return false;
+    }
+    if (typeof this.expressions === "undefined") {
+    } else if (Array.isArray(this.expressions)) {
+      if (!tupleOf(...this.expressions).matchValue(node.expressions, [
+        ...keys,
+        "expressions"
+      ])) {
+        return false;
+      }
+    } else if (!this.expressions.matchValue(node.expressions, [...keys, "expressions"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class SpreadElementMatcher extends Matcher {
+  argument;
+  constructor(argument) {
+    super();
+    this.argument = argument;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isSpreadElement(node)) {
+      return false;
+    }
+    if (typeof this.argument === "undefined") {
+    } else if (!this.argument.matchValue(node.argument, [...keys, "argument"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class StringLiteralMatcher extends Matcher {
+  value;
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isStringLiteral(node)) {
+      return false;
+    }
+    if (typeof this.value === "undefined") {
+    } else if (typeof this.value === "string") {
+      if (this.value !== node.value) {
+        return false;
+      }
+    } else if (!this.value.matchValue(node.value, [...keys, "value"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class SwitchCaseMatcher extends Matcher {
+  test;
+  consequent;
+  constructor(test, consequent) {
+    super();
+    this.test = test;
+    this.consequent = consequent;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isSwitchCase(node)) {
+      return false;
+    }
+    if (typeof this.test === "undefined") {
+    } else if (this.test === null) {
+      if (node.test !== null) {
+        return false;
+      }
+    } else if (!this.test.matchValue(node.test, [...keys, "test"])) {
+      return false;
+    }
+    if (typeof this.consequent === "undefined") {
+    } else if (Array.isArray(this.consequent)) {
+      if (!tupleOf(...this.consequent).matchValue(node.consequent, [
+        ...keys,
+        "consequent"
+      ])) {
+        return false;
+      }
+    } else if (!this.consequent.matchValue(node.consequent, [...keys, "consequent"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class SwitchStatementMatcher extends Matcher {
+  discriminant;
+  cases;
+  constructor(discriminant, cases) {
+    super();
+    this.discriminant = discriminant;
+    this.cases = cases;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isSwitchStatement(node)) {
+      return false;
+    }
+    if (typeof this.discriminant === "undefined") {
+    } else if (!this.discriminant.matchValue(node.discriminant, [
+      ...keys,
+      "discriminant"
+    ])) {
+      return false;
+    }
+    if (typeof this.cases === "undefined") {
+    } else if (Array.isArray(this.cases)) {
+      if (!tupleOf(...this.cases).matchValue(node.cases, [
+        ...keys,
+        "cases"
+      ])) {
+        return false;
+      }
+    } else if (!this.cases.matchValue(node.cases, [...keys, "cases"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class TemplateLiteralMatcher extends Matcher {
+  quasis;
+  expressions;
+  constructor(quasis, expressions) {
+    super();
+    this.quasis = quasis;
+    this.expressions = expressions;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isTemplateLiteral(node)) {
+      return false;
+    }
+    if (typeof this.quasis === "undefined") {
+    } else if (Array.isArray(this.quasis)) {
+      if (!tupleOf(...this.quasis).matchValue(node.quasis, [
+        ...keys,
+        "quasis"
+      ])) {
+        return false;
+      }
+    } else if (!this.quasis.matchValue(node.quasis, [...keys, "quasis"])) {
+      return false;
+    }
+    if (typeof this.expressions === "undefined") {
+    } else if (Array.isArray(this.expressions)) {
+      if (!tupleOf(...this.expressions).matchValue(node.expressions, [
+        ...keys,
+        "expressions"
+      ])) {
+        return false;
+      }
+    } else if (!this.expressions.matchValue(node.expressions, [...keys, "expressions"])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class ThisExpressionMatcher extends Matcher {
+  constructor() {
+    super();
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isThisExpression(node)) {
+      return false;
+    }
+    return true;
+  }
+}
+class TryStatementMatcher extends Matcher {
+  block;
+  handler;
+  finalizer;
+  constructor(block, handler, finalizer) {
+    super();
+    this.block = block;
+    this.handler = handler;
+    this.finalizer = finalizer;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isTryStatement(node)) {
+      return false;
+    }
+    if (typeof this.block === "undefined") {
+    } else if (!this.block.matchValue(node.block, [...keys, "block"])) {
+      return false;
+    }
+    if (typeof this.handler === "undefined") {
+    } else if (this.handler === null) {
+      if (node.handler !== null) {
+        return false;
+      }
+    } else if (!this.handler.matchValue(node.handler, [...keys, "handler"])) {
+      return false;
+    }
+    if (typeof this.finalizer === "undefined") {
+    } else if (this.finalizer === null) {
+      if (node.finalizer !== null) {
+        return false;
+      }
+    } else if (!this.finalizer.matchValue(node.finalizer, [...keys, "finalizer"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class UnaryExpressionMatcher extends Matcher {
+  operator;
+  argument;
+  prefix;
+  constructor(operator, argument, prefix) {
+    super();
+    this.operator = operator;
+    this.argument = argument;
+    this.prefix = prefix;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isUnaryExpression(node)) {
+      return false;
+    }
+    if (typeof this.operator === "undefined") {
+    } else if (typeof this.operator === "string") {
+      if (this.operator !== node.operator) {
+        return false;
+      }
+    } else if (!this.operator.matchValue(node.operator, [...keys, "operator"])) {
+      return false;
+    }
+    if (typeof this.argument === "undefined") {
+    } else if (!this.argument.matchValue(node.argument, [...keys, "argument"])) {
+      return false;
+    }
+    if (typeof this.prefix === "undefined") {
+    } else if (typeof this.prefix === "boolean") {
+      if (this.prefix !== node.prefix) {
+        return false;
+      }
+    } else if (!this.prefix.matchValue(node.prefix, [...keys, "prefix"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class UpdateExpressionMatcher extends Matcher {
+  operator;
+  argument;
+  prefix;
+  constructor(operator, argument, prefix) {
+    super();
+    this.operator = operator;
+    this.argument = argument;
+    this.prefix = prefix;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isUpdateExpression(node)) {
+      return false;
+    }
+    if (typeof this.operator === "undefined") {
+    } else if (typeof this.operator === "string") {
+      if (this.operator !== node.operator) {
+        return false;
+      }
+    } else if (!this.operator.matchValue(node.operator, [...keys, "operator"])) {
+      return false;
+    }
+    if (typeof this.argument === "undefined") {
+    } else if (!this.argument.matchValue(node.argument, [...keys, "argument"])) {
+      return false;
+    }
+    if (typeof this.prefix === "undefined") {
+    } else if (typeof this.prefix === "boolean") {
+      if (this.prefix !== node.prefix) {
+        return false;
+      }
+    } else if (!this.prefix.matchValue(node.prefix, [...keys, "prefix"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class VariableDeclarationMatcher extends Matcher {
+  kind;
+  declarations;
+  constructor(kind, declarations) {
+    super();
+    this.kind = kind;
+    this.declarations = declarations;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isVariableDeclaration(node)) {
+      return false;
+    }
+    if (typeof this.kind === "undefined") {
+    } else if (typeof this.kind === "string") {
+      if (this.kind !== node.kind) {
+        return false;
+      }
+    } else if (!this.kind.matchValue(node.kind, [...keys, "kind"])) {
+      return false;
+    }
+    if (typeof this.declarations === "undefined") {
+    } else if (Array.isArray(this.declarations)) {
+      if (!tupleOf(...this.declarations).matchValue(node.declarations, [
+        ...keys,
+        "declarations"
+      ])) {
+        return false;
+      }
+    } else if (!this.declarations.matchValue(node.declarations, [
+      ...keys,
+      "declarations"
+    ])) {
+      return false;
+    }
+    return true;
+  }
+}
+
+class VariableDeclaratorMatcher extends Matcher {
+  id;
+  init;
+  constructor(id, init) {
+    super();
+    this.id = id;
+    this.init = init;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isVariableDeclarator(node)) {
+      return false;
+    }
+    if (typeof this.id === "undefined") {
+    } else if (!this.id.matchValue(node.id, [...keys, "id"])) {
+      return false;
+    }
+    if (typeof this.init === "undefined") {
+    } else if (this.init === null) {
+      if (node.init !== null) {
+        return false;
+      }
+    } else if (!this.init.matchValue(node.init, [...keys, "init"])) {
+      return false;
+    }
+    return true;
+  }
+}
+class WhileStatementMatcher extends Matcher {
+  test;
+  body;
+  constructor(test, body) {
+    super();
+    this.test = test;
+    this.body = body;
+  }
+  matchValue(node, keys) {
+    if (!t11.isNode(node) || !t11.isWhileStatement(node)) {
+      return false;
+    }
+    if (typeof this.test === "undefined") {
+    } else if (!this.test.matchValue(node.test, [...keys, "test"])) {
+      return false;
+    }
+    if (typeof this.body === "undefined") {
+    } else if (!this.body.matchValue(node.body, [...keys, "body"])) {
+      return false;
+    }
+    return true;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/or.ts
+function or(...matchersOrValues) {
+  return new OrMatcher(...matchersOrValues);
+}
+
+class OrMatcher extends Matcher {
+  matchersOrValues;
+  constructor(...matchersOrValues) {
+    super();
+    this.matchersOrValues = matchersOrValues;
+  }
+  matchValue(value, keys) {
+    for (const matcherOrValue of this.matchersOrValues) {
+      if (matcherOrValue instanceof Matcher) {
+        if (matcherOrValue.matchValue(value, keys)) {
+          return true;
+        }
+      } else if (matcherOrValue === value) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=codemod-js+codemod+packages@matchers&commit=f7526b4223cf97_3hwilm7arfqh7gehb4jjanlmea/node_modules/@codemod/matchers/src/matchers/predicate.ts
+function predicate(predicate2) {
+  return new PredicateMatcher(predicate2);
+}
+
+class PredicateMatcher extends Matcher {
+  predicate2;
+  constructor(predicate2) {
+    super();
+    this.predicate = predicate2;
+  }
+  matchValue(value) {
+    return this.predicate(value);
+  }
+}
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/ast-utils/matcher.ts
+import * as t12 from "@babel/types";
 function infiniteLoop(body) {
-  return m.or(m.forStatement(undefined, null, undefined, body), m.forStatement(undefined, truthyMatcher, undefined, body), m.whileStatement(truthyMatcher, body));
+  return or(forStatement(undefined, null, undefined, body), forStatement(undefined, truthyMatcher, undefined, body), whileStatement(truthyMatcher, body));
 }
 function constKey(name) {
-  return m.or(m.identifier(name), m.stringLiteral(name));
+  return or(identifier(name), stringLiteral(name));
 }
 function constObjectProperty(value) {
-  return m.or(m.objectProperty(m.identifier(), value, false), m.objectProperty(m.or(m.stringLiteral(), m.numericLiteral()), value));
+  return or(objectProperty(identifier(), value, false), objectProperty(or(stringLiteral(), numericLiteral()), value));
 }
 function matchIife(body) {
-  return m.callExpression(m.functionExpression(null, [], body ? m.blockStatement(body) : undefined), []);
+  return callExpression(functionExpression(null, [], body ? blockStatement(body) : undefined), []);
 }
 function constMemberExpression(object, property) {
   if (typeof object === "string")
-    object = m.identifier(object);
-  return m.or(m.memberExpression(object, m.identifier(property), false), m.memberExpression(object, m.stringLiteral(property), true));
+    object = identifier(object);
+  return or(memberExpression(object, identifier(property), false), memberExpression(object, stringLiteral(property), true));
 }
-function findParent(path, matcher2) {
-  return path.findParent((path2) => matcher2.match(path2.node));
+function findParent(path, matcher) {
+  return path.findParent((path2) => matcher.match(path2.node));
 }
 function createFunctionMatcher(params, body) {
-  const captures = Array.from({ length: params }, () => m.capture(m.anyString()));
-  return m.functionExpression(undefined, captures.map(m.identifier), m.blockStatement(body(...captures.map((c) => m.identifier(m.fromCapture(c))))));
+  const captures = Array.from({ length: params }, () => capture(anyString()));
+  return functionExpression(undefined, captures.map(identifier), blockStatement(body(...captures.map((c) => identifier(fromCapture(c))))));
 }
 function isReadonlyObject(binding, memberAccess) {
   if (!binding.constant && binding.constantViolations[0] !== binding.path)
@@ -95,18 +2183,18 @@ function isReadonlyObject(binding, memberAccess) {
 function isTemporaryVariable(binding, references, kind = "var") {
   return binding !== undefined && binding.references === references && binding.constantViolations.length === 1 && (kind === "var" ? binding.path.isVariableDeclarator() && binding.path.node.init === null : binding.path.listKey === "params" && binding.path.isIdentifier());
 }
-var anyLiteral = m.matcher((node) => t2.isLiteral(node) && (!t2.isTemplateLiteral(node) || node.expressions.length === 0));
+var safeLiteral = predicate((node) => t12.isLiteral(node) && (!t12.isTemplateLiteral(node) || node.expressions.length === 0));
 var iife = matchIife();
 var emptyIife = matchIife([]);
-var trueMatcher = m.or(m.booleanLiteral(true), m.unaryExpression("!", m.numericLiteral(0)), m.unaryExpression("!", m.unaryExpression("!", m.numericLiteral(1))), m.unaryExpression("!", m.unaryExpression("!", m.arrayExpression([]))));
-var falseMatcher = m.or(m.booleanLiteral(false), m.unaryExpression("!", m.arrayExpression([])));
-var truthyMatcher = m.or(trueMatcher, m.arrayExpression([]));
+var trueMatcher = or(booleanLiteral(true), unaryExpression("!", numericLiteral(0)), unaryExpression("!", unaryExpression("!", numericLiteral(1))), unaryExpression("!", unaryExpression("!", arrayExpression([]))));
+var falseMatcher = or(booleanLiteral(false), unaryExpression("!", arrayExpression([])));
+var truthyMatcher = or(trueMatcher, arrayExpression([]));
 
-// node_modules/webcrack/src/ast-utils/inline.ts
-function inlineVariable(binding, value = m2.anyExpression(), unsafeAssignments = false) {
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/ast-utils/inline.ts
+function inlineVariable(binding, value = anyExpression(), unsafeAssignments = false) {
   const varDeclarator = binding.path.node;
-  const varMatcher = m2.variableDeclarator(m2.identifier(binding.identifier.name), value);
-  const assignmentMatcher = m2.assignmentExpression("=", m2.identifier(binding.identifier.name), value);
+  const varMatcher = variableDeclarator(identifier(binding.identifier.name), value);
+  const assignmentMatcher = assignmentExpression("=", identifier(binding.identifier.name), value);
   if (binding.constant && varMatcher.match(varDeclarator)) {
     binding.referencePaths.forEach((ref) => {
       ref.replaceWith(varDeclarator.init);
@@ -130,10 +2218,10 @@ function inlineArrayElements(array, references) {
     memberPath.replaceWith(replacement);
   }
 }
-function inlineObjectProperties(binding, property = m2.objectProperty()) {
+function inlineObjectProperties(binding, property = objectProperty()) {
   const varDeclarator = binding.path.node;
-  const objectProperties = m2.capture(m2.arrayOf(property));
-  const varMatcher = m2.variableDeclarator(m2.identifier(binding.identifier.name), m2.objectExpression(objectProperties));
+  const objectProperties = capture(arrayOf(property));
+  const varMatcher = variableDeclarator(identifier(binding.identifier.name), objectExpression(objectProperties));
   if (!varMatcher.match(varDeclarator))
     return;
   const propertyMap = new Map(objectProperties.current.map((p) => [getPropName(p.key), p.value]));
@@ -152,13 +2240,13 @@ function inlineObjectProperties(binding, property = m2.objectProperty()) {
   binding.path.remove();
 }
 function inlineFunction(fn, caller) {
-  if (t3.isRestElement(fn.params[1])) {
-    caller.replaceWith(t3.callExpression(caller.node.arguments[0], caller.node.arguments.slice(1)));
+  if (t13.isRestElement(fn.params[1])) {
+    caller.replaceWith(t13.callExpression(caller.node.arguments[0], caller.node.arguments.slice(1)));
     return;
   }
   const returnedValue = fn.body.body[0].argument;
-  const clone = t3.cloneNode(returnedValue, true);
-  traverse2(clone, {
+  const clone = t13.cloneNode(returnedValue, true);
+  traverse4(clone, {
     Identifier(path) {
       const paramIndex = fn.params.findIndex((p) => p.name === path.node.name);
       if (paramIndex !== -1) {
@@ -174,11 +2262,11 @@ function inlineFunctionAliases(binding) {
   const state = { changes: 0 };
   const refs = [...binding.referencePaths];
   for (const ref of refs) {
-    const fn = findParent(ref, m2.functionDeclaration());
-    const fnName = m2.capture(m2.anyString());
-    const returnedCall = m2.capture(m2.callExpression(m2.identifier(binding.identifier.name), m2.anyList(m2.slice({ min: 2 }))));
-    const matcher3 = m2.functionDeclaration(m2.identifier(fnName), m2.anyList(m2.slice({ min: 2 })), m2.blockStatement([m2.returnStatement(returnedCall)]));
-    if (fn && matcher3.match(fn.node)) {
+    const fn = findParent(ref, functionDeclaration());
+    const fnName = capture(anyString());
+    const returnedCall = capture(callExpression(identifier(binding.identifier.name), anyList(slice({ min: 2 }))));
+    const matcher2 = functionDeclaration(identifier(fnName), anyList(slice({ min: 2 })), blockStatement([returnStatement(returnedCall)]));
+    if (fn && matcher2.match(fn.node)) {
       const paramUsedInDecodeCall = fn.node.params.some((param) => {
         const binding2 = fn.scope.getBinding(param.name);
         return binding2?.referencePaths.some((ref2) => ref2.findParent((p) => p.node === returnedCall.current));
@@ -190,7 +2278,7 @@ function inlineFunctionAliases(binding) {
         continue;
       const fnRefs = fnBinding.referencePaths;
       refs.push(...fnRefs);
-      const callRefs = fnRefs.filter((ref2) => t3.isCallExpression(ref2.parent) && t3.isIdentifier(ref2.parent.callee, { name: fnName.current })).map((ref2) => ref2.parentPath);
+      const callRefs = fnRefs.filter((ref2) => t13.isCallExpression(ref2.parent) && t13.isIdentifier(ref2.parent.callee, { name: fnName.current })).map((ref2) => ref2.parentPath);
       for (const callRef of callRefs) {
         inlineFunction(fn.node, callRef);
         state.changes++;
@@ -205,10 +2293,10 @@ function inlineFunctionAliases(binding) {
 function inlineVariableAliases(binding, targetName = binding.identifier.name) {
   const state = { changes: 0 };
   const refs = [...binding.referencePaths];
-  const varName = m2.capture(m2.anyString());
-  const matcher3 = m2.or(m2.variableDeclarator(m2.identifier(varName), m2.identifier(binding.identifier.name)), m2.assignmentExpression("=", m2.identifier(varName), m2.identifier(binding.identifier.name)));
+  const varName = capture(anyString());
+  const matcher2 = or(variableDeclarator(identifier(varName), identifier(binding.identifier.name)), assignmentExpression("=", identifier(varName), identifier(binding.identifier.name)));
   for (const ref of refs) {
-    if (matcher3.match(ref.parent)) {
+    if (matcher2.match(ref.parent)) {
       const varScope = ref.scope;
       const varBinding = varScope.getBinding(varName.current);
       if (!varBinding)
@@ -216,7 +2304,7 @@ function inlineVariableAliases(binding, targetName = binding.identifier.name) {
       state.changes += inlineVariableAliases(varBinding, targetName).changes;
       if (ref.parentPath?.isAssignmentExpression()) {
         varBinding.path.remove();
-        if (t3.isExpressionStatement(ref.parentPath.parent)) {
+        if (t13.isExpressionStatement(ref.parentPath.parent)) {
           ref.parentPath.remove();
         } else {
           ref.parentPath.replaceWith(ref.parentPath.node.right);
@@ -226,16 +2314,15 @@ function inlineVariableAliases(binding, targetName = binding.identifier.name) {
       }
       state.changes++;
     } else {
-      ref.replaceWith(t3.identifier(targetName));
+      ref.replaceWith(t13.identifier(targetName));
       state.changes++;
     }
   }
   return state;
 }
-// node_modules/webcrack/src/ast-utils/rename.ts
-import traverse4 from "@babel/traverse";
-import * as t4 from "@babel/types";
-import * as m3 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/ast-utils/rename.ts
+import traverse6 from "@babel/traverse";
+import * as t14 from "@babel/types";
 function renameFast(binding, newName) {
   binding.referencePaths.forEach((ref) => {
     if (!ref.isIdentifier()) {
@@ -245,18 +2332,18 @@ function renameFast(binding, newName) {
       ref.scope.rename(newName);
     ref.node.name = newName;
   });
-  const patternMatcher = m3.assignmentExpression("=", m3.or(m3.arrayPattern(), m3.objectPattern()));
+  const patternMatcher = assignmentExpression("=", or(arrayPattern(), objectPattern()));
   binding.constantViolations.forEach((ref) => {
     if (ref.scope.hasBinding(newName))
       ref.scope.rename(newName);
-    if (ref.isAssignmentExpression() && t4.isIdentifier(ref.node.left)) {
+    if (ref.isAssignmentExpression() && t14.isIdentifier(ref.node.left)) {
       ref.node.left.name = newName;
-    } else if (ref.isUpdateExpression() && t4.isIdentifier(ref.node.argument)) {
+    } else if (ref.isUpdateExpression() && t14.isIdentifier(ref.node.argument)) {
       ref.node.argument.name = newName;
-    } else if (ref.isVariableDeclarator() && t4.isIdentifier(ref.node.id)) {
+    } else if (ref.isVariableDeclarator() && t14.isIdentifier(ref.node.id)) {
       ref.node.id.name = newName;
     } else if (ref.isFor() || patternMatcher.match(ref.node)) {
-      traverse4(ref.node, {
+      traverse6(ref.node, {
         Identifier(path) {
           if (path.scope !== ref.scope)
             return path.skip();
@@ -274,78 +2361,77 @@ function renameFast(binding, newName) {
   binding.scope.bindings[newName] = binding;
   binding.identifier.name = newName;
 }
-// node_modules/webcrack/src/ast-utils/transform.ts
-import traverse6, {
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/ast-utils/transform.ts
+import traverse8, {
 visitors
 } from "@babel/traverse";
 import debug from "debug";
-async function applyTransformAsync(ast, transform, options) {
+async function applyTransformAsync(ast, transform, options2) {
   logger(`${transform.name}: started`);
   const state = { changes: 0 };
-  await transform.run?.(ast, state, options);
+  await transform.run?.(ast, state, options2);
   if (transform.visitor)
-    traverse6(ast, transform.visitor(options), undefined, state);
+    traverse8(ast, transform.visitor(options2), undefined, state);
   logger(`${transform.name}: finished with ${state.changes} changes`);
   return state;
 }
-function applyTransform(ast, transform, options, noScopeOverride) {
+function applyTransform(ast, transform, options2, noScopeOverride) {
   logger(`${transform.name}: started`);
   const state = { changes: 0 };
-  transform.run?.(ast, state, options);
+  transform.run?.(ast, state, options2);
   if (transform.visitor) {
-    const visitor = transform.visitor(options);
+    const visitor = transform.visitor(options2);
     visitor.noScope = noScopeOverride || !transform.scope;
-    traverse6(ast, visitor, undefined, state);
+    traverse8(ast, visitor, undefined, state);
   }
   logger(`${transform.name}: finished with ${state.changes} changes`);
   return state;
 }
-function applyTransforms(ast, transforms, options = {}) {
-  options.log ??= true;
-  const name = options.name ?? transforms.map((t5) => t5.name).join(", ");
-  if (options.log)
+function applyTransforms(ast, transforms, options2 = {}) {
+  options2.log ??= true;
+  const name = options2.name ?? transforms.map((t15) => t15.name).join(", ");
+  if (options2.log)
     logger(`${name}: started`);
   const state = { changes: 0 };
   for (const transform of transforms) {
     transform.run?.(ast, state);
   }
-  const traverseOptions = transforms.flatMap((t5) => t5.visitor?.() ?? []);
+  const traverseOptions = transforms.flatMap((t15) => t15.visitor?.() ?? []);
   if (traverseOptions.length > 0) {
     const visitor = visitors.merge(traverseOptions);
-    visitor.noScope = options.noScope || transforms.every((t5) => !t5.scope);
-    traverse6(ast, visitor, undefined, state);
+    visitor.noScope = options2.noScope || transforms.every((t15) => !t15.scope);
+    traverse8(ast, visitor, undefined, state);
   }
-  if (options.log)
+  if (options2.log)
     logger(`${name}: finished with ${state.changes} changes`);
   return state;
 }
-function mergeTransforms(options) {
+function mergeTransforms(options2) {
   return {
-    name: options.name,
-    tags: options.tags,
-    scope: options.transforms.some((t5) => t5.scope),
+    name: options2.name,
+    tags: options2.tags,
+    scope: options2.transforms.some((t15) => t15.scope),
     visitor() {
-      return visitors.merge(options.transforms.flatMap((t5) => t5.visitor?.() ?? []));
+      return visitors.merge(options2.transforms.flatMap((t15) => t15.visitor?.() ?? []));
     }
   };
 }
 var logger = debug("webcrack:transforms");
-// node_modules/webcrack/src/unminify/transforms/merge-strings.ts
-import * as t5 from "@babel/types";
-import * as m4 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/merge-strings.ts
+import * as t15 from "@babel/types";
 var merge_strings_default = {
   name: "merge-strings",
   tags: ["safe"],
   visitor() {
-    const left = m4.capture(m4.stringLiteral(m4.anyString()));
-    const right = m4.capture(m4.stringLiteral(m4.anyString()));
-    const matcher4 = m4.binaryExpression("+", left, right);
-    const nestedMatcher = m4.binaryExpression("+", m4.binaryExpression("+", m4.anything(), left), right);
+    const left = capture(stringLiteral(anyString()));
+    const right = capture(stringLiteral(anyString()));
+    const matcher3 = binaryExpression("+", left, right);
+    const nestedMatcher = binaryExpression("+", binaryExpression("+", anything(), left), right);
     return {
       BinaryExpression: {
         exit(path) {
-          if (matcher4.match(path.node)) {
-            path.replaceWith(t5.stringLiteral(left.current.value + right.current.value));
+          if (matcher3.match(path.node)) {
+            path.replaceWith(t15.stringLiteral(left.current.value + right.current.value));
             this.changes++;
           }
         }
@@ -363,65 +2449,62 @@ var merge_strings_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/array-rotator.ts
-import * as m5 from "@codemod/matchers";
-import {callExpression as callExpression5} from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/array-rotator.ts
 function findArrayRotator(stringArray) {
-  const arrayIdentifier = m5.capture(m5.identifier());
-  const pushShift = m5.callExpression(constMemberExpression(arrayIdentifier, "push"), [
-    m5.callExpression(constMemberExpression(m5.fromCapture(arrayIdentifier), "shift"))
+  const arrayIdentifier = capture(identifier());
+  const pushShift = callExpression(constMemberExpression(arrayIdentifier, "push"), [
+    callExpression(constMemberExpression(fromCapture(arrayIdentifier), "shift"))
   ]);
-  const callMatcher = m5.callExpression(m5.functionExpression(null, m5.anything(), m5.blockStatement(m5.anyList(m5.zeroOrMore(), infiniteLoop(m5.matcher((node) => {
-    return m5.containerOf(callExpression5(m5.identifier("parseInt"))).match(node) && m5.blockStatement([
-      m5.tryStatement(m5.containerOf(pushShift), m5.containerOf(pushShift))
+  const callMatcher = callExpression(functionExpression(null, anything(), blockStatement(anyList(zeroOrMore(), infiniteLoop(predicate((node) => {
+    return containerOf(callExpression(identifier("parseInt"))).match(node) && blockStatement([
+      tryStatement(containerOf(pushShift), containerOf(pushShift))
     ]).match(node);
   }))))));
-  const matcher5 = m5.expressionStatement(m5.or(callMatcher, m5.unaryExpression("!", callMatcher)));
+  const matcher3 = expressionStatement(or(callMatcher, unaryExpression("!", callMatcher)));
   for (const ref of stringArray.references) {
-    const rotator = findParent(ref, matcher5);
+    const rotator = findParent(ref, matcher3);
     if (rotator) {
       return rotator;
     }
   }
 }
 
-// node_modules/webcrack/src/deobfuscate/control-flow-object.ts
-import * as t6 from "@babel/types";
-import * as m6 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/control-flow-object.ts
+import * as t16 from "@babel/types";
 var control_flow_object_default = {
   name: "control-flow-object",
   tags: ["safe"],
   scope: true,
   visitor() {
-    const varId = m6.capture(m6.identifier());
-    const propertyName = m6.matcher((name) => /^[a-z]{5}$/i.test(name));
+    const varId = capture(identifier());
+    const propertyName = predicate((name) => /^[a-z]{5}$/i.test(name));
     const propertyKey = constKey(propertyName);
-    const propertyValue = m6.or(m6.stringLiteral(), createFunctionMatcher(2, (left, right) => [
-      m6.returnStatement(m6.or(m6.binaryExpression(undefined, left, right), m6.logicalExpression(undefined, left, right), m6.binaryExpression(undefined, right, left), m6.logicalExpression(undefined, right, left)))
-    ]), m6.matcher((node) => {
-      return t6.isFunctionExpression(node) && createFunctionMatcher(node.params.length, (...params) => [
-        m6.returnStatement(m6.callExpression(params[0], params.slice(1)))
+    const propertyValue = or(stringLiteral(), createFunctionMatcher(2, (left, right) => [
+      returnStatement(or(binaryExpression(undefined, left, right), logicalExpression(undefined, left, right), binaryExpression(undefined, right, left), logicalExpression(undefined, right, left)))
+    ]), predicate((node) => {
+      return t16.isFunctionExpression(node) && createFunctionMatcher(node.params.length, (...params) => [
+        returnStatement(callExpression(params[0], params.slice(1)))
       ]).match(node);
     }), (() => {
-      const fnName = m6.capture(m6.identifier());
-      const restName = m6.capture(m6.identifier());
-      return m6.functionExpression(undefined, [fnName, m6.restElement(restName)], m6.blockStatement([
-        m6.returnStatement(m6.callExpression(m6.fromCapture(fnName), [
-          m6.spreadElement(m6.fromCapture(restName))
+      const fnName = capture(identifier());
+      const restName = capture(identifier());
+      return functionExpression(undefined, [fnName, restElement(restName)], blockStatement([
+        returnStatement(callExpression(fromCapture(fnName), [
+          spreadElement(fromCapture(restName))
         ]))
       ]));
     })());
-    const objectProperties = m6.capture(m6.arrayOf(m6.objectProperty(propertyKey, propertyValue)));
-    const aliasId = m6.capture(m6.identifier());
-    const aliasVar = m6.variableDeclaration(m6.anything(), [
-      m6.variableDeclarator(aliasId, m6.fromCapture(varId))
+    const objectProperties = capture(arrayOf(objectProperty(propertyKey, propertyValue)));
+    const aliasId = capture(identifier());
+    const aliasVar = variableDeclaration(anything(), [
+      variableDeclarator(aliasId, fromCapture(varId))
     ]);
-    const assignedKey = m6.capture(propertyName);
-    const assignedValue = m6.capture(propertyValue);
-    const assignment = m6.expressionStatement(m6.assignmentExpression("=", constMemberExpression(m6.fromCapture(varId), assignedKey), assignedValue));
-    const looseAssignment = m6.expressionStatement(m6.assignmentExpression("=", constMemberExpression(m6.fromCapture(varId), assignedKey)));
-    const memberAccess = constMemberExpression(m6.or(m6.fromCapture(varId), m6.fromCapture(aliasId)), propertyName);
-    const varMatcher = m6.variableDeclarator(varId, m6.capture(m6.objectExpression(objectProperties)));
+    const assignedKey = capture(propertyName);
+    const assignedValue = capture(propertyValue);
+    const assignment = expressionStatement(assignmentExpression("=", constMemberExpression(fromCapture(varId), assignedKey), assignedValue));
+    const looseAssignment = expressionStatement(assignmentExpression("=", constMemberExpression(fromCapture(varId), assignedKey)));
+    const memberAccess = constMemberExpression(or(fromCapture(varId), fromCapture(aliasId)), propertyName);
+    const varMatcher = variableDeclarator(varId, capture(objectExpression(objectProperties)));
     function isConstantBinding(binding) {
       return binding.constant || binding.constantViolations[0] === binding.path;
     }
@@ -448,7 +2531,7 @@ var control_flow_object_default = {
           const memberPath = ref.parentPath;
           const propName = getPropName(memberPath.node.property);
           const value = props.get(propName);
-          if (t6.isStringLiteral(value)) {
+          if (t16.isStringLiteral(value)) {
             memberPath.replaceWith(value);
           } else {
             inlineFunction(value, memberPath.parentPath);
@@ -456,7 +2539,7 @@ var control_flow_object_default = {
           changes++;
         });
         oldRefs.forEach((ref) => {
-          const varDeclarator = findParent(ref, m6.variableDeclarator());
+          const varDeclarator = findParent(ref, variableDeclarator());
           if (varDeclarator)
             changes += transform2(varDeclarator);
         });
@@ -475,7 +2558,7 @@ var control_flow_object_default = {
           applyTransform(statement, merge_strings_default);
         }
         if (assignment.match(statement)) {
-          properties.push(t6.objectProperty(t6.identifier(assignedKey.current), assignedValue.current));
+          properties.push(t16.objectProperty(t16.identifier(assignedKey.current), assignedValue.current));
         } else {
           break;
         }
@@ -506,31 +2589,30 @@ var control_flow_object_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/control-flow-switch.ts
-import * as t7 from "@babel/types";
-import * as m7 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/control-flow-switch.ts
+import * as t17 from "@babel/types";
 var control_flow_switch_default = {
   name: "control-flow-switch",
   tags: ["safe"],
   visitor() {
-    const sequenceName = m7.capture(m7.identifier());
-    const sequenceString = m7.capture(m7.matcher((s) => /^\d+(\|\d+)*$/.test(s)));
-    const iterator = m7.capture(m7.identifier());
-    const cases = m7.capture(m7.arrayOf(m7.switchCase(m7.stringLiteral(m7.matcher((s) => /^\d+$/.test(s))), m7.anyList(m7.zeroOrMore(), m7.or(m7.continueStatement(), m7.returnStatement())))));
-    const matcher7 = m7.blockStatement(m7.anyList(m7.variableDeclaration(undefined, [
-      m7.variableDeclarator(sequenceName, m7.callExpression(constMemberExpression(m7.stringLiteral(sequenceString), "split"), [m7.stringLiteral("|")]))
-    ]), m7.variableDeclaration(undefined, [m7.variableDeclarator(iterator)]), infiniteLoop(m7.blockStatement([
-      m7.switchStatement(m7.memberExpression(m7.fromCapture(sequenceName), m7.updateExpression("++", m7.fromCapture(iterator)), true), cases),
-      m7.breakStatement()
-    ])), m7.zeroOrMore()));
+    const sequenceName = capture(identifier());
+    const sequenceString = capture(predicate((s) => /^\d+(\|\d+)*$/.test(s)));
+    const iterator = capture(identifier());
+    const cases = capture(arrayOf(switchCase(stringLiteral(predicate((s) => /^\d+$/.test(s))), anyList(zeroOrMore(), or(continueStatement(), returnStatement())))));
+    const matcher3 = blockStatement(anyList(variableDeclaration(undefined, [
+      variableDeclarator(sequenceName, callExpression(constMemberExpression(stringLiteral(sequenceString), "split"), [stringLiteral("|")]))
+    ]), variableDeclaration(undefined, [variableDeclarator(iterator)]), infiniteLoop(blockStatement([
+      switchStatement(memberExpression(fromCapture(sequenceName), updateExpression("++", fromCapture(iterator)), true), cases),
+      breakStatement()
+    ])), zeroOrMore()));
     return {
       BlockStatement: {
         exit(path) {
-          if (!matcher7.match(path.node))
+          if (!matcher3.match(path.node))
             return;
           const caseStatements = new Map(cases.current.map((c) => [
             c.test.value,
-            t7.isContinueStatement(c.consequent.at(-1)) ? c.consequent.slice(0, -1) : c.consequent
+            t17.isContinueStatement(c.consequent.at(-1)) ? c.consequent.slice(0, -1) : c.consequent
           ]));
           const sequence = sequenceString.current.split("|");
           const newStatements = sequence.flatMap((s) => caseStatements.get(s));
@@ -542,11 +2624,10 @@ var control_flow_switch_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/dead-code.ts
-import * as t8 from "@babel/types";
-import * as m8 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/dead-code.ts
+import * as t18 from "@babel/types";
 var replace = function(path, node) {
-  if (t8.isBlockStatement(node)) {
+  if (t18.isBlockStatement(node)) {
     path.replaceWithMultiple(node.body);
   } else {
     path.replaceWith(node);
@@ -557,8 +2638,8 @@ var dead_code_default = {
   tags: ["unsafe"],
   scope: true,
   visitor() {
-    const stringComparison = m8.binaryExpression(m8.or("===", "==", "!==", "!="), m8.stringLiteral(), m8.stringLiteral());
-    const testMatcher = m8.or(stringComparison, m8.unaryExpression("!", stringComparison));
+    const stringComparison = binaryExpression(or("===", "==", "!==", "!="), stringLiteral(), stringLiteral());
+    const testMatcher = or(stringComparison, unaryExpression("!", stringComparison));
     return {
       "IfStatement|ConditionalExpression": {
         exit(_path) {
@@ -591,18 +2672,17 @@ var dead_code_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/decoder.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/decoder.ts
 import {expression} from "@babel/template";
-import * as m9 from "@codemod/matchers";
 function findDecoders(stringArray) {
   const decoders = [];
-  const functionName = m9.capture(m9.anyString());
-  const arrayIdentifier = m9.capture(m9.identifier());
-  const matcher8 = m9.functionDeclaration(m9.identifier(functionName), m9.anything(), m9.blockStatement(m9.anyList(m9.variableDeclaration(undefined, [
-    m9.variableDeclarator(arrayIdentifier, m9.callExpression(m9.identifier(stringArray.name)))
-  ]), m9.zeroOrMore(), m9.containerOf(m9.memberExpression(m9.fromCapture(arrayIdentifier), undefined, true)), m9.zeroOrMore())));
+  const functionName = capture(anyString());
+  const arrayIdentifier = capture(identifier());
+  const matcher3 = functionDeclaration(identifier(functionName), anything(), blockStatement(anyList(variableDeclaration(undefined, [
+    variableDeclarator(arrayIdentifier, callExpression(identifier(stringArray.name)))
+  ]), zeroOrMore(), containerOf(memberExpression(fromCapture(arrayIdentifier), undefined, true)), zeroOrMore())));
   for (const ref of stringArray.references) {
-    const decoderFn = findParent(ref, matcher8);
+    const decoderFn = findParent(ref, matcher3);
     if (decoderFn) {
       const oldName = functionName.current;
       const newName = `__DECODE_${decoders.length}__`;
@@ -623,11 +2703,11 @@ class Decoder {
   }
   collectCalls() {
     const calls = [];
-    const literalArgument = m9.or(m9.binaryExpression(m9.anything(), m9.matcher((node) => literalArgument.match(node)), m9.matcher((node) => literalArgument.match(node))), m9.unaryExpression("-", m9.matcher((node) => literalArgument.match(node))), m9.numericLiteral(), m9.stringLiteral());
-    const literalCall = m9.callExpression(m9.identifier(this.name), m9.arrayOf(literalArgument));
-    const expressionCall = m9.callExpression(m9.identifier(this.name), m9.arrayOf(m9.anyExpression()));
-    const conditional = m9.capture(m9.conditionalExpression());
-    const conditionalCall = m9.callExpression(m9.identifier(this.name), [
+    const literalArgument = or(binaryExpression(anything(), predicate((node) => literalArgument.match(node)), predicate((node) => literalArgument.match(node))), unaryExpression("-", predicate((node) => literalArgument.match(node))), numericLiteral(), stringLiteral());
+    const literalCall = callExpression(identifier(this.name), arrayOf(literalArgument));
+    const expressionCall = callExpression(identifier(this.name), arrayOf(anyExpression()));
+    const conditional = capture(conditionalExpression());
+    const conditionalCall = callExpression(identifier(this.name), [
       conditional
     ]);
     const buildExtractedConditional = expression`TEST ? CALLEE(CONSEQUENT) : CALLEE(ALTERNATE)`;
@@ -661,21 +2741,21 @@ class Decoder {
   }
 }
 
-// node_modules/webcrack/src/deobfuscate/inline-decoded-strings.ts
-import * as t9 from "@babel/types";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/inline-decoded-strings.ts
+import * as t19 from "@babel/types";
 var inline_decoded_strings_default = {
   name: "inline-decoded-strings",
   tags: ["unsafe"],
   scope: true,
-  async run(ast2, state, options) {
-    if (!options)
+  async run(ast2, state, options2) {
+    if (!options2)
       return;
-    const calls = options.vm.decoders.flatMap((decoder) => decoder.collectCalls());
-    const decodedValues = await options.vm.decode(calls);
+    const calls = options2.vm.decoders.flatMap((decoder) => decoder.collectCalls());
+    const decodedValues = await options2.vm.decode(calls);
     for (let i = 0;i < calls.length; i++) {
       const call = calls[i];
       const value = decodedValues[i];
-      call.replaceWith(t9.valueToNode(value));
+      call.replaceWith(t19.valueToNode(value));
       if (typeof value !== "string")
         call.addComment("leading", "webcrack:decode_error");
     }
@@ -683,7 +2763,7 @@ var inline_decoded_strings_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/inline-decoder-wrappers.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/inline-decoder-wrappers.ts
 var inline_decoder_wrappers_default = {
   name: "inline-decoder-wrappers",
   tags: ["unsafe"],
@@ -700,19 +2780,18 @@ var inline_decoder_wrappers_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/inline-object-props.ts
-import * as m10 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/inline-object-props.ts
 var inline_object_props_default = {
   name: "inline-object-props",
   tags: ["safe"],
   scope: true,
   visitor() {
-    const varId = m10.capture(m10.identifier());
-    const propertyName = m10.matcher((name) => /^[\w]+$/i.test(name));
+    const varId = capture(identifier());
+    const propertyName = predicate((name) => /^[\w]+$/i.test(name));
     const propertyKey = constKey(propertyName);
-    const objectProperties = m10.capture(m10.arrayOf(m10.objectProperty(propertyKey, m10.or(m10.stringLiteral(), m10.numericLiteral()))));
-    const memberAccess = constMemberExpression(m10.fromCapture(varId), propertyName);
-    const varMatcher = m10.variableDeclarator(varId, m10.objectExpression(objectProperties));
+    const objectProperties = capture(arrayOf(objectProperty(propertyKey, or(stringLiteral(), numericLiteral()))));
+    const memberAccess = constMemberExpression(fromCapture(varId), propertyName);
+    const varMatcher = variableDeclarator(varId, objectExpression(objectProperties));
     return {
       VariableDeclarator(path) {
         if (!varMatcher.match(path.node))
@@ -722,36 +2801,35 @@ var inline_object_props_default = {
         const binding = path.scope.getBinding(varId.current.name);
         if (!binding || !isReadonlyObject(binding, memberAccess))
           return;
-        inlineObjectProperties(binding, m10.objectProperty(propertyKey, m10.or(m10.stringLiteral(), m10.numericLiteral())));
+        inlineObjectProperties(binding, objectProperty(propertyKey, or(stringLiteral(), numericLiteral())));
       }
     };
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/string-array.ts
-import traverse8 from "@babel/traverse";
-import * as m11 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/string-array.ts
+import traverse10 from "@babel/traverse";
 function findStringArray(ast2) {
   let result;
-  const functionName = m11.capture(m11.anyString());
-  const arrayIdentifier = m11.capture(m11.identifier());
-  const arrayExpression3 = m11.capture(m11.arrayExpression(m11.arrayOf(m11.stringLiteral())));
-  const functionAssignment = m11.assignmentExpression("=", m11.identifier(m11.fromCapture(functionName)), m11.functionExpression(undefined, [], m11.blockStatement([m11.returnStatement(m11.fromCapture(arrayIdentifier))])));
-  const variableDeclaration5 = m11.variableDeclaration(undefined, [
-    m11.variableDeclarator(arrayIdentifier, arrayExpression3)
+  const functionName = capture(anyString());
+  const arrayIdentifier = capture(identifier());
+  const arrayExpression2 = capture(arrayExpression(arrayOf(stringLiteral())));
+  const functionAssignment = assignmentExpression("=", identifier(fromCapture(functionName)), functionExpression(undefined, [], blockStatement([returnStatement(fromCapture(arrayIdentifier))])));
+  const variableDeclaration2 = variableDeclaration(undefined, [
+    variableDeclarator(arrayIdentifier, arrayExpression2)
   ]);
-  const matcher10 = m11.functionDeclaration(m11.identifier(functionName), [], m11.or(m11.blockStatement([
-    variableDeclaration5,
-    m11.returnStatement(m11.callExpression(functionAssignment))
-  ]), m11.blockStatement([
-    variableDeclaration5,
-    m11.expressionStatement(functionAssignment),
-    m11.returnStatement(m11.callExpression(m11.identifier(functionName)))
+  const matcher3 = functionDeclaration(identifier(functionName), [], or(blockStatement([
+    variableDeclaration2,
+    returnStatement(callExpression(functionAssignment))
+  ]), blockStatement([
+    variableDeclaration2,
+    expressionStatement(functionAssignment),
+    returnStatement(callExpression(identifier(functionName)))
   ])));
-  traverse8(ast2, {
+  traverse10(ast2, {
     FunctionDeclaration(path) {
-      if (matcher10.match(path.node)) {
-        const length = arrayExpression3.current.elements.length;
+      if (matcher3.match(path.node)) {
+        const length = arrayExpression2.current.elements.length;
         const name = functionName.current;
         const binding = path.scope.getBinding(name);
         renameFast(binding, "__STRING_ARRAY__");
@@ -765,21 +2843,21 @@ function findStringArray(ast2) {
       }
     },
     VariableDeclaration(path) {
-      if (!variableDeclaration5.match(path.node))
+      if (!variableDeclaration2.match(path.node))
         return;
-      const length = arrayExpression3.current.elements.length;
+      const length = arrayExpression2.current.elements.length;
       const binding = path.scope.getBinding(arrayIdentifier.current.name);
-      const memberAccess = m11.memberExpression(m11.fromCapture(arrayIdentifier), m11.numericLiteral(m11.matcher((value) => value < length)));
+      const memberAccess = memberExpression(fromCapture(arrayIdentifier), numericLiteral(predicate((value) => value < length)));
       if (!isReadonlyObject(binding, memberAccess))
         return;
-      inlineArrayElements(arrayExpression3.current, binding.referencePaths);
+      inlineArrayElements(arrayExpression2.current, binding.referencePaths);
       path.remove();
     }
   });
   return result;
 }
 
-// node_modules/webcrack/src/deobfuscate/vm.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/deobfuscate/vm.ts
 import debug2 from "debug";
 class VMDecoder {
   decoders;
@@ -815,7 +2893,7 @@ class VMDecoder {
   }
 }
 
-// node_modules/webcrack/src/deobfuscate/index.ts
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/webcrack/src/deobfuscate/index.ts
 var deobfuscate_default = {
   name: "deobfuscate",
   tags: ["unsafe"],
@@ -846,23 +2924,22 @@ var deobfuscate_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/var-functions.ts
-import * as t10 from "@babel/types";
-import * as m12 from "@codemod/matchers";
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/webcrack/src/deobfuscate/var-functions.ts
+import * as t20 from "@babel/types";
 var var_functions_default = {
   name: "var-functions",
   tags: ["unsafe"],
   visitor() {
-    const name = m12.capture(m12.identifier());
-    const fn = m12.capture(m12.functionExpression(null));
-    const matcher10 = m12.variableDeclaration("var", [
-      m12.variableDeclarator(name, fn)
+    const name = capture(identifier());
+    const fn = capture(functionExpression(null));
+    const matcher3 = variableDeclaration("var", [
+      variableDeclarator(name, fn)
     ]);
     return {
       VariableDeclaration: {
         exit(path) {
-          if (matcher10.match(path.node) && path.key !== "init") {
-            path.replaceWith(t10.functionDeclaration(name.current, fn.current.params, fn.current.body, fn.current.generator, fn.current.async));
+          if (matcher3.match(path.node) && path.key !== "init") {
+            path.replaceWith(t20.functionDeclaration(name.current, fn.current.params, fn.current.body, fn.current.generator, fn.current.async));
           }
         }
       }
@@ -870,26 +2947,25 @@ var var_functions_default = {
   }
 };
 
-// node_modules/webcrack/src/deobfuscate/merge-object-assignments.ts
-import * as t11 from "@babel/types";
-import * as m13 from "@codemod/matchers";
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/webcrack/src/deobfuscate/merge-object-assignments.ts
+import * as t21 from "@babel/types";
 var hasCircularReference = function(node, binding) {
-  return binding.referencePaths.some((path) => path.find((p) => p.node === node)) || m13.containerOf(m13.callExpression()).match(node);
+  return binding.referencePaths.some((path) => path.find((p) => p.node === node)) || containerOf(callExpression()).match(node);
 };
 var merge_object_assignments_default = {
   name: "merge-object-assignments",
   tags: ["safe"],
   scope: true,
   visitor: () => {
-    const id = m13.capture(m13.identifier());
-    const object = m13.capture(m13.objectExpression([]));
-    const varMatcher = m13.variableDeclaration(undefined, [
-      m13.variableDeclarator(id, object)
+    const id = capture(identifier());
+    const object = capture(objectExpression([]));
+    const varMatcher = variableDeclaration(undefined, [
+      variableDeclarator(id, object)
     ]);
-    const key = m13.capture(m13.anyExpression());
-    const computed = m13.capture(m13.anything());
-    const value = m13.capture(m13.anyExpression());
-    const assignmentMatcher = m13.expressionStatement(m13.assignmentExpression("=", m13.memberExpression(m13.fromCapture(id), key, computed), value));
+    const key = capture(anyExpression());
+    const computed = capture(anything());
+    const value = capture(anyExpression());
+    const assignmentMatcher = expressionStatement(assignmentExpression("=", memberExpression(fromCapture(id), key, computed), value));
     return {
       Program(path) {
         path.scope.crawl();
@@ -906,7 +2982,7 @@ var merge_object_assignments_default = {
             if (!assignmentMatcher.match(sibling.node) || hasCircularReference(value.current, binding))
               return;
             const isComputed = computed.current && key.current.type !== "NumericLiteral" && key.current.type !== "StringLiteral";
-            object.current.properties.push(t11.objectProperty(key.current, value.current, isComputed));
+            object.current.properties.push(t21.objectProperty(key.current, value.current, isComputed));
             sibling.remove();
             binding.dereference();
             binding.referencePaths.shift();
@@ -921,9 +2997,9 @@ var merge_object_assignments_default = {
     };
   }
 };
-var inlineableObject = m13.matcher((node) => m13.or(anyLiteral, m13.arrayExpression(m13.arrayOf(inlineableObject)), m13.objectExpression(m13.arrayOf(constObjectProperty(inlineableObject)))).match(node));
+var inlineableObject = predicate((node) => or(safeLiteral, arrayExpression(arrayOf(inlineableObject)), objectExpression(arrayOf(constObjectProperty(inlineableObject)))).match(node));
 
-// node_modules/webcrack/src/unminify/transforms/index.ts
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/webcrack/src/unminify/transforms/index.ts
 var exports_transforms = {};
 __export(exports_transforms, {
   yoda: () => {
@@ -1023,37 +3099,37 @@ __export(exports_transforms, {
   }
 });
 
-// node_modules/webcrack/src/unminify/transforms/block-statements.ts
-import * as t12 from "@babel/types";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/block-statements.ts
+import * as t22 from "@babel/types";
 var block_statements_default = {
   name: "block-statements",
   tags: ["safe"],
   visitor: () => ({
     IfStatement: {
       exit(path) {
-        if (!t12.isBlockStatement(path.node.consequent) && !t12.isEmptyStatement(path.node.consequent)) {
-          path.node.consequent = t12.blockStatement([path.node.consequent]);
+        if (!t22.isBlockStatement(path.node.consequent) && !t22.isEmptyStatement(path.node.consequent)) {
+          path.node.consequent = t22.blockStatement([path.node.consequent]);
           this.changes++;
         }
-        if (path.node.alternate && !t12.isBlockStatement(path.node.alternate)) {
-          path.node.alternate = t12.blockStatement([path.node.alternate]);
+        if (path.node.alternate && !t22.isBlockStatement(path.node.alternate)) {
+          path.node.alternate = t22.blockStatement([path.node.alternate]);
           this.changes++;
         }
       }
     },
     Loop: {
       exit(path) {
-        if (!t12.isBlockStatement(path.node.body) && !t12.isEmptyStatement(path.node.body)) {
-          path.node.body = t12.blockStatement([path.node.body]);
+        if (!t22.isBlockStatement(path.node.body) && !t22.isEmptyStatement(path.node.body)) {
+          path.node.body = t22.blockStatement([path.node.body]);
           this.changes++;
         }
       }
     },
     ArrowFunctionExpression: {
       exit(path) {
-        if (t12.isSequenceExpression(path.node.body)) {
-          path.node.body = t12.blockStatement([
-            t12.returnStatement(path.node.body)
+        if (t22.isSequenceExpression(path.node.body)) {
+          path.node.body = t22.blockStatement([
+            t22.returnStatement(path.node.body)
           ]);
           this.changes++;
         }
@@ -1061,24 +3137,23 @@ var block_statements_default = {
     }
   })
 };
-// node_modules/webcrack/src/unminify/transforms/computed-properties.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/computed-properties.ts
 import {isIdentifierName} from "@babel/helper-validator-identifier";
-import * as t13 from "@babel/types";
-import * as m14 from "@codemod/matchers";
+import * as t23 from "@babel/types";
 var computed_properties_default = {
   name: "computed-properties",
   tags: ["safe"],
   visitor() {
-    const stringMatcher = m14.capture(m14.stringLiteral(m14.matcher((value) => isIdentifierName(value))));
-    const propertyMatcher = m14.or(m14.memberExpression(m14.anything(), stringMatcher, true), m14.optionalMemberExpression(m14.anything(), stringMatcher, true));
-    const keyMatcher = m14.or(m14.objectProperty(stringMatcher), m14.classProperty(stringMatcher), m14.objectMethod(undefined, stringMatcher), m14.classMethod(undefined, stringMatcher));
+    const stringMatcher = capture(stringLiteral(predicate((value) => isIdentifierName(value))));
+    const propertyMatcher = or(memberExpression(anything(), stringMatcher, true), optionalMemberExpression(anything(), stringMatcher, true));
+    const keyMatcher = or(objectProperty(stringMatcher), classProperty(stringMatcher), objectMethod(undefined, stringMatcher), classMethod(undefined, stringMatcher));
     return {
       "MemberExpression|OptionalMemberExpression": {
         exit(path) {
           if (!propertyMatcher.match(path.node))
             return;
           path.node.computed = false;
-          path.node.property = t13.identifier(stringMatcher.current.value);
+          path.node.property = t23.identifier(stringMatcher.current.value);
           this.changes++;
         }
       },
@@ -1089,15 +3164,15 @@ var computed_properties_default = {
           if (path.type === "ClassMethod" && stringMatcher.current.value === "constructor" || path.type === "ObjectProperty" && stringMatcher.current.value === "__proto__")
             return;
           path.node.computed = false;
-          path.node.key = t13.identifier(stringMatcher.current.value);
+          path.node.key = t23.identifier(stringMatcher.current.value);
           this.changes++;
         }
       }
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/for-to-while.ts
-import * as t14 from "@babel/types";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/for-to-while.ts
+import * as t24 from "@babel/types";
 var for_to_while_default = {
   name: "for-to-while",
   tags: ["safe"],
@@ -1108,33 +3183,32 @@ var for_to_while_default = {
           const { test, body, init, update } = path.node;
           if (init || update)
             return;
-          path.replaceWith(test ? t14.whileStatement(test, body) : t14.whileStatement(t14.booleanLiteral(true), body));
+          path.replaceWith(test ? t24.whileStatement(test, body) : t24.whileStatement(t24.booleanLiteral(true), body));
           this.changes++;
         }
       }
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/infinity.ts
-import * as t15 from "@babel/types";
-import * as m15 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/infinity.ts
+import * as t25 from "@babel/types";
 var infinity_default = {
   name: "infinity",
   tags: ["safe"],
   scope: true,
   visitor: () => {
-    const infinityMatcher = m15.binaryExpression("/", m15.numericLiteral(1), m15.numericLiteral(0));
-    const negativeInfinityMatcher = m15.binaryExpression("/", m15.unaryExpression("-", m15.numericLiteral(1)), m15.numericLiteral(0));
+    const infinityMatcher = binaryExpression("/", numericLiteral(1), numericLiteral(0));
+    const negativeInfinityMatcher = binaryExpression("/", unaryExpression("-", numericLiteral(1)), numericLiteral(0));
     return {
       BinaryExpression: {
         exit(path) {
           if (path.scope.hasBinding("Infinity", { noGlobals: true }))
             return;
           if (infinityMatcher.match(path.node)) {
-            path.replaceWith(t15.identifier("Infinity"));
+            path.replaceWith(t25.identifier("Infinity"));
             this.changes++;
           } else if (negativeInfinityMatcher.match(path.node)) {
-            path.replaceWith(t15.unaryExpression("-", t15.identifier("Infinity")));
+            path.replaceWith(t25.unaryExpression("-", t25.identifier("Infinity")));
             this.changes++;
           }
         }
@@ -1142,9 +3216,8 @@ var infinity_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/invert-boolean-logic.ts
-import * as t16 from "@babel/types";
-import * as m16 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/invert-boolean-logic.ts
+import * as t26 from "@babel/types";
 var INVERTED_BINARY_OPERATORS = {
   "==": "!=",
   "===": "!==",
@@ -1163,25 +3236,25 @@ var invert_boolean_logic_default = {
   name: "invert-boolean-logic",
   tags: ["safe"],
   visitor: () => {
-    const logicalExpression3 = m16.logicalExpression(m16.or(...Object.values(INVERTED_LOGICAL_OPERATORS)));
-    const logicalMatcher = m16.unaryExpression("!", logicalExpression3);
-    const binaryExpression7 = m16.capture(m16.binaryExpression(m16.or(...Object.values(INVERTED_BINARY_OPERATORS))));
-    const binaryMatcher = m16.unaryExpression("!", binaryExpression7);
+    const logicalExpression2 = logicalExpression(or(...Object.values(INVERTED_LOGICAL_OPERATORS)));
+    const logicalMatcher = unaryExpression("!", logicalExpression2);
+    const binaryExpression2 = capture(binaryExpression(or(...Object.values(INVERTED_BINARY_OPERATORS))));
+    const binaryMatcher = unaryExpression("!", binaryExpression2);
     return {
       UnaryExpression: {
         exit(path) {
           const { argument } = path.node;
           if (binaryMatcher.match(path.node)) {
-            binaryExpression7.current.operator = INVERTED_BINARY_OPERATORS[binaryExpression7.current.operator];
-            path.replaceWith(binaryExpression7.current);
+            binaryExpression2.current.operator = INVERTED_BINARY_OPERATORS[binaryExpression2.current.operator];
+            path.replaceWith(binaryExpression2.current);
             this.changes++;
           } else if (logicalMatcher.match(path.node)) {
             let current = argument;
-            while (logicalExpression3.match(current)) {
+            while (logicalExpression2.match(current)) {
               current.operator = INVERTED_LOGICAL_OPERATORS[current.operator];
-              current.right = t16.unaryExpression("!", current.right);
-              if (!logicalExpression3.match(current.left)) {
-                current.left = t16.unaryExpression("!", current.left);
+              current.right = t26.unaryExpression("!", current.right);
+              if (!logicalExpression2.match(current.left)) {
+                current.left = t26.unaryExpression("!", current.left);
               }
               current = current.left;
             }
@@ -1193,22 +3266,21 @@ var invert_boolean_logic_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/json-parse.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/json-parse.ts
 import {parseExpression} from "@babel/parser";
-import * as m17 from "@codemod/matchers";
 var json_parse_default = {
   name: "json-parse",
   tags: ["safe"],
   scope: true,
   visitor: () => {
-    const string = m17.capture(m17.anyString());
-    const matcher12 = m17.callExpression(constMemberExpression("JSON", "parse"), [
-      m17.stringLiteral(string)
+    const string = capture(anyString());
+    const matcher3 = callExpression(constMemberExpression("JSON", "parse"), [
+      stringLiteral(string)
     ]);
     return {
       CallExpression: {
         exit(path) {
-          if (matcher12.match(path.node) && !path.scope.hasBinding("JSON", { noGlobals: true })) {
+          if (matcher3.match(path.node) && !path.scope.hasBinding("JSON", { noGlobals: true })) {
             try {
               JSON.parse(string.current);
               const parsed = parseExpression(string.current);
@@ -1222,15 +3294,14 @@ var json_parse_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/logical-to-if.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/logical-to-if.ts
 import {statement} from "@babel/template";
-import * as m18 from "@codemod/matchers";
 var logical_to_if_default = {
   name: "logical-to-if",
   tags: ["safe"],
   visitor: () => {
-    const andMatcher = m18.expressionStatement(m18.logicalExpression("&&"));
-    const orMatcher = m18.expressionStatement(m18.logicalExpression("||"));
+    const andMatcher = expressionStatement(logicalExpression("&&"));
+    const orMatcher = expressionStatement(logicalExpression("||"));
     const buildIf = statement`if (TEST) { BODY; }`;
     const buildIfNot = statement`if (!TEST) { BODY; }`;
     return {
@@ -1255,18 +3326,17 @@ var logical_to_if_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/merge-else-if.ts
-import * as m19 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/merge-else-if.ts
 var merge_else_if_default = {
   name: "merge-else-if",
   tags: ["safe"],
   visitor() {
-    const nestedIf = m19.capture(m19.ifStatement());
-    const matcher12 = m19.ifStatement(m19.anything(), m19.anything(), m19.blockStatement([nestedIf]));
+    const nestedIf = capture(ifStatement());
+    const matcher3 = ifStatement(anything(), anything(), blockStatement([nestedIf]));
     return {
       IfStatement: {
         exit(path) {
-          if (matcher12.match(path.node)) {
+          if (matcher3.match(path.node)) {
             path.node.alternate = nestedIf.current;
             this.changes++;
           }
@@ -1275,22 +3345,21 @@ var merge_else_if_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/number-expressions.ts
-import * as t17 from "@babel/types";
-import * as m20 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/number-expressions.ts
+import * as t27 from "@babel/types";
 var number_expressions_default = {
   name: "number-expressions",
   tags: ["safe"],
   visitor: () => ({
     "BinaryExpression|UnaryExpression": {
       exit(path) {
-        if (matcher13.match(path.node)) {
+        if (matcher3.match(path.node)) {
           const evaluated = path.evaluate();
           if (evaluated.confident) {
             if (path.node.type === "BinaryExpression" && path.node.operator === "/" && !Number.isInteger(evaluated.value)) {
               return;
             }
-            path.replaceWith(t17.valueToNode(evaluated.value));
+            path.replaceWith(t27.valueToNode(evaluated.value));
             path.skip();
             this.changes++;
           }
@@ -1299,8 +3368,8 @@ var number_expressions_default = {
     }
   })
 };
-var matcher13 = m20.or(m20.binaryExpression(m20.or("+", "-", "*", "/"), m20.matcher((node) => matcher13.match(node)), m20.matcher((node) => matcher13.match(node))), m20.binaryExpression("-", m20.or(m20.stringLiteral(), m20.matcher((node) => matcher13.match(node))), m20.or(m20.stringLiteral(), m20.matcher((node) => matcher13.match(node)))), m20.unaryExpression("-", m20.or(m20.stringLiteral(), m20.matcher((node) => matcher13.match(node)))), m20.numericLiteral());
-// node_modules/webcrack/src/unminify/transforms/raw-literals.ts
+var matcher3 = or(binaryExpression(or("+", "-", "*", "/"), predicate((node) => matcher3.match(node)), predicate((node) => matcher3.match(node))), binaryExpression("-", or(stringLiteral(), predicate((node) => matcher3.match(node))), or(stringLiteral(), predicate((node) => matcher3.match(node)))), unaryExpression("-", or(stringLiteral(), predicate((node) => matcher3.match(node)))), numericLiteral());
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/raw-literals.ts
 var raw_literals_default = {
   name: "raw-literals",
   tags: ["safe"],
@@ -1319,26 +3388,25 @@ var raw_literals_default = {
     }
   })
 };
-// node_modules/webcrack/src/unminify/transforms/sequence.ts
-import * as t18 from "@babel/types";
-import * as m21 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/sequence.ts
+import * as t28 from "@babel/types";
 var sequence_default = {
   name: "sequence",
   tags: ["safe"],
   visitor() {
-    const assignmentVariable = m21.or(m21.identifier(), m21.memberExpression(m21.identifier(), m21.identifier()));
-    const assignedSequence = m21.capture(m21.sequenceExpression());
-    const assignmentMatcher = m21.expressionStatement(m21.assignmentExpression(m21.or("=", "+=", "-=", "*=", "/=", "%=", "**=", "<<=", ">>=", ">>>=", "|=", "^=", "&="), assignmentVariable, assignedSequence));
+    const assignmentVariable = or(identifier(), memberExpression(identifier(), identifier()));
+    const assignedSequence = capture(sequenceExpression());
+    const assignmentMatcher = expressionStatement(assignmentExpression(or("=", "+=", "-=", "*=", "/=", "%=", "**=", "<<=", ">>=", ">>>=", "|=", "^=", "&="), assignmentVariable, assignedSequence));
     return {
       ExpressionStatement: {
         exit(path) {
-          if (t18.isSequenceExpression(path.node.expression)) {
-            const statements = path.node.expression.expressions.map((expr) => t18.expressionStatement(expr));
+          if (t28.isSequenceExpression(path.node.expression)) {
+            const statements = path.node.expression.expressions.map((expr) => t28.expressionStatement(expr));
             path.replaceWithMultiple(statements);
             this.changes++;
           } else if (assignmentMatcher.match(path.node)) {
             const value = assignedSequence.current.expressions.pop();
-            const statements = assignedSequence.current.expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = assignedSequence.current.expressions.map((expr) => t28.expressionStatement(expr));
             path.get("expression.right").replaceWith(value);
             path.insertBefore(statements);
             this.changes++;
@@ -1347,10 +3415,10 @@ var sequence_default = {
       },
       ReturnStatement: {
         exit(path) {
-          if (t18.isSequenceExpression(path.node.argument)) {
+          if (t28.isSequenceExpression(path.node.argument)) {
             const expressions = path.node.argument.expressions;
             path.node.argument = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
             path.insertBefore(statements);
             this.changes++;
           }
@@ -1358,10 +3426,10 @@ var sequence_default = {
       },
       IfStatement: {
         exit(path) {
-          if (t18.isSequenceExpression(path.node.test)) {
+          if (t28.isSequenceExpression(path.node.test)) {
             const expressions = path.node.test.expressions;
             path.node.test = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
             path.insertBefore(statements);
             this.changes++;
           }
@@ -1369,10 +3437,10 @@ var sequence_default = {
       },
       SwitchStatement: {
         exit(path) {
-          if (t18.isSequenceExpression(path.node.discriminant)) {
+          if (t28.isSequenceExpression(path.node.discriminant)) {
             const expressions = path.node.discriminant.expressions;
             path.node.discriminant = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
             path.insertBefore(statements);
             this.changes++;
           }
@@ -1380,10 +3448,10 @@ var sequence_default = {
       },
       ThrowStatement: {
         exit(path) {
-          if (t18.isSequenceExpression(path.node.argument)) {
+          if (t28.isSequenceExpression(path.node.argument)) {
             const expressions = path.node.argument.expressions;
             path.node.argument = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
             path.insertBefore(statements);
             this.changes++;
           }
@@ -1391,12 +3459,12 @@ var sequence_default = {
       },
       ForInStatement: {
         exit(path) {
-          const sequence = m21.capture(m21.sequenceExpression());
-          const matcher14 = m21.forInStatement(m21.anything(), sequence);
-          if (matcher14.match(path.node)) {
+          const sequence = capture(sequenceExpression());
+          const matcher4 = forInStatement(anything(), sequence);
+          if (matcher4.match(path.node)) {
             const expressions = sequence.current.expressions;
             path.node.right = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
             path.insertBefore(statements);
             this.changes++;
           }
@@ -1404,27 +3472,27 @@ var sequence_default = {
       },
       ForStatement: {
         exit(path) {
-          if (t18.isSequenceExpression(path.node.init)) {
-            const statements = path.node.init.expressions.map((expr) => t18.expressionStatement(expr));
+          if (t28.isSequenceExpression(path.node.init)) {
+            const statements = path.node.init.expressions.map((expr) => t28.expressionStatement(expr));
             path.insertBefore(statements);
             path.node.init = null;
             this.changes++;
           }
-          if (t18.isSequenceExpression(path.node.update) && path.node.body.type === "EmptyStatement") {
+          if (t28.isSequenceExpression(path.node.update) && path.node.body.type === "EmptyStatement") {
             const expressions = path.node.update.expressions;
             path.node.update = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
-            path.node.body = t18.blockStatement(statements);
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
+            path.node.body = t28.blockStatement(statements);
             this.changes++;
           }
         }
       },
       WhileStatement: {
         exit(path) {
-          if (t18.isSequenceExpression(path.node.test)) {
+          if (t28.isSequenceExpression(path.node.test)) {
             const expressions = path.node.test.expressions;
             path.node.test = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
             path.insertBefore(statements);
             this.changes++;
           }
@@ -1432,14 +3500,14 @@ var sequence_default = {
       },
       VariableDeclaration: {
         exit(path) {
-          const sequence = m21.capture(m21.sequenceExpression());
-          const matcher14 = m21.variableDeclaration(undefined, [
-            m21.variableDeclarator(undefined, sequence)
+          const sequence = capture(sequenceExpression());
+          const matcher4 = variableDeclaration(undefined, [
+            variableDeclarator(undefined, sequence)
           ]);
-          if (matcher14.match(path.node)) {
+          if (matcher4.match(path.node)) {
             const expressions = sequence.current.expressions;
             path.node.declarations[0].init = expressions.pop();
-            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            const statements = expressions.map((expr) => t28.expressionStatement(expr));
             if (path.parentPath.isForStatement() && path.key === "init") {
               path.parentPath.insertBefore(statements);
             } else {
@@ -1452,8 +3520,8 @@ var sequence_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/split-variable-declarations.ts
-import * as t19 from "@babel/types";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/split-variable-declarations.ts
+import * as t29 from "@babel/types";
 var split_variable_declarations_default = {
   name: "split-variable-declarations",
   tags: ["safe"],
@@ -1462,9 +3530,9 @@ var split_variable_declarations_default = {
       exit(path) {
         if (path.node.declarations.length > 1 && path.key !== "init") {
           if (path.parentPath.isExportNamedDeclaration()) {
-            path.parentPath.replaceWithMultiple(path.node.declarations.map((declaration) => t19.exportNamedDeclaration(t19.variableDeclaration(path.node.kind, [declaration]))));
+            path.parentPath.replaceWithMultiple(path.node.declarations.map((declaration) => t29.exportNamedDeclaration(t29.variableDeclaration(path.node.kind, [declaration]))));
           } else {
-            path.replaceWithMultiple(path.node.declarations.map((declaration) => t19.variableDeclaration(path.node.kind, [declaration])));
+            path.replaceWithMultiple(path.node.declarations.map((declaration) => t29.variableDeclaration(path.node.kind, [declaration])));
           }
           this.changes++;
         }
@@ -1472,17 +3540,16 @@ var split_variable_declarations_default = {
     }
   })
 };
-// node_modules/webcrack/src/unminify/transforms/ternary-to-if.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/ternary-to-if.ts
 import {statement as statement2} from "@babel/template";
-import * as m22 from "@codemod/matchers";
 var ternary_to_if_default = {
   name: "ternary-to-if",
   tags: ["safe"],
   visitor() {
-    const test = m22.capture(m22.anyExpression());
-    const consequent = m22.capture(m22.anyExpression());
-    const alternate = m22.capture(m22.anyExpression());
-    const conditional = m22.conditionalExpression(test, consequent, alternate);
+    const test = capture(anyExpression());
+    const consequent = capture(anyExpression());
+    const alternate = capture(anyExpression());
+    const conditional = conditionalExpression(test, consequent, alternate);
     const buildIf = statement2`if (TEST) { CONSEQUENT; } else { ALTERNATE; }`;
     const buildIfReturn = statement2`if (TEST) { return CONSEQUENT; } else { return ALTERNATE; }`;
     return {
@@ -1513,9 +3580,8 @@ var ternary_to_if_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/typeof-undefined.ts
-import * as t20 from "@babel/types";
-import * as m23 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/typeof-undefined.ts
+import * as t30 from "@babel/types";
 var OPERATOR_MAP = {
   ">": "===",
   "<": "!=="
@@ -1524,35 +3590,34 @@ var typeof_undefined_default = {
   name: "typeof-undefined",
   tags: ["safe"],
   visitor() {
-    const operator = m23.capture(m23.or(">", "<"));
-    const argument = m23.capture(m23.anyExpression());
-    const matcher14 = m23.binaryExpression(operator, m23.unaryExpression("typeof", argument), m23.stringLiteral("u"));
+    const operator = capture(or(">", "<"));
+    const argument = capture(anyExpression());
+    const matcher4 = binaryExpression(operator, unaryExpression("typeof", argument), stringLiteral("u"));
     return {
       BinaryExpression: {
         exit(path) {
-          if (!matcher14.match(path.node))
+          if (!matcher4.match(path.node))
             return;
-          path.replaceWith(t20.binaryExpression(OPERATOR_MAP[operator.current], t20.unaryExpression("typeof", argument.current), t20.stringLiteral("undefined")));
+          path.replaceWith(t30.binaryExpression(OPERATOR_MAP[operator.current], t30.unaryExpression("typeof", argument.current), t30.stringLiteral("undefined")));
           this.changes++;
         }
       }
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/unary-expressions.ts
-import * as t21 from "@babel/types";
-import * as m24 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/unary-expressions.ts
+import * as t31 from "@babel/types";
 var unary_expressions_default = {
   name: "unary-expressions",
   tags: ["safe"],
   visitor() {
-    const argument = m24.capture(m24.anyExpression());
-    const matcher14 = m24.expressionStatement(m24.unaryExpression(m24.or("void", "!", "typeof"), argument));
-    const returnVoid = m24.returnStatement(m24.unaryExpression("void", argument));
+    const argument = capture(anyExpression());
+    const matcher4 = expressionStatement(unaryExpression(or("void", "!", "typeof"), argument));
+    const returnVoid = returnStatement(unaryExpression("void", argument));
     return {
       ExpressionStatement: {
         exit(path) {
-          if (!matcher14.match(path.node))
+          if (!matcher4.match(path.node))
             return;
           path.replaceWith(argument.current);
           this.changes++;
@@ -1563,47 +3628,45 @@ var unary_expressions_default = {
           if (!returnVoid.match(path.node))
             return;
           path.replaceWith(argument.current);
-          path.insertAfter(t21.returnStatement());
+          path.insertAfter(t31.returnStatement());
           this.changes++;
         }
       }
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/unminify-booleans.ts
-import * as t22 from "@babel/types";
-import * as m25 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/unminify-booleans.ts
+import * as t32 from "@babel/types";
 var unminify_booleans_default = {
   name: "unminify-booleans",
   tags: ["safe"],
   visitor: () => ({
     UnaryExpression(path) {
       if (trueMatcher2.match(path.node)) {
-        path.replaceWith(t22.booleanLiteral(true));
+        path.replaceWith(t32.booleanLiteral(true));
         this.changes++;
       } else if (falseMatcher2.match(path.node)) {
-        path.replaceWith(t22.booleanLiteral(false));
+        path.replaceWith(t32.booleanLiteral(false));
         this.changes++;
       }
     }
   })
 };
-var trueMatcher2 = m25.or(m25.unaryExpression("!", m25.numericLiteral(0)), m25.unaryExpression("!", m25.unaryExpression("!", m25.numericLiteral(1))), m25.unaryExpression("!", m25.unaryExpression("!", m25.arrayExpression([]))));
-var falseMatcher2 = m25.or(m25.unaryExpression("!", m25.numericLiteral(1)), m25.unaryExpression("!", m25.arrayExpression([])));
-// node_modules/webcrack/src/unminify/transforms/void-to-undefined.ts
-import * as t23 from "@babel/types";
-import * as m26 from "@codemod/matchers";
+var trueMatcher2 = or(unaryExpression("!", numericLiteral(0)), unaryExpression("!", unaryExpression("!", numericLiteral(1))), unaryExpression("!", unaryExpression("!", arrayExpression([]))));
+var falseMatcher2 = or(unaryExpression("!", numericLiteral(1)), unaryExpression("!", arrayExpression([])));
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/void-to-undefined.ts
+import * as t33 from "@babel/types";
 var void_to_undefined_default = {
   name: "void-to-undefined",
   tags: ["safe"],
   scope: true,
   visitor: () => {
-    const matcher14 = m26.unaryExpression("void", m26.numericLiteral(0));
+    const matcher4 = unaryExpression("void", numericLiteral(0));
     return {
       UnaryExpression: {
         exit(path) {
-          if (matcher14.match(path.node) && !path.scope.hasBinding("undefined", { noGlobals: true })) {
-            path.replaceWith(t23.identifier("undefined"));
+          if (matcher4.match(path.node) && !path.scope.hasBinding("undefined", { noGlobals: true })) {
+            path.replaceWith(t33.identifier("undefined"));
             this.changes++;
           }
         }
@@ -1611,9 +3674,8 @@ var void_to_undefined_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/transforms/yoda.ts
-import * as t24 from "@babel/types";
-import * as m27 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/unminify/transforms/yoda.ts
+import * as t34 from "@babel/types";
 var FLIPPED_OPERATORS = {
   "==": "==",
   "===": "===",
@@ -1632,12 +3694,12 @@ var yoda_default = {
   name: "yoda",
   tags: ["safe"],
   visitor: () => {
-    const matcher15 = m27.binaryExpression(m27.or(...Object.values(FLIPPED_OPERATORS)), m27.or(m27.stringLiteral(), m27.numericLiteral(), m27.unaryExpression("-", m27.or(m27.numericLiteral(), m27.identifier("Infinity"))), m27.booleanLiteral(), m27.nullLiteral(), m27.identifier("undefined"), m27.identifier("NaN"), m27.identifier("Infinity")), m27.matcher((node) => !t24.isLiteral(node)));
+    const matcher4 = binaryExpression(or(...Object.values(FLIPPED_OPERATORS)), or(stringLiteral(), numericLiteral(), unaryExpression("-", or(numericLiteral(), identifier("Infinity"))), booleanLiteral(), nullLiteral(), identifier("undefined"), identifier("NaN"), identifier("Infinity")), predicate((node) => !t34.isLiteral(node)));
     return {
       BinaryExpression: {
         exit(path) {
-          if (matcher15.match(path.node)) {
-            path.replaceWith(t24.binaryExpression(FLIPPED_OPERATORS[path.node.operator], path.node.right, path.node.left));
+          if (matcher4.match(path.node)) {
+            path.replaceWith(t34.binaryExpression(FLIPPED_OPERATORS[path.node.operator], path.node.right, path.node.left));
             this.changes++;
           }
         }
@@ -1645,7 +3707,7 @@ var yoda_default = {
     };
   }
 };
-// node_modules/webcrack/src/unminify/index.ts
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/webcrack/src/unminify/index.ts
 var unminify_default = mergeTransforms({
   name: "unminify",
   tags: ["safe"],
@@ -1668,23 +3730,20 @@ async function transform2(ast2) {
 }
 
 // transform/esmodule/module-helper.ts
-import * as t25 from "@babel/types";
-import * as m34 from "@codemod/matchers";
+import * as t35 from "@babel/types";
 
 // utils/matchers/chunk.ts
-import * as m28 from "@codemod/matchers";
 function chunk(id) {
-  return m28.objectProperty(m28.numericLiteral(id), m28.or(functionExpr([]), functionExpr([mod]), functionExpr([mod, exp]), functionExpr([mod, exp, req])));
+  return objectProperty(numericLiteral(id), or(functionExpr([]), functionExpr([mod]), functionExpr([mod, exp]), functionExpr([mod, exp, req])));
 }
-var mod = m28.capture(m28.identifier());
-var exp = m28.capture(m28.identifier());
-var req = m28.capture(m28.identifier());
-var functionExpr = (args) => m28.or(m28.functionExpression(null, args, m28.blockStatement(), false, false), m28.arrowFunctionExpression(args, m28.blockStatement(), false));
-var chunks = m28.objectExpression(m28.anyList(m28.oneOrMore(chunk())));
+var mod = capture(identifier());
+var exp = capture(identifier());
+var req = capture(identifier());
+var functionExpr = (args) => or(functionExpression(null, args, blockStatement(), false, false), arrowFunctionExpression(args, blockStatement(), false));
+var chunks = objectExpression(anyList(oneOrMore(chunk())));
 var chunk_default = chunk();
 
 // utils/matchers/createBinding.ts
-import * as m29 from "@codemod/matchers";
 import tmpl from "@babel/template";
 var __createBinding = tmpl.expression.ast`
 (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -1699,50 +3758,49 @@ var __createBinding = tmpl.expression.ast`
 	o[k2] = m[k];
 }))
 `;
-var obj = m29.capture(m29.identifier());
-var mod2 = m29.capture(m29.identifier());
-var k = m29.capture(m29.identifier());
-var k2 = m29.capture(m29.identifier());
-var desc = m29.capture(m29.identifier());
-var descObj = m29.objectExpression([
-  m29.objectProperty(m29.identifier("enumerable"), m29.booleanLiteral(true)),
-  m29.objectProperty(m29.identifier("get"), m29.functionExpression(null, [], m29.blockStatement([
-    m29.returnStatement(m29.memberExpression(m29.fromCapture(mod2), m29.fromCapture(k), true))
+var obj = capture(identifier());
+var mod2 = capture(identifier());
+var k = capture(identifier());
+var k2 = capture(identifier());
+var desc = capture(identifier());
+var descObj = objectExpression([
+  objectProperty(identifier("enumerable"), booleanLiteral(true)),
+  objectProperty(identifier("get"), functionExpression(null, [], blockStatement([
+    returnStatement(memberExpression(fromCapture(mod2), fromCapture(k), true))
   ])))
 ]);
-var cond = m29.conditionalExpression(m29.binaryExpression("in", m29.stringLiteral("get"), m29.fromCapture(desc)), m29.unaryExpression("!", m29.memberExpression(m29.fromCapture(mod2), m29.identifier("__esModule"), false)), m29.logicalExpression("||", m29.memberExpression(m29.fromCapture(desc), m29.identifier("writable"), false), m29.memberExpression(m29.fromCapture(desc), m29.identifier("configurable"), false)));
-var createBinding_default = m29.variableDeclaration("var", [
-  m29.variableDeclarator(m29.identifier(), m29.logicalExpression("||", m29.logicalExpression("&&", m29.thisExpression(), m29.memberExpression(m29.thisExpression(), m29.identifier("__createBinding"))), m29.conditionalExpression(m29.memberExpression(m29.identifier("Object"), m29.identifier("create")), m29.functionExpression(null, [obj, mod2, k, k2], m29.or(m29.blockStatement([
-    m29.ifStatement(m29.binaryExpression("===", k2, m29.identifier("undefined")), m29.containerOf(m29.expressionStatement(m29.assignmentExpression("=", m29.fromCapture(k2), m29.fromCapture(k)))), null),
-    m29.variableDeclaration("var", [
-      m29.variableDeclarator(desc, m29.callExpression(m29.memberExpression(m29.identifier("Object"), m29.identifier("getOwnPropertyDescriptor"), false), [
-        m29.fromCapture(mod2),
-        m29.fromCapture(k)
+var cond = conditionalExpression(binaryExpression("in", stringLiteral("get"), fromCapture(desc)), unaryExpression("!", memberExpression(fromCapture(mod2), identifier("__esModule"), false)), logicalExpression("||", memberExpression(fromCapture(desc), identifier("writable"), false), memberExpression(fromCapture(desc), identifier("configurable"), false)));
+var createBinding_default = variableDeclaration("var", [
+  variableDeclarator(identifier(), logicalExpression("||", logicalExpression("&&", thisExpression(), memberExpression(thisExpression(), identifier("__createBinding"))), conditionalExpression(memberExpression(identifier("Object"), identifier("create")), functionExpression(null, [obj, mod2, k, k2], or(blockStatement([
+    ifStatement(binaryExpression("===", k2, identifier("undefined")), containerOf(expressionStatement(assignmentExpression("=", fromCapture(k2), fromCapture(k)))), null),
+    variableDeclaration("var", [
+      variableDeclarator(desc, callExpression(memberExpression(identifier("Object"), identifier("getOwnPropertyDescriptor"), false), [
+        fromCapture(mod2),
+        fromCapture(k)
       ]))
     ]),
-    m29.ifStatement(m29.logicalExpression("||", m29.unaryExpression("!", m29.fromCapture(desc), true), m29.or(cond, m29.unaryExpression("!", m29.unaryExpression("!", cond, true), true))), m29.blockStatement([
-      m29.expressionStatement(m29.assignmentExpression("=", m29.fromCapture(desc), descObj))
+    ifStatement(logicalExpression("||", unaryExpression("!", fromCapture(desc), true), or(cond, unaryExpression("!", unaryExpression("!", cond, true), true))), blockStatement([
+      expressionStatement(assignmentExpression("=", fromCapture(desc), descObj))
     ]), null),
-    m29.expressionStatement(m29.callExpression(m29.memberExpression(m29.identifier("Object"), m29.identifier("defineProperty"), false), [
-      m29.fromCapture(obj),
-      m29.fromCapture(k2),
-      m29.fromCapture(desc)
+    expressionStatement(callExpression(memberExpression(identifier("Object"), identifier("defineProperty"), false), [
+      fromCapture(obj),
+      fromCapture(k2),
+      fromCapture(desc)
     ]))
-  ]), m29.blockStatement([
-    m29.ifStatement(m29.binaryExpression("===", k2, m29.identifier("undefined")), m29.containerOf(m29.expressionStatement(m29.assignmentExpression("=", m29.fromCapture(k2), m29.fromCapture(k)))), null),
-    m29.expressionStatement(m29.callExpression(m29.memberExpression(m29.identifier("Object"), m29.identifier("defineProperty"), false), [
-      m29.fromCapture(obj),
-      m29.fromCapture(k2),
+  ]), blockStatement([
+    ifStatement(binaryExpression("===", k2, identifier("undefined")), containerOf(expressionStatement(assignmentExpression("=", fromCapture(k2), fromCapture(k)))), null),
+    expressionStatement(callExpression(memberExpression(identifier("Object"), identifier("defineProperty"), false), [
+      fromCapture(obj),
+      fromCapture(k2),
       descObj
     ]))
-  ]))), m29.functionExpression(null, [obj, mod2, k, k2], m29.blockStatement([
-    m29.ifStatement(m29.binaryExpression("===", k2, m29.identifier("undefined")), m29.containerOf(m29.expressionStatement(m29.assignmentExpression("=", m29.fromCapture(k2), m29.fromCapture(k)))), null),
-    m29.expressionStatement(m29.assignmentExpression("=", m29.memberExpression(m29.fromCapture(obj), m29.fromCapture(k2), true), m29.memberExpression(m29.fromCapture(mod2), m29.fromCapture(k), true)))
+  ]))), functionExpression(null, [obj, mod2, k, k2], blockStatement([
+    ifStatement(binaryExpression("===", k2, identifier("undefined")), containerOf(expressionStatement(assignmentExpression("=", fromCapture(k2), fromCapture(k)))), null),
+    expressionStatement(assignmentExpression("=", memberExpression(fromCapture(obj), fromCapture(k2), true), memberExpression(fromCapture(mod2), fromCapture(k), true)))
   ])))))
 ]);
 
 // utils/matchers/setModuleDefault.ts
-import * as m30 from "@codemod/matchers";
 import tmpl2 from "@babel/template";
 var __setModuleDefault = tmpl2.expression.ast`
 (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
@@ -1751,42 +3809,41 @@ var __setModuleDefault = tmpl2.expression.ast`
 	o["default"] = v;
 })
 `;
-var leftParamObj = m30.capture(m30.identifier());
-var leftParamVal = m30.capture(m30.identifier());
-var leftObjIdentifier = m30.capture(m30.identifier());
-var leftObj = m30.objectExpression([
-  m30.objectProperty(m30.identifier("enumerable"), m30.booleanLiteral(true)),
-  m30.objectProperty(m30.identifier("value"), leftParamVal)
+var leftParamObj = capture(identifier());
+var leftParamVal = capture(identifier());
+var leftObjIdentifier = capture(identifier());
+var leftObj = objectExpression([
+  objectProperty(identifier("enumerable"), booleanLiteral(true)),
+  objectProperty(identifier("value"), leftParamVal)
 ]);
-var rightParamObj = m30.capture(m30.identifier());
-var rightParamVal = m30.capture(m30.identifier());
-var setModuleDefault_default = m30.variableDeclaration("var", [
-  m30.variableDeclarator(m30.identifier(), m30.logicalExpression("||", m30.logicalExpression("&&", m30.thisExpression(), m30.memberExpression(m30.thisExpression(), m30.identifier("__setModuleDefault"))), m30.conditionalExpression(m30.memberExpression(m30.identifier("Object"), m30.identifier("create")), m30.functionExpression(null, [
+var rightParamObj = capture(identifier());
+var rightParamVal = capture(identifier());
+var setModuleDefault_default = variableDeclaration("var", [
+  variableDeclarator(identifier(), logicalExpression("||", logicalExpression("&&", thisExpression(), memberExpression(thisExpression(), identifier("__setModuleDefault"))), conditionalExpression(memberExpression(identifier("Object"), identifier("create")), functionExpression(null, [
     leftParamObj,
     leftParamVal
-  ], m30.or(m30.blockStatement([
-    m30.variableDeclaration("const", [m30.variableDeclarator(leftObjIdentifier, leftObj)]),
-    m30.expressionStatement(m30.callExpression(m30.memberExpression(m30.identifier("Object"), m30.identifier("defineProperty")), [
+  ], or(blockStatement([
+    variableDeclaration("const", [variableDeclarator(leftObjIdentifier, leftObj)]),
+    expressionStatement(callExpression(memberExpression(identifier("Object"), identifier("defineProperty")), [
       leftParamObj,
-      m30.stringLiteral("default"),
+      stringLiteral("default"),
       leftObjIdentifier
     ]))
-  ]), m30.blockStatement([
-    m30.expressionStatement(m30.callExpression(m30.memberExpression(m30.identifier("Object"), m30.identifier("defineProperty")), [
+  ]), blockStatement([
+    expressionStatement(callExpression(memberExpression(identifier("Object"), identifier("defineProperty")), [
       leftParamObj,
-      m30.stringLiteral("default"),
+      stringLiteral("default"),
       leftObj
     ]))
-  ])), false, false), m30.functionExpression(null, [
+  ])), false, false), functionExpression(null, [
     rightParamObj,
     rightParamVal
-  ], m30.blockStatement([
-    m30.expressionStatement(m30.assignmentExpression("=", m30.memberExpression(rightParamObj, m30.identifier("default")), rightParamVal))
+  ], blockStatement([
+    expressionStatement(assignmentExpression("=", memberExpression(rightParamObj, identifier("default")), rightParamVal))
   ])))))
 ]);
 
 // utils/matchers/importStar.ts
-import * as m31 from "@codemod/matchers";
 import tmpl3 from "@babel/template";
 var __importStar = tmpl3.expression.ast`
 (this && this.__importStar) || function (mod) {
@@ -1797,82 +3854,80 @@ var __importStar = tmpl3.expression.ast`
 	return result;
 }
 `;
-var mod3 = m31.capture(m31.identifier());
-var k3 = m31.capture(m31.identifier());
-var result = m31.capture(m31.identifier());
-var importStar_default = m31.variableDeclaration("var", [
-  m31.variableDeclarator(m31.identifier(), m31.logicalExpression("||", m31.logicalExpression("&&", m31.thisExpression(), m31.memberExpression(m31.thisExpression(), m31.identifier("__importStar"), false)), m31.functionExpression(null, [mod3], m31.or(m31.blockStatement([
-    m31.ifStatement(m31.logicalExpression("&&", m31.fromCapture(mod3), m31.memberExpression(m31.fromCapture(mod3), m31.identifier("__esModule"))), m31.containerOf(m31.returnStatement(m31.fromCapture(mod3))), null),
-    m31.variableDeclaration("var", [
-      m31.variableDeclarator(result, m31.objectExpression([]))
+var mod3 = capture(identifier());
+var k3 = capture(identifier());
+var result = capture(identifier());
+var importStar_default = variableDeclaration("var", [
+  variableDeclarator(identifier(), logicalExpression("||", logicalExpression("&&", thisExpression(), memberExpression(thisExpression(), identifier("__importStar"), false)), functionExpression(null, [mod3], or(blockStatement([
+    ifStatement(logicalExpression("&&", fromCapture(mod3), memberExpression(fromCapture(mod3), identifier("__esModule"))), containerOf(returnStatement(fromCapture(mod3))), null),
+    variableDeclaration("var", [
+      variableDeclarator(result, objectExpression([]))
     ]),
-    m31.ifStatement(m31.binaryExpression("!=", m31.fromCapture(mod3), m31.nullLiteral()), m31.containerOf(m31.forInStatement(m31.variableDeclaration("var", [
-      m31.variableDeclarator(k3, null)
-    ]), m31.fromCapture(mod3), m31.containerOf(m31.ifStatement(m31.logicalExpression("&&", m31.binaryExpression("!==", m31.fromCapture(k3), m31.stringLiteral("default")), m31.callExpression(m31.memberExpression(m31.memberExpression(m31.memberExpression(m31.identifier("Object"), m31.identifier("prototype"), false), m31.identifier("hasOwnProperty"), false), m31.identifier("call"), false), [
-      m31.fromCapture(mod3),
-      m31.fromCapture(k3)
-    ])), m31.containerOf(m31.callExpression(m31.identifier(), [
-      m31.fromCapture(result),
-      m31.fromCapture(mod3),
-      m31.fromCapture(k3)
+    ifStatement(binaryExpression("!=", fromCapture(mod3), nullLiteral()), containerOf(forInStatement(variableDeclaration("var", [
+      variableDeclarator(k3, null)
+    ]), fromCapture(mod3), containerOf(ifStatement(logicalExpression("&&", binaryExpression("!==", fromCapture(k3), stringLiteral("default")), callExpression(memberExpression(memberExpression(memberExpression(identifier("Object"), identifier("prototype"), false), identifier("hasOwnProperty"), false), identifier("call"), false), [
+      fromCapture(mod3),
+      fromCapture(k3)
+    ])), containerOf(callExpression(identifier(), [
+      fromCapture(result),
+      fromCapture(mod3),
+      fromCapture(k3)
     ])))))), null),
-    m31.expressionStatement(m31.callExpression(m31.identifier(), [
-      m31.fromCapture(result),
-      m31.fromCapture(mod3)
+    expressionStatement(callExpression(identifier(), [
+      fromCapture(result),
+      fromCapture(mod3)
     ])),
-    m31.returnStatement(m31.fromCapture(result))
+    returnStatement(fromCapture(result))
   ])))))
 ]);
 
 // utils/matchers/importDefault.ts
-import * as m32 from "@codemod/matchers";
 import tmpl4 from "@babel/template";
 var __importDefault = tmpl4.expression.ast`
 (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 }
 `;
-var mod4 = m32.capture(m32.identifier());
-var isEsm = m32.logicalExpression("&&", m32.fromCapture(mod4), m32.memberExpression(m32.fromCapture(mod4), m32.identifier("__esModule"), false));
-var importDefault_default = m32.variableDeclaration("var", [
-  m32.variableDeclarator(m32.identifier(), m32.logicalExpression("||", m32.logicalExpression("&&", m32.thisExpression(), m32.memberExpression(m32.thisExpression(), m32.identifier("__importDefault"))), m32.functionExpression(null, [mod4], m32.blockStatement([
-    m32.or(m32.returnStatement(m32.conditionalExpression(isEsm, m32.fromCapture(mod4), m32.objectExpression([
-      m32.objectProperty(m32.stringLiteral("default"), m32.fromCapture(mod4), false)
-    ]))), m32.ifStatement(isEsm, m32.containerOf(m32.returnStatement(m32.fromCapture(mod4))), m32.containerOf(m32.returnStatement(m32.objectExpression([
-      m32.objectProperty(m32.identifier("default"), m32.fromCapture(mod4), false)
+var mod4 = capture(identifier());
+var isEsm = logicalExpression("&&", fromCapture(mod4), memberExpression(fromCapture(mod4), identifier("__esModule"), false));
+var importDefault_default = variableDeclaration("var", [
+  variableDeclarator(identifier(), logicalExpression("||", logicalExpression("&&", thisExpression(), memberExpression(thisExpression(), identifier("__importDefault"))), functionExpression(null, [mod4], blockStatement([
+    or(returnStatement(conditionalExpression(isEsm, fromCapture(mod4), objectExpression([
+      objectProperty(stringLiteral("default"), fromCapture(mod4), false)
+    ]))), ifStatement(isEsm, containerOf(returnStatement(fromCapture(mod4))), containerOf(returnStatement(objectExpression([
+      objectProperty(identifier("default"), fromCapture(mod4), false)
     ])))))
   ]))))
 ]);
 
 // utils/matchers/exportStar.ts
-import * as m33 from "@codemod/matchers";
 import tmpl5 from "@babel/template";
 var __exportStar = tmpl5.expression.ast`
 (this && this.__exportStar) || function(m, exports) {
 	for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 }
 `;
-var mod5 = m33.capture(m33.identifier());
-var exp2 = m33.capture(m33.identifier());
-var p = m33.capture(m33.identifier());
-var exportStar_default = m33.variableDeclaration("var", [
-  m33.variableDeclarator(m33.identifier(), m33.logicalExpression("||", m33.logicalExpression("&&", m33.thisExpression(), m33.memberExpression(m33.thisExpression(), m33.identifier("__exportStar"), false)), m33.functionExpression(null, [mod5, exp2], m33.blockStatement([
-    m33.forInStatement(m33.variableDeclaration("var", [
-      m33.variableDeclarator(p)
-    ]), m33.fromCapture(mod5), m33.containerOf(m33.ifStatement(m33.logicalExpression("&&", m33.binaryExpression("!==", m33.fromCapture(p), m33.stringLiteral("default")), m33.unaryExpression("!", m33.callExpression(m33.memberExpression(m33.memberExpression(m33.memberExpression(m33.identifier("Object"), m33.identifier("prototype"), false), m33.identifier("hasOwnProperty"), false), m33.identifier("call"), false), [
-      m33.fromCapture(exp2),
-      m33.fromCapture(p)
-    ]), true)), m33.containerOf(m33.expressionStatement(m33.callExpression(m33.identifier(), [
-      m33.fromCapture(exp2),
-      m33.fromCapture(mod5),
-      m33.fromCapture(p)
+var mod5 = capture(identifier());
+var exp2 = capture(identifier());
+var p = capture(identifier());
+var exportStar_default = variableDeclaration("var", [
+  variableDeclarator(identifier(), logicalExpression("||", logicalExpression("&&", thisExpression(), memberExpression(thisExpression(), identifier("__exportStar"), false)), functionExpression(null, [mod5, exp2], blockStatement([
+    forInStatement(variableDeclaration("var", [
+      variableDeclarator(p)
+    ]), fromCapture(mod5), containerOf(ifStatement(logicalExpression("&&", binaryExpression("!==", fromCapture(p), stringLiteral("default")), unaryExpression("!", callExpression(memberExpression(memberExpression(memberExpression(identifier("Object"), identifier("prototype"), false), identifier("hasOwnProperty"), false), identifier("call"), false), [
+      fromCapture(exp2),
+      fromCapture(p)
+    ]), true)), containerOf(expressionStatement(callExpression(identifier(), [
+      fromCapture(exp2),
+      fromCapture(mod5),
+      fromCapture(p)
     ]))))))
   ]))))
 ]);
 
 // transform/esmodule/module-helper.ts
-var preExport = m34.assignmentExpression("=", m34.memberExpression(m34.identifier("exports"), m34.identifier(), false), m34.identifier("undefined"));
-var undefinedExpr = m34.expressionStatement(m34.identifier("undefined"));
+var preExport = assignmentExpression("=", memberExpression(identifier("exports"), identifier(), false), identifier("undefined"));
+var undefinedExpr = expressionStatement(identifier("undefined"));
 var module_helper_default = {
   name: "module-helper",
   tags: ["safe"],
@@ -1918,19 +3973,19 @@ var module_helper_default = {
                 if (!$id.isIdentifier()) {
                   return;
                 }
-                if (importStar_default.match(t25.cloneNode(p2.node))) {
+                if (importStar_default.match(t35.cloneNode(p2.node))) {
                   $id.scope.rename($id.node.name, "__importStar");
                   $decl.get("init").replaceWith(__importStar);
-                } else if (setModuleDefault_default.match(t25.cloneNode(p2.node))) {
+                } else if (setModuleDefault_default.match(t35.cloneNode(p2.node))) {
                   $id.scope.rename($id.node.name, "__setModuleDefault");
                   $decl.get("init").replaceWith(__setModuleDefault);
-                } else if (importDefault_default.match(t25.cloneNode(p2.node))) {
+                } else if (importDefault_default.match(t35.cloneNode(p2.node))) {
                   $id.scope.rename($id.node.name, "__importDefault");
                   $decl.get("init").replaceWith(__importDefault);
-                } else if (createBinding_default.match(t25.cloneNode(p2.node))) {
+                } else if (createBinding_default.match(t35.cloneNode(p2.node))) {
                   $id.scope.rename($id.node.name, "__createBinding");
                   $decl.get("init").replaceWith(__createBinding);
-                } else if (exportStar_default.match(t25.cloneNode(p2.node))) {
+                } else if (exportStar_default.match(t35.cloneNode(p2.node))) {
                   $id.scope.rename($id.node.name, "__exportStar");
                   $decl.get("init").replaceWith(__exportStar);
                 } else {
@@ -1947,7 +4002,7 @@ var module_helper_default = {
 };
 
 // transform/esmodule/indirect-call.ts
-import * as t26 from "@babel/types";
+import * as t36 from "@babel/types";
 var indirect_call_default = {
   name: "indirect-call",
   tags: ["unsafe"],
@@ -1955,16 +4010,16 @@ var indirect_call_default = {
     CallExpression: {
       exit($) {
         const { callee, arguments: args } = $.node;
-        if (!t26.isSequenceExpression(callee)) {
+        if (!t36.isSequenceExpression(callee)) {
           return;
         }
         const exprs = [...callee.expressions];
         const func = exprs.pop();
-        if (!t26.isMemberExpression(func)) {
+        if (!t36.isMemberExpression(func)) {
           return;
         }
-        if (exprs.every((expr) => t26.isPureish(expr))) {
-          $.replaceWith(t26.callExpression(func, args));
+        if (exprs.every((expr) => t36.isPureish(expr))) {
+          $.replaceWith(t36.callExpression(func, args));
           this.changes++;
         }
       }
@@ -1973,12 +4028,12 @@ var indirect_call_default = {
 };
 
 // utils/ast.ts
-import {parse as babelParse} from "@babel/parser";
+import {parse as babelParse2} from "@babel/parser";
 import babelGenerate2 from "@babel/generator";
 import debug4 from "debug";
-import traverse10, {visitors as visitors2} from "@babel/traverse";
-function parse(code) {
-  return babelParse(code, {
+import traverse12, {visitors as visitors2} from "@babel/traverse";
+function parse2(code) {
+  return babelParse2(code, {
     sourceType: "script",
     allowReturnOutsideFunction: true
   });
@@ -1986,14 +4041,14 @@ function parse(code) {
 function generate2(ast2) {
   return babelGenerate2(ast2, { jsescOption: { minimal: true, quotes: "single" } }).code;
 }
-function applyTransform2(ast2, transform3, options, noScopeOverride) {
+function applyTransform2(ast2, transform3, options2, noScopeOverride) {
   logger2(`${transform3.name}: started`);
   const state = { changes: 0 };
-  transform3.run?.(ast2, state, options);
+  transform3.run?.(ast2, state, options2);
   if (transform3.visitor) {
-    const visitor = transform3.visitor(options);
+    const visitor = transform3.visitor(options2);
     visitor.noScope = noScopeOverride ?? !transform3.scope;
-    traverse10(ast2, visitor, undefined, state);
+    traverse12(ast2, visitor, undefined, state);
   }
   logger2(`${transform3.name}: finished with ${state.changes} changes`);
   return state;
@@ -2008,8 +4063,7 @@ function transform3(ast2) {
 }
 
 // transform/syntactic/template-literal.ts
-import * as t27 from "@babel/types";
-import * as m35 from "@codemod/matchers";
+import * as t37 from "@babel/types";
 var escape = function(string) {
   return string.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("$", "\\$").replaceAll("\t", "\\t").replaceAll("\r", "\\r").replaceAll("\0", "\\0");
 };
@@ -2017,7 +4071,7 @@ var template_literal_default = {
   name: "template-literal",
   tags: ["safe"],
   visitor() {
-    const concatExpr = m35.binaryExpression("+", m35.or(m35.stringLiteral(), m35.templateLiteral()), m35.anyExpression());
+    const concatExpr = binaryExpression("+", or(stringLiteral(), templateLiteral()), anyExpression());
     return {
       BinaryExpression: {
         exit($) {
@@ -2032,10 +4086,10 @@ var template_literal_default = {
               if (!last) {
                 throw new Error("Unexpected empty template literal");
               }
-              $left.node.quasis.push(t27.templateElement({
+              $left.node.quasis.push(t37.templateElement({
                 raw: last.value.raw + $right.node.quasis[0].value.raw
               }, false), ...$right.node.quasis.slice(1));
-              $.replaceWith(t27.templateLiteral([
+              $.replaceWith(t37.templateLiteral([
                 ...$left.node.quasis
               ], [
                 ...$left.node.expressions,
@@ -2046,17 +4100,17 @@ var template_literal_default = {
               if (!last) {
                 throw new Error("Unexpected empty template literal");
               }
-              $left.node.quasis.push(t27.templateElement({
+              $left.node.quasis.push(t37.templateElement({
                 raw: escape(last.value.raw + $right.node.value)
               }, true));
               $.replaceWith($left.node);
             } else {
-              $.replaceWith(t27.templateLiteral([
+              $.replaceWith(t37.templateLiteral([
                 ...$left.node.quasis.map((element) => {
                   element.tail = false;
                   return element;
                 }),
-                t27.templateElement({ raw: "" }, true)
+                t37.templateElement({ raw: "" }, true)
               ], [
                 ...$left.node.expressions,
                 $right.node
@@ -2070,9 +4124,9 @@ var template_literal_default = {
               if ($right.isCallExpression() && $right.get("callee").isFunctionExpression()) {
                 return;
               }
-              $.replaceWith(t27.templateLiteral([
-                t27.templateElement({ raw: escape($left.node.value) }, false),
-                t27.templateElement({ raw: "" }, true)
+              $.replaceWith(t37.templateLiteral([
+                t37.templateElement({ raw: escape($left.node.value) }, false),
+                t37.templateElement({ raw: "" }, true)
               ], [
                 $right.node
               ]));
@@ -2091,7 +4145,7 @@ function transform4(ast2) {
   return ast2;
 }
 
-// node_modules/webcrack/src/transpile/transforms/index.ts
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/transpile/transforms/index.ts
 var exports_transforms2 = {};
 __export(exports_transforms2, {
   templateLiterals: () => {
@@ -2121,31 +4175,30 @@ __export(exports_transforms2, {
   }
 });
 
-// node_modules/webcrack/src/transpile/transforms/logical-assignments.ts
-import * as t28 from "@babel/types";
-import * as m36 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/transpile/transforms/logical-assignments.ts
+import * as t38 from "@babel/types";
 var logical_assignments_default = {
   name: "logical-assignments",
   tags: ["safe"],
   scope: true,
   visitor() {
-    const operator = m36.capture(m36.or("||", "&&"));
-    const left = m36.capture(m36.or(m36.identifier(), m36.memberExpression()));
-    const right = m36.capture(m36.anyExpression());
-    const idMatcher = m36.logicalExpression(operator, left, m36.assignmentExpression("=", m36.fromCapture(left), right));
-    const object = m36.capture(m36.anyExpression());
-    const property = m36.capture(m36.anyExpression());
-    const tmpVar = m36.capture(m36.identifier());
-    const member = m36.capture(m36.memberExpression(m36.fromCapture(tmpVar), m36.fromCapture(property)));
-    const memberMatcher = m36.logicalExpression(operator, m36.memberExpression(m36.assignmentExpression("=", tmpVar, object), property), m36.assignmentExpression("=", member, right));
-    const computedMemberMatcher = m36.logicalExpression(operator, m36.memberExpression(object, m36.assignmentExpression("=", tmpVar, property), true), m36.assignmentExpression("=", m36.memberExpression(m36.fromCapture(object), m36.fromCapture(tmpVar), true), right));
-    const tmpVar2 = m36.capture(m36.identifier());
-    const multiComputedMemberMatcher = m36.logicalExpression(operator, m36.memberExpression(m36.assignmentExpression("=", tmpVar, object), m36.assignmentExpression("=", tmpVar2, property), true), m36.assignmentExpression("=", m36.memberExpression(m36.fromCapture(tmpVar), m36.fromCapture(tmpVar2), true), right));
+    const operator = capture(or("||", "&&"));
+    const left = capture(or(identifier(), memberExpression()));
+    const right = capture(anyExpression());
+    const idMatcher = logicalExpression(operator, left, assignmentExpression("=", fromCapture(left), right));
+    const object = capture(anyExpression());
+    const property = capture(anyExpression());
+    const tmpVar = capture(identifier());
+    const member = capture(memberExpression(fromCapture(tmpVar), fromCapture(property)));
+    const memberMatcher = logicalExpression(operator, memberExpression(assignmentExpression("=", tmpVar, object), property), assignmentExpression("=", member, right));
+    const computedMemberMatcher = logicalExpression(operator, memberExpression(object, assignmentExpression("=", tmpVar, property), true), assignmentExpression("=", memberExpression(fromCapture(object), fromCapture(tmpVar), true), right));
+    const tmpVar2 = capture(identifier());
+    const multiComputedMemberMatcher = logicalExpression(operator, memberExpression(assignmentExpression("=", tmpVar, object), assignmentExpression("=", tmpVar2, property), true), assignmentExpression("=", memberExpression(fromCapture(tmpVar), fromCapture(tmpVar2), true), right));
     return {
       LogicalExpression: {
         exit(path) {
           if (idMatcher.match(path.node)) {
-            path.replaceWith(t28.assignmentExpression(operator.current + "=", left.current, right.current));
+            path.replaceWith(t38.assignmentExpression(operator.current + "=", left.current, right.current));
             this.changes++;
           } else if (memberMatcher.match(path.node)) {
             const binding = path.scope.getBinding(tmpVar.current.name);
@@ -2153,14 +4206,14 @@ var logical_assignments_default = {
               return;
             binding.path.remove();
             member.current.object = object.current;
-            path.replaceWith(t28.assignmentExpression(operator.current + "=", member.current, right.current));
+            path.replaceWith(t38.assignmentExpression(operator.current + "=", member.current, right.current));
             this.changes++;
           } else if (computedMemberMatcher.match(path.node)) {
             const binding = path.scope.getBinding(tmpVar.current.name);
             if (!isTemporaryVariable(binding, 1))
               return;
             binding.path.remove();
-            path.replaceWith(t28.assignmentExpression(operator.current + "=", t28.memberExpression(object.current, property.current, true), right.current));
+            path.replaceWith(t38.assignmentExpression(operator.current + "=", t38.memberExpression(object.current, property.current, true), right.current));
             this.changes++;
           } else if (multiComputedMemberMatcher.match(path.node)) {
             const binding = path.scope.getBinding(tmpVar.current.name);
@@ -2169,7 +4222,7 @@ var logical_assignments_default = {
               return;
             binding.path.remove();
             binding2.path.remove();
-            path.replaceWith(t28.assignmentExpression(operator.current + "=", t28.memberExpression(object.current, property.current, true), right.current));
+            path.replaceWith(t38.assignmentExpression(operator.current + "=", t38.memberExpression(object.current, property.current, true), right.current));
             this.changes++;
           }
         }
@@ -2177,32 +4230,31 @@ var logical_assignments_default = {
     };
   }
 };
-// node_modules/webcrack/src/transpile/transforms/nullish-coalescing.ts
-import * as t29 from "@babel/types";
-import * as m37 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/transpile/transforms/nullish-coalescing.ts
+import * as t39 from "@babel/types";
 var nullish_coalescing_default = {
   name: "nullish-coalescing",
   tags: ["safe"],
   scope: true,
   visitor() {
-    const tmpVar = m37.capture(m37.identifier());
-    const left = m37.capture(m37.anyExpression());
-    const right = m37.capture(m37.anyExpression());
-    const idMatcher = m37.conditionalExpression(m37.logicalExpression("&&", m37.binaryExpression("!==", m37.assignmentExpression("=", tmpVar, left), m37.nullLiteral()), m37.binaryExpression("!==", m37.fromCapture(tmpVar), m37.identifier("undefined"))), m37.fromCapture(tmpVar), right);
-    const idLooseMatcher = m37.conditionalExpression(m37.binaryExpression("!=", m37.assignmentExpression("=", tmpVar, left), m37.nullLiteral()), m37.fromCapture(tmpVar), right);
-    const simpleIdMatcher = m37.conditionalExpression(m37.or(m37.logicalExpression("&&", m37.binaryExpression("!==", left, m37.nullLiteral()), m37.binaryExpression("!==", m37.fromCapture(left), m37.identifier("undefined"))), m37.binaryExpression("!=", left, m37.nullLiteral())), m37.fromCapture(left), right);
-    const iifeMatcher = m37.callExpression(m37.arrowFunctionExpression([m37.fromCapture(tmpVar)], m37.anyExpression(), false), []);
+    const tmpVar = capture(identifier());
+    const left = capture(anyExpression());
+    const right = capture(anyExpression());
+    const idMatcher = conditionalExpression(logicalExpression("&&", binaryExpression("!==", assignmentExpression("=", tmpVar, left), nullLiteral()), binaryExpression("!==", fromCapture(tmpVar), identifier("undefined"))), fromCapture(tmpVar), right);
+    const idLooseMatcher = conditionalExpression(binaryExpression("!=", assignmentExpression("=", tmpVar, left), nullLiteral()), fromCapture(tmpVar), right);
+    const simpleIdMatcher = conditionalExpression(or(logicalExpression("&&", binaryExpression("!==", left, nullLiteral()), binaryExpression("!==", fromCapture(left), identifier("undefined"))), binaryExpression("!=", left, nullLiteral())), fromCapture(left), right);
+    const iifeMatcher = callExpression(arrowFunctionExpression([fromCapture(tmpVar)], anyExpression(), false), []);
     return {
       ConditionalExpression: {
         exit(path) {
           if (idMatcher.match(path.node)) {
             const binding = path.scope.getBinding(tmpVar.current.name);
             if (iifeMatcher.match(path.parentPath.parent) && isTemporaryVariable(binding, 2, "param")) {
-              path.parentPath.parentPath.replaceWith(t29.logicalExpression("??", left.current, right.current));
+              path.parentPath.parentPath.replaceWith(t39.logicalExpression("??", left.current, right.current));
               this.changes++;
             } else if (isTemporaryVariable(binding, 2, "var")) {
               binding.path.remove();
-              path.replaceWith(t29.logicalExpression("??", left.current, right.current));
+              path.replaceWith(t39.logicalExpression("??", left.current, right.current));
               this.changes++;
             }
           } else if (idLooseMatcher.match(path.node)) {
@@ -2210,10 +4262,10 @@ var nullish_coalescing_default = {
             if (!isTemporaryVariable(binding, 1))
               return;
             binding.path.remove();
-            path.replaceWith(t29.logicalExpression("??", left.current, right.current));
+            path.replaceWith(t39.logicalExpression("??", left.current, right.current));
             this.changes++;
           } else if (simpleIdMatcher.match(path.node)) {
-            path.replaceWith(t29.logicalExpression("??", left.current, right.current));
+            path.replaceWith(t39.logicalExpression("??", left.current, right.current));
             this.changes++;
           }
         }
@@ -2221,22 +4273,21 @@ var nullish_coalescing_default = {
     };
   }
 };
-// node_modules/webcrack/src/transpile/transforms/nullish-coalescing-assignment.ts
-import * as t30 from "@babel/types";
-import * as m38 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/transpile/transforms/nullish-coalescing-assignment.ts
+import * as t40 from "@babel/types";
 var nullish_coalescing_assignment_default = {
   name: "nullish-coalescing-assignment",
   tags: ["safe"],
   scope: true,
   visitor() {
-    const tmpVar = m38.capture(m38.identifier());
-    const leftId = m38.capture(m38.identifier());
-    const property = m38.capture(m38.identifier());
-    const right = m38.capture(m38.anyExpression());
-    const computed = m38.capture(m38.anything());
-    const memberMatcher = m38.logicalExpression("??", m38.memberExpression(m38.assignmentExpression("=", tmpVar, leftId), property, computed), m38.assignmentExpression("=", m38.memberExpression(m38.fromCapture(tmpVar), m38.fromCapture(property), computed), right));
-    const left = m38.capture(m38.or(m38.identifier(), m38.memberExpression()));
-    const simpleMatcher = m38.logicalExpression("??", left, m38.assignmentExpression("=", m38.fromCapture(left), right));
+    const tmpVar = capture(identifier());
+    const leftId = capture(identifier());
+    const property = capture(identifier());
+    const right = capture(anyExpression());
+    const computed = capture(anything());
+    const memberMatcher = logicalExpression("??", memberExpression(assignmentExpression("=", tmpVar, leftId), property, computed), assignmentExpression("=", memberExpression(fromCapture(tmpVar), fromCapture(property), computed), right));
+    const left = capture(or(identifier(), memberExpression()));
+    const simpleMatcher = logicalExpression("??", left, assignmentExpression("=", fromCapture(left), right));
     return {
       LogicalExpression: {
         exit(path) {
@@ -2245,10 +4296,10 @@ var nullish_coalescing_assignment_default = {
             if (!isTemporaryVariable(binding, 1))
               return;
             binding.path.remove();
-            path.replaceWith(t30.assignmentExpression("??=", t30.memberExpression(leftId.current, property.current, computed.current), right.current));
+            path.replaceWith(t40.assignmentExpression("??=", t40.memberExpression(leftId.current, property.current, computed.current), right.current));
             this.changes++;
           } else if (simpleMatcher.match(path.node)) {
-            path.replaceWith(t30.assignmentExpression("??=", left.current, right.current));
+            path.replaceWith(t40.assignmentExpression("??=", left.current, right.current));
             this.changes++;
           }
         }
@@ -2256,26 +4307,25 @@ var nullish_coalescing_assignment_default = {
     };
   }
 };
-// node_modules/webcrack/src/transpile/transforms/optional-chaining.ts
-import * as t31 from "@babel/types";
-import * as m39 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/transpile/transforms/optional-chaining.ts
+import * as t41 from "@babel/types";
 var optional_chaining_default = {
   name: "optional-chaining",
   tags: ["safe"],
   scope: true,
   visitor() {
-    const object = m39.capture(m39.anyExpression());
-    const member = m39.capture(m39.memberExpression(m39.fromCapture(object)));
-    const simpleMatcher = m39.conditionalExpression(m39.logicalExpression("||", m39.binaryExpression("===", object, m39.nullLiteral()), m39.binaryExpression("===", m39.fromCapture(object), m39.identifier("undefined"))), m39.identifier("undefined"), member);
-    const tmpVar = m39.capture(m39.identifier());
-    const tmpMember = m39.capture(m39.memberExpression(m39.fromCapture(tmpVar)));
-    const tmpMatcher = m39.conditionalExpression(m39.logicalExpression("||", m39.binaryExpression("===", m39.assignmentExpression("=", tmpVar, object), m39.nullLiteral()), m39.binaryExpression("===", m39.fromCapture(tmpVar), m39.identifier("undefined"))), m39.identifier("undefined"), tmpMember);
+    const object = capture(anyExpression());
+    const member = capture(memberExpression(fromCapture(object)));
+    const simpleMatcher = conditionalExpression(logicalExpression("||", binaryExpression("===", object, nullLiteral()), binaryExpression("===", fromCapture(object), identifier("undefined"))), identifier("undefined"), member);
+    const tmpVar = capture(identifier());
+    const tmpMember = capture(memberExpression(fromCapture(tmpVar)));
+    const tmpMatcher = conditionalExpression(logicalExpression("||", binaryExpression("===", assignmentExpression("=", tmpVar, object), nullLiteral()), binaryExpression("===", fromCapture(tmpVar), identifier("undefined"))), identifier("undefined"), tmpMember);
     return {
       ConditionalExpression: {
         exit(path) {
           if (simpleMatcher.match(path.node)) {
             member.current.optional = true;
-            path.replaceWith(t31.optionalMemberExpression(object.current, member.current.property, member.current.computed, true));
+            path.replaceWith(t41.optionalMemberExpression(object.current, member.current.property, member.current.computed, true));
             this.changes++;
           } else if (tmpMatcher.match(path.node)) {
             const binding = path.scope.getBinding(tmpVar.current.name);
@@ -2283,7 +4333,7 @@ var optional_chaining_default = {
               return;
             binding.path.remove();
             tmpMember.current.optional = true;
-            path.replaceWith(t31.optionalMemberExpression(object.current, tmpMember.current.property, tmpMember.current.computed, true));
+            path.replaceWith(t41.optionalMemberExpression(object.current, tmpMember.current.property, tmpMember.current.computed, true));
             this.changes++;
           }
         }
@@ -2291,9 +4341,8 @@ var optional_chaining_default = {
     };
   }
 };
-// node_modules/webcrack/src/transpile/transforms/template-literals.ts
-import * as t32 from "@babel/types";
-import * as m40 from "@codemod/matchers";
+// node_modules/.pnpm/@gitpkg.vercel.app+api+pkg.tgz+url=j4k0xb+webcrack+packages@webcrack&commit=fdf21377287e6b492_xddbf4nx3djzgode7pjz2czwiu/node_modules/webcrack/src/transpile/transforms/template-literals.ts
+import * as t42 from "@babel/types";
 var escape2 = function(str) {
   return str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/\t/g, "\\t").replace(/\r/g, "\\r");
 };
@@ -2309,7 +4358,7 @@ var push = function(template9, value) {
     template9.quasis.push(...value.quasis.slice(1));
   } else {
     template9.expressions.push(value);
-    template9.quasis.push(t32.templateElement({ raw: "" }));
+    template9.quasis.push(t42.templateElement({ raw: "" }));
   }
 };
 var unshift = function(template9, value) {
@@ -2323,24 +4372,24 @@ var unshift = function(template9, value) {
     template9.quasis.unshift(...value.quasis.slice(0, -1));
   } else {
     template9.expressions.unshift(value);
-    template9.quasis.unshift(t32.templateElement({ raw: "" }));
+    template9.quasis.unshift(t42.templateElement({ raw: "" }));
   }
 };
 var template_literals_default = {
   name: "template-literals",
   tags: ["unsafe"],
   visitor() {
-    const concatMatcher = m40.or(m40.callExpression(constMemberExpression(m40.or(m40.stringLiteral(), m40.matcher((node) => concatMatcher.match(node))), "concat"), m40.arrayOf(m40.anyExpression())));
+    const concatMatcher = or(callExpression(constMemberExpression(or(stringLiteral(), predicate((node) => concatMatcher.match(node))), "concat"), arrayOf(anyExpression())));
     return {
       BinaryExpression: {
         exit(path) {
           if (path.node.operator !== "+")
             return;
-          if (t32.isTemplateLiteral(path.node.left)) {
+          if (t42.isTemplateLiteral(path.node.left)) {
             push(path.node.left, path.node.right);
             path.replaceWith(path.node.left);
             this.changes++;
-          } else if (t32.isTemplateLiteral(path.node.right) && t32.isExpression(path.node.left)) {
+          } else if (t42.isTemplateLiteral(path.node.right) && t42.isExpression(path.node.left)) {
             unshift(path.node.right, path.node.left);
             path.replaceWith(path.node.right);
             this.changes++;
@@ -2350,7 +4399,7 @@ var template_literals_default = {
       CallExpression: {
         exit(path) {
           if (concatMatcher.match(path.node) && !concatMatcher.match(path.parentPath.parent)) {
-            const template9 = t32.templateLiteral([t32.templateElement({ raw: "" })], []);
+            const template9 = t42.templateLiteral([t42.templateElement({ raw: "" })], []);
             let current = path.node;
             while (current.type === "CallExpression") {
               for (const arg of current.arguments.reverse()) {
@@ -2367,7 +4416,7 @@ var template_literals_default = {
     };
   }
 };
-// node_modules/webcrack/src/transpile/index.ts
+// /home/mochaa/ghq/git.sr.ht/~self/delance-builder/node_modules/webcrack/src/transpile/index.ts
 var transpile_default = mergeTransforms({
   name: "transpile",
   tags: ["safe"],
@@ -2375,9 +4424,8 @@ var transpile_default = mergeTransforms({
 });
 
 // transform/delance/stringaes.ts
-import traverse12 from "@babel/traverse";
-import * as m41 from "@codemod/matchers";
-import * as t33 from "@babel/types";
+import traverse14 from "@babel/traverse";
+import * as t43 from "@babel/types";
 
 // utils/crypto.ts
 import crypto from "node:crypto";
@@ -2390,9 +4438,9 @@ function lic(x = _lic) {
   _lic = x;
   return _lic;
 }
-function decrypt(m41) {
+function decrypt(m) {
   const c = crypto.createDecipheriv("aes-192-cbc", scrypt(), iv());
-  let a = c.update(m41, "hex", "utf8");
+  let a = c.update(m, "hex", "utf8");
   a += c.final("utf8");
   return a;
 }
@@ -2415,19 +4463,19 @@ var scrypt = () => crypto.scryptSync(lic(), salt(), 24);
 var iv = () => Buffer.from(salt());
 
 // transform/delance/stringaes.ts
-var scrypt2 = m41.callExpression(m41.memberExpression(m41.identifier(), m41.identifier("scryptSync"), false), [
-  m41.memberExpression(m41.identifier(), m41.identifier("licenseErrorText"), false),
-  m41.identifier(),
-  m41.numericLiteral(24)
+var scrypt2 = callExpression(memberExpression(identifier(), identifier("scryptSync"), false), [
+  memberExpression(identifier(), identifier("licenseErrorText"), false),
+  identifier(),
+  numericLiteral(24)
 ]);
-var licenseText = m41.assignmentExpression("=", m41.memberExpression(m41.identifier(), m41.identifier("licenseErrorText")), m41.callExpression(m41.memberExpression(m41.arrayExpression(m41.anyList(m41.oneOrMore(m41.stringLiteral()))), m41.identifier("join"), false), [m41.stringLiteral(" ")]));
+var licenseText = assignmentExpression("=", memberExpression(identifier(), identifier("licenseErrorText")), callExpression(memberExpression(arrayExpression(anyList(oneOrMore(stringLiteral()))), identifier("join"), false), [stringLiteral(" ")]));
 var newSalt;
 var newKey;
 var stringaes_default = {
   name: "string-aes",
   tags: ["safe"],
   run(ast2) {
-    traverse12(ast2, {
+    traverse14(ast2, {
       CallExpression: {
         exit($) {
           if (newSalt || !scrypt2.match($.node)) {
@@ -2467,7 +4515,7 @@ var stringaes_default = {
     }
   },
   visitor() {
-    const encryptedString = m41.callExpression(m41.memberExpression(m41.identifier(), m41.identifier("decrypt"), false), [m41.stringLiteral()]);
+    const encryptedString = callExpression(memberExpression(identifier(), identifier("decrypt"), false), [stringLiteral()]);
     return {
       CallExpression: {
         exit($) {
@@ -2480,7 +4528,7 @@ var stringaes_default = {
           $id.assertIdentifier();
           const $string = $.get("arguments")[0];
           $string.assertStringLiteral();
-          $.replaceWith(t33.stringLiteral(decrypt($string.node.value)));
+          $.replaceWith(t43.stringLiteral(decrypt($string.node.value)));
           this.changes++;
         }
       }
@@ -2489,13 +4537,12 @@ var stringaes_default = {
 };
 
 // transform/delance/antifeature.ts
-import * as t34 from "@babel/types";
-import * as m42 from "@codemod/matchers";
+import * as t44 from "@babel/types";
 import tmpl6 from "@babel/template";
-var entry = m42.capture(m42.numericLiteral());
-var main = m42.callExpression(m42.memberExpression(m42.callExpression(m42.identifier("require"), [entry]), m42.identifier("main"), false), [m42.booleanLiteral(true)]);
-var verifyClient = m42.assignmentExpression("=", m42.memberExpression(m42.identifier("exports"), m42.identifier("verifyClient")), m42.functionExpression(null, [m42.identifier()]));
-var vsda = m42.ifStatement(m42.containerOf(m42.stringLiteral("vsda")));
+var entry = capture(numericLiteral());
+var main = callExpression(memberExpression(callExpression(identifier("require"), [entry]), identifier("main"), false), [booleanLiteral(true)]);
+var verifyClient = assignmentExpression("=", memberExpression(identifier("exports"), identifier("verifyClient")), functionExpression(null, [identifier()]));
+var vsda = ifStatement(containerOf(stringLiteral("vsda")));
 var antifeature_default = {
   name: "anti-feature",
   tags: ["unsafe"],
@@ -2505,7 +4552,7 @@ var antifeature_default = {
         if (!main.match($.node)) {
           return;
         }
-        t34.assertNumericLiteral(entry.current);
+        t44.assertNumericLiteral(entry.current);
         const _target = $.find((p2) => chunk_default.match(p2.node));
         if (!_target) {
           throw new Error("Could not find module chunk");
@@ -2565,7 +4612,7 @@ async function transform6(ast2) {
 
 // index.ts
 async function delance_builder_default(code) {
-  return generate2(await transform6(parse(code)));
+  return generate2(await transform6(parse2(code)));
 }
 export {
   transform6 as transform,
@@ -2573,5 +4620,3 @@ export {
 };
 
 export { delance_builder_default };
-
-//# debugId=623A8DAFD0C674AC64756e2164756e21