refactoring

src/NodeUtils.ts

@@ -6,7 +6,7 @@ import { ILiteralNode } from "./interfaces/nodes/ILiteralNode";
 import { IMemberExpressionNode } from "./interfaces/nodes/IMemberExpressionNode";
 import { IProgramNode } from "./interfaces/nodes/IProgramNode";
 import { IPropertyNode } from "./interfaces/nodes/IPropertyNode";
-import { ITreeNode } from './interfaces/nodes/ITreeNode';
+import { INode } from './interfaces/nodes/INode';
 import { IVariableDeclaratorNode } from "./interfaces/nodes/IVariableDeclaratorNode";
 
 import { NodeType } from "./enums/NodeType";
@@ -28,7 +28,7 @@ export class NodeUtils {
      * @param blockScopeBody
      * @param node
      */
-    public static appendNode (blockScopeBody: ITreeNode[], node: ITreeNode): void {
+    public static appendNode (blockScopeBody: INode[], node: INode): void {
         if (!NodeUtils.validateNode(node)) {
             return;
         }
@@ -39,9 +39,9 @@ export class NodeUtils {
     /**
      * @param node
      * @param index
-     * @returns {ITreeNode}
+     * @returns {INode}
      */
-    public static getBlockScopeNodeByIndex (node: ITreeNode, index: number = 0): ITreeNode {
+    public static getBlockScopeNodeByIndex (node: INode, index: number = 0): INode {
         if (NodeUtils.isNodeHasBlockScope(node) && node.body[index]) {
             return node.body[index];
         }
@@ -52,9 +52,9 @@ export class NodeUtils {
     /**
      * @param node
      * @param depth
-     * @returns {ITreeNode}
+     * @returns {INode}
      */
-    public static getScopeOfNode (node: ITreeNode, depth: number = 0): ITreeNode {
+    public static getScopeOfNode (node: INode, depth: number = 0): INode {
         if (node.parentNode.type === NodeType.Program) {
             return node.parentNode;
         }
@@ -79,14 +79,14 @@ export class NodeUtils {
      * @param types
      * @param limitNodeTypes
      * @param depth
-     * @returns {ITreeNode}
+     * @returns {INode}
      */
     public static getParentNodeWithType (
-        node: ITreeNode,
+        node: INode,
         types: string[],
         limitNodeTypes: string[] = [],
         depth: number = 0
-    ): ITreeNode {
+    ): INode {
         if (node.parentNode.type === NodeType.Program || Utils.arrayContains(limitNodeTypes, node.parentNode.type)) {
             return node.parentNode;
         }
@@ -107,7 +107,7 @@ export class NodeUtils {
      * @param node
      * @param index
      */
-    public static insertNodeAtIndex (blockScopeBody: ITreeNode[], node: ITreeNode, index: number): void {
+    public static insertNodeAtIndex (blockScopeBody: INode[], node: INode, index: number): void {
         if (!NodeUtils.validateNode(node)) {
             return;
         }
@@ -119,7 +119,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    public static isBlockStatementNode (node: ITreeNode): node is IBlockStatementNode {
+    public static isBlockStatementNode (node: INode): node is IBlockStatementNode {
         return node.type === NodeType.BlockStatement;
     }
 
@@ -127,7 +127,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    public static isIdentifierNode (node: ITreeNode): node is IIdentifierNode {
+    public static isIdentifierNode (node: INode): node is IIdentifierNode {
         return node.type === NodeType.Identifier;
     }
 
@@ -135,7 +135,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    public static isLiteralNode (node: ITreeNode): node is ILiteralNode {
+    public static isLiteralNode (node: INode): node is ILiteralNode {
         return node.type === NodeType.Literal;
     }
 
@@ -143,7 +143,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    public static isMemberExpressionNode (node: ITreeNode): node is IMemberExpressionNode {
+    public static isMemberExpressionNode (node: INode): node is IMemberExpressionNode {
         return node.type === NodeType.MemberExpression;
     }
 
@@ -152,7 +152,7 @@ export class NodeUtils {
      * @returns {boolean}
      */
     public static isNodeHasBlockScope (
-        node: ITreeNode
+        node: INode
     ): node is IBlockStatementNode|ICatchClauseNode|IFunctionNode|IProgramNode {
         return node.hasOwnProperty('body');
     }
@@ -162,7 +162,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    public static isProgramNode (node: ITreeNode): node is IProgramNode {
+    public static isProgramNode (node: INode): node is IProgramNode {
         return node.type === NodeType.Program;
     }
 
@@ -171,7 +171,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    public static isPropertyNode (node: ITreeNode): node is IPropertyNode {
+    public static isPropertyNode (node: INode): node is IPropertyNode {
         return node.type === NodeType.Property;
     }
 
@@ -180,7 +180,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    public static isVariableDeclaratorNode (node: ITreeNode): node is IVariableDeclaratorNode {
+    public static isVariableDeclaratorNode (node: INode): node is IVariableDeclaratorNode {
         return node.type === NodeType.VariableDeclarator;
     }
 
@@ -188,7 +188,7 @@ export class NodeUtils {
      * @param blockScopeBody
      * @param node
      */
-    public static prependNode (blockScopeBody: ITreeNode[], node: ITreeNode): void {
+    public static prependNode (blockScopeBody: INode[], node: INode): void {
         if (!NodeUtils.validateNode(node)) {
             return;
         }
@@ -200,7 +200,7 @@ export class NodeUtils {
      * @param node
      * @returns {boolean}
      */
-    private static validateNode (node: ITreeNode): boolean {
+    private static validateNode (node: INode): boolean {
         return !!node;
     }
 }

src/Obfuscator.ts

@@ -1,9 +1,9 @@
 import * as estraverse from 'estraverse';
 
-import { INode } from './interfaces/INode';
+import { ICustomNode } from './interfaces/ICustomNode';
 import { INodeObfuscator } from './interfaces/INodeObfuscator';
 import { INodesGroup } from './interfaces/INodesGroup';
-import { ITreeNode } from './interfaces/nodes/ITreeNode';
+import { INode } from './interfaces/nodes/INode';
 
 import { AppendState } from './enums/AppendState';
 import { NodeType } from './enums/NodeType';
@@ -26,7 +26,7 @@ export class Obfuscator {
     /**
      * @type {Map<string, Node>}
      */
-    private nodes: Map <string, INode> = new Map <string, INode> ();
+    private nodes: Map <string, ICustomNode> = new Map <string, ICustomNode> ();
 
     /**
      * @type {Map<string, Function[]>}
@@ -62,16 +62,16 @@ export class Obfuscator {
     /**
      * @param node
      */
-    public obfuscateNode (node: ITreeNode): void {
+    public obfuscateNode (node: INode): void {
         this.setNewNodes(node);
         this.beforeObfuscation(node);
 
         estraverse.replace(node, {
-            enter: (node: ITreeNode, parent: ITreeNode): any => this.nodeControllerFirstPass(node, parent)
+            enter: (node: INode, parent: INode): any => this.nodeControllerFirstPass(node, parent)
         });
 
         estraverse.replace(node, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => this.nodeControllerSecondPass(node, parent)
+            leave: (node: INode, parent: INode): any => this.nodeControllerSecondPass(node, parent)
         });
 
         this.afterObfuscation(node);
@@ -81,7 +81,7 @@ export class Obfuscator {
      * @param nodeName
      * @param node
      */
-    public setNode (nodeName: string, node: INode): void {
+    public setNode (nodeName: string, node: ICustomNode): void {
         this.nodes.set(nodeName, node);
     }
 
@@ -89,9 +89,9 @@ export class Obfuscator {
      * @param nodesGroup
      */
     public setNodesGroup (nodesGroup: INodesGroup): void {
-        let nodes: Map <string, INode> = nodesGroup.getNodes();
+        let nodes: Map <string, ICustomNode> = nodesGroup.getNodes();
 
-        nodes.forEach((node: INode, key: string) => {
+        nodes.forEach((node: ICustomNode, key: string) => {
             this.nodes.set(key, node);
         });
     }
@@ -99,8 +99,8 @@ export class Obfuscator {
     /**
      * @param node
      */
-    private afterObfuscation (node: ITreeNode): void {
-        this.nodes.forEach((node: INode) => {
+    private afterObfuscation (node: INode): void {
+        this.nodes.forEach((node: ICustomNode) => {
             if (node.getAppendState() === AppendState.AfterObfuscation) {
                 node.appendNode();
             }
@@ -110,15 +110,15 @@ export class Obfuscator {
     /**
      * @param node
      */
-    private beforeObfuscation (node: ITreeNode): void {
-        this.nodes.forEach((node: INode) => {
+    private beforeObfuscation (node: INode): void {
+        this.nodes.forEach((node: ICustomNode) => {
             if (node.getAppendState() === AppendState.BeforeObfuscation) {
                 node.appendNode();
             }
         });
     };
 
-    private setNewNodes (astTree: ITreeNode): void {
+    private setNewNodes (astTree: INode): void {
         if (this.options['disableConsoleOutput']) {
             this.setNode(
                 'consoleOutputDisableExpressionNode',
@@ -147,7 +147,7 @@ export class Obfuscator {
      * @param node
      * @param parent
      */
-    private nodeControllerFirstPass (node: ITreeNode, parent: ITreeNode): void {
+    private nodeControllerFirstPass (node: INode, parent: INode): void {
         Object.defineProperty(node, 'parentNode', {
             configurable: true,
             enumerable: true,
@@ -160,7 +160,7 @@ export class Obfuscator {
      * @param node
      * @param parent
      */
-    private nodeControllerSecondPass (node: ITreeNode, parent: ITreeNode): void {
+    private nodeControllerSecondPass (node: INode, parent: INode): void {
         switch (node.type) {
             default:
                 this.initializeNodeObfuscators(node, parent);
@@ -171,7 +171,7 @@ export class Obfuscator {
      * @param node
      * @param parent
      */
-    private initializeNodeObfuscators (node: ITreeNode, parent: ITreeNode): void {
+    private initializeNodeObfuscators (node: INode, parent: INode): void {
         if (!this.nodeObfuscators.has(node.type)) {
             return;
         }

src/custom-nodes/Node.ts

@@ -1,23 +1,23 @@
-import { INode } from '../interfaces/INode';
-import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+import { ICustomNode } from '../interfaces/ICustomNode';
+import { INode } from '../interfaces/nodes/INode';
 
 import { AppendState } from '../enums/AppendState';
 
-export abstract class Node implements INode {
+export abstract class Node implements ICustomNode {
     /**
      * @type {AppendState}
      */
     protected appendState: AppendState = AppendState.BeforeObfuscation;
 
     /**
-     * @type {ITreeNode}
+     * @type {INode}
      */
-    protected astTree: ITreeNode;
+    protected astTree: INode;
 
     /**
-     * @type {ITreeNode}
+     * @type {INode}
      */
-    protected node: ITreeNode;
+    protected node: INode;
 
     constructor () {}
 
@@ -33,14 +33,14 @@ export abstract class Node implements INode {
     /**
      * @returns any
      */
-    public getNode (): ITreeNode {
+    public getNode (): INode {
         return this.node;
     }
 
     /**
      * @param node
      */
-    public setNode (node: ITreeNode): void {
+    public setNode (node: INode): void {
         this.node = node;
     }
 

src/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.ts

@@ -1,7 +1,7 @@
 import * as esprima from 'esprima';
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from '../../interfaces/nodes/ITreeNode';
+import { INode } from '../../interfaces/nodes/INode';
 
 import { Node } from '../Node';
 import { NodeUtils } from "../../NodeUtils";
@@ -10,7 +10,7 @@ export class ConsoleOutputDisableExpressionNode extends Node {
     /**
      * @param astTree
      */
-    constructor (astTree: ITreeNode) {
+    constructor (astTree: INode) {
         super();
 
         this.astTree = astTree;
@@ -20,7 +20,7 @@ export class ConsoleOutputDisableExpressionNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     NodeUtils.prependNode(node.body, this.getNode());
 

src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode.ts

@@ -1,6 +1,6 @@
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from '../../interfaces/nodes/ITreeNode';
+import { INode } from '../../interfaces/nodes/INode';
 
 import { NodeType } from "../../enums/NodeType";
 
@@ -18,7 +18,7 @@ export class DebugProtectionFunctionCallNode extends Node {
      * @param debugProtectionFunctionName
      */
     constructor (
-        astTree: ITreeNode,
+        astTree: INode,
         debugProtectionFunctionName: string
     ) {
         super();
@@ -31,7 +31,7 @@ export class DebugProtectionFunctionCallNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     NodeUtils.appendNode(node.body, this.getNode());
 

src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode.ts

@@ -1,6 +1,6 @@
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from '../../interfaces/nodes/ITreeNode';
+import { INode } from '../../interfaces/nodes/INode';
 
 import { NodeType } from '../../enums/NodeType';
 
@@ -18,7 +18,7 @@ export class DebugProtectionFunctionIntervalNode extends Node {
      * @param debugProtectionFunctionName
      */
     constructor (
-        astTree: ITreeNode,
+        astTree: INode,
         debugProtectionFunctionName: string
     ) {
         super();
@@ -31,7 +31,7 @@ export class DebugProtectionFunctionIntervalNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     NodeUtils.appendNode(node.body, this.getNode());
 

src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionNode.ts

@@ -1,7 +1,7 @@
 import * as esprima from 'esprima';
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from '../../interfaces/nodes/ITreeNode';
+import { INode } from '../../interfaces/nodes/INode';
 
 import { Node } from '../Node';
 import { NodeUtils } from '../../NodeUtils';
@@ -23,7 +23,7 @@ export class DebugProtectionFunctionNode extends Node {
      * @param debugProtectionFunctionIndex
      */
     constructor (
-        astTree: ITreeNode,
+        astTree: INode,
         debugProtectionFunctionName: string,
         debugProtectionFunctionIndex: number
     ) {
@@ -38,7 +38,7 @@ export class DebugProtectionFunctionNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     NodeUtils.insertNodeAtIndex(node.body, this.getNode(), this.debugProtectionFunctionIndex);
 

src/custom-nodes/unicode-array-nodes/UnicodeArrayNode.ts

@@ -1,7 +1,7 @@
 import * as escodegen from 'escodegen';
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from '../../interfaces/nodes/ITreeNode';
+import { INode } from '../../interfaces/nodes/INode';
 
 import { AppendState } from '../../enums/AppendState';
 import { NodeType } from "../../enums/NodeType";
@@ -41,7 +41,7 @@ export class UnicodeArrayNode extends Node {
      * @param unicodeArrayName
      * @param unicodeArrayRotateValue
      */
-    constructor (astTree: ITreeNode, unicodeArrayName: string, unicodeArrayRotateValue: number = 0) {
+    constructor (astTree: INode, unicodeArrayName: string, unicodeArrayRotateValue: number = 0) {
         super();
 
         this.astTree = astTree;
@@ -53,7 +53,7 @@ export class UnicodeArrayNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     NodeUtils.prependNode(node.body, this.getNode());
 
@@ -80,9 +80,9 @@ export class UnicodeArrayNode extends Node {
     }
 
     /**
-     * @returns {ITreeNode}
+     * @returns {INode}
      */
-    public getNode (): ITreeNode {
+    public getNode (): INode {
         Utils.arrayRotate(this.unicodeArray, this.unicodeArrayRotateValue);
 
         this.updateNode();

src/custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionCallNode.ts

@@ -1,7 +1,7 @@
 import * as estraverse from 'estraverse';
 
 import { IProgramNode } from "../../interfaces/nodes/IProgramNode";
-import { ITreeNode } from "../../interfaces/nodes/ITreeNode";
+import { INode } from "../../interfaces/nodes/INode";
 
 import { NodeType } from "../../enums/NodeType";
 
@@ -31,7 +31,7 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
      * @param unicodeArrayRotateValue
      */
     constructor (
-        astTree: ITreeNode,
+        astTree: INode,
         unicodeArrayRotateFunctionName: string,
         unicodeArrayName: string,
         unicodeArrayRotateValue: number
@@ -49,7 +49,7 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     NodeUtils.prependNode(node.body, this.getNode());
 

src/custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionNode.ts

@@ -2,7 +2,7 @@ import * as escodegen from 'escodegen';
 import * as esprima from 'esprima';
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from '../../interfaces/nodes/ITreeNode';
+import { INode } from '../../interfaces/nodes/INode';
 
 import { NodeType } from "../../enums/NodeType";
 
@@ -27,7 +27,7 @@ export class UnicodeArrayRotateFunctionNode extends Node {
      * @param unicodeArrayName
      */
     constructor (
-        astTree: ITreeNode,
+        astTree: INode,
         unicodeArrayRotateFunctionName: string,
         unicodeArrayName: string
     ) {
@@ -42,7 +42,7 @@ export class UnicodeArrayRotateFunctionNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     NodeUtils.appendNode(node.body, this.getNode());
 

src/interfaces/INode.d.ts → src/interfaces/ICustomNode.d.ts

@@ -1,8 +1,8 @@
-import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+import { INode } from '../interfaces/nodes/INode';
 
 import { AppendState } from '../enums/AppendState';
 
-export interface INode {
+export interface ICustomNode {
     appendNode (): void;
 
     /**
@@ -11,9 +11,9 @@ export interface INode {
     getAppendState (): AppendState;
 
     /**
-     * @returns ITreeNode
+     * @returns INode
      */
-    getNode (): ITreeNode;
+    getNode (): INode;
 
     /**
      * @returns {string}
@@ -28,7 +28,7 @@ export interface INode {
     /**
      * @param node
      */
-    setNode (node: ITreeNode): void;
+    setNode (node: INode): void;
 
     updateNode (): void;
 }

src/interfaces/INodeObfuscator.d.ts

@@ -1,9 +1,9 @@
-import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+import { INode } from '../interfaces/nodes/INode';
 
 export interface INodeObfuscator {
     /**
      * @param node
      * @param parentNode
      */
-    obfuscateNode (node: ITreeNode, parentNode?: ITreeNode): void;
+    obfuscateNode (node: INode, parentNode?: INode): void;
 }

src/interfaces/INodesGroup.d.ts

@@ -1,8 +1,8 @@
-import { INode } from './INode';
+import { ICustomNode } from './ICustomNode';
 
 export interface INodesGroup {
     /**
-     * @returns {Map <string, INode>}
+     * @returns {Map <string, ICustomNode>}
      */
-    getNodes (): Map <string, INode>;
+    getNodes (): Map <string, ICustomNode>;
 }

src/interfaces/nodes/IBlockStatementNode.d.ts

@@ -1,5 +1,5 @@
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IBlockStatementNode extends ITreeNode {
-    body: ITreeNode[];
+export interface IBlockStatementNode extends INode {
+    body: INode[];
 }

src/interfaces/nodes/ICatchClauseNode.d.ts

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

src/interfaces/nodes/IFunctionNode.d.ts

@@ -1,10 +1,10 @@
 import { IIdentifierNode } from "./IIdentifierNode";
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IFunctionNode extends ITreeNode {
+export interface IFunctionNode extends INode {
     id: IIdentifierNode;
     params: IIdentifierNode[];
-    body: ITreeNode[];
+    body: INode[];
     generator: boolean;
     expression: boolean;
 }

src/interfaces/nodes/IIdentifierNode.d.ts

@@ -1,5 +1,5 @@
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IIdentifierNode extends ITreeNode{
+export interface IIdentifierNode extends INode{
     name: string;
 }

src/interfaces/nodes/ILiteralNode.d.ts

@@ -1,6 +1,6 @@
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface ILiteralNode extends ITreeNode {
+export interface ILiteralNode extends INode {
     value: boolean|number|string;
     raw: string;
     'x-verbatim-property': any;

src/interfaces/nodes/IMemberExpressionNode.d.ts

@@ -1,8 +1,8 @@
 import { IIdentifierNode } from "./IIdentifierNode";
 import { ILiteralNode } from "./ILiteralNode";
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IMemberExpressionNode extends ITreeNode {
+export interface IMemberExpressionNode extends INode {
     computed: boolean;
     object: IIdentifierNode;
     property: IIdentifierNode|ILiteralNode;

src/interfaces/nodes/IMethodDefinitionNode.d.ts

@@ -1,9 +1,9 @@
 import { IFunctionExpressionNode } from "./IFunctionExpressionNode";
 import { IIdentifierNode } from "./IIdentifierNode";
 import { ILiteralNode } from "./ILiteralNode";
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IMethodDefinitionNode extends ITreeNode {
+export interface IMethodDefinitionNode extends INode {
     key: IIdentifierNode|ILiteralNode;
     computed: boolean;
     value: IFunctionExpressionNode;

src/interfaces/nodes/INode.d.ts

@@ -0,0 +1,4 @@
+export interface INode {
+    type: string;
+    parentNode?: INode;
+}

src/interfaces/nodes/IObjectExpressionNode.d.ts

@@ -1,6 +1,6 @@
 import { IPropertyNode } from "./IPropertyNode";
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IObjectExpressionNode extends ITreeNode {
+export interface IObjectExpressionNode extends INode {
     properties: IPropertyNode[];
 }

src/interfaces/nodes/IProgramNode.d.ts

@@ -1,5 +1,5 @@
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IProgramNode extends ITreeNode {
-    body: ITreeNode[];
+export interface IProgramNode extends INode {
+    body: INode[];
 }

src/interfaces/nodes/IPropertyNode.d.ts

@@ -1,8 +1,8 @@
 import { IIdentifierNode } from "./IIdentifierNode";
 import { ILiteralNode } from "./ILiteralNode";
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IPropertyNode extends ITreeNode {
+export interface IPropertyNode extends INode {
     key: IIdentifierNode|ILiteralNode;
     computed: boolean;
     value: IIdentifierNode|ILiteralNode;

src/interfaces/nodes/ITreeNode.d.ts

@@ -1,4 +0,0 @@
-export interface ITreeNode {
-    type: string;
-    parentNode?: ITreeNode;
-}

src/interfaces/nodes/IVariableDeclarationNode.d.ts

@@ -1,7 +1,7 @@
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 import { IVariableDeclaratorNode } from "./IVariableDeclaratorNode";
 
-export interface IVariableDeclarationNode extends ITreeNode {
+export interface IVariableDeclarationNode extends INode {
     declarations: IVariableDeclaratorNode[];
     kind: string;
 }

src/interfaces/nodes/IVariableDeclaratorNode.d.ts

@@ -1,7 +1,7 @@
 import { IIdentifierNode } from "./IIdentifierNode";
-import { ITreeNode } from "./ITreeNode";
+import { INode } from "./INode";
 
-export interface IVariableDeclaratorNode extends ITreeNode {
+export interface IVariableDeclaratorNode extends INode {
     id: IIdentifierNode;
     init: any;
 }

src/node-groups/DebugProtectionNodesGroup.ts

@@ -1,8 +1,8 @@
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+import { INode } from '../interfaces/nodes/INode';
 
-import { INode } from '../interfaces/INode';
+import { ICustomNode } from '../interfaces/ICustomNode';
 
 import { DebugProtectionFunctionCallNode } from "../custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode";
 import { DebugProtectionFunctionIntervalNode } from "../custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode";
@@ -14,9 +14,9 @@ import { Utils } from '../Utils';
 
 export class DebugProtectionNodesGroup extends NodesGroup {
     /**
-     * @type {ITreeNode}
+     * @type {INode}
      */
-    private astTree: ITreeNode;
+    private astTree: INode;
 
     /**
      * @type {number}
@@ -35,8 +35,9 @@ export class DebugProtectionNodesGroup extends NodesGroup {
 
     /**
      * @param astTree
+     * @param options
      */
-    constructor (astTree: ITreeNode, options: any) {
+    constructor (astTree: INode, options: any) {
         super();
 
         this.astTree = astTree;
@@ -44,7 +45,7 @@ export class DebugProtectionNodesGroup extends NodesGroup {
 
         this.debugProtectionFunctionIndex = this.getDebugProtectionFunctionIndex();
 
-        this.nodes = new Map <string, INode> ([
+        this.nodes = new Map <string, ICustomNode> ([
             [
                 'debugProtectionFunctionNode',
                 new DebugProtectionFunctionNode(
@@ -80,7 +81,7 @@ export class DebugProtectionNodesGroup extends NodesGroup {
         let randomIndex: number;
 
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode): any => {
+            leave: (node: INode, parent: INode): any => {
                 if (NodeUtils.isProgramNode(node)) {
                     let programBodyLength: number = node.body.length;
 

src/node-groups/NodesGroup.ts

@@ -1,4 +1,4 @@
-import { INode } from '../interfaces/INode';
+import { ICustomNode } from '../interfaces/ICustomNode';
 
 import { INodesGroup } from '../interfaces/INodesGroup';
 
@@ -6,12 +6,12 @@ export abstract class NodesGroup implements INodesGroup {
     /**
      * @type {Map<string, Node>}
      */
-    protected nodes: Map <string, INode>;
+    protected nodes: Map <string, ICustomNode>;
 
     /**
      * @returns {Map<string, INode>}
      */
-    public getNodes (): Map <string, INode> {
+    public getNodes (): Map <string, ICustomNode> {
         return this.nodes;
     }
 }

src/node-groups/UnicodeArrayNodesGroup.ts

@@ -1,6 +1,6 @@
-import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+import { INode } from '../interfaces/nodes/INode';
 
-import { INode } from '../interfaces/INode';
+import { ICustomNode } from '../interfaces/ICustomNode';
 
 import { NodesGroup } from './NodesGroup';
 import { UnicodeArrayNode } from '../custom-nodes/unicode-array-nodes/UnicodeArrayNode';
@@ -17,13 +17,13 @@ export class UnicodeArrayNodesGroup extends NodesGroup {
     /**
      * @param astTree
      */
-    constructor (astTree: ITreeNode) {
+    constructor (astTree: INode) {
         super();
 
         let unicodeArrayName: string = Utils.getRandomVariableName(UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH),
             unicodeArrayRotateValue: number = Utils.getRandomInteger(100, 500);
 
-        this.nodes = new Map <string, INode> ([
+        this.nodes = new Map <string, ICustomNode> ([
             [
                 'unicodeArrayNode',
                 new UnicodeArrayNode(

src/node-obfuscators/CatchClauseObfuscator.ts

@@ -1,7 +1,7 @@
 import * as estraverse from 'estraverse';
 
 import { ICatchClauseNode } from "../interfaces/nodes/ICatchClauseNode";
-import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+import { INode } from '../interfaces/nodes/INode';
 
 import { NodeObfuscator } from './NodeObfuscator';
 import { NodeUtils } from "../NodeUtils";
@@ -34,7 +34,7 @@ export class CatchClauseObfuscator extends NodeObfuscator {
      */
     private replaceCatchClauseParam (catchClauseNode: ICatchClauseNode): void {
         estraverse.replace(catchClauseNode.param, {
-            leave: (node: ITreeNode, parentNode: ITreeNode): any => {
+            leave: (node: INode, parentNode: INode): any => {
                 if (NodeUtils.isIdentifierNode(node)) {
                     this.catchClauseParam.set(node.name, Utils.getRandomVariableName());
                     node.name = this.catchClauseParam.get(node.name);
@@ -52,7 +52,7 @@ export class CatchClauseObfuscator extends NodeObfuscator {
      */
     private replaceCatchClauseParamInBlock (catchClauseNode: ICatchClauseNode): void {
         estraverse.replace(catchClauseNode.body, {
-            leave: (node: ITreeNode, parentNode: ITreeNode): any => {
+            leave: (node: INode, parentNode: INode): any => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.catchClauseParam);
             }
         });

src/node-obfuscators/FunctionDeclarationObfuscator.ts

@@ -1,7 +1,7 @@
 import * as estraverse from 'estraverse';
 
 import { IFunctionDeclarationNode } from "../interfaces/nodes/IFunctionDeclarationNode";
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 
 import { NodeType } from "../enums/NodeType";
 
@@ -28,7 +28,7 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
      * @param functionDeclarationNode
      * @param parentNode
      */
-    public obfuscateNode (functionDeclarationNode: IFunctionDeclarationNode, parentNode: ITreeNode): void {
+    public obfuscateNode (functionDeclarationNode: IFunctionDeclarationNode, parentNode: INode): void {
         if (parentNode.type === NodeType.Program) {
             return;
         }
@@ -42,7 +42,7 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
      */
     private replaceFunctionName (functionDeclarationNode: IFunctionDeclarationNode): void {
         estraverse.replace(functionDeclarationNode.id, {
-            leave: (node: ITreeNode): any => {
+            leave: (node: INode): any => {
                 if (NodeUtils.isIdentifierNode(node)) {
                     this.functionName.set(node.name, Utils.getRandomVariableName());
                     node.name = this.functionName.get(node.name);
@@ -59,12 +59,12 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
      * @param functionDeclarationNode
      */
     private replaceFunctionCalls (functionDeclarationNode: IFunctionDeclarationNode): void {
-        let scopeNode: ITreeNode = NodeUtils.getScopeOfNode(
+        let scopeNode: INode = NodeUtils.getScopeOfNode(
             functionDeclarationNode
         );
 
         estraverse.replace(scopeNode, {
-            enter: (node: ITreeNode, parentNode: ITreeNode): any => {
+            enter: (node: INode, parentNode: INode): any => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionName);
             }
         });

src/node-obfuscators/FunctionObfuscator.ts

@@ -1,7 +1,7 @@
 import * as estraverse from 'estraverse';
 
 import { IFunctionNode } from "../interfaces/nodes/IFunctionNode";
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 
 import { NodeObfuscator } from './NodeObfuscator';
 import { NodeUtils } from "../NodeUtils";
@@ -33,9 +33,9 @@ export class FunctionObfuscator extends NodeObfuscator {
      * @param functionNode
      */
     private replaceFunctionParams (functionNode: IFunctionNode): void {
-        functionNode.params.forEach((paramsNode: ITreeNode) => {
+        functionNode.params.forEach((paramsNode: INode) => {
             estraverse.replace(paramsNode, {
-                leave: (node: ITreeNode): any => {
+                leave: (node: INode): any => {
                     if (NodeUtils.isIdentifierNode(node)) {
                         this.functionParams.set(node.name, Utils.getRandomVariableName());
                         node.name = this.functionParams.get(node.name);
@@ -54,7 +54,7 @@ export class FunctionObfuscator extends NodeObfuscator {
      */
     private replaceFunctionParamsInBody (functionNode: IFunctionNode): void {
         estraverse.replace(functionNode.body, {
-            leave: (node: ITreeNode, parentNode: ITreeNode): any => {
+            leave: (node: INode, parentNode: INode): any => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionParams);
             }
         });

src/node-obfuscators/LiteralObfuscator.ts

@@ -2,7 +2,7 @@ import * as escodegen from 'escodegen';
 
 import { ILiteralNode } from "../interfaces/nodes/ILiteralNode";
 
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 import { NodeObfuscator } from './NodeObfuscator';
 import { NodeUtils } from "../NodeUtils";
 
@@ -11,7 +11,7 @@ export class LiteralObfuscator extends NodeObfuscator {
      * @param literalNode
      * @param parentNode
      */
-    public obfuscateNode (literalNode: ILiteralNode, parentNode: ITreeNode): void {
+    public obfuscateNode (literalNode: ILiteralNode, parentNode: INode): void {
         if (NodeUtils.isPropertyNode(parentNode) && parentNode.key === literalNode) {
             return;
         }

src/node-obfuscators/MemberExpressionObfuscator.ts

@@ -4,7 +4,7 @@ import * as estraverse from 'estraverse';
 import { IIdentifierNode } from "../interfaces/nodes/IIdentifierNode";
 import { ILiteralNode } from "../interfaces/nodes/ILiteralNode";
 import { IMemberExpressionNode } from "../interfaces/nodes/IMemberExpressionNode";
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 
 import { NodeType } from "../enums/NodeType";
 
@@ -17,7 +17,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
      */
     public obfuscateNode (memberExpressionNode: IMemberExpressionNode): void {
         estraverse.replace(memberExpressionNode.property, {
-            leave: (node: ITreeNode, parentNode: ITreeNode): any => {
+            leave: (node: INode, parentNode: INode): any => {
                 if (NodeUtils.isLiteralNode(node)) {
                     this.literalNodeController(node);
 

src/node-obfuscators/MethodDefinitionObfuscator.ts

@@ -1,7 +1,7 @@
 import * as estraverse from 'estraverse';
 
 import { IMethodDefinitionNode } from "../interfaces/nodes/IMethodDefinitionNode";
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 
 import { NodeObfuscator } from './NodeObfuscator';
 import { NodeUtils } from "../NodeUtils";
@@ -26,7 +26,7 @@ export class MethodDefinitionObfuscator extends NodeObfuscator {
      * @param methodDefinitionNode
      * @param parentNode
      */
-    public obfuscateNode (methodDefinitionNode: IMethodDefinitionNode, parentNode: ITreeNode): void {
+    public obfuscateNode (methodDefinitionNode: IMethodDefinitionNode, parentNode: INode): void {
         this.replaceMethodName(methodDefinitionNode);
     }
 
@@ -35,7 +35,7 @@ export class MethodDefinitionObfuscator extends NodeObfuscator {
      */
     private replaceMethodName (methodDefinitionNode: IMethodDefinitionNode): void {
         estraverse.replace(methodDefinitionNode.key, {
-            leave: (node: ITreeNode): any => {
+            leave: (node: INode): any => {
                 if (
                     NodeUtils.isIdentifierNode(node) &&
                     !Utils.arrayContains(this.ignoredNames, node.name) &&

src/node-obfuscators/NodeObfuscator.ts

@@ -1,6 +1,6 @@
-import { INode } from '../interfaces/INode';
+import { ICustomNode } from '../interfaces/ICustomNode';
 import { INodeObfuscator } from '../interfaces/INodeObfuscator';
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 
 import { JSFuck } from "../enums/JSFuck";
 
@@ -11,12 +11,12 @@ export abstract class NodeObfuscator implements INodeObfuscator {
     /**
      * @type Map <string, Node>
      */
-    protected nodes: Map <string, INode>;
+    protected nodes: Map <string, ICustomNode>;
 
     /**
      * @param nodes
      */
-    constructor(nodes: Map <string, INode>) {
+    constructor(nodes: Map <string, ICustomNode>) {
         this.nodes = nodes;
     }
 
@@ -24,14 +24,14 @@ export abstract class NodeObfuscator implements INodeObfuscator {
      * @param node
      * @param parentNode
      */
-    public abstract obfuscateNode (node: ITreeNode, parentNode?: ITreeNode): void;
+    public abstract obfuscateNode (node: INode, parentNode?: INode): void;
 
     /**
      * @param node
      * @param parentNode
      * @param namesMap
      */
-    protected replaceNodeIdentifierByNewValue (node: ITreeNode, parentNode: ITreeNode, namesMap: Map <string, string>): void {
+    protected replaceNodeIdentifierByNewValue (node: INode, parentNode: INode, namesMap: Map <string, string>): void {
         if (NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) {
             if (
                 (NodeUtils.isPropertyNode(parentNode) && parentNode.key === node) ||

src/node-obfuscators/ObjectExpressionObfuscator.ts

@@ -5,7 +5,7 @@ import { IIdentifierNode } from "../interfaces/nodes/IIdentifierNode";
 import { ILiteralNode } from "../interfaces/nodes/ILiteralNode";
 import { IObjectExpressionNode } from "../interfaces/nodes/IObjectExpressionNode";
 import { IPropertyNode } from "../interfaces/nodes/IPropertyNode";
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 
 import { NodeType } from "../enums/NodeType";
 
@@ -30,7 +30,7 @@ export class ObjectExpressionObfuscator extends NodeObfuscator {
     public obfuscateNode (objectExpressionNode: IObjectExpressionNode): void {
         objectExpressionNode.properties.forEach((property: IPropertyNode) => {
             estraverse.replace(property.key, {
-                leave: (node: ITreeNode, parentNode: ITreeNode): any => {
+                leave: (node: INode, parentNode: INode): any => {
                     if (NodeUtils.isLiteralNode(node)) {
                         this.literalNodeController(node);
 

src/node-obfuscators/VariableDeclarationObfuscator.ts

@@ -1,6 +1,6 @@
 import * as estraverse from 'estraverse';
 
-import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+import { INode } from "../interfaces/nodes/INode";
 import { IVariableDeclarationNode } from "../interfaces/nodes/IVariableDeclarationNode";
 import { IVariableDeclaratorNode } from "../interfaces/nodes/IVariableDeclaratorNode";
 
@@ -30,7 +30,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
      * @param variableDeclarationNode
      * @param parentNode
      */
-    public obfuscateNode (variableDeclarationNode: IVariableDeclarationNode, parentNode: ITreeNode): void {
+    public obfuscateNode (variableDeclarationNode: IVariableDeclarationNode, parentNode: INode): void {
         if (parentNode.type === NodeType.Program) {
             return;
         }
@@ -45,7 +45,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
     private replaceVariableName (variableDeclarationNode: IVariableDeclarationNode): void {
         variableDeclarationNode.declarations.forEach((declarationNode: IVariableDeclaratorNode) => {
             estraverse.replace(declarationNode.id, {
-                enter: (node: ITreeNode): any => {
+                enter: (node: INode): any => {
                     if (NodeUtils.isIdentifierNode(node)) {
                         this.variableNames.set(node.name, Utils.getRandomVariableName());
                         node.name = this.variableNames.get(node.name);
@@ -63,8 +63,8 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
      * @param variableDeclarationNode
      * @param variableParentNode
      */
-    private replaceVariableCalls (variableDeclarationNode: IVariableDeclarationNode, variableParentNode: ITreeNode): void {
-        let scopeNode: ITreeNode;
+    private replaceVariableCalls (variableDeclarationNode: IVariableDeclarationNode, variableParentNode: INode): void {
+        let scopeNode: INode;
 
         scopeNode = variableDeclarationNode.kind === 'var' ? NodeUtils.getScopeOfNode(
             variableDeclarationNode
@@ -73,7 +73,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
         let isNodeAfterVariableDeclaratorFlag: boolean = false;
 
         estraverse.replace(scopeNode, {
-            enter: (node: ITreeNode, parentNode: ITreeNode): any => {
+            enter: (node: INode, parentNode: INode): any => {
                 const functionNodes: string[] = [
                     NodeType.ArrowFunctionExpression,
                     NodeType.FunctionDeclaration,
@@ -82,7 +82,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
 
                 if (Utils.arrayContains(functionNodes, node.type)) {
                     estraverse.replace(node, {
-                        enter: (node: ITreeNode, parentNode: ITreeNode): any => {
+                        enter: (node: INode, parentNode: INode): any => {
                             this.replaceNodeIdentifierByNewValue(node, parentNode, this.variableNames);
                         }
                     });