js-confuser 1.7.1 → 1.7.2

package/src/util/compare.ts

@@ -74,19 +74,52 @@ export function isDirective(object: Node, parents: Node[]) {
   return parents[dIndex].expression == (parents[dIndex - 1] || object);
 }
 
+export function isModuleSource(object: Node, parents: Node[]) {
+  if (!parents[0]) {
+    return false;
+  }
+
+  if (parents[0].type == "ImportDeclaration" && parents[0].source == object) {
+    return true;
+  }
+
+  if (parents[0].type == "ImportExpression" && parents[0].source == object) {
+    return true;
+  }
+
+  if (
+    parents[1] &&
+    parents[1].type == "CallExpression" &&
+    parents[1].arguments[0] === object &&
+    parents[1].callee.type == "Identifier"
+  ) {
+    if (
+      parents[1].callee.name == "require" ||
+      parents[1].callee.name == "import"
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function isMoveable(object: Node, parents: Node[]) {
+  return !isDirective(object, parents) && !isModuleSource(object, parents);
+}
+
 export function isIndependent(object: Node, parents: Node[]) {
   if (object.type == "Literal") {
     return true;
   }
 
-  var parent = parents[0];
-
   if (object.type == "Identifier") {
-    var set = new Set(["null", "undefined"]);
-    if (set.has(object.name)) {
+    if (primitiveIdentifiers.has(object.name)) {
       return true;
     }
-    if (parent.type == "Property") {
+
+    var parent = parents[0];
+    if (parent && parent.type == "Property") {
       if (!parent.computed && parent.key == object) {
         return true;
       }
@@ -105,6 +138,7 @@ export function isIndependent(object: Node, parents: Node[]) {
       if (object != $object) {
         if (!Array.isArray($object) && !isIndependent($object, $parents)) {
           allowIt = false;
+          return "EXIT";
         }
       }
     });

package/src/util/gen.ts

@@ -1,4 +1,5 @@
 import { ok } from "assert";
+import { predictableFunctionTag } from "../constants";
 import { isValidIdentifier } from "./compare";
 
 export type Type =
@@ -306,6 +307,7 @@ export function FunctionExpression(params: Node[], body: any[]) {
     generator: false,
     expression: false,
     async: false,
+    [predictableFunctionTag]: true,
   };
 }
 
@@ -340,6 +342,7 @@ export function FunctionDeclaration(
     generator: false,
     expression: false,
     async: false,
+    [predictableFunctionTag]: true,
   };
 }
 
@@ -529,16 +532,20 @@ export function AddComment(node: Node, text: string) {
   return node;
 }
 
+export function Super() {
+  return { type: "Super" };
+}
+
 export function MethodDefinition(
-  identifier: Node,
+  key: Node,
   functionExpression: Node,
   kind: "method" | "constructor" | "get" | "set",
-  isStatic = true,
+  isStatic = false,
   computed = false
 ) {
   return {
     type: "MethodDefinition",
-    key: identifier,
+    key: key,
     computed: computed,
     value: functionExpression,
     kind: kind,

package/src/util/insert.ts

@@ -3,6 +3,12 @@ import { getBlock, isBlock } from "../traverse";
 import { Node } from "./gen";
 import { getIdentifierInfo, validateChain } from "./identifiers";
 
+export function isClass(object: Node): boolean {
+  return (
+    object.type === "ClassDeclaration" || object.type === "ClassExpression"
+  );
+}
+
 /**
  * - `FunctionDeclaration`
  * - `FunctionExpression`
@@ -18,6 +24,17 @@ export function isFunction(object: Node): boolean {
   ].includes(object && object.type);
 }
 
+export function isStrictModeFunction(object: Node): boolean {
+  ok(isFunction(object));
+
+  return (
+    object.body.type === "BlockStatement" &&
+    object.body.body[0] &&
+    object.body.body[0].type === "ExpressionStatement" &&
+    object.body.body[0].directive === "use strict"
+  );
+}
+
 /**
  * The function context where the object is.
  *

package/src/util/scope.ts

@@ -1,9 +1,21 @@
+import { ok } from "assert";
 import { isBlock } from "../traverse";
+import { Node } from "./gen";
 
-export function isLexicalScope(object) {
+export function isLexicalScope(object: Node) {
   return isBlock(object) || object.type == "SwitchCase";
 }
 
-export function getLexicalScope(object, parents) {
+export function getLexicalScope(object: Node, parents: Node[]): Node {
   return [object, ...parents].find((node) => isLexicalScope(node));
 }
+
+export function getLexicalScopeBody(object: Node): Node[] {
+  ok(isLexicalScope(object));
+
+  return isBlock(object)
+    ? object.body
+    : object.type === "SwitchCase"
+    ? object.consequent
+    : ok("Unhandled case");
+}

package/test/code/Cash.test.ts

@@ -32,12 +32,18 @@ test("Variant #1: Cash.js on High Preset (Strict Mode)", async () => {
     $: false,
   } as any;
   window.window = window;
+  global.window = window;
 
-  // writeFileSync(join(__dirname, "Cash.output.js"), output, {
-  //   encoding: "utf-8",
-  // });
+  try {
+    eval(output);
+  } catch (e) {
+    console.error(e);
+    writeFileSync("dev.output.js", output, {
+      encoding: "utf-8",
+    });
 
-  eval(output);
+    expect(true).toStrictEqual(false);
+  }
 
   expect(window).toHaveProperty("cash");
 });

package/test/code/StrictMode.src.js

@@ -0,0 +1,65 @@
+"use strict";
+
+function TestStrictMode() {
+  "use strict";
+
+  var isStrictMode = () => {
+    try {
+      undefined = true;
+    } catch (E) {
+      return true;
+    }
+    return false;
+  };
+
+  // filler code to make transformations more likely to affect this function
+  var x, y, z;
+  var string1 = "Hello World";
+  var string2 = "use strict";
+
+  var chars = string2.split("");
+  var count = 0;
+  for (var char of chars) {
+    count++;
+  }
+
+  expect(count).toStrictEqual(10);
+
+  // This function should be in strict mode
+  expect(isStrictMode()).toStrictEqual(true);
+}
+
+var isStrictMode = () => {
+  try {
+    undefined = true;
+  } catch (E) {
+    return true;
+  }
+  return false;
+};
+
+// Global level should be in strict mode
+expect(isStrictMode()).toStrictEqual(true);
+TestStrictMode();
+
+// Direct vs. Indirect eval usage
+var evalString = `
+var isStrictMode = () => {
+  try {
+    undefined = true;
+  } catch (E) {
+    return true;
+  }
+  return false;
+};
+
+isStrictMode();`;
+
+// Direct eval -> Preserve global strict-mode
+var directEvalResult = eval(evalString);
+expect(directEvalResult).toStrictEqual(true);
+
+// Indirect eval -> Does not inherit context strict-mode
+var _eval_ = eval;
+var indirectEvalResult = _eval_(evalString);
+expect(indirectEvalResult).toStrictEqual(false);

package/test/code/StrictMode.test.js

@@ -0,0 +1,37 @@
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import JsConfuser from "../../src/index";
+
+var StrictMode_JS = readFileSync(
+  join(__dirname, "./StrictMode.src.js"),
+  "utf-8"
+);
+
+test("Variant #1: StrictMode on High Preset", async () => {
+  var output = await JsConfuser(StrictMode_JS, {
+    target: "node",
+    preset: "high",
+  });
+
+  //writeFileSync("./dev.output.js", output);
+
+  eval(output);
+});
+
+test("Variant #2: StrictMode on 2x High Preset", async () => {
+  var output = await JsConfuser(StrictMode_JS, {
+    target: "node",
+    preset: "high",
+  });
+
+  //writeFileSync("./dev.output1.js", output);
+
+  var output2 = await JsConfuser(output, {
+    target: "node",
+    preset: "high",
+  });
+
+  //writeFileSync("./dev.output2.js", output2);
+
+  eval(output2);
+});

package/test/compare.test.ts

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

package/test/options.test.ts

@@ -1,76 +1,132 @@
 import JsConfuser from "../src/index";
 
-it("should accept percentages", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameGlobals: true,
-    renameVariables: true,
-    stringConcealing: 0.5,
+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");
   });
 
-  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
+    });
 
-it("should 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");
   });
 
-  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,
+      },
+    });
 
-it("should 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");
   });
 
-  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,
+    });
 
-it("should 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");
   });
 
-  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,
+    });
 
-it("should 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");
   });
 
-  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");
+  });
 });
 
-it("should work with debugComments enabled", async () => {
-  var output = await JsConfuser(`var TEST_VARIABLE;`, {
-    target: "node",
-    renameGlobals: true,
-    renameVariables: true,
-    compact: false,
-    indent: 2,
-    debugComments: true,
+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);
   });
 
-  expect(output).not.toContain("TEST_VARIABLE");
+  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);
+  });
 });