js-confuser 1.7.3 → 2.0.0-alpha.0

package/test/compare.test.ts

@@ -1,104 +0,0 @@
-import Template from "../src/templates/template";
-import { isIndependent } from "../src/util/compare";
-import {
-  ArrayExpression,
-  FunctionExpression,
-  Identifier,
-  Literal,
-} from "../src/util/gen";
-
-describe("isIndependent", () => {
-  it("should return true for literals", () => {
-    expect(isIndependent(Literal("String"), [])).toStrictEqual(true);
-  });
-
-  it("should return false for identifiers", () => {
-    expect(
-      isIndependent(Identifier("variable"), [{ type: "Program" }])
-    ).toStrictEqual(false);
-  });
-
-  it("should return true for reserved identifiers (undefined, NaN, etc)", () => {
-    expect(
-      isIndependent(Identifier("undefined"), [{ type: "Program" }])
-    ).toStrictEqual(true);
-  });
-
-  it("should return true for arrays of literals", () => {
-    expect(
-      isIndependent(ArrayExpression([Literal("String")]), [])
-    ).toStrictEqual(true);
-  });
-
-  it("should return false for arrays with identifiers", () => {
-    expect(
-      isIndependent(
-        ArrayExpression([Literal("String"), Identifier("variable")]),
-        []
-      )
-    ).toStrictEqual(false);
-  });
-
-  it("should return false for everything else", () => {
-    expect(isIndependent(FunctionExpression([], []), [])).toStrictEqual(false);
-  });
-
-  it("various cases", () => {
-    expect(
-      isIndependent(
-        new Template(`({
-      x: 1,
-      y: 2,
-      z: 3,
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(true);
-
-    expect(
-      isIndependent(
-        new Template(`({
-      x: 1,
-      y: 2,
-      z: [3,4,5,6,7,"My String",undefined,null,NaN],
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(true);
-
-    expect(
-      isIndependent(
-        new Template(`({
-      x: 1,
-      y: 2,
-      z: 3,
-      _: function(){return value}
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(false);
-
-    expect(
-      isIndependent(
-        new Template(`({
-      x: 1,
-      y: 2,
-      z: 3,
-      _: [value]
-    })`).single().expression,
-        []
-      )
-    ).toStrictEqual(false);
-
-    expect(
-      isIndependent(
-        new Template(`([
-          {
-            x: value
-          }
-        ])`).single().expression,
-        []
-      )
-    ).toStrictEqual(false);
-  });
-});

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,150 +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");
-  });
-
-  test("Variant #7: Error on invalid lock option", async () => {
-    expect(
-      JsConfuser(`var TEST_VARIABLE;`, {
-        target: "node",
-        lock: "invalid",
-      } as any)
-    ).rejects.toThrow();
-
-    expect(
-      JsConfuser(`var TEST_VARIABLE;`, {
-        target: "node",
-        lock: {
-          invalidProperty: true,
-        },
-      } as any)
-    ).rejects.toThrow();
-  });
-});
-
-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();
-  });
-});