expose-kit 0.4.0 → 0.6.0

package/README.md

@@ -105,7 +105,7 @@ With this alone:
 ### 3. Apply transforms step by step
 
 After `safe-scope`, combine common techniques like:
-- `expand-array` and more
+- `expand-array`, `expand-object` and more
 - legacy obfuscator-specific commands
 
 After **each step**, run `parsable` again.
@@ -196,14 +196,90 @@ Args:
   Target array variable name
 - `--o, --output <file>`  
   Output file path  
-  - No extension → `file.expand-array.js`
-  - With extension → `file.expand-array.<ext>`
 
 Notes:
-- Each replacement is validated by reparsing; invalid replacements (e.g. `++a[0]` or `a[0]++`) are skipped.-
+- Each replacement is validated by reparsing; unsafe replacements are skipped. 
+    (This array is intended to be immutable, so caution is required)
 
 ---
 
+### `expose expand-object`
+
+Expand object property access for primitive values.
+```js
+const obj = { a: 1, b: 2 };
+// before
+console.log(obj.a, obj["b"]);
+// after
+console.log(1, 2);
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/expand-object/mocks).
+
+```bash
+expose expand-object path/to/file.js --target objectName --output path/to/file.expand-object.js
+```
+
+Args:
+- `--target <name>`  
+  Target object variable name
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Each replacement is validated by reparsing; unsafe replacements are skipped.
+    (This object is intended to be immutable, so caution is required)
+
+---
+
+### `expose object-packer`
+
+Pack consecutive object property assignments into literals.
+```js
+const obj = {};
+// before
+obj.a = 0;
+obj["b"] = 1;
+// after
+const obj = { a: 0, b: 1 };
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/object-packer/mocks).
+
+```bash
+expose object-packer path/to/file.js --output path/to/file.object-packer.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Packs only consecutive assignments following an empty object literal.
+- Stops when a property value references the object itself.
+
+---
+
+### `expose remove-unused`
+
+Remove unused variabless.
+```js
+// before
+var a = 0, b = 1;
+console.log(a);
+// after
+var a = 0;
+console.log(a);
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/remove-unused/mocks).
+
+```bash
+expose remove-unused path/to/file.js --output path/to/file.remove-unused.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+
 ## Community & Support
 
 - Missing a feature? → [Create an issue](https://github.com/EdamAme-x/expose-kit/issues)

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // index.ts
 import { Command } from "commander";
-import { dirname as dirname4, join as join4 } from "path";
+import { dirname as dirname7, join as join7 } from "path";
 import { fileURLToPath } from "url";
 import chalk4 from "chalk";
 
@@ -364,15 +364,27 @@ var findTargetArray = (ast, targetName) => {
   if (!found) return null;
   let hasRiskOfSideEffects = false;
   patchDefault(traverse2)(ast, {
-    Identifier(path) {
+    MemberExpression(path) {
       if (hasRiskOfSideEffects) return;
-      if (!t.isIdentifier(path.node, { name: targetName })) return;
+      if (!t.isIdentifier(path.node.object, { name: targetName })) return;
       const parent = path.parentPath;
       if (!parent) return;
-      if (parent.isVariableDeclarator() && parent.get("id") === path) return;
-      if (parent.isAssignmentExpression() && parent.get("left") === path) return;
-      if (parent.isMemberExpression() && parent.get("object") === path) return;
-      hasRiskOfSideEffects = true;
+      if (isAssignmentTarget(path)) {
+        hasRiskOfSideEffects = true;
+      }
+    },
+    AssignmentExpression(path) {
+      if (hasRiskOfSideEffects) return;
+      const left = path.get("left");
+      if (left.isIdentifier({ name: targetName })) {
+        hasRiskOfSideEffects = true;
+      }
+    },
+    UpdateExpression(path) {
+      if (hasRiskOfSideEffects) return;
+      if (t.isIdentifier(path.node.argument, { name: targetName })) {
+        hasRiskOfSideEffects = true;
+      }
     }
   });
   const result = found;
@@ -386,7 +398,9 @@ var expandArrayAccess = async (code, filename, targetName) => {
     throw new Error(`Target array '${targetName}' is not a primitive array`);
   }
   if (targetArray.hasRiskOfSideEffects) {
-    const continueAnswer = await createPrompt("The target array has risk of side effects, do you want to continue? (y/n)");
+    const continueAnswer = await createPrompt(
+      "The target array has risk of side effects, do you want to continue? (y/n)"
+    );
     if (continueAnswer !== "y") {
       throw new Error("User cancelled");
     }
@@ -491,7 +505,7 @@ var expand_array_default = createCommand((program2) => {
   );
 });
 
-// commands/pre-evaluate/index.ts
+// commands/expand-object/index.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { basename as basename3, dirname as dirname3, extname as extname3, join as join3 } from "path";
 import { parse as parse4 } from "@babel/parser";
@@ -502,10 +516,463 @@ import loading4 from "loading-cli";
 var createDefaultOutputPath3 = (inputPath) => {
   const ext = extname3(inputPath);
   if (!ext) {
-    return `${inputPath}.pre-evaluate.js`;
+    return `${inputPath}.expand-object.js`;
   }
   const base = basename3(inputPath, ext);
-  return join3(dirname3(inputPath), `${base}.pre-evaluate${ext}`);
+  return join3(dirname3(inputPath), `${base}.expand-object${ext}`);
+};
+var getPropertyKeyFromObjectProperty = (property) => {
+  if (t2.isIdentifier(property.key)) {
+    return property.key.name;
+  }
+  if (t2.isStringLiteral(property.key)) {
+    return property.key.value;
+  }
+  if (t2.isNumericLiteral(property.key)) {
+    return String(property.key.value);
+  }
+  return null;
+};
+var getPropertyKeyFromMemberExpression = (node) => {
+  if (!node.computed && t2.isIdentifier(node.property)) {
+    return node.property.name;
+  }
+  if (!node.computed || !t2.isExpression(node.property)) {
+    return null;
+  }
+  if (t2.isStringLiteral(node.property)) {
+    return node.property.value;
+  }
+  if (t2.isNumericLiteral(node.property)) {
+    return String(node.property.value);
+  }
+  if (t2.isTemplateLiteral(node.property) && node.property.expressions.length === 0) {
+    return node.property.quasis[0]?.value.cooked ?? null;
+  }
+  return null;
+};
+var isAssignmentTarget2 = (path) => {
+  const parent = path.parentPath;
+  if (!parent) return false;
+  if (parent.isUpdateExpression()) return true;
+  if (parent.isAssignmentExpression() && parent.get("left") === path) {
+    return true;
+  }
+  if (parent.isForInStatement() && parent.get("left") === path) {
+    return true;
+  }
+  if (parent.isForOfStatement() && parent.get("left") === path) {
+    return true;
+  }
+  return false;
+};
+var collectMutatedProperties = (ast, targetName) => {
+  const mutatedProperties = /* @__PURE__ */ new Set();
+  let hasUnknownMutations = false;
+  patchDefault(traverse3)(ast, {
+    MemberExpression(path) {
+      if (!t2.isIdentifier(path.node.object, { name: targetName })) return;
+      const parent = path.parentPath;
+      if (!parent) return;
+      const isMutationTarget = parent.isUpdateExpression() || parent.isAssignmentExpression() && parent.get("left") === path || parent.isForInStatement() && parent.get("left") === path || parent.isForOfStatement() && parent.get("left") === path;
+      if (!isMutationTarget) return;
+      const propertyKey = getPropertyKeyFromMemberExpression(path.node);
+      if (!propertyKey) {
+        hasUnknownMutations = true;
+        return;
+      }
+      mutatedProperties.add(propertyKey);
+    }
+  });
+  return { mutatedProperties, hasUnknownMutations };
+};
+var getPropertyMap = (objectNode) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const property of objectNode.properties) {
+    if (!t2.isObjectProperty(property)) {
+      return null;
+    }
+    if (property.computed) {
+      return null;
+    }
+    if (!t2.isExpression(property.value)) {
+      return null;
+    }
+    const key = getPropertyKeyFromObjectProperty(property);
+    if (!key) {
+      return null;
+    }
+    map.set(key, property.value);
+  }
+  return map;
+};
+var findTargetObject = (ast, targetName) => {
+  let found = null;
+  patchDefault(traverse3)(ast, {
+    VariableDeclarator(path) {
+      if (found) return;
+      if (!t2.isIdentifier(path.node.id, { name: targetName })) return;
+      if (!t2.isObjectExpression(path.node.init)) return;
+      const propertyMap = getPropertyMap(path.node.init);
+      if (!propertyMap) return;
+      found = {
+        binding: path.scope.getBinding(targetName) ?? null,
+        objectNode: path.node.init,
+        propertyMap
+      };
+    },
+    AssignmentExpression(path) {
+      if (found) return;
+      if (!t2.isIdentifier(path.node.left, { name: targetName })) return;
+      if (!t2.isObjectExpression(path.node.right)) return;
+      const propertyMap = getPropertyMap(path.node.right);
+      if (!propertyMap) return;
+      found = {
+        binding: path.scope.getBinding(targetName) ?? null,
+        objectNode: path.node.right,
+        propertyMap
+      };
+    }
+  });
+  if (!found) return null;
+  let hasRiskOfSideEffects = false;
+  patchDefault(traverse3)(ast, {
+    MemberExpression(path) {
+      if (hasRiskOfSideEffects) return;
+      if (!t2.isIdentifier(path.node.object, { name: targetName })) return;
+      const parent = path.parentPath;
+      if (!parent) return;
+      if (isAssignmentTarget2(path)) {
+        hasRiskOfSideEffects = true;
+      }
+    },
+    AssignmentExpression(path) {
+      if (hasRiskOfSideEffects) return;
+      const left = path.get("left");
+      if (left.isIdentifier({ name: targetName })) {
+        hasRiskOfSideEffects = true;
+      }
+    },
+    UpdateExpression(path) {
+      if (hasRiskOfSideEffects) return;
+      if (t2.isIdentifier(path.node.argument, { name: targetName })) {
+        hasRiskOfSideEffects = true;
+      }
+    }
+  });
+  const result = found;
+  result.hasRiskOfSideEffects = hasRiskOfSideEffects;
+  return result;
+};
+var expandObjectAccess = async (code, filename, targetName) => {
+  const ast = parse4(code, createParseOptions(filename));
+  const targetObject = findTargetObject(ast, targetName);
+  if (!targetObject) {
+    throw new Error(`Target object '${targetName}' is not a primitive object`);
+  }
+  if (targetObject.hasRiskOfSideEffects) {
+    const continueAnswer = await createPrompt(
+      "The target object has risk of side effects, do you want to continue? (y/n)"
+    );
+    if (continueAnswer !== "y") {
+      throw new Error("User cancelled");
+    }
+  }
+  const candidates = [];
+  const mutatedInfo = collectMutatedProperties(ast, targetName);
+  if (mutatedInfo.hasUnknownMutations) {
+    return {
+      code: patchDefault(generate3)(ast).code,
+      replacedCount: 0
+    };
+  }
+  patchDefault(traverse3)(ast, {
+    MemberExpression(path) {
+      if (isAssignmentTarget2(path)) return;
+      if (!t2.isIdentifier(path.node.object, { name: targetName })) return;
+      if (targetObject.binding && path.scope.getBinding(targetName) !== targetObject.binding) {
+        return;
+      }
+      const propertyKey = getPropertyKeyFromMemberExpression(path.node);
+      if (!propertyKey) return;
+      if (mutatedInfo.mutatedProperties.has(propertyKey)) return;
+      const replacement = targetObject.propertyMap.get(propertyKey);
+      if (!replacement) return;
+      candidates.push({
+        path,
+        replacement: t2.cloneNode(replacement, true)
+      });
+    }
+  });
+  let replacedCount = 0;
+  for (const candidate of candidates) {
+    const original = t2.cloneNode(candidate.path.node, true);
+    candidate.path.replaceWith(t2.cloneNode(candidate.replacement, true));
+    const nextCode = patchDefault(generate3)(ast).code;
+    try {
+      parse4(nextCode, createParseOptions(filename));
+      replacedCount += 1;
+    } catch {
+      candidate.path.replaceWith(original);
+    }
+  }
+  return {
+    code: patchDefault(generate3)(ast).code,
+    replacedCount
+  };
+};
+var expand_object_default = createCommand((program2) => {
+  program2.command("expand-object").description("Expand object property access for primitive values").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--target <name>", "Target object variable name").option("--o, --output <file>", "Output file path").option("--unlimited", "Unlimited timeout").action(
+    async (fileArgument, options) => {
+      await timeout(
+        async ({ finish }) => {
+          const filename = fileArgument ?? options.file ?? await createPrompt("Enter the file path:");
+          if (!filename) {
+            showError("No file provided");
+            return finish();
+          }
+          const targetName = options.target ?? await createPrompt("Enter the target variable name:");
+          if (!targetName) {
+            showError("No target variable provided");
+            return finish();
+          }
+          try {
+            const fileContent = readFileSync4(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath3(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading4("Expanding object access...").start();
+            try {
+              const { code: output, replacedCount } = await expandObjectAccess(
+                fileContent,
+                filename,
+                targetName
+              );
+              writeFileSync3(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved expand-object file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply expand-object transform");
+              showError(
+                `Error transforming file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+              );
+              return finish();
+            }
+          } catch (error) {
+            showError(
+              `Error reading file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+            return finish();
+          }
+        },
+        options.unlimited ? null : 120 * 1e3
+      );
+    }
+  );
+});
+
+// commands/object-packer/index.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename4, dirname as dirname4, extname as extname4, join as join4 } from "path";
+import { parse as parse5 } from "@babel/parser";
+import traverse4 from "@babel/traverse";
+import generate4 from "@babel/generator";
+import * as t3 from "@babel/types";
+import loading5 from "loading-cli";
+var createDefaultOutputPath4 = (inputPath) => {
+  const ext = extname4(inputPath);
+  if (!ext) {
+    return `${inputPath}.object-packer.js`;
+  }
+  const base = basename4(inputPath, ext);
+  return join4(dirname4(inputPath), `${base}.object-packer${ext}`);
+};
+var isEmptyObjectExpression = (node) => {
+  return t3.isObjectExpression(node) && node.properties.length === 0;
+};
+var isPropertyAssignment = (node, objectName) => {
+  return t3.isAssignmentExpression(node) && t3.isMemberExpression(node.left) && t3.isIdentifier(node.left.object, { name: objectName });
+};
+var hasSelfReference = (value, statementPath, arrayIndex, binding, log) => {
+  try {
+    const statementContainerPath = statementPath.parentPath?.get(
+      `${statementPath.parentKey}.${arrayIndex}`
+    );
+    let detected = false;
+    patchDefault(traverse4)(
+      value,
+      {
+        Identifier(path) {
+          if (detected) return;
+          if (path.node.name !== binding.identifier.name) return;
+          if (path.scope.getBinding(binding.identifier.name) === binding) {
+            detected = true;
+            path.stop();
+          }
+        }
+      },
+      statementContainerPath.scope,
+      void 0,
+      statementContainerPath
+    );
+    return detected;
+  } catch (error) {
+    log(
+      `Error looking for self reference when object packing: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+};
+var packObjectProperties = (code, filename) => {
+  const ast = parse5(code, createParseOptions(filename));
+  let packedCount = 0;
+  let removedStatements = 0;
+  const log = (message) => console.warn(message);
+  patchDefault(traverse4)(ast, {
+    VariableDeclarator(path) {
+      if (!t3.isIdentifier(path.node.id)) return;
+      if (!path.node.init || !isEmptyObjectExpression(path.node.init)) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      const objectExpression = path.node.init;
+      const statementPath = path.getStatementParent();
+      if (!statementPath || !statementPath.parentPath || typeof statementPath.key !== "number") {
+        return;
+      }
+      const statements = statementPath.parentPath.node[statementPath.parentKey];
+      let localRemoved = 0;
+      let localPacked = 0;
+      for (let i = statementPath.key + 1; i < statements.length; i++) {
+        const node = statements[i];
+        if (t3.isExpressionStatement(node) && isPropertyAssignment(node.expression, path.node.id.name)) {
+          const assignment = node.expression;
+          if (isPropertyAssignment(assignment.right, path.node.id.name)) {
+            const properties = [assignment.left];
+            let right = assignment.right;
+            while (isPropertyAssignment(right, path.node.id.name)) {
+              properties.push(right.left);
+              right = right.right;
+            }
+            if (!t3.isLiteral(right)) {
+              break;
+            }
+            for (const { property } of properties) {
+              if (t3.isPrivateName(property)) {
+                break;
+              }
+              const isComputed = !t3.isStringLiteral(property) && !t3.isNumericLiteral(property) && !t3.isIdentifier(property);
+              objectExpression.properties.push(
+                t3.objectProperty(
+                  t3.cloneNode(property),
+                  t3.cloneNode(right, true),
+                  isComputed
+                )
+              );
+              localPacked += 1;
+            }
+            localRemoved += 1;
+          } else {
+            const key = assignment.left.property;
+            if (t3.isPrivateName(key)) {
+              break;
+            }
+            const isComputed = !t3.isStringLiteral(key) && !t3.isNumericLiteral(key) && !t3.isIdentifier(key);
+            if (hasSelfReference(assignment.right, statementPath, i, binding, log)) {
+              break;
+            }
+            objectExpression.properties.push(
+              t3.objectProperty(
+                t3.cloneNode(key),
+                t3.cloneNode(assignment.right, true),
+                isComputed
+              )
+            );
+            localPacked += 1;
+            localRemoved += 1;
+          }
+        } else {
+          break;
+        }
+      }
+      if (localRemoved > 0) {
+        statements.splice(statementPath.key + 1, localRemoved);
+        packedCount += localPacked;
+        removedStatements += localRemoved;
+      }
+    }
+  });
+  return {
+    code: patchDefault(generate4)(ast).code,
+    packedCount,
+    removedStatements
+  };
+};
+var object_packer_default = createCommand((program2) => {
+  program2.command("object-packer").description("Pack consecutive object property assignments into literals").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--o, --output <file>", "Output file path").option("--unlimited", "Unlimited timeout").action(
+    async (fileArgument, options) => {
+      await timeout(
+        async ({ finish }) => {
+          const filename = fileArgument ?? options.file ?? await createPrompt("Enter the file path:");
+          if (!filename) {
+            showError("No file provided");
+            return finish();
+          }
+          try {
+            const fileContent = readFileSync5(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath4(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading5("Packing object properties...").start();
+            try {
+              const { code: output, packedCount, removedStatements } = packObjectProperties(fileContent, filename);
+              writeFileSync4(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved object-packer file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${packedCount} properties packed, ${removedStatements} statements removed)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply object-packer transform");
+              showError(
+                `Error transforming file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+              );
+              return finish();
+            }
+          } catch (error) {
+            showError(
+              `Error reading file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+            return finish();
+          }
+        },
+        options.unlimited ? null : 120 * 1e3
+      );
+    }
+  );
+});
+
+// commands/pre-evaluate/index.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename5, dirname as dirname5, extname as extname5, join as join5 } from "path";
+import { parse as parse6 } from "@babel/parser";
+import traverse5 from "@babel/traverse";
+import generate5 from "@babel/generator";
+import * as t4 from "@babel/types";
+import loading6 from "loading-cli";
+var createDefaultOutputPath5 = (inputPath) => {
+  const ext = extname5(inputPath);
+  if (!ext) {
+    return `${inputPath}.pre-evaluate.js`;
+  }
+  const base = basename5(inputPath, ext);
+  return join5(dirname5(inputPath), `${base}.pre-evaluate${ext}`);
 };
 var isSupportedNumberOperator = (operator) => {
   return operator === "-" || operator === "*" || operator === "/" || operator === "%" || operator === "**" || operator === "<<" || operator === ">>" || operator === ">>>" || operator === "|" || operator === "&" || operator === "^";
@@ -639,13 +1106,13 @@ var shouldSkipReferencedIdentifier = (path) => {
   return false;
 };
 var preEvaluate = (code, filename) => {
-  const ast = parse4(code, createParseOptions(filename));
+  const ast = parse6(code, createParseOptions(filename));
   const state = {
     bindingValues: /* @__PURE__ */ new Map(),
     bindingStack: /* @__PURE__ */ new Set()
   };
   let replacedCount = 0;
-  patchDefault(traverse3)(ast, {
+  patchDefault(traverse5)(ast, {
     ReferencedIdentifier(path) {
       if (shouldSkipReferencedIdentifier(path)) {
         return;
@@ -653,9 +1120,9 @@ var preEvaluate = (code, filename) => {
       const value = evaluateExpression(path, state);
       if (value === null) return;
       if (typeof value === "number") {
-        path.replaceWith(t2.numericLiteral(value));
+        path.replaceWith(t4.numericLiteral(value));
       } else {
-        path.replaceWith(t2.stringLiteral(value));
+        path.replaceWith(t4.stringLiteral(value));
       }
       replacedCount += 1;
     },
@@ -664,9 +1131,9 @@ var preEvaluate = (code, filename) => {
         const value = evaluateExpression(path, state);
         if (value === null) return;
         if (typeof value === "number") {
-          path.replaceWith(t2.numericLiteral(value));
+          path.replaceWith(t4.numericLiteral(value));
         } else {
-          path.replaceWith(t2.stringLiteral(value));
+          path.replaceWith(t4.stringLiteral(value));
         }
         replacedCount += 1;
       }
@@ -676,9 +1143,9 @@ var preEvaluate = (code, filename) => {
         const value = evaluateExpression(path, state);
         if (value === null) return;
         if (typeof value === "number") {
-          path.replaceWith(t2.numericLiteral(value));
+          path.replaceWith(t4.numericLiteral(value));
         } else {
-          path.replaceWith(t2.stringLiteral(value));
+          path.replaceWith(t4.stringLiteral(value));
         }
         replacedCount += 1;
       }
@@ -688,16 +1155,16 @@ var preEvaluate = (code, filename) => {
         const value = evaluateExpression(path, state);
         if (value === null) return;
         if (typeof value === "number") {
-          path.replaceWith(t2.numericLiteral(value));
+          path.replaceWith(t4.numericLiteral(value));
         } else {
-          path.replaceWith(t2.stringLiteral(value));
+          path.replaceWith(t4.stringLiteral(value));
         }
         replacedCount += 1;
       }
     }
   });
   return {
-    code: patchDefault(generate3)(ast).code,
+    code: patchDefault(generate5)(ast).code,
     replacedCount
   };
 };
@@ -712,20 +1179,20 @@ var pre_evaluate_default = createCommand((program2) => {
             return finish();
           }
           try {
-            const fileContent = readFileSync4(filename, "utf8");
-            const defaultOutputPath = createDefaultOutputPath3(filename);
+            const fileContent = readFileSync6(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath5(filename);
             let outputPath = options.output;
             if (!outputPath) {
               const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
               outputPath = promptPath || defaultOutputPath;
             }
-            const loader = loading4("Pre-evaluating constants...").start();
+            const loader = loading6("Pre-evaluating constants...").start();
             try {
               const { code: output, replacedCount } = preEvaluate(
                 fileContent,
                 filename
               );
-              writeFileSync3(outputPath, output, "utf8");
+              writeFileSync5(outputPath, output, "utf8");
               loader.succeed(
                 `Saved pre-evaluate file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
               );
@@ -750,6 +1217,112 @@ var pre_evaluate_default = createCommand((program2) => {
   );
 });
 
+// commands/remove-unused/index.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename6, dirname as dirname6, extname as extname6, join as join6 } from "path";
+import { parse as parse7 } from "@babel/parser";
+import traverse6 from "@babel/traverse";
+import generate6 from "@babel/generator";
+import * as t5 from "@babel/types";
+import loading7 from "loading-cli";
+var createDefaultOutputPath6 = (inputPath) => {
+  const ext = extname6(inputPath);
+  if (!ext) {
+    return `${inputPath}.remove-unused.js`;
+  }
+  const base = basename6(inputPath, ext);
+  return join6(dirname6(inputPath), `${base}.remove-unused${ext}`);
+};
+var removeUnusedVariables = (code, filename) => {
+  const ast = parse7(code, createParseOptions(filename));
+  let changed = false;
+  patchDefault(traverse6)(ast, {
+    Scope(path) {
+      for (const binding of Object.values(path.scope.bindings)) {
+        if (!binding.referenced && binding.constantViolations.length === 0 && binding.path.key !== "handler" && !binding.path.isFunctionExpression()) {
+          if (t5.isProgram(binding.scope.block) && (binding.kind === "var" || binding.kind === "hoisted")) {
+            continue;
+          }
+          const targets = binding.path.parentKey === "params" ? [...binding.referencePaths, ...binding.constantViolations] : [
+            binding.path,
+            ...binding.referencePaths,
+            ...binding.constantViolations
+          ];
+          for (const targetPath of targets) {
+            if (targetPath.isVariableDeclarator() && (t5.isArrayPattern(targetPath.node.id) && targetPath.node.id.elements.length > 1 || t5.isObjectPattern(targetPath.node.id) && targetPath.node.id.properties.length > 1)) {
+              continue;
+            }
+            if (targetPath.key === "consequent" || targetPath.key === "alternate" || targetPath.key === "body") {
+              targetPath.replaceWith(t5.blockStatement([]));
+            } else {
+              const parentPath = targetPath.parentPath;
+              if (parentPath?.isVariableDeclaration() && parentPath.node.declarations.length === 1) {
+                parentPath.remove();
+              } else {
+                targetPath.remove();
+              }
+            }
+            changed = true;
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: patchDefault(generate6)(ast).code,
+    changed
+  };
+};
+var remove_unused_default = createCommand((program2) => {
+  program2.command("remove-unused").description("Remove unused variables and declarations").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--o, --output <file>", "Output file path").option("--unlimited", "Unlimited timeout").action(
+    async (fileArgument, options) => {
+      await timeout(
+        async ({ finish }) => {
+          const filename = fileArgument ?? options.file ?? await createPrompt("Enter the file path:");
+          if (!filename) {
+            showError("No file provided");
+            return finish();
+          }
+          try {
+            const fileContent = readFileSync7(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath6(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading7("Removing unused variables...").start();
+            try {
+              const { code: output, changed } = removeUnusedVariables(
+                fileContent,
+                filename
+              );
+              writeFileSync6(outputPath, output, "utf8");
+              const diffLines = diff(fileContent, output).length;
+              loader.succeed(
+                `Saved remove-unused file to: ${outputPath} (${diffLines} lines changed${changed ? ", removed unused declarations" : ", no changes"})`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply remove-unused transform");
+              showError(
+                `Error transforming file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+              );
+              return finish();
+            }
+          } catch (error) {
+            showError(
+              `Error reading file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+            return finish();
+          }
+        },
+        options.unlimited ? null : 120 * 1e3
+      );
+    }
+  );
+});
+
 // utils/cli/showCredit.ts
 import chalk3 from "chalk";
 var beautify = (strings, ...values) => {
@@ -774,10 +1347,10 @@ var calmGradienrain = (text) => {
   const endHue = 300;
   const saturation = 0.45;
   const value = 0.8;
-  const ease = (t3) => t3 * t3 * (3 - 2 * t3);
+  const ease = (t6) => t6 * t6 * (3 - 2 * t6);
   return text.split("").map((char, i) => {
-    const t3 = ease(i / Math.max(text.length - 1, 1));
-    const hue = startHue + (endHue - startHue) * t3;
+    const t6 = ease(i / Math.max(text.length - 1, 1));
+    const hue = startHue + (endHue - startHue) * t6;
     const c = value * saturation;
     const h = hue / 60;
     const x = c * (1 - Math.abs(h % 2 - 1));
@@ -801,10 +1374,10 @@ ${calmGradienrain(`Expose Kit v${VERSION}`)}
 `;
 
 // index.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname4(__filename);
-var pkg = JSON.parse(readFileSync5(join4(__dirname, "package.json"), "utf8"));
+var __dirname = dirname7(__filename);
+var pkg = JSON.parse(readFileSync8(join7(__dirname, "package.json"), "utf8"));
 console.log(showCredit(pkg.version));
 console.log();
 var program = new Command();
@@ -813,7 +1386,15 @@ program.name("expose").description("CLI for Deobfuscating").version(
   "-v, --version",
   "display version number"
 );
-var commands = [parsable_default, safe_scope_default, expand_array_default, pre_evaluate_default];
+var commands = [
+  parsable_default,
+  safe_scope_default,
+  expand_array_default,
+  expand_object_default,
+  object_packer_default,
+  pre_evaluate_default,
+  remove_unused_default
+];
 for (const command of commands) {
   command(program);
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expose-kit",
-	"version": "0.4.0",
+	"version": "0.6.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expose-kit",
-	"version": "0.4.0",
+	"version": "0.6.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",