js-confuser 1.7.3 → 2.0.0-alpha.0

package/test/traverse.test.ts

@@ -1,139 +0,0 @@
-import traverse, { assertNoCircular } from "../src/traverse";
-import { Node } from "../src/util/gen";
-
-describe("traverse", function () {
-  test("Variant #1: Traverse tree", function () {
-    var executionOrder = [];
-
-    var tree: Node = {
-      type: "Program",
-      start: 0,
-      end: 27,
-      body: [
-        {
-          type: "ExpressionStatement",
-          start: 0,
-          end: 27,
-          expression: {
-            type: "CallExpression",
-            start: 0,
-            end: 26,
-            callee: {
-              type: "MemberExpression",
-              start: 0,
-              end: 11,
-              object: {
-                type: "Identifier",
-                start: 0,
-                end: 7,
-                name: "console",
-              },
-              property: {
-                type: "Identifier",
-                start: 8,
-                end: 11,
-                name: "log",
-              },
-              computed: false,
-              optional: false,
-            },
-            arguments: [
-              {
-                type: "Literal",
-                start: 12,
-                end: 25,
-                value: "Hello World",
-                raw: '"Hello World"',
-              },
-            ],
-            optional: false,
-          },
-        },
-      ],
-      sourceType: "module",
-    };
-
-    var literalParents;
-
-    traverse(tree, (object, parents) => {
-      if (object.type) {
-        if (object.type === "Literal") {
-          literalParents = parents;
-        }
-
-        executionOrder.push("ENTER:" + object.type);
-
-        return () => {
-          executionOrder.push("EXIT:" + object.type);
-        };
-      }
-    });
-
-    var displayString = executionOrder.join(",");
-
-    expect(displayString).toStrictEqual(
-      "ENTER:Program,ENTER:ExpressionStatement,ENTER:CallExpression,ENTER:MemberExpression,ENTER:Identifier,EXIT:Identifier,ENTER:Identifier,EXIT:Identifier,EXIT:MemberExpression,ENTER:Literal,EXIT:Literal,EXIT:CallExpression,EXIT:ExpressionStatement,EXIT:Program"
-    );
-
-    var displayLiteralParents = literalParents
-      .map((x) => (Array.isArray(x) ? "(array)" : x.type))
-      .join(",");
-    expect(displayLiteralParents).toStrictEqual(
-      "(array),CallExpression,ExpressionStatement,(array),Program"
-    );
-  });
-});
-
-describe("assertNoCircular", function () {
-  test("Variant #1: Valid tree", function () {
-    var tree = {
-      a: 1,
-      b: 2,
-      c: 3,
-      d: {
-        a: 1,
-        b: 2,
-        c: 3,
-      },
-      e: [
-        {
-          a: 1,
-          b: 2,
-          c: 3,
-          f: {
-            a: 1,
-          },
-        },
-      ],
-    };
-
-    expect(() => assertNoCircular(tree)).not.toThrow();
-  });
-
-  test("Variant #2: Invalid tree", function () {
-    var circularRef = {};
-
-    var tree = {
-      a: 1,
-      b: 2,
-      c: circularRef,
-      d: {
-        a: 1,
-        b: 2,
-        c: 3,
-      },
-      e: [
-        {
-          a: 1,
-          b: 2,
-          c: 3,
-          f: {
-            a: circularRef,
-          },
-        },
-      ],
-    };
-
-    expect(() => assertNoCircular(tree)).toThrow();
-  });
-});

package/test/util/compare.test.ts

@@ -1,34 +0,0 @@
-import { isEquivalent, isValidIdentifier } from "../../src/util/compare";
-import { Identifier } from "../../src/util/gen";
-
-it("should compare nodes correctly", () => {
-  expect(isEquivalent(Identifier("name"), Identifier("name"))).toStrictEqual(
-    true
-  );
-
-  expect(
-    isEquivalent(Identifier("name"), Identifier("different_name"))
-  ).toStrictEqual(false);
-});
-
-describe("isValidIdentifier", () => {
-  test("Variant #1: Basic examples", () => {
-    // true examples
-    expect(isValidIdentifier("myClass")).toStrictEqual(true);
-    expect(isValidIdentifier("MyClass")).toStrictEqual(true);
-    expect(isValidIdentifier("$myObject")).toStrictEqual(true);
-    expect(isValidIdentifier("_myObject")).toStrictEqual(true);
-    expect(isValidIdentifier("myObject2")).toStrictEqual(true);
-    expect(isValidIdentifier("_0")).toStrictEqual(true);
-
-    // false examples
-    expect(isValidIdentifier("0")).toStrictEqual(false);
-    expect(isValidIdentifier("0myInvalidVar")).toStrictEqual(false);
-    expect(isValidIdentifier("^")).toStrictEqual(false);
-    expect(isValidIdentifier("%")).toStrictEqual(false);
-    expect(isValidIdentifier("invalid*Var")).toStrictEqual(false);
-    expect(isValidIdentifier("invalid!")).toStrictEqual(false);
-    expect(isValidIdentifier("my invalid var")).toStrictEqual(false);
-    expect(isValidIdentifier("my-invalid-var")).toStrictEqual(false);
-  });
-});

package/test/util/gen.test.ts

@@ -1,121 +0,0 @@
-import {
-  AssignmentExpression,
-  AssignmentPattern,
-  AwaitExpression,
-  BinaryExpression,
-  BlockStatement,
-  BreakStatement,
-  ClassDeclaration,
-  DebuggerStatement,
-  FunctionDeclaration,
-  FunctionExpression,
-  Identifier,
-  IfStatement,
-  Literal,
-  MemberExpression,
-  MethodDefinition,
-  ObjectExpression,
-  Property,
-  RegexLiteral,
-  RestElement,
-  SequenceExpression,
-  SwitchDefaultCase,
-  ThrowStatement,
-  WithStatement,
-} from "../../src/util/gen";
-
-it("should return correct types", async () => {
-  expect(BreakStatement("label")).toHaveProperty("type", "BreakStatement");
-  expect(AwaitExpression(Identifier("test"))).toHaveProperty(
-    "type",
-    "AwaitExpression"
-  );
-  expect(AwaitExpression(Identifier("test"))).toHaveProperty(
-    "type",
-    "AwaitExpression"
-  );
-  expect(RegexLiteral("match", "")).toHaveProperty("type", "Literal");
-  expect(SwitchDefaultCase([])).toHaveProperty("type", "SwitchCase");
-  expect(
-    MethodDefinition(
-      Identifier("name"),
-      FunctionExpression([], []),
-      "method",
-      false,
-      false
-    )
-  ).toHaveProperty("type", "MethodDefinition");
-  expect(ThrowStatement(Identifier("error"))).toHaveProperty(
-    "type",
-    "ThrowStatement"
-  );
-  expect(ThrowStatement(Identifier("error"))).toHaveProperty(
-    "type",
-    "ThrowStatement"
-  );
-
-  expect(ClassDeclaration(Identifier("className"), null, [])).toHaveProperty(
-    "type",
-    "ClassDeclaration"
-  );
-
-  expect(WithStatement(Identifier("variable"), [])).toHaveProperty(
-    "type",
-    "WithStatement"
-  );
-
-  expect(DebuggerStatement()).toHaveProperty("type", "DebuggerStatement");
-  expect(RestElement(Identifier("array"))).toHaveProperty(
-    "type",
-    "RestElement"
-  );
-});
-
-it("should throw when parameters are missing", async () => {
-  expect(Identifier).toThrow();
-  expect(() => Identifier("this")).toThrow();
-  expect(() => Identifier("super")).toThrow();
-  expect(() => Literal(undefined)).toThrow();
-
-  expect(BlockStatement).toThrow();
-  expect(() =>
-    BinaryExpression("||", Identifier("left"), Identifier("right"))
-  ).toThrow();
-
-  expect(() =>
-    BinaryExpression("||", Identifier("left"), Identifier("right"))
-  ).toThrow();
-
-  expect(Property).toThrow();
-  expect(() => Property(Identifier("key"), null)).toThrow();
-
-  expect(ObjectExpression).toThrow();
-  expect(IfStatement).toThrow();
-  expect(() => IfStatement(Identifier("test"), null)).toThrow();
-  expect(() =>
-    IfStatement(Identifier("test"), Identifier("notArray") as any)
-  ).toThrow();
-  expect(() =>
-    IfStatement(Identifier("test"), [], Identifier("notArray") as any)
-  ).toThrow();
-
-  expect(() => FunctionDeclaration("test", [], null)).toThrow();
-  expect(() => FunctionDeclaration("test", [], [[]] as any)).toThrow();
-  expect(() => SequenceExpression(null)).toThrow();
-  expect(() => SequenceExpression([])).toThrow();
-
-  expect(() => MemberExpression(null, Identifier("target"), false)).toThrow();
-  expect(() => MemberExpression(Identifier("object"), null, false)).toThrow();
-  expect(() =>
-    MemberExpression(Identifier("object"), Literal("stringKey"), false)
-  ).toThrow();
-
-  expect(() => AssignmentPattern(Identifier("object"), null)).toThrow();
-  expect(() => AssignmentPattern(null, Identifier("defaultValue"))).toThrow();
-  expect(() => WithStatement(null, [])).toThrow();
-  expect(() => WithStatement([] as any, [])).toThrow();
-
-  expect(() =>
-    MemberExpression(Identifier("new"), Identifier("target"), false)
-  ).toThrow();
-});

package/test/util/identifiers.test.ts

@@ -1,253 +0,0 @@
-import { ok } from "assert";
-import parseJS, { parseSync } from "../../src/parser";
-import traverse from "../../src/traverse";
-import { Location, Node } from "../../src/util/gen";
-import {
-  getFunctionParameters,
-  getIdentifierInfo,
-  validateChain,
-} from "../../src/util/identifiers";
-
-describe("getIdentifierInfo", () => {
-  test("Variant #1: Determine function declarations", async () => {
-    var tree = await parseJS(`function abc(){}`);
-
-    var object = tree.body[0].id;
-
-    expect(object.type).toStrictEqual("Identifier");
-
-    var parents = [tree.body[0], tree.body, tree];
-
-    var info = getIdentifierInfo(object, parents as any);
-
-    expect(info.isFunctionDeclaration).toStrictEqual(true);
-    expect(info.spec.isDefined).toStrictEqual(true);
-  });
-
-  test("Variant #2: Determine labels", async () => {
-    var tree = await parseJS(`label: for (var i = 0; i < 0; i++ ) {}`);
-
-    var object = tree.body[0].label;
-
-    expect(object.type).toStrictEqual("Identifier");
-
-    var parents = [tree.body[0], tree.body, tree];
-
-    var info = getIdentifierInfo(object, parents as any);
-
-    expect(info.isLabel).toStrictEqual(true);
-    expect(info.spec.isReferenced).toStrictEqual(false);
-  });
-
-  test("Variant #3: Error when a non-identifier node is given", async () => {
-    expect(() => {
-      getIdentifierInfo({ type: "Literal", value: true }, []);
-    }).toThrow();
-  });
-
-  function findIdentifier(tree: Node, identifierName: string) {
-    var searchLocation: Location;
-
-    traverse(tree, (o, p) => {
-      if (o.type === "Identifier" && o.name === identifierName) {
-        ok(!searchLocation);
-        searchLocation = [o, p];
-      }
-    });
-
-    ok(searchLocation);
-    return searchLocation;
-  }
-
-  test("Variant #4: Variable declaration assignment pattern", async () => {
-    var tree = parseSync(`
-      var [ definedIdentifier = nonDefinedIdentifier ] = [];
-    `);
-
-    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
-    var definedInfo = getIdentifierInfo(
-      definedIdentifier[0],
-      definedIdentifier[1]
-    );
-    expect(definedInfo.spec.isDefined).toStrictEqual(true);
-    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
-
-    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
-    var nonDefinedInfo = getIdentifierInfo(
-      nonDefinedIdentifier[0],
-      nonDefinedIdentifier[1]
-    );
-    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
-    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
-  });
-
-  test("Variant #5: Function parameter assignment pattern", async () => {
-    var tree = parseSync(`
-      function myFunction(definedIdentifier = nonDefinedIdentifier) {
-
-      }
-    `);
-
-    var myFunction = findIdentifier(tree, "myFunction");
-    var myFunctionInfo = getIdentifierInfo(myFunction[0], myFunction[1]);
-
-    expect(myFunctionInfo.isFunctionDeclaration).toStrictEqual(true);
-    expect(myFunctionInfo.spec.isDefined).toStrictEqual(true);
-
-    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
-    var definedInfo = getIdentifierInfo(
-      definedIdentifier[0],
-      definedIdentifier[1]
-    );
-    expect(definedInfo.spec.isDefined).toStrictEqual(true);
-    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
-
-    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
-    var nonDefinedInfo = getIdentifierInfo(
-      nonDefinedIdentifier[0],
-      nonDefinedIdentifier[1]
-    );
-    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
-    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
-  });
-
-  test("Variant #6: Object pattern", async () => {
-    var tree = parseSync(`
-      var { nonDefinedIdentifier: definedIdentifier } = {};
-
-      ( { nonModifiedIdentifier: modifiedIdentifier } = {} );
-    `);
-
-    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
-    var definedInfo = getIdentifierInfo(
-      definedIdentifier[0],
-      definedIdentifier[1]
-    );
-    expect(definedInfo.spec.isDefined).toStrictEqual(true);
-    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
-
-    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
-    var nonDefinedInfo = getIdentifierInfo(
-      nonDefinedIdentifier[0],
-      nonDefinedIdentifier[1]
-    );
-    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
-    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(false);
-
-    var modifiedIdentifier = findIdentifier(tree, "modifiedIdentifier");
-    var modifiedInfo = getIdentifierInfo(
-      modifiedIdentifier[0],
-      modifiedIdentifier[1]
-    );
-    expect(modifiedInfo.spec.isDefined).toStrictEqual(false);
-    expect(modifiedInfo.spec.isModified).toStrictEqual(true);
-    expect(modifiedInfo.spec.isReferenced).toStrictEqual(true);
-
-    var nonModifiedIdentifier = findIdentifier(tree, "nonModifiedIdentifier");
-    var nonModifiedInfo = getIdentifierInfo(
-      nonModifiedIdentifier[0],
-      nonModifiedIdentifier[1]
-    );
-
-    expect(nonModifiedInfo.spec.isDefined).toStrictEqual(false);
-    expect(nonModifiedInfo.spec.isModified).toStrictEqual(false);
-    expect(nonModifiedInfo.spec.isReferenced).toStrictEqual(false);
-  });
-
-  test("Variant #7: Default parameter, function expression", async () => {
-    var tree = parseSync(`
-      function myFunction( myParameter = function() {
-        var myNestedDeclaration = true;
-      } ){
-
-      }
-    `);
-
-    var myNestedDeclaration = findIdentifier(tree, "myNestedDeclaration");
-    var myNestedDeclarationInfo = getIdentifierInfo(
-      myNestedDeclaration[0],
-      myNestedDeclaration[1]
-    );
-
-    expect(myNestedDeclarationInfo.isVariableDeclaration).toStrictEqual(true);
-    expect(myNestedDeclarationInfo.spec.isDefined).toStrictEqual(true);
-    expect(myNestedDeclarationInfo.spec.isReferenced).toStrictEqual(true);
-    expect(myNestedDeclarationInfo.spec.isModified).toStrictEqual(false);
-  });
-});
-
-describe("validateChain", () => {
-  test("Variant #1: Error when parents is not an array", () => {
-    expect(() => {
-      validateChain({ type: "Identifier", name: "name" }, {} as any);
-    }).toThrow();
-  });
-
-  test("Variant #2: Error when object is undefined", () => {
-    expect(() => {
-      validateChain(undefined, []);
-    }).toThrow();
-  });
-
-  test("Variant #3: Error when object is not connected to direct parent", () => {
-    expect(() => {
-      validateChain({ type: "Identifier", name: "name" }, [
-        { type: "Program", body: [] },
-      ]);
-    }).toThrow();
-  });
-});
-
-describe("getFunctionParameters", () => {
-  test("Variant #1: Work with default values and destructuring", async () => {
-    var code = `function a(A=_b,{B,[_c]:C},[D]){}`;
-    var tree = await parseJS(code);
-
-    var object = tree.body[0];
-    var parents: any = [tree.body, tree];
-
-    var locations = getFunctionParameters(object, parents);
-    var names = locations.map((x) => x[0].name);
-
-    expect(names).toStrictEqual(["A", "B", "C", "D"]);
-  });
-
-  test("Variant #2: Work with spread element", async () => {
-    var code = `function a(...A){}`;
-    var tree = await parseJS(code);
-
-    var object = tree.body[0];
-    var parents: any = [tree.body, tree];
-
-    var locations = getFunctionParameters(object, parents);
-    var names = locations.map((x) => x[0].name);
-
-    expect(names).toStrictEqual(["A"]);
-  });
-
-  test("Variant #3: Normal parameters", async () => {
-    var code = `function a(A,B,C,D){}`;
-    var tree = await parseJS(code);
-
-    var object = tree.body[0];
-    var parents: any = [tree.body, tree];
-
-    var locations = getFunctionParameters(object, parents);
-    var names = locations.map((x) => x[0].name);
-
-    expect(names).toStrictEqual(["A", "B", "C", "D"]);
-  });
-
-  test("Variant #4: Default values as functions", async () => {
-    var code = `function a(A = function(_a){ return _a; },B = function(_a, _b = function(){return this;}){return _a + _b();},C,D){}`;
-    var tree = await parseJS(code);
-
-    var object = tree.body[0];
-    var parents: any = [tree.body, tree];
-
-    var locations = getFunctionParameters(object, parents);
-    var names = locations.map((x) => x[0].name);
-
-    expect(names).toStrictEqual(["A", "B", "C", "D"]);
-  });
-});

package/test/util/insert.test.ts

@@ -1,142 +0,0 @@
-import { ok } from "assert";
-import { compileJsSync } from "../../src/compiler";
-import parseJS, { parseSync } from "../../src/parser";
-import traverse, { isBlock } from "../../src/traverse";
-import { Identifier, Location } from "../../src/util/gen";
-import {
-  deleteDeclaration,
-  isVarContext,
-  isFunction,
-  deleteDirect,
-  getContexts,
-  getLexContext,
-  getVarContext,
-  computeFunctionLength,
-} from "../../src/util/insert";
-
-it("isBlock() should be true for block statements and program", async () => {
-  expect(isBlock({ type: "Program", body: [] })).toStrictEqual(true);
-  expect(isBlock({ type: "BlockStatement", body: [] })).toStrictEqual(true);
-});
-
-it("isVarContext() should return true for Function Nodes", () => {
-  expect(isVarContext({ type: "FunctionDeclaration" })).toStrictEqual(true);
-  expect(isVarContext({ type: "FunctionExpression" })).toStrictEqual(true);
-  expect(isVarContext({ type: "ArrowFunctionExpression" })).toStrictEqual(true);
-});
-
-it("isFunction() should return true for Function Nodes", () => {
-  expect(isFunction({ type: "FunctionDeclaration" })).toStrictEqual(true);
-  expect(isFunction({ type: "FunctionExpression" })).toStrictEqual(true);
-  expect(isFunction({ type: "ArrowFunctionExpression" })).toStrictEqual(true);
-});
-
-it("isVarContext() should return true for the Program Node (root node)", () => {
-  expect(isVarContext({ type: "Program" })).toStrictEqual(true);
-});
-
-it("should delete variable declarations correctly", async () => {
-  var tree = await parseJS("var a = 1;");
-
-  deleteDeclaration(tree.body[0].declarations[0], [
-    tree.body[0].declarations,
-    tree.body[0],
-    tree.body,
-    tree,
-  ]);
-
-  expect(tree.body.length).toStrictEqual(0);
-});
-
-it("should delete function declarations correctly", async () => {
-  var tree = await parseJS("function a(){}");
-
-  deleteDeclaration(tree.body[0], [tree.body as any, tree]);
-
-  expect(tree.body.length).toStrictEqual(0);
-});
-
-it("should delete variable declarations with multiple declarations without leave side-effects", async () => {
-  var tree = await parseJS("var a = 1, b = 1, c = 1");
-
-  // delete "b"
-  deleteDeclaration(tree.body[0].declarations[1], [
-    tree.body[0].declarations,
-    tree.body[0],
-    tree.body,
-    tree,
-  ]);
-
-  expect(tree.body.length).toStrictEqual(1);
-  expect(tree.body[0].declarations.length).toStrictEqual(2);
-  expect(tree.body[0].declarations.find((x) => x.id.name == "b")).toBeFalsy();
-  expect(tree.body[0].declarations.map((x) => x.id.name)).toEqual(["a", "c"]);
-});
-
-it("getContexts should return correct results", () => {
-  expect(getContexts({ type: "Program", body: [] }, [])).toEqual([
-    { type: "Program", body: [] },
-  ]);
-});
-
-it("should throw when missing parameters", () => {
-  expect(deleteDirect).toThrow();
-  expect(() => deleteDirect(Identifier("node"), null)).toThrow();
-
-  expect(getLexContext).toThrow();
-  expect(getVarContext).toThrow();
-  expect(() => getLexContext(Identifier("test"), [])).toThrow();
-  expect(() => getVarContext(Identifier("test"), [])).toThrow();
-});
-
-test("computeFunctionLength", () => {
-  var tree = parseSync(`
-  function zeroParameters(){}; // 0
-  function oneParameter(a){}; // 1
-  function twoParameter(a,b){}; // 2
-  function restParameter1(...a){}; // 0
-  function restParameter2(a,b,...c){}; // 2
-  function defaultValue(a,b,c=1,d){}; // 2
-  function arrayPattern([a],[b = 2],[[c]]){}; // 3
-  function objectPattern({a},{b = 2},{c, d}){}; // 3
-  function mixed(a,{b},[c = 3],d,e=5,f,...g){}; // 4
-  `);
-
-  function getFunction(searchName: string): Location {
-    var searchLocation: Location;
-    traverse(tree, (o, p) => {
-      if (o.type === "FunctionDeclaration" && o.id.name === searchName) {
-        ok(!searchLocation);
-        searchLocation = [o, p];
-      }
-    });
-
-    ok(searchLocation);
-    return searchLocation;
-  }
-
-  expect(
-    computeFunctionLength(getFunction("zeroParameters")[0].params)
-  ).toStrictEqual(0);
-  expect(
-    computeFunctionLength(getFunction("oneParameter")[0].params)
-  ).toStrictEqual(1);
-  expect(
-    computeFunctionLength(getFunction("twoParameter")[0].params)
-  ).toStrictEqual(2);
-  expect(
-    computeFunctionLength(getFunction("restParameter1")[0].params)
-  ).toStrictEqual(0);
-  expect(
-    computeFunctionLength(getFunction("restParameter2")[0].params)
-  ).toStrictEqual(2);
-  expect(
-    computeFunctionLength(getFunction("arrayPattern")[0].params)
-  ).toStrictEqual(3);
-  expect(
-    computeFunctionLength(getFunction("objectPattern")[0].params)
-  ).toStrictEqual(3);
-  expect(computeFunctionLength(getFunction("mixed")[0].params)).toStrictEqual(
-    4
-  );
-});

package/test/util/math.test.ts

@@ -1,5 +0,0 @@
-import { getFactors } from "../../src/util/math";
-
-it("getFactors() should return correct factors", () => {
-  expect(getFactors(6)).toEqual([1, 6, 2, 3]);
-});