js-confuser 1.7.2 → 2.0.0-alpha.0

package/test/index.test.ts

@@ -1,249 +0,0 @@
-import JsConfuser, {
-  debugObfuscation,
-  debugTransformations,
-} from "../src/index";
-
-it("should be a function", async () => {
-  expect(typeof JsConfuser).toBe("function");
-});
-
-it("should return be an awaited string", async () => {
-  var output = await JsConfuser("5+5", {
-    target: "browser",
-    opaquePredicates: true,
-  });
-
-  expect(typeof output).toBe("string");
-});
-
-it("should error when options are empty", async () => {
-  var invalid: any = {};
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when no obfuscation options", async () => {
-  var invalid: any = {
-    target: "browser",
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error on invalid target values", async () => {
-  var invalid: any = {
-    target: "__invalid__target__",
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when target property missing", async () => {
-  var invalid: any = {
-    objectExtraction: true,
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when invalid options are passed in", async () => {
-  var invalid: any = {
-    target: "browser",
-    __invalid__prop__: true,
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when browserLock is used on target 'node'", async () => {
-  var invalid: any = {
-    target: "node",
-    lock: {
-      browserLock: ["firefox"],
-    },
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when invalid browser names are passed in", async () => {
-  var invalid: any = {
-    target: "browser",
-    lock: {
-      browserLock: ["__invalid__browser__"],
-    },
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when invalid os names are passed in", async () => {
-  var invalid: any = {
-    target: "browser",
-    lock: {
-      osLock: ["__invalid__browser__"],
-    },
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when invalid startDate is passed in", async () => {
-  var invalid: any = {
-    target: "browser",
-    lock: {
-      startDate: "__invalid__date__object__",
-    },
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when invalid endDate is passed in", async () => {
-  var invalid: any = {
-    target: "browser",
-    lock: {
-      endDate: "__invalid__date__object__",
-    },
-  };
-
-  await expect(async () => {
-    return await JsConfuser("5+5", invalid);
-  }).rejects.toThrow();
-});
-
-it("should error when source code is not a string", async () => {
-  await expect(async () => {
-    return await JsConfuser({} as any, {
-      target: "node",
-      preset: "low",
-    });
-  }).rejects.toThrow();
-});
-
-it("should error when invalid source code is passed in", async () => {
-  await expect(async () => {
-    return await JsConfuser("#?!if?//for:;1(function:class{))]][]", {
-      target: "node",
-      preset: "low",
-    });
-  }).rejects.toThrow();
-});
-
-describe("obfuscateAST", () => {
-  test("Variant #1: Mutate AST", async () => {
-    var AST = {
-      type: "Program",
-      body: [
-        {
-          type: "ExpressionStatement",
-          expression: { type: "Literal", value: true },
-        },
-      ],
-    };
-    var before = JSON.stringify(AST);
-
-    JsConfuser.obfuscateAST(AST, { target: "node", es5: true });
-
-    var after = JSON.stringify(AST);
-
-    // Same object reference
-    expect(AST === AST).toStrictEqual(true);
-
-    // Different string
-    expect(before !== after).toStrictEqual(false);
-  });
-
-  test("Variant #2: Error on invalid parameters", async () => {
-    await expect(async () => {
-      return await JsConfuser.obfuscateAST("string", {
-        target: "node",
-        preset: "low",
-      });
-    }).rejects.toThrow();
-  });
-
-  test("Variant #3: Error on invalid AST", async () => {
-    await expect(async () => {
-      var invalidAST = {
-        type: "NotProgram",
-      };
-
-      return await JsConfuser.obfuscateAST(invalidAST, {
-        target: "node",
-        preset: "low",
-      });
-    }).rejects.toThrow();
-  });
-});
-
-describe("debugTransformations", () => {
-  test("Variant #1: Return array of objects containing `name`, `code`, and `ms` properties", async () => {
-    var frames = await debugTransformations(`console.log(1)`, {
-      target: "node",
-      preset: "low",
-    });
-
-    expect(Array.isArray(frames)).toStrictEqual(true);
-    expect(frames.length).toBeTruthy();
-
-    frames.forEach((frame) => {
-      expect(typeof frame.name).toStrictEqual("string");
-      expect(typeof frame.code).toStrictEqual("string");
-      expect(typeof frame.ms).toStrictEqual("number");
-    });
-  });
-});
-
-describe("debugObfuscation", () => {
-  test("Variant #1: Return array of objects containing code, ms, and name properties", async () => {
-    var called = false;
-
-    var callback = (name, complete, totalTransforms) => {
-      expect(typeof name).toStrictEqual("string");
-      expect(typeof complete).toStrictEqual("number");
-      expect(typeof totalTransforms).toStrictEqual("number");
-
-      called = true;
-    };
-    var output = await debugObfuscation(
-      `console.log(1)`,
-      { target: "node", preset: "low" },
-      callback,
-      require("perf_hooks").performance
-    );
-
-    expect(typeof output).toStrictEqual("object");
-    expect(typeof output.obfuscated).toStrictEqual("string");
-    expect(typeof output.obfuscationTime).toStrictEqual("number");
-    expect(typeof output.compileTime).toStrictEqual("number");
-    expect(typeof output.parseTime).toStrictEqual("number");
-    expect(typeof output.totalPossibleTransforms).toStrictEqual("number");
-    expect(typeof output.totalTransforms).toStrictEqual("number");
-    expect(typeof output.transformationTimes).toStrictEqual("object");
-    expect(typeof output.transformationTimes.RenameVariables).toStrictEqual(
-      "number"
-    );
-
-    eval(output.obfuscated);
-    expect(called).toStrictEqual(true);
-  });
-});

package/test/options.test.ts

@@ -1,132 +0,0 @@
-import JsConfuser from "../src/index";
-
-describe("options", () => {
-  test("Variant #1: Accept percentages", async () => {
-    var output = await JsConfuser(`var TEST_VARIABLE;`, {
-      target: "node",
-      renameGlobals: true,
-      renameVariables: true,
-      stringConcealing: 0.5,
-    });
-
-    expect(output).not.toContain("TEST_VARIABLE");
-  });
-
-  test("Variant #2: Accept probability arrays", async () => {
-    var output = await JsConfuser(`var TEST_VARIABLE;`, {
-      target: "node",
-      renameVariables: true,
-      renameGlobals: true,
-      identifierGenerator: ["hexadecimal", "mangled"], // half hexadecimal, half randomized
-    });
-
-    expect(output).not.toContain("TEST_VARIABLE");
-  });
-
-  test("Variant #3: Accept probability maps", async () => {
-    var output = await JsConfuser(`var TEST_VARIABLE;`, {
-      target: "node",
-      renameVariables: true,
-      renameGlobals: true,
-      identifierGenerator: {
-        // 25% each
-        hexadecimal: 0.25,
-        randomized: 0.25,
-        mangled: 0.25,
-        number: 0.25,
-      },
-    });
-
-    expect(output).not.toContain("TEST_VARIABLE");
-  });
-
-  test("Variant #4: Work with compact false", async () => {
-    var output = await JsConfuser(`var TEST_VARIABLE;`, {
-      target: "node",
-      renameGlobals: true,
-      renameVariables: true,
-      compact: false,
-    });
-
-    expect(output).not.toContain("TEST_VARIABLE");
-  });
-
-  test("Variant #5: Work with indent set to 2 spaces", async () => {
-    var output = await JsConfuser(`var TEST_VARIABLE;`, {
-      target: "node",
-      renameGlobals: true,
-      renameVariables: true,
-      compact: false,
-      indent: 2,
-    });
-
-    expect(output).not.toContain("TEST_VARIABLE");
-  });
-
-  test("Variant #6: Work with debugComments enabled", async () => {
-    var output = await JsConfuser(`var TEST_VARIABLE;`, {
-      target: "node",
-      renameGlobals: true,
-      renameVariables: true,
-      compact: false,
-      indent: 2,
-      debugComments: true,
-    });
-
-    expect(output).not.toContain("TEST_VARIABLE");
-  });
-});
-
-describe("options.preserveFunctionLength", () => {
-  test("Variant #1: Enabled by default", async () => {
-    var output = await JsConfuser(
-      `
-    function myFunction(a, b, c, d = "") {
-      // Function.length = 3
-    }
-
-    TEST_OUTPUT = myFunction.length; // 3
-    `,
-      {
-        target: "node",
-        preset: "high",
-      }
-    );
-
-    var TEST_OUTPUT;
-    eval(output);
-    expect(TEST_OUTPUT).toStrictEqual(3);
-  });
-
-  test("Variant #2: Disabled", async () => {
-    var output = await JsConfuser(
-      `
-    function myFunction(a, b, c, d = "") {
-      // Function.length = 3
-    }
-
-    TEST_OUTPUT = myFunction.length; // 3
-    `,
-      {
-        target: "node",
-        preset: "high",
-        preserveFunctionLength: false,
-
-        stringEncoding: false,
-        stringCompression: false,
-        stringConcealing: false,
-        stringSplitting: false,
-        deadCode: false,
-        duplicateLiteralsRemoval: false,
-
-        rgf: true,
-      }
-    );
-
-    expect(output).not.toContain("defineProperty");
-
-    var TEST_OUTPUT;
-    eval(output);
-    expect(TEST_OUTPUT).not.toStrictEqual(3);
-  });
-});

package/test/presets.test.ts

@@ -1,22 +0,0 @@
-import presets from "../src/presets";
-
-it('High preset should have "preset": "high"', async () => {
-  expect(presets.high.preset).toStrictEqual("high");
-});
-
-it('Medium preset should have "preset": "medium"', async () => {
-  expect(presets.medium.preset).toStrictEqual("medium");
-});
-
-it('Low preset should have "preset": "low"', async () => {
-  expect(presets.low.preset).toStrictEqual("low");
-});
-
-it("No preset should have eval, lock, or RGF enabled", async () => {
-  Object.keys(presets).forEach((key) => {
-    expect(typeof presets[key]).toStrictEqual("object");
-    expect(!!presets[key].eval).toEqual(false);
-    expect(!!presets[key].lock).toEqual(false);
-    expect(!!presets[key].rgf).toEqual(false);
-  });
-});

package/test/probability.test.ts

@@ -1,44 +0,0 @@
-import { isProbabilityMapProbable } from "../src/probability";
-
-describe("isProbabilityMapProbable", function () {
-  test("Variant #1: True examples", function () {
-    expect(isProbabilityMapProbable(true)).toStrictEqual(true);
-    expect(isProbabilityMapProbable(1)).toStrictEqual(true);
-    expect(isProbabilityMapProbable(0.1)).toStrictEqual(true);
-
-    expect(
-      isProbabilityMapProbable({
-        mode: 1,
-      })
-    ).toStrictEqual(true);
-
-    expect(isProbabilityMapProbable(["mode"])).toStrictEqual(true);
-
-    // Function are always true
-    expect(isProbabilityMapProbable(() => true)).toStrictEqual(true);
-    expect(isProbabilityMapProbable(() => false)).toStrictEqual(true);
-  });
-
-  test("Variant #2: False examples", function () {
-    expect(isProbabilityMapProbable(false)).toStrictEqual(false);
-    expect(isProbabilityMapProbable(0)).toStrictEqual(false);
-    expect(isProbabilityMapProbable(undefined)).toStrictEqual(false);
-    expect(isProbabilityMapProbable(null)).toStrictEqual(false);
-
-    expect(isProbabilityMapProbable([false])).toStrictEqual(false);
-  });
-
-  test("Variant #3: Invalid examples", function () {
-    // Invalid percentage
-    expect(() => isProbabilityMapProbable(1.1)).toThrow();
-    expect(() => isProbabilityMapProbable(50)).toThrow();
-    expect(() => isProbabilityMapProbable(-0.1)).toThrow();
-    expect(() => isProbabilityMapProbable(NaN)).toThrow();
-
-    // Empty object
-    expect(() => isProbabilityMapProbable({})).toThrow();
-
-    // Empty array
-    expect(() => isProbabilityMapProbable([])).toThrow();
-  });
-});

package/test/templates/template.test.ts

@@ -1,14 +0,0 @@
-import Template from "../../src/templates/template";
-
-describe("Template", () => {
-  test("Variant #1: Error when invalid code passed in", () => {
-    var _consoleError = console.error;
-    console.error = () => {};
-
-    expect(() => {
-      Template(`#&!#Ylet{}class)--1]?|:!@#`).compile();
-    }).toThrow();
-
-    console.error = _consoleError;
-  });
-});

package/test/transforms/antiTooling.test.ts

@@ -1,52 +0,0 @@
-import JsConfuser from "../../src/index";
-
-// https://github.com/MichaelXF/js-confuser/issues/74
-test("Variant #1: Don't break Symbols", async () => {
-  if (typeof Symbol !== "undefined") {
-    for (var i = 0; i < 6; i++) {
-      var output = await JsConfuser(
-        `
-  
-      var sym1 = Symbol();
-    
-      if (true) {
-        sym1;
-        sym1;
-        sym1;
-      }
-  
-      TEST_OUTPUT = sym1;
-    
-      `,
-        { target: "node", renameVariables: true }
-      );
-
-      var TEST_OUTPUT;
-
-      eval(output);
-      expect(typeof TEST_OUTPUT).toStrictEqual("symbol");
-    }
-  }
-});
-
-test("Variant #2: Join expressions into sequence expressions", async () => {
-  var output = await JsConfuser(
-    `
-  TEST_OUTPUT = 0;
-  TEST_OUTPUT++;
-  TEST_OUTPUT++;
-  TEST_OUTPUT++;
-  if(TEST_OUTPUT > 0) {
-    TEST_OUTPUT *= 2;
-  }
-  `,
-    { target: "node", renameVariables: true }
-  );
-
-  expect(output).toContain("(TEST_OUTPUT=0,TEST_OUTPUT++");
-
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual(6);
-});

package/test/transforms/calculator.test.ts

@@ -1,78 +0,0 @@
-import JsConfuser from "../../src/index";
-
-it("should hide binary expressions", async () => {
-  var code = `5 + 5`;
-
-  var output = await JsConfuser(code, { target: "browser", calculator: true });
-
-  expect(output).not.toContain("5+5");
-  expect(output).not.toContain("5 + 5");
-  expect(output).toContain("switch");
-});
-
-it("should result with correct values", async () => {
-  var code = `input(5 + 5)`;
-
-  var output = await JsConfuser(code, { target: "browser", calculator: true });
-
-  function input(x) {
-    expect(x).toStrictEqual(10);
-  }
-
-  eval(output);
-});
-
-it("should execute property with complex operations", async () => {
-  var code = `input((40 * 35 + 4) * 4 + 2)`;
-
-  var output = await JsConfuser(code, { target: "browser", calculator: true });
-
-  var value;
-  function input(x) {
-    value = x;
-  }
-
-  eval(output);
-
-  expect(value).toStrictEqual(5618);
-});
-
-it("should apply to unary operators", async () => {
-  var code = `
-  var one = +1;
-  var negativeOne = -one;
-
-  var trueValue = true;
-  var falseValue = !trueValue;
-
-  TEST_OUTPUT = typeof (1, falseValue) === "boolean" && negativeOne === ~~-1 && void 0 === undefined;
-  `;
-
-  var output = await JsConfuser(code, { target: "node", calculator: true });
-
-  expect(output).toContain("_calc");
-  expect(output).not.toContain("+1");
-  expect(output).not.toContain("-one");
-  expect(output).not.toContain("typeof(1,falseValue)");
-  expect(output).not.toContain("void 0");
-
-  var TEST_OUTPUT = true;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual(true);
-});
-
-it("should not break typeof expressions", async () => {
-  var code = `
-    TEST_OUTPUT = typeof nonExistentVariable === "undefined";
-    `;
-
-  var output = await JsConfuser(code, { target: "node", calculator: true });
-
-  expect(output).not.toContain("_calc");
-
-  var TEST_OUTPUT;
-  eval(output);
-
-  expect(TEST_OUTPUT).toStrictEqual(true);
-});