js-confuser 1.7.2 → 2.0.0-alpha.0

package/test/transforms/string/stringCompression.test.ts

@@ -1,120 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("should work", async () => {
-  var output = await JsConfuser(`input("Hello World")`, {
-    target: "node",
-    stringCompression: true,
-  });
-
-  var value,
-    input = (x) => (value = x);
-
-  eval(output);
-
-  expect(value).toStrictEqual("Hello World");
-});
-
-it("should work on property keys", async () => {
-  var code = `
-  var myObject = {
-    myKey: 100
-  }
-
-  TEST_VAR = myObject.myKey;
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringCompression: true,
-  });
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should work on class keys", async () => {
-  var code = `
-  class MyClass {
-    myMethod(){
-      return 100;
-    }
-  }
-
-  var myObject = new MyClass();
-
-  TEST_VAR = myObject.myMethod();
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringCompression: true,
-  });
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should not encode constructor key", async () => {
-  var code = `
-  class MyClass {
-    constructor(){
-      TEST_VAR = 100;
-    }
-  }
-
-  new MyClass();
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringCompression: true,
-  });
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should be configurable by custom function option", async () => {
-  var code = `
-  TEST_OUTPUT_1 = "My String 1";
-  TEST_OUTPUT_2 = "My String 2";
-  TEST_OUTPUT_3 = "My String 3";
-  `;
-
-  var stringsFound = [];
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringCompression: (strValue) => {
-      stringsFound.push(strValue);
-
-      // Change all strings but "My String 2"
-      return strValue !== "My String 2";
-    },
-  });
-
-  // Ensure all strings were found
-  expect(stringsFound).toContain("My String 1");
-  expect(stringsFound).toContain("My String 2");
-  expect(stringsFound).toContain("My String 3");
-
-  // Ensure the strings got changed (except for "My String 2")
-  expect(output).not.toContain("TEST_OUTPUT_1='My String 1'");
-  expect(output).toContain("TEST_OUTPUT_2='My String 2'");
-  expect(output).not.toContain("TEST_OUTPUT_3='My String 3'");
-
-  // Make sure the code still works!
-  var TEST_OUTPUT_1, TEST_OUTPUT_2, TEST_OUTPUT_3;
-
-  eval(output);
-
-  expect(TEST_OUTPUT_1).toStrictEqual("My String 1");
-  expect(TEST_OUTPUT_2).toStrictEqual("My String 2");
-  expect(TEST_OUTPUT_3).toStrictEqual("My String 3");
-});

package/test/transforms/string/stringConcealing.test.ts

@@ -1,299 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("should conceal strings", async () => {
-  var code = `var TEST_STRING = "Hello World"`;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringConcealing: true,
-  });
-
-  expect(output).not.toContain("Hello World");
-});
-
-it("should decode strings properly", async () => {
-  var code = `
-   var TEST_STRING = "Hello World"
-
-   input(TEST_STRING);
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringConcealing: true,
-  });
-
-  expect(output).not.toContain("Hello World");
-
-  var value;
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual("Hello World");
-});
-
-it("should decode multiple strings properly", async () => {
-  var code = `
-    TEST_STRING_1 = "Hello World"
-    TEST_STRING_2 = "Hello World"
-    TEST_STRING_3 = "Another String"
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringConcealing: true,
-  });
-
-  expect(output).not.toContain("Hello World");
-  expect(output).not.toContain("Another String");
-
-  var TEST_STRING_1, TEST_STRING_2, TEST_STRING_3;
-
-  eval(output);
-
-  expect(TEST_STRING_1).toStrictEqual("Hello World");
-  expect(TEST_STRING_2).toStrictEqual("Hello World");
-  expect(TEST_STRING_3).toStrictEqual("Another String");
-});
-
-it("should not encode import expressions", async () => {
-  var code = `
-   import("my-module").then(module=>{
-     // ...
-   })
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringConcealing: true,
-  });
-
-  expect(output).toContain("my-module");
-});
-
-it("should not encode import statements", async () => {
-  var code = `
-   import x from "my-module"
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringConcealing: true,
-  });
-
-  expect(output).toContain("my-module");
-});
-
-it("should not encode require imports", async () => {
-  var code = `
-   require("my-module")
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringConcealing: true,
-  });
-
-  expect(output).toContain("my-module");
-});
-
-it("should not encode directives ('use strict')", async () => {
-  var code = `
-  'use strict'
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringConcealing: true,
-  });
-
-  expect(output).toContain("use strict");
-});
-
-it("should work on property keys", async () => {
-  var code = `
-  var myObject = {
-    myKey: 100
-  }
-
-  TEST_VAR = myObject.myKey;
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringConcealing: true,
-  });
-
-  expect(output).not.toContain("myKey");
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should work on class keys", async () => {
-  var code = `
-  class MyClass {
-    myMethod(){
-      return 100;
-    }
-  }
-
-  var myObject = new MyClass();
-
-  TEST_VAR = myObject.myMethod();
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringConcealing: true,
-  });
-
-  expect(output).not.toContain("myMethod");
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should not encode constructor key", async () => {
-  var code = `
-  class MyClass {
-    constructor(){
-      TEST_VAR = 100;
-    }
-  }
-
-  new MyClass();
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringConcealing: true,
-  });
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-// https://github.com/MichaelXF/js-confuser/issues/82
-it("should work inside the Class Constructor function", async () => {
-  var code = `
-  class MyClass1 {}
-  class MyClass2 extends MyClass1 {
-    constructor(){
-      super();
-      this["myString1"] = true;
-      this["myString2"] = true;
-      this["myString3"] = true;
-    }
-  }
-
-  var instance = new MyClass2();
-
-  TEST_OUTPUT = instance.myString1 === true; // true
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringConcealing: true,
-  });
-
-  // Ensure the strings got encrypted properly
-  expect(output).not.toContain("myString");
-
-  // Ensure the code works
-  var TEST_OUTPUT = false;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual(true);
-});
-
-it("should be configurable by custom function option", async () => {
-  var code = `
-  var myVar1 = "My First String";
-  var myVar2 = "My Second String";
-  var myVar3 = "My Third String";
-
-  TEST_RESULT = [myVar1, myVar2, myVar3];
-  `;
-
-  var strings = [];
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringConcealing: (str) => {
-      strings.push(str);
-
-      return str !== "My Second String";
-    },
-  });
-
-  // Ensure stringConcealing found all the strings
-  expect(strings).toContain("My First String");
-  expect(strings).toContain("My Second String");
-  expect(strings).toContain("My Third String");
-
-  // These strings should be encoded
-  expect(output).not.toContain("My First String");
-  expect(output).not.toContain("My Third String");
-
-  // This string should NOT be encoded
-  expect(output).toContain("My Second String");
-
-  // Ensure strings get properly decoded
-  var TEST_RESULT;
-
-  eval(output);
-  expect(TEST_RESULT).toStrictEqual([
-    "My First String",
-    "My Second String",
-    "My Third String",
-  ]);
-});
-
-test("Variant #13: Work without TextEncoder or Buffer being defined", async () => {
-  var output = await JsConfuser(
-    `
-  TEST_OUTPUT = [];
-  TEST_OUTPUT.push("My First String");
-  TEST_OUTPUT.push("My Second String");
-  TEST_OUTPUT.push("My Third String");
-  TEST_OUTPUT.push("My Fourth String");
-  TEST_OUTPUT.push("My Fifth String");
-  `,
-    { target: "node", stringConcealing: true }
-  );
-
-  // Ensure the strings got changed
-  expect(output).not.toContain("My First String");
-  expect(output).not.toContain("My Second String");
-  expect(output).not.toContain("My Third String");
-  expect(output).not.toContain("My Fourth String");
-  expect(output).not.toContain("My Fifth String");
-
-  // Disable TextEncoder and Buffer
-  var global = {};
-  var window = {};
-  var Buffer = undefined;
-  var TextEncoder = undefined;
-
-  // Test the code
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual([
-    "My First String",
-    "My Second String",
-    "My Third String",
-    "My Fourth String",
-    "My Fifth String",
-  ]);
-});

package/test/transforms/string/stringEncoding.test.ts

@@ -1,95 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-test("Variant #1: Encode strings", async () => {
-  var code = `var TEST_STRING = "encoded."`;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringEncoding: true,
-  });
-
-  expect(output).not.toContain("encoded.");
-
-  expect(
-    output.includes(
-      "\\u0065\\u006e\\u0063\\u006f\\u0064\\u0065\\u0064\\u002e"
-    ) || output.includes("\\x65\\x6e\\x63\\x6f\\x64\\x65\\x64\\x2e")
-  ).toStrictEqual(true);
-});
-
-test("Variant #2: Encode strings AND still have same result", async () => {
-  var code = `input("encoded.")`;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringEncoding: true,
-  });
-
-  expect(output).not.toContain("encoded.");
-
-  expect(
-    output.includes(
-      "\\u0065\\u006e\\u0063\\u006f\\u0064\\u0065\\u0064\\u002e"
-    ) || output.includes("\\x65\\x6e\\x63\\x6f\\x64\\x65\\x64\\x2e")
-  ).toStrictEqual(true);
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual("encoded.");
-});
-
-test("Variant #3: Encode object property keys", async () => {
-  var code = `TEST_OUTPUT = { myProperty1: true, "myProperty2": true }`;
-
-  var output = await JsConfuser(code, { target: "node", stringEncoding: true });
-
-  // Ensure the strings got changed
-  expect(output).not.toContain("myProperty1");
-  expect(output).not.toContain("myProperty2");
-
-  // Ensure output is exactly the same
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual({ myProperty1: true, myProperty2: true });
-});
-
-test("Variant #4: Encode object destructuring property keys", async () => {
-  var code = `({ ["myDestructedKey"]: TEST_OUTPUT } = { myDestructedKey: true })`;
-
-  var output = await JsConfuser(code, { target: "node", stringEncoding: true });
-
-  // Ensure the string(s) got changed
-  expect(output).not.toContain("myDestructedKey");
-
-  // Ensure output is exactly the same
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual(true);
-});
-
-// This test multiple transformations
-test("Variant #5: Preserve 'use strict' directive", async () => {
-  var code = `
-  "use strict";
-
-  var filler1;
-  var filler2;
-  var filler3;
-
-  var anotherVar = "use strict";
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    preset: "high",
-  });
-
-  expect(output.startsWith("'use strict'")).toStrictEqual(true);
-});

package/test/transforms/string/stringSplitting.test.ts

@@ -1,135 +0,0 @@
-import JsConfuser from "../../../src/index";
-
-it("should split strings", async () => {
-  var code = `var TEST_STRING = "the brown dog jumped over the lazy fox."`;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringSplitting: true,
-  });
-
-  expect(output).not.toContain("the brown dog jumped over the lazy fox.");
-});
-
-it("should split strings and concatenate correctly", async () => {
-  var code = `input("the brown dog jumped over the lazy fox.")`;
-
-  var output = await JsConfuser(code, {
-    target: "browser",
-    stringSplitting: true,
-  });
-
-  var value = "never_called";
-  function input(valueIn) {
-    value = valueIn;
-  }
-
-  expect(output).not.toContain("the brown dog jumped over the lazy fox.");
-
-  eval(output);
-
-  expect(value).toStrictEqual("the brown dog jumped over the lazy fox.");
-});
-
-it("should work on property keys", async () => {
-  var code = `
-  var myObject = {
-    myVeryLongStringThatShouldGetSplit: 100
-  }
-
-  TEST_VAR = myObject.myVeryLongStringThatShouldGetSplit;
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringSplitting: true,
-  });
-
-  expect(output).not.toContain("myVeryLongStringThatShouldGetSplit");
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should work on class keys", async () => {
-  var code = `
-  class MyClass {
-    myVeryLongMethodName(){
-      return 100;
-    }
-  }
-
-  var myObject = new MyClass();
-
-  TEST_VAR = myObject.myVeryLongMethodName();
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringSplitting: true,
-  });
-
-  expect(output).not.toContain("myVeryLongMethodName");
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should not encode constructor key", async () => {
-  var code = `
-  class MyClass {
-    constructor(){
-      TEST_VAR = 100;
-    }
-  }
-
-  new MyClass();
-  `;
-
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringSplitting: true,
-  });
-
-  var TEST_VAR;
-  eval(output);
-
-  expect(TEST_VAR).toStrictEqual(100);
-});
-
-it("should allow custom callback to exclude strings", async () => {
-  var code = `
-  var str1 = "-- Hello World --";
-  var str2 = "-- This String Will Not Be Split --";
-  var str3 = "-- This string Will Be Split --";
-  `;
-
-  var strings = [];
-  var output = await JsConfuser(code, {
-    target: "node",
-    stringSplitting: (str) => {
-      strings.push(str);
-
-      if (str == "-- This String Will Not Be Split --") {
-        return false;
-      }
-
-      return true;
-    },
-  });
-
-  expect(strings).toEqual([
-    "-- Hello World --",
-    "-- This String Will Not Be Split --",
-    "-- This string Will Be Split --",
-  ]);
-
-  expect(output).toContain("-- This String Will Not Be Split --");
-
-  expect(output).not.toContain("-- Hello World --");
-  expect(output).not.toContain("-- This string Will Be Split --");
-});

package/test/transforms/transform.test.ts

@@ -1,66 +0,0 @@
-import Obfuscator from "../../src/obfuscator";
-import Transform from "../../src/transforms/transform";
-
-describe("Transform class", () => {
-  class MyTransformClass extends Transform {
-    constructor(o) {
-      super(o);
-    }
-  }
-
-  const myObfuscator = new Obfuscator({
-    target: "node",
-    identifierGenerator: "mangled",
-  });
-  const myTransform = new MyTransformClass(myObfuscator);
-
-  const tree = {
-    type: "Program",
-    body: [],
-  };
-
-  test("Variant #1: Not implemented match()", () => {
-    expect(() => myTransform.match(tree, [])).toThrow();
-  });
-
-  test("Variant #2: Not implemented transform()", () => {
-    expect(() => myTransform.transform(tree, [])).toThrow();
-  });
-
-  test("Variant #3: getGenerator()", () => {
-    const generator = myTransform.getGenerator();
-
-    const generated = new Set<string>();
-
-    const count = 50;
-
-    for (var i = 0; i < count; i++) {
-      const newName = generator.generate();
-      generated.add(newName);
-    }
-
-    // This ensures all generated names are unique!
-    expect(generated.size).toStrictEqual(count);
-  });
-
-  test("Variant #4: getGenerator() with overrideMode parameter", () => {
-    // number generator
-    const generator = myTransform.getGenerator("number");
-
-    expect(generator.generate()).toStrictEqual("var_1");
-    expect(generator.generate()).toStrictEqual("var_2");
-    expect(generator.generate()).toStrictEqual("var_3");
-
-    // hexadecimal generator
-    const anotherGenerator = myTransform.getGenerator("hexadecimal");
-
-    expect(anotherGenerator.generate()).toContain("_0x");
-
-    // mangled generator
-    const yetAnotherGenerator = myTransform.getGenerator("mangled");
-
-    expect(yetAnotherGenerator.generate()).toStrictEqual("a");
-    expect(yetAnotherGenerator.generate()).toStrictEqual("b");
-    expect(yetAnotherGenerator.generate()).toStrictEqual("c");
-  });
-});