expose-kit 0.3.0 → 0.5.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.
@@ -124,7 +124,7 @@ Check whether a file is syntactically valid.
 
 ```js
 parsable:     const x = 810;
-not parsable: cons x; = 810;
+not parsable: const ;x; == 810;
 ```
 
 ```bash
@@ -143,6 +143,7 @@ Rename bindings per scope for safer transformations.
 ```bash
 expose safe-scope path/to/file.js --output path/to/file.safe-scope.js
 ```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/safe-scope/mocks).
 
 Args:
 - `--o, --output <file>`  
@@ -152,6 +153,104 @@ Args:
 
 ---
 
+### `expose pre-evaluate`
+
+Pre-evaluate const numeric/string expressions. (Safe evaluate)
+
+```js
+const a = 1 + 2 * 3; // => 7
+const c = "aaaa";
+const b = "a" + c; // => "aaaaa"
+```
+
+```bash
+expose pre-evaluate path/to/file.js --output path/to/file.pre-evaluate.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+  - No extension → `file.pre-evaluate.js`
+  - With extension → `file.pre-evaluate.<ext>`
+
+---
+
+### `expose expand-array`
+
+Expand array index access for primitive values.
+```js
+var a = [1, 1, 4, 5, 1, 4];
+// before
+console.log(a[0], a[2], a[3]);
+// after
+console.log(1, 4, 5);
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/expand-array/mocks).
+
+```bash
+expose expand-array path/to/file.js --target arrayName --output path/to/file.expand-array.js
+```
+
+Args:
+- `--target <name>`  
+  Target array variable name
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Each replacement is validated by reparsing; invalid replacements (e.g. `++a[0]` or `a[0]++`) are skipped.-
+
+---
+
+### `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; invalid replacements are skipped.
+
+---
+
+### `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 dirname2, join as join2 } from "path";
+import { dirname as dirname6, join as join6 } from "path";
 import { fileURLToPath } from "url";
 import chalk4 from "chalk";
 
@@ -261,6 +261,886 @@ var safe_scope_default = createCommand((program2) => {
   );
 });
 
+// commands/expand-array/index.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, dirname as dirname2, extname as extname2, join as join2 } from "path";
+import { parse as parse3 } from "@babel/parser";
+import traverse2 from "@babel/traverse";
+import generate2 from "@babel/generator";
+import * as t from "@babel/types";
+import loading3 from "loading-cli";
+var createDefaultOutputPath2 = (inputPath) => {
+  const ext = extname2(inputPath);
+  if (!ext) {
+    return `${inputPath}.expand-array.js`;
+  }
+  const base = basename2(inputPath, ext);
+  return join2(dirname2(inputPath), `${base}.expand-array${ext}`);
+};
+var isPrimitiveArray = (arrayNode) => {
+  return arrayNode.elements.every((element) => {
+    if (!element || t.isSpreadElement(element)) {
+      return false;
+    }
+    return true;
+  });
+};
+var getIndexFromProperty = (property) => {
+  if (t.isNumericLiteral(property) && Number.isInteger(property.value)) {
+    return property.value;
+  }
+  if (t.isStringLiteral(property)) {
+    if (!/^-?\d+$/.test(property.value)) {
+      return null;
+    }
+    return Number.parseInt(property.value, 10);
+  }
+  if (t.isUnaryExpression(property, { operator: "-" }) && t.isNumericLiteral(property.argument)) {
+    return -property.argument.value;
+  }
+  return null;
+};
+var isAssignmentTarget = (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 collectMutatedIndexes = (ast, targetName) => {
+  const mutatedIndexes = /* @__PURE__ */ new Set();
+  let hasUnknownMutations = false;
+  patchDefault(traverse2)(ast, {
+    MemberExpression(path) {
+      if (!path.node.computed) return;
+      if (!t.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;
+      if (!t.isExpression(path.node.property)) return;
+      const index = getIndexFromProperty(path.node.property);
+      if (index === null) {
+        hasUnknownMutations = true;
+        return;
+      }
+      mutatedIndexes.add(index);
+    }
+  });
+  return { mutatedIndexes, hasUnknownMutations };
+};
+var findTargetArray = (ast, targetName) => {
+  let found = null;
+  patchDefault(traverse2)(ast, {
+    VariableDeclarator(path) {
+      if (found) return;
+      if (!t.isIdentifier(path.node.id, { name: targetName })) return;
+      if (!t.isArrayExpression(path.node.init)) return;
+      if (!isPrimitiveArray(path.node.init)) return;
+      found = {
+        binding: path.scope.getBinding(targetName) ?? null,
+        arrayNode: path.node.init
+      };
+    },
+    AssignmentExpression(path) {
+      if (found) return;
+      if (!t.isIdentifier(path.node.left, { name: targetName })) return;
+      if (!t.isArrayExpression(path.node.right)) return;
+      if (!isPrimitiveArray(path.node.right)) return;
+      found = {
+        binding: path.scope.getBinding(targetName) ?? null,
+        arrayNode: path.node.right
+      };
+    }
+  });
+  if (!found) return null;
+  let hasRiskOfSideEffects = false;
+  patchDefault(traverse2)(ast, {
+    MemberExpression(path) {
+      if (hasRiskOfSideEffects) return;
+      if (!t.isIdentifier(path.node.object, { name: targetName })) return;
+      const parent = path.parentPath;
+      if (!parent) return;
+      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;
+  result.hasRiskOfSideEffects = hasRiskOfSideEffects;
+  return result;
+};
+var expandArrayAccess = async (code, filename, targetName) => {
+  const ast = parse3(code, createParseOptions(filename));
+  const targetArray = findTargetArray(ast, targetName);
+  if (!targetArray) {
+    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)"
+    );
+    if (continueAnswer !== "y") {
+      throw new Error("User cancelled");
+    }
+  }
+  const candidates = [];
+  const mutatedInfo = collectMutatedIndexes(ast, targetName);
+  if (mutatedInfo.hasUnknownMutations) {
+    return {
+      code: patchDefault(generate2)(ast).code,
+      replacedCount: 0
+    };
+  }
+  patchDefault(traverse2)(ast, {
+    MemberExpression(path) {
+      if (!path.node.computed) return;
+      if (isAssignmentTarget(path)) return;
+      if (!t.isIdentifier(path.node.object, { name: targetName })) return;
+      if (targetArray.binding && path.scope.getBinding(targetName) !== targetArray.binding) {
+        return;
+      }
+      if (!t.isExpression(path.node.property)) return;
+      const index = getIndexFromProperty(path.node.property);
+      if (index === null || index < 0) return;
+      if (mutatedInfo.mutatedIndexes.has(index)) return;
+      const element = targetArray.arrayNode.elements[index];
+      if (!element || t.isSpreadElement(element)) return;
+      candidates.push({
+        path,
+        replacement: t.cloneNode(element, true)
+      });
+    }
+  });
+  let replacedCount = 0;
+  for (const candidate of candidates) {
+    const original = t.cloneNode(candidate.path.node, true);
+    candidate.path.replaceWith(t.cloneNode(candidate.replacement, true));
+    const nextCode = patchDefault(generate2)(ast).code;
+    try {
+      parse3(nextCode, createParseOptions(filename));
+      replacedCount += 1;
+    } catch {
+      candidate.path.replaceWith(original);
+    }
+  }
+  return {
+    code: patchDefault(generate2)(ast).code,
+    replacedCount
+  };
+};
+var expand_array_default = createCommand((program2) => {
+  program2.command("expand-array").description("Expand array index access for primitive values").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--target <name>", "Target array 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 = readFileSync3(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath2(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading3("Expanding array access...").start();
+            try {
+              const { code: output, replacedCount } = await expandArrayAccess(
+                fileContent,
+                filename,
+                targetName
+              );
+              writeFileSync2(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved expand-array file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply expand-array 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/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";
+import traverse3 from "@babel/traverse";
+import generate3 from "@babel/generator";
+import * as t2 from "@babel/types";
+import loading4 from "loading-cli";
+var createDefaultOutputPath3 = (inputPath) => {
+  const ext = extname3(inputPath);
+  if (!ext) {
+    return `${inputPath}.expand-object.js`;
+  }
+  const base = basename3(inputPath, 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/pre-evaluate/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}.pre-evaluate.js`;
+  }
+  const base = basename4(inputPath, ext);
+  return join4(dirname4(inputPath), `${base}.pre-evaluate${ext}`);
+};
+var isSupportedNumberOperator = (operator) => {
+  return operator === "-" || operator === "*" || operator === "/" || operator === "%" || operator === "**" || operator === "<<" || operator === ">>" || operator === ">>>" || operator === "|" || operator === "&" || operator === "^";
+};
+var resolveBindingValue = (binding, state) => {
+  if (!binding.constant || binding.kind !== "const") {
+    return null;
+  }
+  const cached = state.bindingValues.get(binding);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (state.bindingStack.has(binding)) {
+    return null;
+  }
+  state.bindingStack.add(binding);
+  let value = null;
+  if (binding.path.isVariableDeclarator()) {
+    if (binding.path.node.init) {
+      const initPath = binding.path.get("init");
+      if (!Array.isArray(initPath) && initPath.isExpression()) {
+        value = evaluateExpression(initPath, state);
+      }
+    }
+  }
+  state.bindingStack.delete(binding);
+  if (value !== null) {
+    state.bindingValues.set(binding, value);
+  }
+  return value;
+};
+var evaluateExpression = (path, state) => {
+  if (path.isNumericLiteral()) {
+    return path.node.value;
+  }
+  if (path.isStringLiteral()) {
+    return path.node.value;
+  }
+  if (path.isParenthesizedExpression()) {
+    const inner = path.get("expression");
+    if (!Array.isArray(inner) && inner.isExpression()) {
+      return evaluateExpression(inner, state);
+    }
+    return null;
+  }
+  if (path.isIdentifier()) {
+    const binding = path.scope.getBinding(path.node.name);
+    if (!binding) return null;
+    return resolveBindingValue(binding, state);
+  }
+  if (path.isUnaryExpression()) {
+    const argumentPath = path.get("argument");
+    if (Array.isArray(argumentPath) || !argumentPath.isExpression()) {
+      return null;
+    }
+    const argument = evaluateExpression(argumentPath, state);
+    if (argument === null || typeof argument !== "number") {
+      return null;
+    }
+    if (path.node.operator === "+") return +argument;
+    if (path.node.operator === "-") return -argument;
+    if (path.node.operator === "~") return ~argument;
+    return null;
+  }
+  if (path.isBinaryExpression()) {
+    const leftPath = path.get("left");
+    const rightPath = path.get("right");
+    if (Array.isArray(leftPath) || Array.isArray(rightPath) || !leftPath.isExpression() || !rightPath.isExpression()) {
+      return null;
+    }
+    const left = evaluateExpression(leftPath, state);
+    const right = evaluateExpression(rightPath, state);
+    if (left === null || right === null) {
+      return null;
+    }
+    if (path.node.operator === "+") {
+      if (typeof left === "string" || typeof right === "string") {
+        return `${left}${right}`;
+      }
+      if (typeof left === "number" && typeof right === "number") {
+        return left + right;
+      }
+      return null;
+    }
+    if (typeof left !== "number" || typeof right !== "number" || !isSupportedNumberOperator(path.node.operator)) {
+      return null;
+    }
+    switch (path.node.operator) {
+      case "-":
+        return left - right;
+      case "*":
+        return left * right;
+      case "/":
+        return left / right;
+      case "%":
+        return left % right;
+      case "**":
+        return left ** right;
+      case "<<":
+        return left << right;
+      case ">>":
+        return left >> right;
+      case ">>>":
+        return left >>> right;
+      case "|":
+        return left | right;
+      case "&":
+        return left & right;
+      case "^":
+        return left ^ right;
+      default:
+        return null;
+    }
+  }
+  return null;
+};
+var shouldSkipReferencedIdentifier = (path) => {
+  const parent = path.parentPath;
+  if (!parent) return false;
+  if (parent.isObjectProperty()) {
+    if (parent.node.shorthand) return true;
+    if (parent.get("key") === path && !parent.node.computed) {
+      return true;
+    }
+  }
+  if (parent.isObjectMethod()) {
+    if (parent.get("key") === path && !parent.node.computed) {
+      return true;
+    }
+  }
+  return false;
+};
+var preEvaluate = (code, filename) => {
+  const ast = parse5(code, createParseOptions(filename));
+  const state = {
+    bindingValues: /* @__PURE__ */ new Map(),
+    bindingStack: /* @__PURE__ */ new Set()
+  };
+  let replacedCount = 0;
+  patchDefault(traverse4)(ast, {
+    ReferencedIdentifier(path) {
+      if (shouldSkipReferencedIdentifier(path)) {
+        return;
+      }
+      const value = evaluateExpression(path, state);
+      if (value === null) return;
+      if (typeof value === "number") {
+        path.replaceWith(t3.numericLiteral(value));
+      } else {
+        path.replaceWith(t3.stringLiteral(value));
+      }
+      replacedCount += 1;
+    },
+    UnaryExpression: {
+      exit(path) {
+        const value = evaluateExpression(path, state);
+        if (value === null) return;
+        if (typeof value === "number") {
+          path.replaceWith(t3.numericLiteral(value));
+        } else {
+          path.replaceWith(t3.stringLiteral(value));
+        }
+        replacedCount += 1;
+      }
+    },
+    BinaryExpression: {
+      exit(path) {
+        const value = evaluateExpression(path, state);
+        if (value === null) return;
+        if (typeof value === "number") {
+          path.replaceWith(t3.numericLiteral(value));
+        } else {
+          path.replaceWith(t3.stringLiteral(value));
+        }
+        replacedCount += 1;
+      }
+    },
+    ParenthesizedExpression: {
+      exit(path) {
+        const value = evaluateExpression(path, state);
+        if (value === null) return;
+        if (typeof value === "number") {
+          path.replaceWith(t3.numericLiteral(value));
+        } else {
+          path.replaceWith(t3.stringLiteral(value));
+        }
+        replacedCount += 1;
+      }
+    }
+  });
+  return {
+    code: patchDefault(generate4)(ast).code,
+    replacedCount
+  };
+};
+var pre_evaluate_default = createCommand((program2) => {
+  program2.command("pre-evaluate").description("Pre-evaluate const numeric/string expressions").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("Pre-evaluating constants...").start();
+            try {
+              const { code: output, replacedCount } = preEvaluate(
+                fileContent,
+                filename
+              );
+              writeFileSync4(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved pre-evaluate file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply pre-evaluate 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/remove-unused/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}.remove-unused.js`;
+  }
+  const base = basename5(inputPath, ext);
+  return join5(dirname5(inputPath), `${base}.remove-unused${ext}`);
+};
+var removeUnusedVariables = (code, filename) => {
+  const ast = parse6(code, createParseOptions(filename));
+  let changed = false;
+  patchDefault(traverse5)(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 (t4.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() && (t4.isArrayPattern(targetPath.node.id) && targetPath.node.id.elements.length > 1 || t4.isObjectPattern(targetPath.node.id) && targetPath.node.id.properties.length > 1)) {
+              continue;
+            }
+            if (targetPath.key === "consequent" || targetPath.key === "alternate" || targetPath.key === "body") {
+              targetPath.replaceWith(t4.blockStatement([]));
+            } else {
+              const parentPath = targetPath.parentPath;
+              if (parentPath?.isVariableDeclaration() && parentPath.node.declarations.length === 1) {
+                parentPath.remove();
+              } else {
+                targetPath.remove();
+              }
+            }
+            changed = true;
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: patchDefault(generate5)(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 = 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 = loading6("Removing unused variables...").start();
+            try {
+              const { code: output, changed } = removeUnusedVariables(
+                fileContent,
+                filename
+              );
+              writeFileSync5(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) => {
@@ -285,10 +1165,10 @@ var calmGradienrain = (text) => {
   const endHue = 300;
   const saturation = 0.45;
   const value = 0.8;
-  const ease = (t) => t * t * (3 - 2 * t);
+  const ease = (t5) => t5 * t5 * (3 - 2 * t5);
   return text.split("").map((char, i) => {
-    const t = ease(i / Math.max(text.length - 1, 1));
-    const hue = startHue + (endHue - startHue) * t;
+    const t5 = ease(i / Math.max(text.length - 1, 1));
+    const hue = startHue + (endHue - startHue) * t5;
     const c = value * saturation;
     const h = hue / 60;
     const x = c * (1 - Math.abs(h % 2 - 1));
@@ -312,10 +1192,10 @@ ${calmGradienrain(`Expose Kit v${VERSION}`)}
 `;
 
 // index.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
-var pkg = JSON.parse(readFileSync3(join2(__dirname, "package.json"), "utf8"));
+var __dirname = dirname6(__filename);
+var pkg = JSON.parse(readFileSync7(join6(__dirname, "package.json"), "utf8"));
 console.log(showCredit(pkg.version));
 console.log();
 var program = new Command();
@@ -324,7 +1204,14 @@ program.name("expose").description("CLI for Deobfuscating").version(
   "-v, --version",
   "display version number"
 );
-var commands = [parsable_default, safe_scope_default];
+var commands = [
+  parsable_default,
+  safe_scope_default,
+  expand_array_default,
+  expand_object_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.3.0",
+	"version": "0.5.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.3.0",
+	"version": "0.5.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",