js-confuser 1.7.1 → 1.7.2

package/dist/util/compare.js

@@ -8,18 +8,17 @@ exports.isEquivalent = isEquivalent;
 exports.isIndependent = isIndependent;
 exports.isInsideType = isInsideType;
 exports.isLoop = isLoop;
+exports.isModuleSource = isModuleSource;
+exports.isMoveable = isMoveable;
 exports.isPrimitive = isPrimitive;
 exports.isValidIdentifier = isValidIdentifier;
-
 var _traverse = require("../traverse");
-
 function isEquivalent(first, second) {
   var extra = {
     start: 1,
     end: 1,
     loc: 1
   };
-
   function removeExtra(obj) {
     if (typeof obj === "object") {
       for (var property in obj) {
@@ -34,88 +33,89 @@ function isEquivalent(first, second) {
         }
       }
     }
-
     return obj;
   }
-
   return JSON.stringify(removeExtra(first)) == JSON.stringify(removeExtra(second));
 }
 /**
  * Statements that allowed `break;` and `continue;` statements
  * @param object
  */
-
-
 function isLoop(object) {
   return ["SwitchStatement", "WhileStatement", "DoWhileStatement", "ForStatement", "ForInStatement", "ForOfStatement"].includes(object.type);
 }
-
 function isValidIdentifier(name) {
   if (typeof name !== "string") {
     return false;
   }
-
   if (name.includes(".") || name.includes(" ")) {
     return false;
   }
-
   var x = name.match(/^[A-Za-z$_][A-Za-z0-9$_]*/);
   return !!(x && x[0] == name);
 }
-
 function isInsideType(type, object, parents) {
   return [object, ...parents].some(x => x.type == type);
 }
-
 function isDirective(object, parents) {
   var dIndex = parents.findIndex(x => x.directive);
-
   if (dIndex == -1) {
     return false;
   }
-
   return parents[dIndex].expression == (parents[dIndex - 1] || object);
 }
-
+function isModuleSource(object, parents) {
+  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;
+}
+function isMoveable(object, parents) {
+  return !isDirective(object, parents) && !isModuleSource(object, parents);
+}
 function isIndependent(object, parents) {
   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;
       }
     }
-
     return false;
   }
-
   if (object.type == "ArrayExpression" || object.type == "ObjectExpression" || object.type == "Property") {
     var allowIt = true;
     (0, _traverse.walk)(object, parents, ($object, $parents) => {
       if (object != $object) {
         if (!Array.isArray($object) && !isIndependent($object, $parents)) {
           allowIt = false;
+          return "EXIT";
         }
       }
     });
     return allowIt;
   }
-
   return false;
 }
-
 var primitiveIdentifiers = new Set(["undefined", "NaN"]);
+
 /**
  * booleans, numbers, string, null, undefined, NaN, infinity
  *
@@ -127,7 +127,6 @@ var primitiveIdentifiers = new Set(["undefined", "NaN"]);
  * @param node
  * @returns
  */
-
 function isPrimitive(node) {
   if (node.type == "Literal") {
     if (node.value === null) {
@@ -142,6 +141,5 @@ function isPrimitive(node) {
   } else if (node.type == "Identifier") {
     return primitiveIdentifiers.has(node.name);
   }
-
   return false;
 }

package/dist/util/gen.js

@@ -37,6 +37,7 @@ exports.RestElement = RestElement;
 exports.ReturnStatement = ReturnStatement;
 exports.SequenceExpression = SequenceExpression;
 exports.SpreadElement = SpreadElement;
+exports.Super = Super;
 exports.SwitchCase = SwitchCase;
 exports.SwitchDefaultCase = SwitchDefaultCase;
 exports.SwitchStatement = SwitchStatement;
@@ -49,25 +50,37 @@ exports.VariableDeclaration = VariableDeclaration;
 exports.VariableDeclarator = VariableDeclarator;
 exports.WhileStatement = WhileStatement;
 exports.WithStatement = WithStatement;
-
 var _assert = require("assert");
+var _constants = require("../constants");
+/**
+ * 0. First index is the Node.
+ * 1. Second index is the parents as an array.
+ */
+
+/**
+ * Eval Callbacks are called once all transformations are done.
+ *
+ * - Called with object, and parents.
+ */
+
+/**
+ * - 0. First index is the Node.
+ * - ...1 Parent nodes.
+ */
 
 function Literal(value) {
   if (typeof value === "undefined") {
     throw new Error("value is undefined");
   }
-
   if (typeof value == "number" && value < 0) {
     return UnaryExpression("-", Literal(Math.abs(value)));
   }
-
   (0, _assert.ok)(value === value, "NaN value is disallowed");
   return {
     type: "Literal",
     value: value
   };
 }
-
 function RegexLiteral(pattern, flags) {
   return {
     type: "Literal",
@@ -77,37 +90,30 @@ function RegexLiteral(pattern, flags) {
     }
   };
 }
-
 function Identifier(name) {
   if (!name) {
     throw new Error("name is null/empty");
   }
-
   if (name == "this") {
     throw new Error("Use ThisExpression");
   }
-
   if (name == "super") {
     throw new Error("Use Super");
   }
-
   return {
     type: "Identifier",
     name: name.toString()
   };
 }
-
 function BlockStatement(body) {
   if (!Array.isArray(body)) {
     throw new Error("not array");
   }
-
   return {
     type: "BlockStatement",
     body: body
   };
 }
-
 function LogicalExpression(operator, left, right) {
   return {
     type: "LogicalExpression",
@@ -116,12 +122,10 @@ function LogicalExpression(operator, left, right) {
     right
   };
 }
-
 function BinaryExpression(operator, left, right) {
   if (operator == "||" || operator == "&&") {
     throw new Error("invalid operator, use LogicalExpression");
   }
-
   return {
     type: "BinaryExpression",
     operator,
@@ -129,13 +133,11 @@ function BinaryExpression(operator, left, right) {
     right
   };
 }
-
 function ThisExpression() {
   return {
     type: "ThisExpression"
   };
 }
-
 function SwitchCase(test, consequent) {
   (0, _assert.ok)(test === null || test);
   (0, _assert.ok)(Array.isArray(consequent));
@@ -145,11 +147,9 @@ function SwitchCase(test, consequent) {
     consequent
   };
 }
-
 function SwitchDefaultCase(consequent) {
   return SwitchCase(null, consequent);
 }
-
 function LabeledStatement(label, body) {
   return {
     type: "LabeledStatement",
@@ -157,7 +157,6 @@ function LabeledStatement(label, body) {
     body: body
   };
 }
-
 function SwitchStatement(discriminant, cases) {
   return {
     type: "SwitchStatement",
@@ -165,26 +164,21 @@ function SwitchStatement(discriminant, cases) {
     cases: cases
   };
 }
-
 function BreakStatement(label) {
   return {
     type: "BreakStatement",
     label: label ? Identifier(label) : null
   };
 }
-
 function Property(key, value) {
   let computed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   let kind = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "init";
-
   if (!key) {
     throw new Error("key is undefined");
   }
-
   if (!value) {
     throw new Error("value is undefined");
   }
-
   return {
     type: "Property",
     key: key,
@@ -195,39 +189,31 @@ function Property(key, value) {
     shorthand: false
   };
 }
-
 function ObjectExpression(properties) {
   if (!properties) {
     throw new Error("properties is null");
   }
-
   return {
     type: "ObjectExpression",
     properties: properties
   };
 }
-
 function VariableDeclarator(id) {
   let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
   if (typeof id === "string") {
     id = Identifier(id);
   }
-
   return {
     type: "VariableDeclarator",
     id,
     init
   };
 }
-
 function VariableDeclaration(declarations) {
   let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "var";
-
   if (!Array.isArray(declarations)) {
     declarations = [declarations];
   }
-
   (0, _assert.ok)(Array.isArray(declarations));
   (0, _assert.ok)(declarations.length);
   (0, _assert.ok)(!declarations.find(x => x.type == "ExpressionStatement"));
@@ -237,7 +223,6 @@ function VariableDeclaration(declarations) {
     kind: kind
   };
 }
-
 function ForStatement(variableDeclaration, test, update, body) {
   (0, _assert.ok)(variableDeclaration);
   (0, _assert.ok)(test);
@@ -250,7 +235,6 @@ function ForStatement(variableDeclaration, test, update, body) {
     body: BlockStatement(body)
   };
 }
-
 function WhileStatement(test, body) {
   (0, _assert.ok)(test);
   return {
@@ -259,26 +243,20 @@ function WhileStatement(test, body) {
     body: BlockStatement(body)
   };
 }
-
 function IfStatement(test, consequent) {
   let alternate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-
   if (!test) {
     throw new Error("test is undefined");
   }
-
   if (!consequent) {
     throw new Error("consequent undefined, use empty array instead");
   }
-
   if (!Array.isArray(consequent)) {
     throw new Error("consequent needs to be array, found " + consequent.type);
   }
-
   if (alternate && !Array.isArray(alternate)) {
     throw new Error("alternate needs to be array, found " + alternate.type);
   }
-
   return {
     type: "IfStatement",
     test: test,
@@ -286,7 +264,6 @@ function IfStatement(test, consequent) {
     alternate: alternate ? BlockStatement(alternate) : null
   };
 }
-
 function FunctionExpression(params, body) {
   (0, _assert.ok)(Array.isArray(params), "params should be an array");
   return {
@@ -296,9 +273,11 @@ function FunctionExpression(params, body) {
     body: BlockStatement(body),
     generator: false,
     expression: false,
-    async: false
+    async: false,
+    [_constants.predictableFunctionTag]: true
   };
 }
+
 /**
  * ```js
  * function name(p[0], p[1], p[2], ...p[4]){
@@ -310,17 +289,13 @@ function FunctionExpression(params, body) {
  * @param params
  * @param body
  */
-
-
 function FunctionDeclaration(name, params, body) {
   if (!body) {
     throw new Error("undefined body");
   }
-
   if (body && Array.isArray(body[0])) {
     throw new Error("nested array");
   }
-
   (0, _assert.ok)(Array.isArray(params), "params should be an array");
   return {
     type: "FunctionDeclaration",
@@ -329,29 +304,25 @@ function FunctionDeclaration(name, params, body) {
     body: BlockStatement(body),
     generator: false,
     expression: false,
-    async: false
+    async: false,
+    [_constants.predictableFunctionTag]: true
   };
 }
-
 function DebuggerStatement() {
   return {
     type: "DebuggerStatement"
   };
 }
-
 function ReturnStatement() {
   let argument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-
   if (argument) {
     (0, _assert.ok)(argument.type, "Argument should be a node");
   }
-
   return {
     type: "ReturnStatement",
     argument: argument
   };
 }
-
 function AwaitExpression(argument) {
   (0, _assert.ok)(argument.type, "Argument should be a node");
   return {
@@ -359,7 +330,6 @@ function AwaitExpression(argument) {
     argument
   };
 }
-
 function ConditionalExpression(test, consequent, alternate) {
   (0, _assert.ok)(test);
   (0, _assert.ok)(consequent);
@@ -371,7 +341,6 @@ function ConditionalExpression(test, consequent, alternate) {
     alternate
   };
 }
-
 function ExpressionStatement(expression) {
   (0, _assert.ok)(expression.type);
   return {
@@ -379,7 +348,6 @@ function ExpressionStatement(expression) {
     expression: expression
   };
 }
-
 function UnaryExpression(operator, argument) {
   (0, _assert.ok)(typeof operator === "string");
   (0, _assert.ok)(argument.type);
@@ -389,7 +357,6 @@ function UnaryExpression(operator, argument) {
     argument
   };
 }
-
 function UpdateExpression(operator, argument) {
   let prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   return {
@@ -399,41 +366,32 @@ function UpdateExpression(operator, argument) {
     prefix
   };
 }
-
 function SequenceExpression(expressions) {
   if (!expressions) {
     throw new Error("expressions undefined");
   }
-
   if (!expressions.length) {
     throw new Error("expressions length = 0");
   }
-
   return {
     type: "SequenceExpression",
     expressions: expressions
   };
 }
-
 function MemberExpression(object, property) {
   let computed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-
   if (!object) {
     throw new Error("object undefined");
   }
-
   if (!property) {
     throw new Error("property undefined");
   }
-
   if (!computed && property.type == "Literal") {
     throw new Error("literal must be computed property");
   }
-
   if (object.name == "new" && property.name == "target") {
     throw new Error("new.target is a MetaProperty");
   }
-
   return {
     type: "MemberExpression",
     computed: computed,
@@ -441,7 +399,6 @@ function MemberExpression(object, property) {
     property: property
   };
 }
-
 function CallExpression(callee, args) {
   (0, _assert.ok)(Array.isArray(args), "args should be an array");
   return {
@@ -450,7 +407,6 @@ function CallExpression(callee, args) {
     arguments: args
   };
 }
-
 function NewExpression(callee, args) {
   return {
     type: "NewExpression",
@@ -458,7 +414,6 @@ function NewExpression(callee, args) {
     arguments: args
   };
 }
-
 function AssignmentExpression(operator, left, right) {
   return {
     type: "AssignmentExpression",
@@ -467,7 +422,6 @@ function AssignmentExpression(operator, left, right) {
     right: right
   };
 }
-
 function ArrayPattern(elements) {
   (0, _assert.ok)(Array.isArray(elements));
   return {
@@ -475,7 +429,6 @@ function ArrayPattern(elements) {
     elements: elements
   };
 }
-
 function ArrayExpression(elements) {
   (0, _assert.ok)(Array.isArray(elements));
   return {
@@ -483,7 +436,6 @@ function ArrayExpression(elements) {
     elements
   };
 }
-
 function AssignmentPattern(left, right) {
   (0, _assert.ok)(left);
   (0, _assert.ok)(right);
@@ -493,7 +445,6 @@ function AssignmentPattern(left, right) {
     right: right
   };
 }
-
 function AddComment(node, text) {
   if (node.leadingComments) {
     node.leadingComments.push({
@@ -508,23 +459,25 @@ function AddComment(node, text) {
       }]
     });
   }
-
   return node;
 }
-
-function MethodDefinition(identifier, functionExpression, kind) {
-  let isStatic = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+function Super() {
+  return {
+    type: "Super"
+  };
+}
+function MethodDefinition(key, functionExpression, kind) {
+  let isStatic = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   let computed = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   return {
     type: "MethodDefinition",
-    key: identifier,
+    key: key,
     computed: computed,
     value: functionExpression,
     kind: kind,
     static: isStatic
   };
 }
-
 function ClassDeclaration(id) {
   let superClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   let body = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
@@ -538,7 +491,6 @@ function ClassDeclaration(id) {
     }
   };
 }
-
 function ClassExpression(id) {
   let superClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   let body = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
@@ -552,14 +504,12 @@ function ClassExpression(id) {
     }
   };
 }
-
 function ThrowStatement(argument) {
   return {
     type: "ThrowStatement",
     argument: argument
   };
 }
-
 function WithStatement(object, body) {
   (0, _assert.ok)(object, "object");
   (0, _assert.ok)(object.type, "object should be node");
@@ -569,33 +519,30 @@ function WithStatement(object, body) {
     body: BlockStatement(body)
   };
 }
+
 /**
  * `fn(...args)`
  * @param argument
  * @returns
  */
-
-
 function SpreadElement(argument) {
   return {
     type: "SpreadElement",
     argument
   };
 }
+
 /**
  * `function fn(...params){}`
  * @param argument
  * @returns
  */
-
-
 function RestElement(argument) {
   return {
     type: "RestElement",
     argument
   };
 }
-
 function CatchClause() {
   let param = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
   let body = arguments.length > 1 ? arguments[1] : undefined;
@@ -605,7 +552,6 @@ function CatchClause() {
     body: BlockStatement(body)
   };
 }
-
 function TryStatement(body, handler, finallyBody) {
   (0, _assert.ok)(handler);
   (0, _assert.ok)(handler.type == "CatchClause");

package/dist/util/guard.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isStringLiteral = isStringLiteral;
-
 function isStringLiteral(node) {
   return node.type === "Literal" && typeof node.value === "string" && !node.regex;
 }