obfuscators refactoring

dist/index.js

@@ -1855,7 +1855,7 @@ module.exports =
 	        key: 'obfuscateNode',
 	        value: function obfuscateNode(catchClauseNode) {
 	            this.replaceCatchClauseParam(catchClauseNode);
-	            this.replaceCatchClauseParamInBlock(catchClauseNode);
+	            this.replaceCatchClauseParamInBlockStatement(catchClauseNode);
 	        }
 	    }, {
 	        key: 'replaceCatchClauseParam',
@@ -1874,8 +1874,8 @@ module.exports =
 	            });
 	        }
 	    }, {
-	        key: 'replaceCatchClauseParamInBlock',
-	        value: function replaceCatchClauseParamInBlock(catchClauseNode) {
+	        key: 'replaceCatchClauseParamInBlockStatement',
+	        value: function replaceCatchClauseParamInBlockStatement(catchClauseNode) {
 	            var _this3 = this;
 	
 	            estraverse.replace(catchClauseNode.body, {
@@ -2017,7 +2017,7 @@ module.exports =
 	        key: 'obfuscateNode',
 	        value: function obfuscateNode(functionNode) {
 	            this.replaceFunctionParams(functionNode);
-	            this.replaceFunctionParamsInBody(functionNode);
+	            this.replaceFunctionParamsInBlockStatement(functionNode);
 	        }
 	    }, {
 	        key: 'replaceFunctionParams',
@@ -2038,8 +2038,8 @@ module.exports =
 	            });
 	        }
 	    }, {
-	        key: 'replaceFunctionParamsInBody',
-	        value: function replaceFunctionParamsInBody(functionNode) {
+	        key: 'replaceFunctionParamsInBlockStatement',
+	        value: function replaceFunctionParamsInBlockStatement(functionNode) {
 	            var _this3 = this;
 	
 	            estraverse.replace(functionNode.body, {
@@ -2160,7 +2160,7 @@ module.exports =
 	            estraverse.replace(memberExpressionNode.property, {
 	                leave: function leave(node, parentNode) {
 	                    if (Nodes_1.Nodes.isLiteralNode(node)) {
-	                        _this2.literalNodeController(node);
+	                        _this2.obfuscateLiteralProperty(node);
 	                        return;
 	                    }
 	                    if (Nodes_1.Nodes.isIdentifierNode(node)) {
@@ -2168,14 +2168,14 @@ module.exports =
 	                            return;
 	                        }
 	                        memberExpressionNode.computed = true;
-	                        _this2.identifierNodeController(node);
+	                        _this2.obfuscateIdentifierProperty(node);
 	                    }
 	                }
 	            });
 	        }
 	    }, {
-	        key: 'identifierNodeController',
-	        value: function identifierNodeController(node) {
+	        key: 'obfuscateIdentifierProperty',
+	        value: function obfuscateIdentifierProperty(node) {
 	            var nodeValue = node.name,
 	                literalNode = {
 	                raw: '\'' + nodeValue + '\'',
@@ -2190,8 +2190,8 @@ module.exports =
 	            Object.assign(node, literalNode);
 	        }
 	    }, {
-	        key: 'literalNodeController',
-	        value: function literalNodeController(node) {
+	        key: 'obfuscateLiteralProperty',
+	        value: function obfuscateLiteralProperty(node) {
 	            switch (_typeof(node.value)) {
 	                case 'string':
 	                    if (node['x-verbatim-property']) {
@@ -2321,19 +2321,19 @@ module.exports =
 	                estraverse.replace(property.key, {
 	                    leave: function leave(node, parentNode) {
 	                        if (Nodes_1.Nodes.isLiteralNode(node)) {
-	                            _this2.literalNodeController(node);
+	                            _this2.obfuscateLiteralPropertyKey(node);
 	                            return;
 	                        }
 	                        if (Nodes_1.Nodes.isIdentifierNode(node)) {
-	                            _this2.identifierNodeController(node);
+	                            _this2.obfuscateIdentifierPropertyKey(node);
 	                        }
 	                    }
 	                });
 	            });
 	        }
 	    }, {
-	        key: 'literalNodeController',
-	        value: function literalNodeController(node) {
+	        key: 'obfuscateLiteralPropertyKey',
+	        value: function obfuscateLiteralPropertyKey(node) {
 	            switch (_typeof(node.value)) {
 	                case 'string':
 	                    if (node['x-verbatim-property']) {
@@ -2349,8 +2349,8 @@ module.exports =
 	            }
 	        }
 	    }, {
-	        key: 'identifierNodeController',
-	        value: function identifierNodeController(node) {
+	        key: 'obfuscateIdentifierPropertyKey',
+	        value: function obfuscateIdentifierPropertyKey(node) {
 	            var nodeValue = node.name,
 	                literalNode = {
 	                raw: '\'' + nodeValue + '\'',

src/interfaces/nodes/ICatchClauseNode.d.ts

@@ -1,7 +1,8 @@
+import { IBlockStatementNode } from "./IBlockStatementNode";
 import { IIdentifierNode } from "./IIdentifierNode";
 import { INode } from "./INode";
 
 export interface ICatchClauseNode extends INode {
     param: IIdentifierNode;
-    body: INode[];
+    body: IBlockStatementNode;
 }

src/node-obfuscators/CatchClauseObfuscator.ts

@@ -6,6 +6,7 @@ import { INode } from '../interfaces/nodes/INode';
 import { NodeObfuscator } from './NodeObfuscator';
 import { Nodes } from "../Nodes";
 import { Utils } from '../Utils';
+import {IBlockStatementNode} from "../interfaces/nodes/IBlockStatementNode";
 
 /**
  * replaces:
@@ -26,7 +27,7 @@ export class CatchClauseObfuscator extends NodeObfuscator {
      */
     public obfuscateNode (catchClauseNode: ICatchClauseNode): void {
         this.replaceCatchClauseParam(catchClauseNode);
-        this.replaceCatchClauseParamInBlock(catchClauseNode);
+        this.replaceCatchClauseParamInBlockStatement(catchClauseNode);
     }
 
     /**
@@ -50,7 +51,7 @@ export class CatchClauseObfuscator extends NodeObfuscator {
     /**
      * @param catchClauseNode
      */
-    private replaceCatchClauseParamInBlock (catchClauseNode: ICatchClauseNode): void {
+    private replaceCatchClauseParamInBlockStatement (catchClauseNode: ICatchClauseNode): void {
         estraverse.replace(catchClauseNode.body, {
             leave: (node: INode, parentNode: INode): any => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.catchClauseParam);

src/node-obfuscators/FunctionObfuscator.ts

@@ -1,5 +1,6 @@
 import * as estraverse from 'estraverse';
 
+import { IBlockStatementNode } from "../interfaces/nodes/IBlockStatementNode";
 import { IFunctionNode } from "../interfaces/nodes/IFunctionNode";
 import { INode } from "../interfaces/nodes/INode";
 
@@ -26,7 +27,7 @@ export class FunctionObfuscator extends NodeObfuscator {
      */
     public obfuscateNode (functionNode: IFunctionNode): void {
         this.replaceFunctionParams(functionNode);
-        this.replaceFunctionParamsInBody(functionNode);
+        this.replaceFunctionParamsInBlockStatement(functionNode);
     }
 
     /**
@@ -52,7 +53,7 @@ export class FunctionObfuscator extends NodeObfuscator {
     /**
      * @param functionNode
      */
-    private replaceFunctionParamsInBody (functionNode: IFunctionNode): void {
+    private replaceFunctionParamsInBlockStatement (functionNode: IFunctionNode): void {
         estraverse.replace(functionNode.body, {
             leave: (node: INode, parentNode: INode): any => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionParams);

src/node-obfuscators/MemberExpressionObfuscator.ts

@@ -19,7 +19,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
         estraverse.replace(memberExpressionNode.property, {
             leave: (node: INode, parentNode: INode): any => {
                 if (Nodes.isLiteralNode(node)) {
-                    this.literalNodeController(node);
+                    this.obfuscateLiteralProperty(node);
 
                     return;
                 }
@@ -30,7 +30,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
                     }
 
                     memberExpressionNode.computed = true;
-                    this.identifierNodeController(node);
+                    this.obfuscateIdentifierProperty(node);
                 }
             }
         });
@@ -48,7 +48,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
      *
      * @param node
      */
-    private identifierNodeController (node: IIdentifierNode): void {
+    private obfuscateIdentifierProperty (node: IIdentifierNode): void {
         let nodeValue: string = node.name,
             literalNode: ILiteralNode = {
                 raw: `'${nodeValue}'`,
@@ -74,7 +74,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
      *
      * @param node
      */
-    private literalNodeController (node: ILiteralNode): void {
+    private obfuscateLiteralProperty (node: ILiteralNode): void {
         switch (typeof node.value) {
             case 'string':
                 if (node['x-verbatim-property']) {

src/node-obfuscators/ObjectExpressionObfuscator.ts

@@ -28,27 +28,28 @@ export class ObjectExpressionObfuscator extends NodeObfuscator {
      * @param objectExpressionNode
      */
     public obfuscateNode (objectExpressionNode: IObjectExpressionNode): void {
-        objectExpressionNode.properties.forEach((property: IPropertyNode) => {
-            estraverse.replace(property.key, {
-                leave: (node: INode, parentNode: INode): any => {
-                    if (Nodes.isLiteralNode(node)) {
-                        this.literalNodeController(node);
+        objectExpressionNode.properties
+            .forEach((property: IPropertyNode) => {
+                estraverse.replace(property.key, {
+                    leave: (node: INode, parentNode: INode): any => {
+                        if (Nodes.isLiteralNode(node)) {
+                            this.obfuscateLiteralPropertyKey(node);
 
-                        return;
-                    }
+                            return;
+                        }
 
-                    if (Nodes.isIdentifierNode(node)) {
-                        this.identifierNodeController(node);
+                        if (Nodes.isIdentifierNode(node)) {
+                            this.obfuscateIdentifierPropertyKey(node);
+                        }
                     }
-                }
+                });
             });
-        });
     }
 
     /**
      * @param node
      */
-    private literalNodeController (node: ILiteralNode): void {
+    private obfuscateLiteralPropertyKey (node: ILiteralNode): void {
         switch (typeof node.value) {
             case 'string':
                 if (node['x-verbatim-property']) {
@@ -70,7 +71,7 @@ export class ObjectExpressionObfuscator extends NodeObfuscator {
     /**
      * @param node
      */
-    private identifierNodeController (node: IIdentifierNode): void {
+    private obfuscateIdentifierPropertyKey (node: IIdentifierNode): void {
         let nodeValue: string = node.name,
             literalNode: ILiteralNode = {
                 raw: `'${nodeValue}'`,

src/types/TNodeWithBlockStatement.d.ts

@@ -1,5 +1,4 @@
 import { IBlockStatementNode } from "../interfaces/nodes/IBlockStatementNode";
-import { ICatchClauseNode } from "../interfaces/nodes/ICatchClauseNode";
 import { IProgramNode } from "../interfaces/nodes/IProgramNode";
 
-export type TNodeWithBlockStatement = IBlockStatementNode|ICatchClauseNode|IProgramNode;
+export type TNodeWithBlockStatement = IBlockStatementNode|IProgramNode;

test/dev/test.js

@@ -51,6 +51,11 @@ let obfuscatedCode = JavaScriptObfuscator.obfuscate(
         test2(22);
         console.log(105.4);
         console.log(true, false);
+        
+        try {
+        } catch (error) {
+            console.log(error);
+        }
     })();
     `,
     {