@delance/builder 0.2.0

package/dist/index.js

@@ -0,0 +1,2577 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// transform/webcrack/index.ts
+import {getQuickJS, shouldInterruptAfterDeadline} from "quickjs-emscripten";
+
+// node_modules/webcrack/src/deobfuscate/index.ts
+import debug3 from "debug";
+
+// node_modules/webcrack/src/ast-utils/ast.ts
+import * as t from "@babel/types";
+function getPropName(node) {
+  if (t.isIdentifier(node)) {
+    return node.name;
+  }
+  if (t.isStringLiteral(node)) {
+    return node.value;
+  }
+  if (t.isNumericLiteral(node)) {
+    return node.value.toString();
+  }
+}
+// node_modules/webcrack/src/ast-utils/generator.ts
+import babelGenerate from "@babel/generator";
+function generate(ast, options = defaultOptions) {
+  return babelGenerate(ast, options).code;
+}
+function codePreview(node) {
+  const code = generate(node, {
+    minified: true,
+    shouldPrintComment: () => false,
+    ...defaultOptions
+  });
+  if (code.length > 100) {
+    return code.slice(0, 70) + " \u2026 " + code.slice(-30);
+  }
+  return code;
+}
+var defaultOptions = { jsescOption: { minimal: true } };
+// node_modules/webcrack/src/ast-utils/inline.ts
+import traverse2 from "@babel/traverse";
+import * as t3 from "@babel/types";
+import * as m2 from "@codemod/matchers";
+
+// node_modules/webcrack/src/ast-utils/matcher.ts
+import * as t2 from "@babel/types";
+import * as m from "@codemod/matchers";
+function infiniteLoop(body) {
+  return m.or(m.forStatement(undefined, null, undefined, body), m.forStatement(undefined, truthyMatcher, undefined, body), m.whileStatement(truthyMatcher, body));
+}
+function constKey(name) {
+  return m.or(m.identifier(name), m.stringLiteral(name));
+}
+function constObjectProperty(value) {
+  return m.or(m.objectProperty(m.identifier(), value, false), m.objectProperty(m.or(m.stringLiteral(), m.numericLiteral()), value));
+}
+function matchIife(body) {
+  return m.callExpression(m.functionExpression(null, [], body ? m.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));
+}
+function findParent(path, matcher2) {
+  return path.findParent((path2) => matcher2.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))))));
+}
+function isReadonlyObject(binding, memberAccess) {
+  if (!binding.constant && binding.constantViolations[0] !== binding.path)
+    return false;
+  function isPatternAssignment(member) {
+    return member.parentPath?.isArrayPattern() || member.parentPath?.isAssignmentPattern() || member.parentPath?.parentPath?.isObjectPattern() || member.parentPath?.isAssignmentPattern();
+  }
+  return binding.referencePaths.every((path) => memberAccess.match(path.parent) && !path.parentPath?.parentPath?.isAssignmentExpression({
+    left: path.parent
+  }) && !path.parentPath?.parentPath?.isUpdateExpression({
+    argument: path.parent
+  }) && !path.parentPath?.parentPath?.isUnaryExpression({
+    argument: path.parent,
+    operator: "delete"
+  }) && !isPatternAssignment(path.parentPath));
+}
+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 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([]));
+
+// node_modules/webcrack/src/ast-utils/inline.ts
+function inlineVariable(binding, value = m2.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);
+  if (binding.constant && varMatcher.match(varDeclarator)) {
+    binding.referencePaths.forEach((ref) => {
+      ref.replaceWith(varDeclarator.init);
+    });
+    binding.path.remove();
+  } else if (unsafeAssignments && binding.constantViolations.length === 1 && assignmentMatcher.match(binding.constantViolations[0]?.node)) {
+    const assignment = binding.constantViolations[0];
+    binding.referencePaths.forEach((ref) => {
+      ref.replaceWith(assignment.node.right);
+    });
+    assignment.remove();
+    binding.path.remove();
+  }
+}
+function inlineArrayElements(array, references) {
+  for (const reference of references) {
+    const memberPath = reference.parentPath;
+    const property = memberPath.node.property;
+    const index = property.value;
+    const replacement = array.elements[index];
+    memberPath.replaceWith(replacement);
+  }
+}
+function inlineObjectProperties(binding, property = m2.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));
+  if (!varMatcher.match(varDeclarator))
+    return;
+  const propertyMap = new Map(objectProperties.current.map((p) => [getPropName(p.key), p.value]));
+  if (!binding.referencePaths.every((ref) => {
+    const member = ref.parent;
+    const propName = getPropName(member.property);
+    return propertyMap.has(propName);
+  }))
+    return;
+  binding.referencePaths.forEach((ref) => {
+    const memberPath = ref.parentPath;
+    const propName = getPropName(memberPath.node.property);
+    const value = propertyMap.get(propName);
+    memberPath.replaceWith(value);
+  });
+  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)));
+    return;
+  }
+  const returnedValue = fn.body.body[0].argument;
+  const clone = t3.cloneNode(returnedValue, true);
+  traverse2(clone, {
+    Identifier(path) {
+      const paramIndex = fn.params.findIndex((p) => p.name === path.node.name);
+      if (paramIndex !== -1) {
+        path.replaceWith(caller.node.arguments[paramIndex]);
+        path.skip();
+      }
+    },
+    noScope: true
+  });
+  caller.replaceWith(clone);
+}
+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 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));
+      });
+      if (!paramUsedInDecodeCall)
+        continue;
+      const fnBinding = fn.scope.parent.getBinding(fnName.current);
+      if (!fnBinding)
+        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);
+      for (const callRef of callRefs) {
+        inlineFunction(fn.node, callRef);
+        state.changes++;
+      }
+      fn.remove();
+      state.changes++;
+    }
+  }
+  binding.scope.crawl();
+  return state;
+}
+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)));
+  for (const ref of refs) {
+    if (matcher3.match(ref.parent)) {
+      const varScope = ref.scope;
+      const varBinding = varScope.getBinding(varName.current);
+      if (!varBinding)
+        continue;
+      state.changes += inlineVariableAliases(varBinding, targetName).changes;
+      if (ref.parentPath?.isAssignmentExpression()) {
+        varBinding.path.remove();
+        if (t3.isExpressionStatement(ref.parentPath.parent)) {
+          ref.parentPath.remove();
+        } else {
+          ref.parentPath.replaceWith(ref.parentPath.node.right);
+        }
+      } else if (ref.parentPath?.isVariableDeclarator()) {
+        ref.parentPath.remove();
+      }
+      state.changes++;
+    } else {
+      ref.replaceWith(t3.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";
+function renameFast(binding, newName) {
+  binding.referencePaths.forEach((ref) => {
+    if (!ref.isIdentifier()) {
+      throw new Error(`Unexpected reference (${ref.type}): ${codePreview(ref.node)}`);
+    }
+    if (ref.scope.hasBinding(newName))
+      ref.scope.rename(newName);
+    ref.node.name = newName;
+  });
+  const patternMatcher = m3.assignmentExpression("=", m3.or(m3.arrayPattern(), m3.objectPattern()));
+  binding.constantViolations.forEach((ref) => {
+    if (ref.scope.hasBinding(newName))
+      ref.scope.rename(newName);
+    if (ref.isAssignmentExpression() && t4.isIdentifier(ref.node.left)) {
+      ref.node.left.name = newName;
+    } else if (ref.isUpdateExpression() && t4.isIdentifier(ref.node.argument)) {
+      ref.node.argument.name = newName;
+    } else if (ref.isVariableDeclarator() && t4.isIdentifier(ref.node.id)) {
+      ref.node.id.name = newName;
+    } else if (ref.isFor() || patternMatcher.match(ref.node)) {
+      traverse4(ref.node, {
+        Identifier(path) {
+          if (path.scope !== ref.scope)
+            return path.skip();
+          if (path.node.name === binding.identifier.name) {
+            path.node.name = newName;
+          }
+        },
+        noScope: true
+      });
+    } else {
+      throw new Error(`Unexpected constant violation (${ref.type}): ${codePreview(ref.node)}`);
+    }
+  });
+  binding.scope.removeOwnBinding(binding.identifier.name);
+  binding.scope.bindings[newName] = binding;
+  binding.identifier.name = newName;
+}
+// node_modules/webcrack/src/ast-utils/transform.ts
+import traverse6, {
+visitors
+} from "@babel/traverse";
+import debug from "debug";
+async function applyTransformAsync(ast, transform, options) {
+  logger(`${transform.name}: started`);
+  const state = { changes: 0 };
+  await transform.run?.(ast, state, options);
+  if (transform.visitor)
+    traverse6(ast, transform.visitor(options), undefined, state);
+  logger(`${transform.name}: finished with ${state.changes} changes`);
+  return state;
+}
+function applyTransform(ast, transform, options, noScopeOverride) {
+  logger(`${transform.name}: started`);
+  const state = { changes: 0 };
+  transform.run?.(ast, state, options);
+  if (transform.visitor) {
+    const visitor = transform.visitor(options);
+    visitor.noScope = noScopeOverride || !transform.scope;
+    traverse6(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)
+    logger(`${name}: started`);
+  const state = { changes: 0 };
+  for (const transform of transforms) {
+    transform.run?.(ast, state);
+  }
+  const traverseOptions = transforms.flatMap((t5) => t5.visitor?.() ?? []);
+  if (traverseOptions.length > 0) {
+    const visitor = visitors.merge(traverseOptions);
+    visitor.noScope = options.noScope || transforms.every((t5) => !t5.scope);
+    traverse6(ast, visitor, undefined, state);
+  }
+  if (options.log)
+    logger(`${name}: finished with ${state.changes} changes`);
+  return state;
+}
+function mergeTransforms(options) {
+  return {
+    name: options.name,
+    tags: options.tags,
+    scope: options.transforms.some((t5) => t5.scope),
+    visitor() {
+      return visitors.merge(options.transforms.flatMap((t5) => t5.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";
+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);
+    return {
+      BinaryExpression: {
+        exit(path) {
+          if (matcher4.match(path.node)) {
+            path.replaceWith(t5.stringLiteral(left.current.value + right.current.value));
+            this.changes++;
+          }
+        }
+      },
+      StringLiteral: {
+        exit(path) {
+          if (nestedMatcher.match(path.parent)) {
+            left.current.value += right.current.value;
+            path.remove();
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/array-rotator.ts
+import * as m5 from "@codemod/matchers";
+import {callExpression as callExpression5} from "@codemod/matchers";
+function findArrayRotator(stringArray) {
+  const arrayIdentifier = m5.capture(m5.identifier());
+  const pushShift = m5.callExpression(constMemberExpression(arrayIdentifier, "push"), [
+    m5.callExpression(constMemberExpression(m5.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))
+    ]).match(node);
+  }))))));
+  const matcher5 = m5.expressionStatement(m5.or(callMatcher, m5.unaryExpression("!", callMatcher)));
+  for (const ref of stringArray.references) {
+    const rotator = findParent(ref, matcher5);
+    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";
+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 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)))
+      ]).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 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 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)));
+    function isConstantBinding(binding) {
+      return binding.constant || binding.constantViolations[0] === binding.path;
+    }
+    function transform2(path) {
+      let changes = 0;
+      if (varMatcher.match(path.node)) {
+        const binding = path.scope.getBinding(varId.current.name);
+        if (!binding)
+          return changes;
+        if (!isConstantBinding(binding))
+          return changes;
+        if (!transformObjectKeys(binding))
+          return changes;
+        if (!isReadonlyObject(binding, memberAccess))
+          return changes;
+        const props = new Map(objectProperties.current.map((p) => [
+          getPropName(p.key),
+          p.value
+        ]));
+        if (!props.size)
+          return changes;
+        const oldRefs = [...binding.referencePaths];
+        [...binding.referencePaths].reverse().forEach((ref) => {
+          const memberPath = ref.parentPath;
+          const propName = getPropName(memberPath.node.property);
+          const value = props.get(propName);
+          if (t6.isStringLiteral(value)) {
+            memberPath.replaceWith(value);
+          } else {
+            inlineFunction(value, memberPath.parentPath);
+          }
+          changes++;
+        });
+        oldRefs.forEach((ref) => {
+          const varDeclarator = findParent(ref, m6.variableDeclarator());
+          if (varDeclarator)
+            changes += transform2(varDeclarator);
+        });
+        path.remove();
+        changes++;
+      }
+      return changes;
+    }
+    function transformObjectKeys(objBinding) {
+      const container = objBinding.path.parentPath.container;
+      const startIndex = objBinding.path.parentPath.key + 1;
+      const properties = [];
+      for (let i = startIndex;i < container.length; i++) {
+        const statement = container[i];
+        if (looseAssignment.match(statement)) {
+          applyTransform(statement, merge_strings_default);
+        }
+        if (assignment.match(statement)) {
+          properties.push(t6.objectProperty(t6.identifier(assignedKey.current), assignedValue.current));
+        } else {
+          break;
+        }
+      }
+      const aliasAssignment = container[startIndex + properties.length];
+      if (!aliasVar.match(aliasAssignment))
+        return true;
+      if (objBinding.references !== properties.length + 1)
+        return false;
+      const aliasBinding = objBinding.scope.getBinding(aliasId.current.name);
+      if (!isReadonlyObject(aliasBinding, memberAccess))
+        return false;
+      objectProperties.current.push(...properties);
+      container.splice(startIndex, properties.length);
+      objBinding.referencePaths = aliasBinding.referencePaths;
+      objBinding.references = aliasBinding.references;
+      objBinding.identifier.name = aliasBinding.identifier.name;
+      aliasBinding.path.remove();
+      return true;
+    }
+    return {
+      VariableDeclarator: {
+        exit(path) {
+          this.changes += transform2(path);
+        }
+      }
+    };
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/control-flow-switch.ts
+import * as t7 from "@babel/types";
+import * as m7 from "@codemod/matchers";
+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()));
+    return {
+      BlockStatement: {
+        exit(path) {
+          if (!matcher7.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
+          ]));
+          const sequence = sequenceString.current.split("|");
+          const newStatements = sequence.flatMap((s) => caseStatements.get(s));
+          path.node.body.splice(0, 3, ...newStatements);
+          this.changes += newStatements.length + 3;
+        }
+      }
+    };
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/dead-code.ts
+import * as t8 from "@babel/types";
+import * as m8 from "@codemod/matchers";
+var replace = function(path, node) {
+  if (t8.isBlockStatement(node)) {
+    path.replaceWithMultiple(node.body);
+  } else {
+    path.replaceWith(node);
+  }
+};
+var dead_code_default = {
+  name: "dead-code",
+  tags: ["unsafe"],
+  scope: true,
+  visitor() {
+    const stringComparison = m8.binaryExpression(m8.or("===", "==", "!==", "!="), m8.stringLiteral(), m8.stringLiteral());
+    const testMatcher = m8.or(stringComparison, m8.unaryExpression("!", stringComparison));
+    return {
+      "IfStatement|ConditionalExpression": {
+        exit(_path) {
+          const path = _path;
+          if (!testMatcher.match(path.node.test))
+            return;
+          const { scope } = path;
+          function renameShadowedVariables(localScope) {
+            if (localScope === scope)
+              return;
+            for (const name in localScope.bindings) {
+              if (scope.hasBinding(name)) {
+                renameFast(localScope.bindings[name], scope.generateUid(name));
+              }
+            }
+          }
+          if (path.get("test").evaluateTruthy()) {
+            renameShadowedVariables(path.get("consequent").scope);
+            replace(path, path.node.consequent);
+          } else if (path.node.alternate) {
+            renameShadowedVariables(path.get("alternate").scope);
+            replace(path, path.node.alternate);
+          } else {
+            path.remove();
+          }
+          this.changes++;
+        }
+      }
+    };
+  }
+};
+
+// 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())));
+  for (const ref of stringArray.references) {
+    const decoderFn = findParent(ref, matcher8);
+    if (decoderFn) {
+      const oldName = functionName.current;
+      const newName = `__DECODE_${decoders.length}__`;
+      const binding = decoderFn.scope.getBinding(oldName);
+      renameFast(binding, newName);
+      decoders.push(new Decoder(newName, decoderFn));
+    }
+  }
+  return decoders;
+}
+
+class Decoder {
+  name;
+  path;
+  constructor(name, path) {
+    this.name = name;
+    this.path = path;
+  }
+  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), [
+      conditional
+    ]);
+    const buildExtractedConditional = expression`TEST ? CALLEE(CONSEQUENT) : CALLEE(ALTERNATE)`;
+    const binding = this.path.scope.getBinding(this.name);
+    for (const ref of binding.referencePaths) {
+      if (conditionalCall.match(ref.parent)) {
+        const [replacement] = ref.parentPath.replaceWith(buildExtractedConditional({
+          TEST: conditional.current.test,
+          CALLEE: ref.parent.callee,
+          CONSEQUENT: conditional.current.consequent,
+          ALTERNATE: conditional.current.alternate
+        }));
+        replacement.scope.crawl();
+      } else if (literalCall.match(ref.parent)) {
+        calls.push(ref.parentPath);
+      } else if (expressionCall.match(ref.parent)) {
+        ref.parentPath.traverse({
+          ReferencedIdentifier(path) {
+            const varBinding = path.scope.getBinding(path.node.name);
+            if (!varBinding)
+              return;
+            inlineVariable(varBinding, literalArgument, true);
+          }
+        });
+        if (literalCall.match(ref.parent)) {
+          calls.push(ref.parentPath);
+        }
+      }
+    }
+    return calls;
+  }
+}
+
+// node_modules/webcrack/src/deobfuscate/inline-decoded-strings.ts
+import * as t9 from "@babel/types";
+var inline_decoded_strings_default = {
+  name: "inline-decoded-strings",
+  tags: ["unsafe"],
+  scope: true,
+  async run(ast2, state, options) {
+    if (!options)
+      return;
+    const calls = options.vm.decoders.flatMap((decoder) => decoder.collectCalls());
+    const decodedValues = await options.vm.decode(calls);
+    for (let i = 0;i < calls.length; i++) {
+      const call = calls[i];
+      const value = decodedValues[i];
+      call.replaceWith(t9.valueToNode(value));
+      if (typeof value !== "string")
+        call.addComment("leading", "webcrack:decode_error");
+    }
+    state.changes += calls.length;
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/inline-decoder-wrappers.ts
+var inline_decoder_wrappers_default = {
+  name: "inline-decoder-wrappers",
+  tags: ["unsafe"],
+  scope: true,
+  run(ast2, state, decoder) {
+    if (!decoder?.node.id)
+      return;
+    const decoderName = decoder.node.id.name;
+    const decoderBinding = decoder.parentPath.scope.getBinding(decoderName);
+    if (decoderBinding) {
+      state.changes += inlineVariableAliases(decoderBinding).changes;
+      state.changes += inlineFunctionAliases(decoderBinding).changes;
+    }
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/inline-object-props.ts
+import * as m10 from "@codemod/matchers";
+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 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));
+    return {
+      VariableDeclarator(path) {
+        if (!varMatcher.match(path.node))
+          return;
+        if (objectProperties.current.length === 0)
+          return;
+        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())));
+      }
+    };
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/string-array.ts
+import traverse8 from "@babel/traverse";
+import * as m11 from "@codemod/matchers";
+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 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)))
+  ])));
+  traverse8(ast2, {
+    FunctionDeclaration(path) {
+      if (matcher10.match(path.node)) {
+        const length = arrayExpression3.current.elements.length;
+        const name = functionName.current;
+        const binding = path.scope.getBinding(name);
+        renameFast(binding, "__STRING_ARRAY__");
+        result = {
+          path,
+          references: binding.referencePaths,
+          name: "__STRING_ARRAY__",
+          length
+        };
+        path.stop();
+      }
+    },
+    VariableDeclaration(path) {
+      if (!variableDeclaration5.match(path.node))
+        return;
+      const length = arrayExpression3.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)));
+      if (!isReadonlyObject(binding, memberAccess))
+        return;
+      inlineArrayElements(arrayExpression3.current, binding.referencePaths);
+      path.remove();
+    }
+  });
+  return result;
+}
+
+// node_modules/webcrack/src/deobfuscate/vm.ts
+import debug2 from "debug";
+class VMDecoder {
+  decoders;
+  setupCode;
+  sandbox;
+  constructor(sandbox, stringArray, decoders, rotator) {
+    this.sandbox = sandbox;
+    this.decoders = decoders;
+    const generateOptions = {
+      compact: true,
+      shouldPrintComment: () => false
+    };
+    const stringArrayCode = generate(stringArray.path.node, generateOptions);
+    const rotatorCode = rotator ? generate(rotator.node, generateOptions) : "";
+    const decoderCode = decoders.map((decoder) => generate(decoder.path.node, generateOptions)).join(";\n");
+    this.setupCode = [stringArrayCode, rotatorCode, decoderCode].join(";\n");
+  }
+  async decode(calls) {
+    const code = `(() => {
+      ${this.setupCode}
+      return [${calls.join(",")}]
+    })()`;
+    try {
+      const result = await this.sandbox(code);
+      return result;
+    } catch (error) {
+      debug2("webcrack:deobfuscate")("vm code:", code);
+      if (error instanceof Error && (error.message.includes("undefined symbol") || error.message.includes("Segmentation fault"))) {
+        throw new Error("isolated-vm version mismatch. Check https://webcrack.netlify.app/docs/guide/common-errors.html#isolated-vm", { cause: error });
+      }
+      throw error;
+    }
+  }
+}
+
+// node_modules/webcrack/src/deobfuscate/index.ts
+var deobfuscate_default = {
+  name: "deobfuscate",
+  tags: ["unsafe"],
+  scope: true,
+  async run(ast2, state, sandbox) {
+    if (!sandbox)
+      return;
+    const logger2 = debug3("webcrack:deobfuscate");
+    const stringArray = findStringArray(ast2);
+    logger2(stringArray ? `String Array: ${stringArray.length} strings` : "String Array: no");
+    if (!stringArray)
+      return;
+    const rotator = findArrayRotator(stringArray);
+    logger2(`String Array Rotate: ${rotator ? "yes" : "no"}`);
+    const decoders = findDecoders(stringArray);
+    logger2(`String Array Encodings: ${decoders.length}`);
+    state.changes += applyTransform(ast2, inline_object_props_default).changes;
+    for (const decoder2 of decoders) {
+      state.changes += applyTransform(ast2, inline_decoder_wrappers_default, decoder2.path).changes;
+    }
+    const vm2 = new VMDecoder(sandbox, stringArray, decoders, rotator);
+    state.changes += (await applyTransformAsync(ast2, inline_decoded_strings_default, { vm: vm2 })).changes;
+    stringArray.path.remove();
+    rotator?.remove();
+    decoders.forEach((decoder2) => decoder2.path.remove());
+    state.changes += 2 + decoders.length;
+    state.changes += applyTransforms(ast2, [merge_strings_default, dead_code_default, control_flow_object_default, control_flow_switch_default], { noScope: true }).changes;
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/var-functions.ts
+import * as t10 from "@babel/types";
+import * as m12 from "@codemod/matchers";
+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)
+    ]);
+    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));
+          }
+        }
+      }
+    };
+  }
+};
+
+// node_modules/webcrack/src/deobfuscate/merge-object-assignments.ts
+import * as t11 from "@babel/types";
+import * as m13 from "@codemod/matchers";
+var hasCircularReference = function(node, binding) {
+  return binding.referencePaths.some((path) => path.find((p) => p.node === node)) || m13.containerOf(m13.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 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));
+    return {
+      Program(path) {
+        path.scope.crawl();
+      },
+      VariableDeclaration: {
+        exit(path) {
+          if (!path.inList || !varMatcher.match(path.node))
+            return;
+          const binding = path.scope.getBinding(id.current.name);
+          const container = path.container;
+          const siblingIndex = path.key + 1;
+          while (siblingIndex < container.length) {
+            const sibling = path.getSibling(siblingIndex);
+            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));
+            sibling.remove();
+            binding.dereference();
+            binding.referencePaths.shift();
+            if (binding.references === 1 && inlineableObject.match(object.current)) {
+              binding.referencePaths[0].replaceWith(object.current);
+              path.remove();
+              this.changes++;
+            }
+          }
+        }
+      }
+    };
+  }
+};
+var inlineableObject = m13.matcher((node) => m13.or(anyLiteral, m13.arrayExpression(m13.arrayOf(inlineableObject)), m13.objectExpression(m13.arrayOf(constObjectProperty(inlineableObject)))).match(node));
+
+// node_modules/webcrack/src/unminify/transforms/index.ts
+var exports_transforms = {};
+__export(exports_transforms, {
+  yoda: () => {
+    {
+      return yoda_default;
+    }
+  },
+  voidToUndefined: () => {
+    {
+      return void_to_undefined_default;
+    }
+  },
+  unminifyBooleans: () => {
+    {
+      return unminify_booleans_default;
+    }
+  },
+  unaryExpressions: () => {
+    {
+      return unary_expressions_default;
+    }
+  },
+  typeofUndefined: () => {
+    {
+      return typeof_undefined_default;
+    }
+  },
+  ternaryToIf: () => {
+    {
+      return ternary_to_if_default;
+    }
+  },
+  splitVariableDeclarations: () => {
+    {
+      return split_variable_declarations_default;
+    }
+  },
+  sequence: () => {
+    {
+      return sequence_default;
+    }
+  },
+  rawLiterals: () => {
+    {
+      return raw_literals_default;
+    }
+  },
+  numberExpressions: () => {
+    {
+      return number_expressions_default;
+    }
+  },
+  mergeStrings: () => {
+    {
+      return merge_strings_default;
+    }
+  },
+  mergeElseIf: () => {
+    {
+      return merge_else_if_default;
+    }
+  },
+  logicalToIf: () => {
+    {
+      return logical_to_if_default;
+    }
+  },
+  jsonParse: () => {
+    {
+      return json_parse_default;
+    }
+  },
+  invertBooleanLogic: () => {
+    {
+      return invert_boolean_logic_default;
+    }
+  },
+  infinity: () => {
+    {
+      return infinity_default;
+    }
+  },
+  forToWhile: () => {
+    {
+      return for_to_while_default;
+    }
+  },
+  computedProperties: () => {
+    {
+      return computed_properties_default;
+    }
+  },
+  blockStatements: () => {
+    {
+      return block_statements_default;
+    }
+  }
+});
+
+// node_modules/webcrack/src/unminify/transforms/block-statements.ts
+import * as t12 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]);
+          this.changes++;
+        }
+        if (path.node.alternate && !t12.isBlockStatement(path.node.alternate)) {
+          path.node.alternate = t12.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]);
+          this.changes++;
+        }
+      }
+    },
+    ArrowFunctionExpression: {
+      exit(path) {
+        if (t12.isSequenceExpression(path.node.body)) {
+          path.node.body = t12.blockStatement([
+            t12.returnStatement(path.node.body)
+          ]);
+          this.changes++;
+        }
+      }
+    }
+  })
+};
+// 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";
+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));
+    return {
+      "MemberExpression|OptionalMemberExpression": {
+        exit(path) {
+          if (!propertyMatcher.match(path.node))
+            return;
+          path.node.computed = false;
+          path.node.property = t13.identifier(stringMatcher.current.value);
+          this.changes++;
+        }
+      },
+      "ObjectProperty|ClassProperty|ObjectMethod|ClassMethod": {
+        exit(path) {
+          if (!keyMatcher.match(path.node))
+            return;
+          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);
+          this.changes++;
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/for-to-while.ts
+import * as t14 from "@babel/types";
+var for_to_while_default = {
+  name: "for-to-while",
+  tags: ["safe"],
+  visitor() {
+    return {
+      ForStatement: {
+        exit(path) {
+          const { test, body, init, update } = path.node;
+          if (init || update)
+            return;
+          path.replaceWith(test ? t14.whileStatement(test, body) : t14.whileStatement(t14.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";
+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));
+    return {
+      BinaryExpression: {
+        exit(path) {
+          if (path.scope.hasBinding("Infinity", { noGlobals: true }))
+            return;
+          if (infinityMatcher.match(path.node)) {
+            path.replaceWith(t15.identifier("Infinity"));
+            this.changes++;
+          } else if (negativeInfinityMatcher.match(path.node)) {
+            path.replaceWith(t15.unaryExpression("-", t15.identifier("Infinity")));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/invert-boolean-logic.ts
+import * as t16 from "@babel/types";
+import * as m16 from "@codemod/matchers";
+var INVERTED_BINARY_OPERATORS = {
+  "==": "!=",
+  "===": "!==",
+  "!=": "==",
+  "!==": "===",
+  ">": "<=",
+  "<": ">=",
+  ">=": "<",
+  "<=": ">"
+};
+var INVERTED_LOGICAL_OPERATORS = {
+  "||": "&&",
+  "&&": "||"
+};
+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);
+    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);
+            this.changes++;
+          } else if (logicalMatcher.match(path.node)) {
+            let current = argument;
+            while (logicalExpression3.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 = current.left;
+            }
+            path.replaceWith(argument);
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// 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)
+    ]);
+    return {
+      CallExpression: {
+        exit(path) {
+          if (matcher12.match(path.node) && !path.scope.hasBinding("JSON", { noGlobals: true })) {
+            try {
+              JSON.parse(string.current);
+              const parsed = parseExpression(string.current);
+              path.replaceWith(parsed);
+              this.changes++;
+            } catch (error) {
+            }
+          }
+        }
+      }
+    };
+  }
+};
+// 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 buildIf = statement`if (TEST) { BODY; }`;
+    const buildIfNot = statement`if (!TEST) { BODY; }`;
+    return {
+      ExpressionStatement: {
+        exit(path) {
+          const expression2 = path.node.expression;
+          if (andMatcher.match(path.node)) {
+            path.replaceWith(buildIf({
+              TEST: expression2.left,
+              BODY: expression2.right
+            }));
+            this.changes++;
+          } else if (orMatcher.match(path.node)) {
+            path.replaceWith(buildIfNot({
+              TEST: expression2.left,
+              BODY: expression2.right
+            }));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/merge-else-if.ts
+import * as m19 from "@codemod/matchers";
+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]));
+    return {
+      IfStatement: {
+        exit(path) {
+          if (matcher12.match(path.node)) {
+            path.node.alternate = nestedIf.current;
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/number-expressions.ts
+import * as t17 from "@babel/types";
+import * as m20 from "@codemod/matchers";
+var number_expressions_default = {
+  name: "number-expressions",
+  tags: ["safe"],
+  visitor: () => ({
+    "BinaryExpression|UnaryExpression": {
+      exit(path) {
+        if (matcher13.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.skip();
+            this.changes++;
+          }
+        }
+      }
+    }
+  })
+};
+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 raw_literals_default = {
+  name: "raw-literals",
+  tags: ["safe"],
+  visitor: () => ({
+    StringLiteral(path) {
+      if (path.node.extra) {
+        path.node.extra = undefined;
+        this.changes++;
+      }
+    },
+    NumericLiteral(path) {
+      if (path.node.extra) {
+        path.node.extra = undefined;
+        this.changes++;
+      }
+    }
+  })
+};
+// node_modules/webcrack/src/unminify/transforms/sequence.ts
+import * as t18 from "@babel/types";
+import * as m21 from "@codemod/matchers";
+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));
+    return {
+      ExpressionStatement: {
+        exit(path) {
+          if (t18.isSequenceExpression(path.node.expression)) {
+            const statements = path.node.expression.expressions.map((expr) => t18.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));
+            path.get("expression.right").replaceWith(value);
+            path.insertBefore(statements);
+            this.changes++;
+          }
+        }
+      },
+      ReturnStatement: {
+        exit(path) {
+          if (t18.isSequenceExpression(path.node.argument)) {
+            const expressions = path.node.argument.expressions;
+            path.node.argument = expressions.pop();
+            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            path.insertBefore(statements);
+            this.changes++;
+          }
+        }
+      },
+      IfStatement: {
+        exit(path) {
+          if (t18.isSequenceExpression(path.node.test)) {
+            const expressions = path.node.test.expressions;
+            path.node.test = expressions.pop();
+            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            path.insertBefore(statements);
+            this.changes++;
+          }
+        }
+      },
+      SwitchStatement: {
+        exit(path) {
+          if (t18.isSequenceExpression(path.node.discriminant)) {
+            const expressions = path.node.discriminant.expressions;
+            path.node.discriminant = expressions.pop();
+            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            path.insertBefore(statements);
+            this.changes++;
+          }
+        }
+      },
+      ThrowStatement: {
+        exit(path) {
+          if (t18.isSequenceExpression(path.node.argument)) {
+            const expressions = path.node.argument.expressions;
+            path.node.argument = expressions.pop();
+            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            path.insertBefore(statements);
+            this.changes++;
+          }
+        }
+      },
+      ForInStatement: {
+        exit(path) {
+          const sequence = m21.capture(m21.sequenceExpression());
+          const matcher14 = m21.forInStatement(m21.anything(), sequence);
+          if (matcher14.match(path.node)) {
+            const expressions = sequence.current.expressions;
+            path.node.right = expressions.pop();
+            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            path.insertBefore(statements);
+            this.changes++;
+          }
+        }
+      },
+      ForStatement: {
+        exit(path) {
+          if (t18.isSequenceExpression(path.node.init)) {
+            const statements = path.node.init.expressions.map((expr) => t18.expressionStatement(expr));
+            path.insertBefore(statements);
+            path.node.init = null;
+            this.changes++;
+          }
+          if (t18.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);
+            this.changes++;
+          }
+        }
+      },
+      WhileStatement: {
+        exit(path) {
+          if (t18.isSequenceExpression(path.node.test)) {
+            const expressions = path.node.test.expressions;
+            path.node.test = expressions.pop();
+            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            path.insertBefore(statements);
+            this.changes++;
+          }
+        }
+      },
+      VariableDeclaration: {
+        exit(path) {
+          const sequence = m21.capture(m21.sequenceExpression());
+          const matcher14 = m21.variableDeclaration(undefined, [
+            m21.variableDeclarator(undefined, sequence)
+          ]);
+          if (matcher14.match(path.node)) {
+            const expressions = sequence.current.expressions;
+            path.node.declarations[0].init = expressions.pop();
+            const statements = expressions.map((expr) => t18.expressionStatement(expr));
+            if (path.parentPath.isForStatement() && path.key === "init") {
+              path.parentPath.insertBefore(statements);
+            } else {
+              path.insertBefore(statements);
+            }
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/split-variable-declarations.ts
+import * as t19 from "@babel/types";
+var split_variable_declarations_default = {
+  name: "split-variable-declarations",
+  tags: ["safe"],
+  visitor: () => ({
+    VariableDeclaration: {
+      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]))));
+          } else {
+            path.replaceWithMultiple(path.node.declarations.map((declaration) => t19.variableDeclaration(path.node.kind, [declaration])));
+          }
+          this.changes++;
+        }
+      }
+    }
+  })
+};
+// 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 buildIf = statement2`if (TEST) { CONSEQUENT; } else { ALTERNATE; }`;
+    const buildIfReturn = statement2`if (TEST) { return CONSEQUENT; } else { return ALTERNATE; }`;
+    return {
+      ExpressionStatement: {
+        exit(path) {
+          if (conditional.match(path.node.expression)) {
+            path.replaceWith(buildIf({
+              TEST: test.current,
+              CONSEQUENT: consequent.current,
+              ALTERNATE: alternate.current
+            }));
+            this.changes++;
+          }
+        }
+      },
+      ReturnStatement: {
+        exit(path) {
+          if (conditional.match(path.node.argument)) {
+            path.replaceWith(buildIfReturn({
+              TEST: test.current,
+              CONSEQUENT: consequent.current,
+              ALTERNATE: alternate.current
+            }));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/typeof-undefined.ts
+import * as t20 from "@babel/types";
+import * as m23 from "@codemod/matchers";
+var OPERATOR_MAP = {
+  ">": "===",
+  "<": "!=="
+};
+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"));
+    return {
+      BinaryExpression: {
+        exit(path) {
+          if (!matcher14.match(path.node))
+            return;
+          path.replaceWith(t20.binaryExpression(OPERATOR_MAP[operator.current], t20.unaryExpression("typeof", argument.current), t20.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";
+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));
+    return {
+      ExpressionStatement: {
+        exit(path) {
+          if (!matcher14.match(path.node))
+            return;
+          path.replaceWith(argument.current);
+          this.changes++;
+        }
+      },
+      ReturnStatement: {
+        exit(path) {
+          if (!returnVoid.match(path.node))
+            return;
+          path.replaceWith(argument.current);
+          path.insertAfter(t21.returnStatement());
+          this.changes++;
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/unminify-booleans.ts
+import * as t22 from "@babel/types";
+import * as m25 from "@codemod/matchers";
+var unminify_booleans_default = {
+  name: "unminify-booleans",
+  tags: ["safe"],
+  visitor: () => ({
+    UnaryExpression(path) {
+      if (trueMatcher2.match(path.node)) {
+        path.replaceWith(t22.booleanLiteral(true));
+        this.changes++;
+      } else if (falseMatcher2.match(path.node)) {
+        path.replaceWith(t22.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 void_to_undefined_default = {
+  name: "void-to-undefined",
+  tags: ["safe"],
+  scope: true,
+  visitor: () => {
+    const matcher14 = m26.unaryExpression("void", m26.numericLiteral(0));
+    return {
+      UnaryExpression: {
+        exit(path) {
+          if (matcher14.match(path.node) && !path.scope.hasBinding("undefined", { noGlobals: true })) {
+            path.replaceWith(t23.identifier("undefined"));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/transforms/yoda.ts
+import * as t24 from "@babel/types";
+import * as m27 from "@codemod/matchers";
+var FLIPPED_OPERATORS = {
+  "==": "==",
+  "===": "===",
+  "!=": "!=",
+  "!==": "!==",
+  ">": "<",
+  "<": ">",
+  ">=": "<=",
+  "<=": ">=",
+  "*": "*",
+  "^": "^",
+  "&": "&",
+  "|": "|"
+};
+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)));
+    return {
+      BinaryExpression: {
+        exit(path) {
+          if (matcher15.match(path.node)) {
+            path.replaceWith(t24.binaryExpression(FLIPPED_OPERATORS[path.node.operator], path.node.right, path.node.left));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/unminify/index.ts
+var unminify_default = mergeTransforms({
+  name: "unminify",
+  tags: ["safe"],
+  transforms: Object.values(exports_transforms)
+});
+
+// transform/webcrack/index.ts
+async function transform2(ast2) {
+  applyTransforms(ast2, [block_statements_default, sequence_default, split_variable_declarations_default, var_functions_default], {
+    name: "prepare"
+  });
+  const quickjs = await getQuickJS();
+  await applyTransformAsync(ast2, deobfuscate_default, async (code) => quickjs.evalCode(code, {
+    shouldInterrupt: shouldInterruptAfterDeadline(Date.now() + 2000),
+    memoryLimitBytes: 1048576
+  }));
+  applyTransform(ast2, unminify_default);
+  applyTransform(ast2, merge_object_assignments_default);
+  return ast2;
+}
+
+// transform/esmodule/module-helper.ts
+import * as t25 from "@babel/types";
+import * as m34 from "@codemod/matchers";
+
+// 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])));
+}
+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 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) {
+	if (k2 === undefined) k2 = k;
+	var desc = Object.getOwnPropertyDescriptor(m, k);
+	if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		desc = { enumerable: true, get: function() { return m[k]; } };
+	}
+	Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+	if (k2 === undefined) k2 = k;
+	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 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)
+      ]))
+    ]),
+    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))
+    ]), null),
+    m29.expressionStatement(m29.callExpression(m29.memberExpression(m29.identifier("Object"), m29.identifier("defineProperty"), false), [
+      m29.fromCapture(obj),
+      m29.fromCapture(k2),
+      m29.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),
+      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)))
+  ])))))
+]);
+
+// 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) {
+	Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+	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 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, [
+    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")), [
+      leftParamObj,
+      m30.stringLiteral("default"),
+      leftObjIdentifier
+    ]))
+  ]), m30.blockStatement([
+    m30.expressionStatement(m30.callExpression(m30.memberExpression(m30.identifier("Object"), m30.identifier("defineProperty")), [
+      leftParamObj,
+      m30.stringLiteral("default"),
+      leftObj
+    ]))
+  ])), false, false), m30.functionExpression(null, [
+    rightParamObj,
+    rightParamVal
+  ], m30.blockStatement([
+    m30.expressionStatement(m30.assignmentExpression("=", m30.memberExpression(rightParamObj, m30.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) {
+	if (mod && mod.__esModule) return mod;
+	var result = {};
+	if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	__setModuleDefault(result, mod);
+	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([]))
+    ]),
+    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)
+    ])))))), null),
+    m31.expressionStatement(m31.callExpression(m31.identifier(), [
+      m31.fromCapture(result),
+      m31.fromCapture(mod3)
+    ])),
+    m31.returnStatement(m31.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)
+    ])))))
+  ]))))
+]);
+
+// 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)
+    ]))))))
+  ]))))
+]);
+
+// 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 module_helper_default = {
+  name: "module-helper",
+  tags: ["safe"],
+  scope: true,
+  visitor: () => ({
+    ObjectExpression: {
+      enter($) {
+        if (!chunks.match($.node)) {
+          return;
+        }
+        const $chunks = $.get("properties");
+        for (const $chunk of $chunks) {
+          $chunk.assertObjectProperty();
+          const $func = $chunk.get("value");
+          $func.assertFunction();
+          const $p = $func.get("params");
+          $p.forEach(($parameter, i) => {
+            $parameter.assertIdentifier();
+            switch (i) {
+              case 0: {
+                $func.scope.rename($parameter.node.name, "module");
+                break;
+              }
+              case 1: {
+                $func.scope.rename($parameter.node.name, "exports");
+                break;
+              }
+              case 2: {
+                $func.scope.rename($parameter.node.name, "require");
+                break;
+              }
+              default: {
+                throw new Error("Unexpected param");
+              }
+            }
+          });
+          $func.traverse({
+            VariableDeclaration: {
+              exit(p2) {
+                const $decl = p2.get("declarations.0");
+                $decl.assertVariableDeclarator();
+                const $id = $decl.get("id");
+                if (!$id.isIdentifier()) {
+                  return;
+                }
+                if (importStar_default.match(t25.cloneNode(p2.node))) {
+                  $id.scope.rename($id.node.name, "__importStar");
+                  $decl.get("init").replaceWith(__importStar);
+                } else if (setModuleDefault_default.match(t25.cloneNode(p2.node))) {
+                  $id.scope.rename($id.node.name, "__setModuleDefault");
+                  $decl.get("init").replaceWith(__setModuleDefault);
+                } else if (importDefault_default.match(t25.cloneNode(p2.node))) {
+                  $id.scope.rename($id.node.name, "__importDefault");
+                  $decl.get("init").replaceWith(__importDefault);
+                } else if (createBinding_default.match(t25.cloneNode(p2.node))) {
+                  $id.scope.rename($id.node.name, "__createBinding");
+                  $decl.get("init").replaceWith(__createBinding);
+                } else if (exportStar_default.match(t25.cloneNode(p2.node))) {
+                  $id.scope.rename($id.node.name, "__exportStar");
+                  $decl.get("init").replaceWith(__exportStar);
+                } else {
+                  return;
+                }
+                this.changes++;
+              }
+            }
+          }, this);
+        }
+      }
+    }
+  })
+};
+
+// transform/esmodule/indirect-call.ts
+import * as t26 from "@babel/types";
+var indirect_call_default = {
+  name: "indirect-call",
+  tags: ["unsafe"],
+  visitor: () => ({
+    CallExpression: {
+      exit($) {
+        const { callee, arguments: args } = $.node;
+        if (!t26.isSequenceExpression(callee)) {
+          return;
+        }
+        const exprs = [...callee.expressions];
+        const func = exprs.pop();
+        if (!t26.isMemberExpression(func)) {
+          return;
+        }
+        if (exprs.every((expr) => t26.isPureish(expr))) {
+          $.replaceWith(t26.callExpression(func, args));
+          this.changes++;
+        }
+      }
+    }
+  })
+};
+
+// utils/ast.ts
+import {parse as babelParse} 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, {
+    sourceType: "script",
+    allowReturnOutsideFunction: true
+  });
+}
+function generate2(ast2) {
+  return babelGenerate2(ast2, { jsescOption: { minimal: true, quotes: "single" } }).code;
+}
+function applyTransform2(ast2, transform3, options, noScopeOverride) {
+  logger2(`${transform3.name}: started`);
+  const state = { changes: 0 };
+  transform3.run?.(ast2, state, options);
+  if (transform3.visitor) {
+    const visitor = transform3.visitor(options);
+    visitor.noScope = noScopeOverride ?? !transform3.scope;
+    traverse10(ast2, visitor, undefined, state);
+  }
+  logger2(`${transform3.name}: finished with ${state.changes} changes`);
+  return state;
+}
+var logger2 = debug4("delance:transforms");
+
+// transform/esmodule/index.ts
+function transform3(ast2) {
+  applyTransform2(ast2, module_helper_default);
+  applyTransform2(ast2, indirect_call_default);
+  return ast2;
+}
+
+// transform/syntactic/template-literal.ts
+import * as t27 from "@babel/types";
+import * as m35 from "@codemod/matchers";
+var escape = function(string) {
+  return string.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("$", "\\$").replaceAll("\t", "\\t").replaceAll("\r", "\\r").replaceAll("\0", "\\0");
+};
+var template_literal_default = {
+  name: "template-literal",
+  tags: ["safe"],
+  visitor() {
+    const concatExpr = m35.binaryExpression("+", m35.or(m35.stringLiteral(), m35.templateLiteral()), m35.anyExpression());
+    return {
+      BinaryExpression: {
+        exit($) {
+          if (!concatExpr.match($.node)) {
+            return;
+          }
+          const $left = $.get("left");
+          const $right = $.get("right");
+          if ($left.isTemplateLiteral()) {
+            if ($right.isTemplateLiteral()) {
+              const last = $left.node.quasis.pop();
+              if (!last) {
+                throw new Error("Unexpected empty template literal");
+              }
+              $left.node.quasis.push(t27.templateElement({
+                raw: last.value.raw + $right.node.quasis[0].value.raw
+              }, false), ...$right.node.quasis.slice(1));
+              $.replaceWith(t27.templateLiteral([
+                ...$left.node.quasis
+              ], [
+                ...$left.node.expressions,
+                ...$right.node.expressions
+              ]));
+            } else if ($right.isStringLiteral()) {
+              const last = $left.node.quasis.pop();
+              if (!last) {
+                throw new Error("Unexpected empty template literal");
+              }
+              $left.node.quasis.push(t27.templateElement({
+                raw: escape(last.value.raw + $right.node.value)
+              }, true));
+              $.replaceWith($left.node);
+            } else {
+              $.replaceWith(t27.templateLiteral([
+                ...$left.node.quasis.map((element) => {
+                  element.tail = false;
+                  return element;
+                }),
+                t27.templateElement({ raw: "" }, true)
+              ], [
+                ...$left.node.expressions,
+                $right.node
+              ]));
+            }
+          } else if ($left.isStringLiteral()) {
+            if ($right.isStringLiteral()) {
+              $left.node.value += $right.node.value;
+              $.replaceWith($left);
+            } else {
+              if ($right.isCallExpression() && $right.get("callee").isFunctionExpression()) {
+                return;
+              }
+              $.replaceWith(t27.templateLiteral([
+                t27.templateElement({ raw: escape($left.node.value) }, false),
+                t27.templateElement({ raw: "" }, true)
+              ], [
+                $right.node
+              ]));
+            }
+          }
+          this.changes++;
+        }
+      }
+    };
+  }
+};
+
+// transform/syntactic/index.ts
+function transform4(ast2) {
+  applyTransform2(ast2, template_literal_default);
+  return ast2;
+}
+
+// node_modules/webcrack/src/transpile/transforms/index.ts
+var exports_transforms2 = {};
+__export(exports_transforms2, {
+  templateLiterals: () => {
+    {
+      return template_literals_default;
+    }
+  },
+  optionalChaining: () => {
+    {
+      return optional_chaining_default;
+    }
+  },
+  nullishCoalescingAssignment: () => {
+    {
+      return nullish_coalescing_assignment_default;
+    }
+  },
+  nullishCoalescing: () => {
+    {
+      return nullish_coalescing_default;
+    }
+  },
+  logicalAssignments: () => {
+    {
+      return logical_assignments_default;
+    }
+  }
+});
+
+// node_modules/webcrack/src/transpile/transforms/logical-assignments.ts
+import * as t28 from "@babel/types";
+import * as m36 from "@codemod/matchers";
+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));
+    return {
+      LogicalExpression: {
+        exit(path) {
+          if (idMatcher.match(path.node)) {
+            path.replaceWith(t28.assignmentExpression(operator.current + "=", left.current, right.current));
+            this.changes++;
+          } else if (memberMatcher.match(path.node)) {
+            const binding = path.scope.getBinding(tmpVar.current.name);
+            if (!isTemporaryVariable(binding, 1))
+              return;
+            binding.path.remove();
+            member.current.object = object.current;
+            path.replaceWith(t28.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));
+            this.changes++;
+          } else if (multiComputedMemberMatcher.match(path.node)) {
+            const binding = path.scope.getBinding(tmpVar.current.name);
+            const binding2 = path.scope.getBinding(tmpVar2.current.name);
+            if (!isTemporaryVariable(binding, 1) || !isTemporaryVariable(binding2, 1))
+              return;
+            binding.path.remove();
+            binding2.path.remove();
+            path.replaceWith(t28.assignmentExpression(operator.current + "=", t28.memberExpression(object.current, property.current, true), right.current));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/transpile/transforms/nullish-coalescing.ts
+import * as t29 from "@babel/types";
+import * as m37 from "@codemod/matchers";
+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), []);
+    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));
+              this.changes++;
+            } else if (isTemporaryVariable(binding, 2, "var")) {
+              binding.path.remove();
+              path.replaceWith(t29.logicalExpression("??", left.current, right.current));
+              this.changes++;
+            }
+          } else if (idLooseMatcher.match(path.node)) {
+            const binding = path.scope.getBinding(tmpVar.current.name);
+            if (!isTemporaryVariable(binding, 1))
+              return;
+            binding.path.remove();
+            path.replaceWith(t29.logicalExpression("??", left.current, right.current));
+            this.changes++;
+          } else if (simpleIdMatcher.match(path.node)) {
+            path.replaceWith(t29.logicalExpression("??", left.current, right.current));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/transpile/transforms/nullish-coalescing-assignment.ts
+import * as t30 from "@babel/types";
+import * as m38 from "@codemod/matchers";
+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));
+    return {
+      LogicalExpression: {
+        exit(path) {
+          if (memberMatcher.match(path.node)) {
+            const binding = path.scope.getBinding(tmpVar.current.name);
+            if (!isTemporaryVariable(binding, 1))
+              return;
+            binding.path.remove();
+            path.replaceWith(t30.assignmentExpression("??=", t30.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));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/transpile/transforms/optional-chaining.ts
+import * as t31 from "@babel/types";
+import * as m39 from "@codemod/matchers";
+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);
+    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));
+            this.changes++;
+          } else if (tmpMatcher.match(path.node)) {
+            const binding = path.scope.getBinding(tmpVar.current.name);
+            if (!isTemporaryVariable(binding, 2))
+              return;
+            binding.path.remove();
+            tmpMember.current.optional = true;
+            path.replaceWith(t31.optionalMemberExpression(object.current, tmpMember.current.property, tmpMember.current.computed, true));
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/transpile/transforms/template-literals.ts
+import * as t32 from "@babel/types";
+import * as m40 from "@codemod/matchers";
+var escape2 = function(str) {
+  return str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/\t/g, "\\t").replace(/\r/g, "\\r");
+};
+var push = function(template9, value) {
+  if (value.type === "StringLiteral") {
+    const lastQuasi = template9.quasis.at(-1);
+    lastQuasi.value.raw += escape2(value.value);
+  } else if (value.type === "TemplateLiteral") {
+    const lastQuasi = template9.quasis.at(-1);
+    const firstQuasi = value.quasis[0];
+    lastQuasi.value.raw += firstQuasi.value.raw;
+    template9.expressions.push(...value.expressions);
+    template9.quasis.push(...value.quasis.slice(1));
+  } else {
+    template9.expressions.push(value);
+    template9.quasis.push(t32.templateElement({ raw: "" }));
+  }
+};
+var unshift = function(template9, value) {
+  if (value.type === "StringLiteral") {
+    const firstQuasi = template9.quasis[0];
+    firstQuasi.value.raw = escape2(value.value) + firstQuasi.value.raw;
+  } else if (value.type === "TemplateLiteral") {
+    const firstQuasi = template9.quasis[0];
+    firstQuasi.value.raw = value.quasis[0].value.raw + firstQuasi.value.raw;
+    template9.expressions.unshift(...value.expressions);
+    template9.quasis.unshift(...value.quasis.slice(0, -1));
+  } else {
+    template9.expressions.unshift(value);
+    template9.quasis.unshift(t32.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())));
+    return {
+      BinaryExpression: {
+        exit(path) {
+          if (path.node.operator !== "+")
+            return;
+          if (t32.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)) {
+            unshift(path.node.right, path.node.left);
+            path.replaceWith(path.node.right);
+            this.changes++;
+          }
+        }
+      },
+      CallExpression: {
+        exit(path) {
+          if (concatMatcher.match(path.node) && !concatMatcher.match(path.parentPath.parent)) {
+            const template9 = t32.templateLiteral([t32.templateElement({ raw: "" })], []);
+            let current = path.node;
+            while (current.type === "CallExpression") {
+              for (const arg of current.arguments.reverse()) {
+                unshift(template9, arg);
+              }
+              current = current.callee.object;
+            }
+            unshift(template9, current);
+            path.replaceWith(template9);
+            this.changes++;
+          }
+        }
+      }
+    };
+  }
+};
+// node_modules/webcrack/src/transpile/index.ts
+var transpile_default = mergeTransforms({
+  name: "transpile",
+  tags: ["safe"],
+  transforms: Object.values(exports_transforms2)
+});
+
+// transform/delance/stringaes.ts
+import traverse12 from "@babel/traverse";
+import * as m41 from "@codemod/matchers";
+import * as t33 from "@babel/types";
+
+// utils/crypto.ts
+import crypto from "node:crypto";
+import {Buffer} from "node:buffer";
+function salt(x = _salt) {
+  _salt = x;
+  return _salt;
+}
+function lic(x = _lic) {
+  _lic = x;
+  return _lic;
+}
+function decrypt(m41) {
+  const c = crypto.createDecipheriv("aes-192-cbc", scrypt(), iv());
+  let a = c.update(m41, "hex", "utf8");
+  a += c.final("utf8");
+  return a;
+}
+var _salt = "SEE  LICENSE.txt";
+var _lic = [
+  ",oidutS lausiV tfosorciM htiw ylno erawtfos eht fo seipoc fo rebmun yna esu dna llatsni yam uoY",
+  "stcudorp tfosorciM rosseccus dna ,revreS noitadnuoF maeT ,spOveD eruzA ,edoC oidutS lausiV ,caM rof oidutS lausiV",
+  ".snoitacilppa ruoy tset dna poleved ot )\u201DsecivreS dna stcudorP oidutS lausiV\u201C eht ,ylevitcelloc( secivres dna",
+  ".sthgir rehto lla sevreser tfosorciM .erawtfos eht esu ot sthgir emos uoy sevig ylno tnemeerga sihT .dlos ton ,desnecil si erawtfos ehT",
+  ":ton yam uoY",
+  ";syaw niatrec ni ti esu ot uoy wolla ylno taht erawtfos eht ni snoitatimil lacinhcet yna dnuora krow",
+  ",erawtfos eht rof edoc ecruos eht evired ot tpmetta esiwrehto ro ,erawtfos eht elbmessasid ro elipmoced ,reenigne esrever",
+  ";erawtfos eht ni dedulcni eb yam taht stnenopmoc ecruos nepo niatrec fo esu gninrevog smret gnisnecil ytrap driht yb deriuqer tnetxe eht ot dna tpecxe",
+  ";erawtfos eht ni sreilppus sti ro tfosorciM fo seciton yna yfidom ro ,kcolb ,eziminim ,evomer",
+  "ro ;erawlam etagaporp ro etaerc ot ro wal eht tsniaga si taht yaw yna ni erawtfos eht esu",
+  ",)evoba smret eht ot tcejbus ,edoc elbatubirtsid yna rof tpecxe( erawtfos eht esael ro ,etubirtsid ,hsilbup ,erahs",
+  ".ytrap driht yna ot tnemeerga siht ro erawtfos eht refsnart ro ,esu ot srehto rof gnireffo enola-dnats a sa erawtfos eht edivorp"
+].map((x) => [...x].reverse().join("")).join(" ");
+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 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 newSalt;
+var newKey;
+var stringaes_default = {
+  name: "string-aes",
+  tags: ["safe"],
+  run(ast2) {
+    traverse12(ast2, {
+      CallExpression: {
+        exit($) {
+          if (newSalt || !scrypt2.match($.node)) {
+            return;
+          }
+          const $id = $.get("arguments.1");
+          $id.assertIdentifier();
+          const _decl = $.scope.getBinding($id.node.name)?.path;
+          if (!_decl) {
+            throw new Error("Could not find declaration");
+          }
+          const $decl = _decl;
+          $decl.assertVariableDeclarator();
+          const $salt = $decl.get("init");
+          if (!$salt.isStringLiteral()) {
+            throw new Error("Salt not initialized");
+          }
+          newSalt = $salt.node.value;
+        }
+      },
+      AssignmentExpression: {
+        exit($) {
+          if (newKey || !licenseText.match($.node)) {
+            return;
+          }
+          const $strs = $.get("right.callee.object.elements");
+          newKey = $strs.map(($_) => {
+            $_.assertStringLiteral();
+            return $_.node.value;
+          }).join(" ");
+        }
+      }
+    });
+    if (newSalt && newKey) {
+      salt(newSalt);
+      lic(newKey);
+    }
+  },
+  visitor() {
+    const encryptedString = m41.callExpression(m41.memberExpression(m41.identifier(), m41.identifier("decrypt"), false), [m41.stringLiteral()]);
+    return {
+      CallExpression: {
+        exit($) {
+          if (!encryptedString.match($.node)) {
+            return;
+          }
+          const $callee = $.get("callee");
+          $callee.assertMemberExpression();
+          const $id = $callee.get("object");
+          $id.assertIdentifier();
+          const $string = $.get("arguments")[0];
+          $string.assertStringLiteral();
+          $.replaceWith(t33.stringLiteral(decrypt($string.node.value)));
+          this.changes++;
+        }
+      }
+    };
+  }
+};
+
+// transform/delance/antifeature.ts
+import * as t34 from "@babel/types";
+import * as m42 from "@codemod/matchers";
+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 antifeature_default = {
+  name: "anti-feature",
+  tags: ["unsafe"],
+  visitor: () => ({
+    CallExpression: {
+      exit($) {
+        if (!main.match($.node)) {
+          return;
+        }
+        t34.assertNumericLiteral(entry.current);
+        const _target = $.find((p2) => chunk_default.match(p2.node));
+        if (!_target) {
+          throw new Error("Could not find module chunk");
+        }
+        const $target = _target;
+        $target.assertObjectProperty();
+        const $value = $target.get("value");
+        $value.assertFunction();
+        $value.get("body").replaceWith(tmpl6.statement.ast`{
+						require(${entry.current}).main(false);
+					}`);
+        $.stop();
+        this.changes++;
+      }
+    },
+    AssignmentExpression: {
+      exit($) {
+        if (!verifyClient.match($.node)) {
+          return;
+        }
+        const $value = $.get("right");
+        $value.assertFunction();
+        $value.get("body").replaceWith(tmpl6.statement.ast`{
+						return;
+					}`);
+        this.changes++;
+      }
+    },
+    IfStatement: {
+      exit($) {
+        if (!vsda.match($.node)) {
+          return;
+        }
+        $.remove();
+        this.changes++;
+      }
+    }
+  })
+};
+
+// transform/delance/index.ts
+function transform5(ast2) {
+  applyTransform2(ast2, stringaes_default);
+  applyTransform2(ast2, antifeature_default);
+  applyTransform(ast2, transpile_default);
+  return ast2;
+}
+
+// transform/index.ts
+async function transform6(ast2) {
+  await transform2(ast2);
+  transform4(ast2);
+  transform3(ast2);
+  transform5(ast2);
+  return ast2;
+}
+
+// index.ts
+async function delance_builder_default(code) {
+  return generate2(await transform6(parse(code)));
+}
+export {
+  transform6 as transform,
+  delance_builder_default as default
+};
+
+export { delance_builder_default };
+
+//# debugId=623A8DAFD0C674AC64756e2164756e21