0.9.0-dev.5

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.9.0-dev.4",
+  "version": "0.9.0-dev.5",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -26,7 +26,7 @@
     "class-validator": "0.6.6",
     "commander": "2.9.0",
     "escodegen": "1.8.1",
-    "esprima": "3.1.2",
+    "esprima": "3.1.3",
     "estraverse": "4.2.0",
     "inversify": "^3.0.0-rc.2",
     "lodash": "^4.17.2",
@@ -47,7 +47,7 @@
     "@types/lodash": "^4.14.44",
     "@types/mkdirp": "0.3.29",
     "@types/mocha": "2.2.34",
-    "@types/node": "6.0.52",
+    "@types/node": "6.0.53",
     "@types/sinon": "1.16.33",
     "@types/string-template": "1.0.2",
     "awesome-typescript-loader": "3.0.0-beta.17",
@@ -61,7 +61,7 @@
     "mocha": "3.2.0",
     "sinon": "2.0.0-pre.4",
     "ts-node": "1.7.2",
-    "tslint": "4.1.1",
+    "tslint": "4.2.0",
     "tslint-loader": "^3.3.0",
     "typescript": "2.1.4",
     "webpack": "2.2.0-rc.2",

src/Obfuscator.ts

@@ -109,7 +109,7 @@ export class Obfuscator implements IObfuscator {
             return astTree;
         }
 
-        NodeUtils.parentize(astTree);
+        astTree = <ESTree.Program>NodeUtils.parentize(astTree);
 
         const stackTraceData: IStackTraceData[] = this.stackTraceAnalyzer.analyze(astTree.body);
 
@@ -129,7 +129,7 @@ export class Obfuscator implements IObfuscator {
 
         // first pass: control flow flattening
         if (this.options.controlFlowFlattening) {
-            this.transformAstTree(
+            astTree = this.transformAstTree(
                 astTree,
                 VisitorDirection.leave,
                 this.nodeTransformersFactory(Obfuscator.nodeControlFlowTransformersMap)
@@ -137,11 +137,13 @@ export class Obfuscator implements IObfuscator {
         }
 
         // second pass: nodes obfuscation
-        this.transformAstTree(
+        console.time();
+        astTree = this.transformAstTree(
             astTree,
             VisitorDirection.enter,
             this.nodeTransformersFactory(Obfuscator.nodeObfuscatorsMap)
         );
+        console.timeEnd();
 
         this.obfuscationEventEmitter.emit(ObfuscationEvents.AfterObfuscation, astTree, stackTraceData);
 
@@ -157,15 +159,19 @@ export class Obfuscator implements IObfuscator {
         astTree: ESTree.Program,
         direction: TVisitorDirection,
         nodeTransformersConcreteFactory: (nodeType: string) => INodeTransformer[]
-    ): void {
-        estraverse.traverse(astTree, {
-            [direction]: (node: ESTree.Node, parentNode: ESTree.Node): void => {
+    ): ESTree.Program {
+        estraverse.replace(astTree, {
+            [direction]: (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node => {
                 const nodeTransformers: INodeTransformer[] = nodeTransformersConcreteFactory(node.type);
 
                 nodeTransformers.forEach((nodeTransformer: INodeTransformer) => {
-                    nodeTransformer.transformNode(node, parentNode);
+                    node = nodeTransformer.transformNode(node, parentNode);
                 });
+
+                return node;
             }
         });
+
+        return astTree;
     }
 }

src/custom-nodes/control-flow-storage-nodes/ControlFlowStorageNode.ts

@@ -43,7 +43,7 @@ export class ControlFlowStorageNode extends AbstractCustomNode {
      * @returns {TStatement[]}
      */
     protected getNodeStructure (): TStatement[] {
-        const structure: ESTree.Node = Nodes.getVariableDeclarationNode([
+        let structure: ESTree.Node = Nodes.getVariableDeclarationNode([
             Nodes.getVariableDeclaratorNode(
                 Nodes.getIdentifierNode(this.controlFlowStorage.getStorageId()),
                 Nodes.getObjectExpressionNode(
@@ -59,7 +59,7 @@ export class ControlFlowStorageNode extends AbstractCustomNode {
             )
         ]);
 
-        NodeUtils.parentize(structure);
+        structure = NodeUtils.parentize(structure);
 
         return [structure];
     }

src/interfaces/node-transformers/INodeTransformer.d.ts

@@ -4,6 +4,7 @@ export interface INodeTransformer {
     /**
      * @param node
      * @param parentNode
+     * @returns {ESTree.Node}
      */
-    transformNode (node: ESTree.Node, parentNode?: ESTree.Node): void;
+    transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node;
 }

src/node-transformers/AbstractNodeTransformer.ts

@@ -32,6 +32,7 @@ export abstract class AbstractNodeTransformer implements INodeTransformer {
     /**
      * @param node
      * @param parentNode
+     * @returns {ESTree.Node}
      */
-    public abstract transformNode (node: ESTree.Node, parentNode?: ESTree.Node): void;
+    public abstract transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node;
 }

src/node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer.ts

@@ -113,9 +113,12 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
 
     /**
      * @param functionNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (functionNode: ESTree.Function): void {
+    public transformNode (functionNode: ESTree.Function): ESTree.Node {
         this.changeFunctionBodyControlFlow(functionNode);
+
+        return functionNode;
     }
 
     /**

src/node-transformers/node-obfuscators/CatchClauseObfuscator.ts

@@ -45,12 +45,15 @@ export class CatchClauseObfuscator extends AbstractNodeTransformer {
 
     /**
      * @param catchClauseNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (catchClauseNode: ESTree.CatchClause): void {
+    public transformNode (catchClauseNode: ESTree.CatchClause): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
 
         this.storeCatchClauseParam(catchClauseNode, nodeIdentifier);
         this.replaceCatchClauseParam(catchClauseNode, nodeIdentifier);
+
+        return catchClauseNode;
     }
 
     /**

src/node-transformers/node-obfuscators/FunctionDeclarationObfuscator.ts

@@ -54,18 +54,21 @@ export class FunctionDeclarationObfuscator extends AbstractNodeTransformer {
     /**
      * @param functionDeclarationNode
      * @param parentNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (functionDeclarationNode: ESTree.FunctionDeclaration, parentNode: ESTree.Node): void {
+    public transformNode (functionDeclarationNode: ESTree.FunctionDeclaration, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
         const blockScopeOfFunctionDeclarationNode: TNodeWithBlockStatement = NodeUtils
             .getBlockScopesOfNode(functionDeclarationNode)[0];
 
         if (blockScopeOfFunctionDeclarationNode.type === NodeType.Program) {
-            return;
+            return functionDeclarationNode;
         }
 
         this.storeFunctionName(functionDeclarationNode, nodeIdentifier);
         this.replaceFunctionName(blockScopeOfFunctionDeclarationNode, nodeIdentifier);
+
+        return functionDeclarationNode;
     }
 
     /**

src/node-transformers/node-obfuscators/FunctionObfuscator.ts

@@ -45,12 +45,15 @@ export class FunctionObfuscator extends AbstractNodeTransformer {
 
     /**
      * @param functionNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (functionNode: ESTree.Function): void {
+    public transformNode (functionNode: ESTree.Function): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
 
         this.storeFunctionParams(functionNode, nodeIdentifier);
         this.replaceFunctionParams(functionNode, nodeIdentifier);
+
+        return functionNode;
     }
 
     /**

src/node-transformers/node-obfuscators/LabeledStatementObfuscator.ts

@@ -53,12 +53,15 @@ export class LabeledStatementObfuscator extends AbstractNodeTransformer {
 
     /**
      * @param labeledStatementNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (labeledStatementNode: ESTree.LabeledStatement): void {
+    public transformNode (labeledStatementNode: ESTree.LabeledStatement): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
 
         this.storeLabeledStatementName(labeledStatementNode, nodeIdentifier);
         this.replaceLabeledStatementName(labeledStatementNode, nodeIdentifier);
+
+        return labeledStatementNode;
     }
 
     /**

src/node-transformers/node-obfuscators/LiteralObfuscator.ts

@@ -35,10 +35,11 @@ export class LiteralObfuscator extends AbstractNodeTransformer {
     /**
      * @param literalNode
      * @param parentNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): void {
+    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
         if (Node.isPropertyNode(parentNode) && parentNode.key === literalNode) {
-            return;
+            return literalNode;
         }
 
         let content: string;
@@ -63,12 +64,14 @@ export class LiteralObfuscator extends AbstractNodeTransformer {
                 break;
 
             default:
-                return;
+                return literalNode;
         }
 
         literalNode['x-verbatim-property'] = {
             content : content,
             precedence: escodegen.Precedence.Primary
         };
+
+        return literalNode;
     }
 }

src/node-transformers/node-obfuscators/MemberExpressionObfuscator.ts

@@ -35,20 +35,23 @@ export class MemberExpressionObfuscator extends AbstractNodeTransformer {
 
     /**
      * @param memberExpressionNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (memberExpressionNode: ESTree.MemberExpression): void {
+    public transformNode (memberExpressionNode: ESTree.MemberExpression): ESTree.Node {
         if (Node.isLiteralNode(memberExpressionNode.property)) {
             memberExpressionNode.property = this.obfuscateLiteralProperty(memberExpressionNode.property);
         }
 
         if (Node.isIdentifierNode(memberExpressionNode.property)) {
             if (memberExpressionNode.computed) {
-                return;
+                return memberExpressionNode;
             }
 
             memberExpressionNode.computed = true;
             memberExpressionNode.property = this.obfuscateIdentifierProperty(memberExpressionNode.property);
         }
+
+        return memberExpressionNode;
     }
 
     /**

src/node-transformers/node-obfuscators/MethodDefinitionObfuscator.ts

@@ -47,9 +47,12 @@ export class MethodDefinitionObfuscator extends AbstractNodeTransformer {
     /**
      * @param methodDefinitionNode
      * @param parentNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): void {
+    public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
         this.replaceMethodName(methodDefinitionNode);
+
+        return methodDefinitionNode;
     }
 
     /**

src/node-transformers/node-obfuscators/ObjectExpressionObfuscator.ts

@@ -67,8 +67,9 @@ export class ObjectExpressionObfuscator extends AbstractNodeTransformer {
 
     /**
      * @param objectExpressionNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (objectExpressionNode: ESTree.ObjectExpression): void {
+    public transformNode (objectExpressionNode: ESTree.ObjectExpression): ESTree.Node {
         objectExpressionNode.properties
             .forEach((property: ESTree.Property) => {
                 if (property.shorthand) {
@@ -87,5 +88,7 @@ export class ObjectExpressionObfuscator extends AbstractNodeTransformer {
                     }
                 });
             });
+
+        return objectExpressionNode;
     }
 }

src/node-transformers/node-obfuscators/VariableDeclarationObfuscator.ts

@@ -55,13 +55,14 @@ export class VariableDeclarationObfuscator extends AbstractNodeTransformer {
     /**
      * @param variableDeclarationNode
      * @param parentNode
+     * @returns {ESTree.Node}
      */
-    public transformNode (variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): void {
+    public transformNode (variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): ESTree.Node {
         const blockScopeOfVariableDeclarationNode: TNodeWithBlockStatement = NodeUtils
             .getBlockScopesOfNode(variableDeclarationNode)[0];
 
         if (blockScopeOfVariableDeclarationNode.type === NodeType.Program) {
-            return;
+            return variableDeclarationNode;
         }
 
         const nodeIdentifier: number = this.nodeIdentifier++;
@@ -71,6 +72,8 @@ export class VariableDeclarationObfuscator extends AbstractNodeTransformer {
 
         this.storeVariableNames(variableDeclarationNode, nodeIdentifier);
         this.replaceVariableNames(scopeNode, nodeIdentifier);
+
+        return variableDeclarationNode;
     }
 
     /**

src/node/NodeUtils.ts

@@ -24,8 +24,9 @@ export class NodeUtils {
 
     /**
      * @param node
+     * @return {T}
      */
-    public static addXVerbatimPropertyToLiterals (node: ESTree.Node): void {
+    public static addXVerbatimPropertyToLiterals <T extends ESTree.Node> (node: T): T {
         NodeUtils.typedReplace(node, NodeType.Literal, {
             leave: (node: ESTree.Literal) => {
                 node['x-verbatim-property'] = {
@@ -34,6 +35,8 @@ export class NodeUtils {
                 };
             }
         });
+
+        return node;
     }
 
     /**
@@ -41,10 +44,10 @@ export class NodeUtils {
      * @returns {TStatement[]}
      */
     public static convertCodeToStructure (code: string): TStatement[] {
-        const structure: ESTree.Program = esprima.parse(code);
+        let structure: ESTree.Program = esprima.parse(code);
 
-        NodeUtils.addXVerbatimPropertyToLiterals(structure);
-        NodeUtils.parentize(structure);
+        structure = NodeUtils.addXVerbatimPropertyToLiterals(structure);
+        structure = NodeUtils.parentize(structure);
 
         return <TStatement[]>structure.body;
     }
@@ -142,8 +145,9 @@ export class NodeUtils {
 
     /**
      * @param node
+     * @return {T}
      */
-    public static parentize (node: ESTree.Node): void {
+    public static parentize <T extends ESTree.Node> (node: T): T {
         let isRootNode: boolean = true;
 
         estraverse.replace(node, {
@@ -167,6 +171,8 @@ export class NodeUtils {
                 node.obfuscated = false;
             }
         });
+
+        return node;
     }
 
     /**

src/utils/Utils.ts

@@ -159,7 +159,7 @@ export class Utils {
                 prefix = '\\u';
                 template = '0'.repeat(4);
             }
-            
+
             return `${prefix}${(template + escape.charCodeAt(0).toString(radix)).slice(-template.length)}`;
         });
 

test/unit-tests/node/NodeAppender.spec.ts

@@ -40,8 +40,8 @@ describe('NodeAppender', () => {
                 )
             );
 
-            NodeUtils.parentize(astTree);
-            NodeUtils.parentize(expectedAstTree);
+            astTree = NodeUtils.parentize(astTree);
+            expectedAstTree = NodeUtils.parentize(expectedAstTree);
 
             NodeAppender.appendNode(astTree, node);
         });
@@ -205,8 +205,8 @@ describe('NodeAppender', () => {
                 )
             );
 
-            NodeUtils.parentize(astTree);
-            NodeUtils.parentize(expectedAstTree);
+            astTree = NodeUtils.parentize(astTree);
+            expectedAstTree = NodeUtils.parentize(expectedAstTree);
 
             NodeAppender.insertNodeAtIndex(astTree, node, 2);
         });
@@ -238,8 +238,8 @@ describe('NodeAppender', () => {
                 )
             );
 
-            NodeUtils.parentize(astTree);
-            NodeUtils.parentize(expectedAstTree);
+            astTree = NodeUtils.parentize(astTree);
+            expectedAstTree = NodeUtils.parentize(expectedAstTree);
 
             NodeAppender.prependNode(astTree, node);
         });

test/unit-tests/node/NodeUtils.spec.ts

@@ -51,11 +51,11 @@ describe('NodeUtils', () => {
                 variableDeclarationNode
             ]);
 
-            programNode['parentNode'] = programNode;
-            variableDeclarationNode['parentNode'] = programNode;
-            variableDeclaratorNode['parentNode'] = variableDeclarationNode;
-            identifierNode['parentNode'] = variableDeclaratorNode;
-            literalNode['parentNode'] = variableDeclaratorNode;
+            programNode.parentNode = programNode;
+            variableDeclarationNode.parentNode = programNode;
+            variableDeclaratorNode.parentNode = variableDeclarationNode;
+            identifierNode.parentNode = variableDeclaratorNode;
+            literalNode.parentNode = variableDeclaratorNode;
         });
 
         it('should convert code to `ESTree.Node[]` structure array', () => {
@@ -162,15 +162,15 @@ describe('NodeUtils', () => {
                 functionDeclarationNode
             ]);
 
-            programNode['parentNode'] = programNode;
-            functionDeclarationNode['parentNode'] = programNode;
-            functionDeclarationBlockStatementNode['parentNode'] = functionDeclarationNode;
-            expressionStatementNode1['parentNode'] = functionDeclarationBlockStatementNode;
-            ifStatementNode1['parentNode'] = functionDeclarationBlockStatementNode;
-            ifStatementBlockStatementNode1['parentNode'] = ifStatementNode1;
-            ifStatementNode2['parentNode'] = ifStatementBlockStatementNode1;
-            ifStatementBlockStatementNode2['parentNode'] = ifStatementNode2;
-            expressionStatementNode3['parentNode'] = ifStatementBlockStatementNode2;
+            programNode.parentNode = programNode;
+            functionDeclarationNode.parentNode = programNode;
+            functionDeclarationBlockStatementNode.parentNode = functionDeclarationNode;
+            expressionStatementNode1.parentNode = functionDeclarationBlockStatementNode;
+            ifStatementNode1.parentNode = functionDeclarationBlockStatementNode;
+            ifStatementBlockStatementNode1.parentNode = ifStatementNode1;
+            ifStatementNode2.parentNode = ifStatementBlockStatementNode1;
+            ifStatementBlockStatementNode2.parentNode = ifStatementNode2;
+            expressionStatementNode3.parentNode = ifStatementBlockStatementNode2;
         });
 
         it('should return block-scope node for given node', () => {
@@ -249,17 +249,17 @@ describe('NodeUtils', () => {
                 functionDeclarationNode1
             ]);
 
-            programNode['parentNode'] = programNode;
-            functionDeclarationNode1['parentNode'] = programNode;
-            functionDeclarationBlockStatementNode1['parentNode'] = functionDeclarationNode1;
-            expressionStatementNode1['parentNode'] = functionDeclarationBlockStatementNode1;
-            ifStatementNode1['parentNode'] = functionDeclarationBlockStatementNode1;
-            ifStatementBlockStatementNode1['parentNode'] = ifStatementNode1;
-            functionDeclarationNode2['parentNode'] = ifStatementBlockStatementNode1;
-            functionDeclarationBlockStatementNode2['parentNode'] = functionDeclarationNode2;
-            expressionStatementNode2['parentNode'] = functionDeclarationBlockStatementNode2;
-            ifStatementNode2['parentNode'] = functionDeclarationBlockStatementNode2;
-            ifStatementBlockStatementNode2['parentNode'] = ifStatementNode2;
+            programNode.parentNode = programNode;
+            functionDeclarationNode1.parentNode = programNode;
+            functionDeclarationBlockStatementNode1.parentNode = functionDeclarationNode1;
+            expressionStatementNode1.parentNode = functionDeclarationBlockStatementNode1;
+            ifStatementNode1.parentNode = functionDeclarationBlockStatementNode1;
+            ifStatementBlockStatementNode1.parentNode = ifStatementNode1;
+            functionDeclarationNode2.parentNode = ifStatementBlockStatementNode1;
+            functionDeclarationBlockStatementNode2.parentNode = functionDeclarationNode2;
+            expressionStatementNode2.parentNode = functionDeclarationBlockStatementNode2;
+            ifStatementNode2.parentNode = functionDeclarationBlockStatementNode2;
+            ifStatementBlockStatementNode2.parentNode = ifStatementNode2;
         });
 
         it('should return block-scope depth for given node', () => {
@@ -308,27 +308,27 @@ describe('NodeUtils', () => {
                 ifStatementNode
             ]);
 
-            NodeUtils.parentize(programNode);
+            programNode = NodeUtils.parentize(programNode);
 
-            assert.deepEqual(programNode['parentNode'], programNode);
-            assert.deepEqual(ifStatementNode['parentNode'], programNode);
-            assert.deepEqual(ifStatementBlockStatementNode['parentNode'], ifStatementNode);
-            assert.deepEqual(expressionStatementNode1['parentNode'], ifStatementBlockStatementNode);
-            assert.deepEqual(expressionStatementNode2['parentNode'], ifStatementBlockStatementNode);
+            assert.deepEqual(programNode.parentNode, programNode);
+            assert.deepEqual(ifStatementNode.parentNode, programNode);
+            assert.deepEqual(ifStatementBlockStatementNode.parentNode, ifStatementNode);
+            assert.deepEqual(expressionStatementNode1.parentNode, ifStatementBlockStatementNode);
+            assert.deepEqual(expressionStatementNode2.parentNode, ifStatementBlockStatementNode);
         });
 
         it('should parentize given AST-tree', () => {
             programNode = Nodes.getProgramNode([
                 ifStatementNode
             ]);
-            programNode['parentNode'] = programNode;
+            programNode.parentNode = programNode;
 
-            NodeUtils.parentize(ifStatementNode);
+            ifStatementNode = NodeUtils.parentize(ifStatementNode);
 
-            assert.deepEqual(ifStatementNode['parentNode'], programNode);
-            assert.deepEqual(ifStatementBlockStatementNode['parentNode'], ifStatementNode);
-            assert.deepEqual(expressionStatementNode1['parentNode'], ifStatementBlockStatementNode);
-            assert.deepEqual(expressionStatementNode2['parentNode'], ifStatementBlockStatementNode);
+            assert.deepEqual(ifStatementNode.parentNode, programNode);
+            assert.deepEqual(ifStatementBlockStatementNode.parentNode, ifStatementNode);
+            assert.deepEqual(expressionStatementNode1.parentNode, ifStatementBlockStatementNode);
+            assert.deepEqual(expressionStatementNode2.parentNode, ifStatementBlockStatementNode);
         });
     });
 });

tslint.json

@@ -57,6 +57,7 @@
     "no-default-export": true,
     "no-duplicate-variable": true,
     "no-empty": false,
+    "no-empty-interface": true,
     "no-eval": false,
     "no-inferrable-types": false,
     "no-internal-module": true,
@@ -67,8 +68,9 @@
     "no-require-imports": false,
     "no-shadowed-variable": false,
     "no-string-literal": true,
+    "no-string-throw": true,
     "no-switch-case-fall-through": false,
-    "no-trailing-whitespace": true,
+    "no-trailing-whitespace": false,
     "no-unused-expression": true,
     "no-use-before-declare": true,
     "no-var-keyword": true,