expose-kit 0.3.0 → 0.4.0

package/README.md

@@ -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,57 @@ 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  
+  - 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.-
+
+---
+
 ## 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 dirname4, join as join4 } from "path";
 import { fileURLToPath } from "url";
 import chalk4 from "chalk";
 
@@ -261,6 +261,495 @@ 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, {
+    Identifier(path) {
+      if (hasRiskOfSideEffects) return;
+      if (!t.isIdentifier(path.node, { 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;
+    }
+  });
+  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/pre-evaluate/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}.pre-evaluate.js`;
+  }
+  const base = basename3(inputPath, ext);
+  return join3(dirname3(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 = parse4(code, createParseOptions(filename));
+  const state = {
+    bindingValues: /* @__PURE__ */ new Map(),
+    bindingStack: /* @__PURE__ */ new Set()
+  };
+  let replacedCount = 0;
+  patchDefault(traverse3)(ast, {
+    ReferencedIdentifier(path) {
+      if (shouldSkipReferencedIdentifier(path)) {
+        return;
+      }
+      const value = evaluateExpression(path, state);
+      if (value === null) return;
+      if (typeof value === "number") {
+        path.replaceWith(t2.numericLiteral(value));
+      } else {
+        path.replaceWith(t2.stringLiteral(value));
+      }
+      replacedCount += 1;
+    },
+    UnaryExpression: {
+      exit(path) {
+        const value = evaluateExpression(path, state);
+        if (value === null) return;
+        if (typeof value === "number") {
+          path.replaceWith(t2.numericLiteral(value));
+        } else {
+          path.replaceWith(t2.stringLiteral(value));
+        }
+        replacedCount += 1;
+      }
+    },
+    BinaryExpression: {
+      exit(path) {
+        const value = evaluateExpression(path, state);
+        if (value === null) return;
+        if (typeof value === "number") {
+          path.replaceWith(t2.numericLiteral(value));
+        } else {
+          path.replaceWith(t2.stringLiteral(value));
+        }
+        replacedCount += 1;
+      }
+    },
+    ParenthesizedExpression: {
+      exit(path) {
+        const value = evaluateExpression(path, state);
+        if (value === null) return;
+        if (typeof value === "number") {
+          path.replaceWith(t2.numericLiteral(value));
+        } else {
+          path.replaceWith(t2.stringLiteral(value));
+        }
+        replacedCount += 1;
+      }
+    }
+  });
+  return {
+    code: patchDefault(generate3)(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 = 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("Pre-evaluating constants...").start();
+            try {
+              const { code: output, replacedCount } = preEvaluate(
+                fileContent,
+                filename
+              );
+              writeFileSync3(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
+      );
+    }
+  );
+});
+
 // utils/cli/showCredit.ts
 import chalk3 from "chalk";
 var beautify = (strings, ...values) => {
@@ -285,10 +774,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 = (t3) => t3 * t3 * (3 - 2 * t3);
   return text.split("").map((char, i) => {
-    const t = ease(i / Math.max(text.length - 1, 1));
-    const hue = startHue + (endHue - startHue) * t;
+    const t3 = ease(i / Math.max(text.length - 1, 1));
+    const hue = startHue + (endHue - startHue) * t3;
     const c = value * saturation;
     const h = hue / 60;
     const x = c * (1 - Math.abs(h % 2 - 1));
@@ -312,10 +801,10 @@ ${calmGradienrain(`Expose Kit v${VERSION}`)}
 `;
 
 // index.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
-var pkg = JSON.parse(readFileSync3(join2(__dirname, "package.json"), "utf8"));
+var __dirname = dirname4(__filename);
+var pkg = JSON.parse(readFileSync5(join4(__dirname, "package.json"), "utf8"));
 console.log(showCredit(pkg.version));
 console.log();
 var program = new Command();
@@ -324,7 +813,7 @@ 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, pre_evaluate_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.4.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.4.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",