js-confuser 2.0.0-alpha.5 → 2.0.1

package/src/utils/NameGen.ts

@@ -1,116 +1,116 @@
-import { ok } from "assert";
-import { ObfuscateOptions } from "../options";
-import { alphabeticalGenerator, createZeroWidthGenerator } from "./gen-utils";
-import {
-  choice,
-  getRandomChineseString,
-  getRandomHexString,
-  getRandomInteger,
-} from "./random-utils";
-import { reservedKeywords, reservedObjectPrototype } from "../constants";
-import Obfuscator from "../obfuscator";
-
-/**
- * Generate random names for variables and properties.
- */
-export class NameGen {
-  public generatedNames = new Set<string>();
-  public notSafeForReuseNames = new Set<string>();
-
-  private counter = 1;
-  private zeroWidthGenerator = createZeroWidthGenerator();
-
-  constructor(
-    private identifierGenerator: ObfuscateOptions["identifierGenerator"] = "randomized",
-    public options = {
-      avoidReserved: false,
-      avoidObjectPrototype: false,
-    }
-  ) {}
-
-  private attemptGenerate() {
-    if (typeof this.identifierGenerator === "function") {
-      var value = this.identifierGenerator();
-      ok(
-        typeof value === "string",
-        "Custom identifier generator must return a string"
-      );
-      return value;
-    }
-
-    var mode = Obfuscator.prototype.computeProbabilityMap(
-      this.identifierGenerator
-    );
-
-    const randomizedLength = getRandomInteger(6, 8);
-
-    switch (mode) {
-      case "randomized":
-        var characters =
-          "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
-        var numbers = "0123456789".split("");
-
-        var combined = [...characters, ...numbers];
-
-        var result = "";
-        for (var i = 0; i < randomizedLength; i++) {
-          result += choice(i == 0 ? characters : combined);
-        }
-        return result;
-
-      case "hexadecimal":
-        return "_0x" + getRandomHexString(randomizedLength);
-
-      case "mangled":
-        var mangledName = "";
-        do {
-          mangledName = alphabeticalGenerator(this.counter++);
-        } while (reservedKeywords.includes(mangledName));
-
-        return mangledName;
-
-      case "number":
-        return "var_" + this.counter++;
-
-      case "zeroWidth":
-        return this.zeroWidthGenerator.generate();
-
-      case "chinese":
-        return getRandomChineseString(randomizedLength);
-
-      default:
-        throw new Error(
-          "Invalid identifier generator mode: " + this.identifierGenerator
-        );
-    }
-  }
-
-  generate(isSafeForReuse = true): string {
-    let name: string;
-
-    do {
-      name = this.attemptGenerate();
-
-      // Avoid reserved keywords
-      if (this.options.avoidReserved && reservedKeywords.includes(name)) {
-        name = "";
-        continue;
-      }
-
-      // Avoid reserved object prototype properties
-      if (
-        this.options.avoidObjectPrototype &&
-        reservedObjectPrototype.has(name)
-      ) {
-        name = "";
-        continue;
-      }
-    } while (!name || this.generatedNames.has(name));
-
-    this.generatedNames.add(name);
-    if (!isSafeForReuse) {
-      this.notSafeForReuseNames.add(name);
-    }
-    return name;
-  }
-}
+import { ok } from "assert";
+import { ObfuscateOptions } from "../options";
+import { alphabeticalGenerator, createZeroWidthGenerator } from "./gen-utils";
+import {
+  choice,
+  getRandomChineseString,
+  getRandomHexString,
+  getRandomInteger,
+} from "./random-utils";
+import { reservedKeywords, reservedObjectPrototype } from "../constants";
+import Obfuscator from "../obfuscator";
+
+/**
+ * Generate random names for variables and properties.
+ */
+export class NameGen {
+  public generatedNames = new Set<string>();
+  public notSafeForReuseNames = new Set<string>();
+
+  private counter = 1;
+  private zeroWidthGenerator = createZeroWidthGenerator();
+
+  constructor(
+    private identifierGenerator: ObfuscateOptions["identifierGenerator"] = "randomized",
+    public options = {
+      avoidReserved: false,
+      avoidObjectPrototype: false,
+    }
+  ) {}
+
+  private attemptGenerate() {
+    if (typeof this.identifierGenerator === "function") {
+      var value = this.identifierGenerator();
+      ok(
+        typeof value === "string",
+        "Custom identifier generator must return a string"
+      );
+      return value;
+    }
+
+    var mode = Obfuscator.prototype.computeProbabilityMap(
+      this.identifierGenerator
+    );
+
+    const randomizedLength = getRandomInteger(6, 8);
+
+    switch (mode) {
+      case "randomized":
+        var characters =
+          "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
+        var numbers = "0123456789".split("");
+
+        var combined = [...characters, ...numbers];
+
+        var result = "";
+        for (var i = 0; i < randomizedLength; i++) {
+          result += choice(i == 0 ? characters : combined);
+        }
+        return result;
+
+      case "hexadecimal":
+        return "_0x" + getRandomHexString(randomizedLength);
+
+      case "mangled":
+        var mangledName = "";
+        do {
+          mangledName = alphabeticalGenerator(this.counter++);
+        } while (reservedKeywords.includes(mangledName));
+
+        return mangledName;
+
+      case "number":
+        return "var_" + this.counter++;
+
+      case "zeroWidth":
+        return this.zeroWidthGenerator.generate();
+
+      case "chinese":
+        return getRandomChineseString(randomizedLength);
+
+      default:
+        throw new Error(
+          "Invalid identifier generator mode: " + this.identifierGenerator
+        );
+    }
+  }
+
+  generate(isSafeForReuse = true): string {
+    let name: string;
+
+    do {
+      name = this.attemptGenerate();
+
+      // Avoid reserved keywords
+      if (this.options.avoidReserved && reservedKeywords.includes(name)) {
+        name = "";
+        continue;
+      }
+
+      // Avoid reserved object prototype properties
+      if (
+        this.options.avoidObjectPrototype &&
+        reservedObjectPrototype.has(name)
+      ) {
+        name = "";
+        continue;
+      }
+    } while (!name || this.generatedNames.has(name));
+
+    this.generatedNames.add(name);
+    if (!isSafeForReuse) {
+      this.notSafeForReuseNames.add(name);
+    }
+    return name;
+  }
+}

package/src/utils/PredicateGen.ts

@@ -1,61 +1,61 @@
-import { NodePath } from "@babel/traverse";
-import { PluginInstance } from "../transforms/plugin";
-import * as t from "@babel/types";
-import { prepend } from "./ast-utils";
-import { NameGen } from "./NameGen";
-import Template from "../templates/template";
-
-export default class PredicateGen {
-  constructor(public plugin: PluginInstance) {}
-
-  dummyFunctionName: string | null = null;
-  programPath: NodePath<t.Program> | null = null;
-
-  ensureCreated() {
-    if (this.dummyFunctionName) return;
-
-    this.dummyFunctionName = this.plugin.getPlaceholder("dummyFunction");
-
-    // Insert dummy function
-    prepend(
-      this.programPath,
-
-      this.plugin.skip(
-        t.functionDeclaration(
-          t.identifier(this.dummyFunctionName),
-          [],
-          t.blockStatement([])
-        )
-      )
-    );
-  }
-
-  generateTrueExpression(path: NodePath): t.Expression {
-    return t.unaryExpression("!", this.generateFalseExpression(path));
-  }
-
-  generateFalseExpression(path: NodePath): t.Expression {
-    this.programPath = path.find((p) => p.isProgram()) as NodePath<t.Program>;
-    this.ensureCreated();
-
-    // Overcomplicated way to get a random property name that doesn't exist on the Function
-    var randomProperty: string;
-    var nameGen = new NameGen("randomized");
-
-    function PrototypeCollision() {}
-    PrototypeCollision(); // Call it for code coverage :D
-
-    do {
-      randomProperty = nameGen.generate();
-    } while (
-      !randomProperty ||
-      PrototypeCollision[randomProperty] !== undefined
-    );
-
-    return this.plugin.skip(
-      new Template(
-        `"${randomProperty}" in ${this.dummyFunctionName}`
-      ).expression()
-    );
-  }
-}
+import { NodePath } from "@babel/traverse";
+import { PluginInstance } from "../transforms/plugin";
+import * as t from "@babel/types";
+import { prepend } from "./ast-utils";
+import { NameGen } from "./NameGen";
+import Template from "../templates/template";
+
+export default class PredicateGen {
+  constructor(public plugin: PluginInstance) {}
+
+  dummyFunctionName: string | null = null;
+  programPath: NodePath<t.Program> | null = null;
+
+  ensureCreated() {
+    if (this.dummyFunctionName) return;
+
+    this.dummyFunctionName = this.plugin.getPlaceholder("dummyFunction");
+
+    // Insert dummy function
+    prepend(
+      this.programPath,
+
+      this.plugin.skip(
+        t.functionDeclaration(
+          t.identifier(this.dummyFunctionName),
+          [],
+          t.blockStatement([])
+        )
+      )
+    );
+  }
+
+  generateTrueExpression(path: NodePath): t.Expression {
+    return t.unaryExpression("!", this.generateFalseExpression(path));
+  }
+
+  generateFalseExpression(path: NodePath): t.Expression {
+    this.programPath = path.find((p) => p.isProgram()) as NodePath<t.Program>;
+    this.ensureCreated();
+
+    // Overcomplicated way to get a random property name that doesn't exist on the Function
+    var randomProperty: string;
+    var nameGen = new NameGen("randomized");
+
+    function PrototypeCollision() {}
+    PrototypeCollision(); // Call it for code coverage :D
+
+    do {
+      randomProperty = nameGen.generate();
+    } while (
+      !randomProperty ||
+      PrototypeCollision[randomProperty] !== undefined
+    );
+
+    return this.plugin.skip(
+      new Template(
+        `"${randomProperty}" in ${this.dummyFunctionName}`
+      ).expression()
+    );
+  }
+}