Added node interfaces

index.ts

@@ -3,6 +3,8 @@
 import * as esprima from 'esprima';
 import * as escodegen from 'escodegen';
 
+import { IProgramNode } from './src/interfaces/nodes/IProgramNode';
+
 import { Obfuscator } from './src/Obfuscator';
 
 export class JavaScriptObfuscator {
@@ -21,7 +23,7 @@ export class JavaScriptObfuscator {
      * @param options
      */
     public static obfuscate (sourceCode: string, options: any = {}): string {
-        let astTree: any = esprima.parse(sourceCode),
+        let astTree: IProgramNode = esprima.parse(sourceCode),
             obfuscator: Obfuscator = new Obfuscator(options);
 
         obfuscator.obfuscateNode(astTree);
@@ -33,7 +35,7 @@ export class JavaScriptObfuscator {
      * @param astTree
      * @param options
      */
-    private static generateCode (astTree: any, options: any = {}): string {
+    private static generateCode (astTree: IProgramNode, options: any = {}): string {
         let escodegenParams: any = Object.assign({}, JavaScriptObfuscator.escodegenParams);
 
         if (options.hasOwnProperty('compact')) {

src/NodeUtils.js

@@ -33,5 +33,8 @@ class NodeUtils {
         }
         return node.parentNode;
     }
+    static isIdentifierNode(node) {
+        return node.type === 'Identifier';
+    }
 }
 exports.NodeUtils = NodeUtils;

src/NodeUtils.ts

@@ -1,9 +1,13 @@
+import { IIdentifierNode } from "./interfaces/nodes/IIdentifierNode";
+import { ITreeNode } from './interfaces/nodes/ITreeNode';
+
 export class NodeUtils {
     /**
      * @param node
      * @param deep
+     * @returns {ITreeNode}
      */
-    public static getNodeScope (node: any,  deep: number = 0): any {
+    public static getNodeScope (node: ITreeNode,  deep: number = 0): ITreeNode {
         let scopeNodes: string[] = [
             'FunctionDeclaration',
             'FunctionExpression',
@@ -35,8 +39,14 @@ export class NodeUtils {
      * @param types
      * @param limitNodeTypes
      * @param deep
+     * @returns {ITreeNode}
      */
-    public static getParentNodeWithType (node: any, types: string[], limitNodeTypes: string[] = [], deep: number = 0): any {
+    public static getParentNodeWithType (
+        node: ITreeNode,
+        types: string[],
+        limitNodeTypes: string[] = [],
+        deep: number = 0
+    ): ITreeNode {
         if (node.parentNode.type === 'Program' || limitNodeTypes.indexOf(node.parentNode.type) >= 0) {
             return node.parentNode;
         }
@@ -51,4 +61,12 @@ export class NodeUtils {
 
         return node.parentNode;
     }
-}
+
+    /**
+     * @param node
+     * @returns {boolean}
+     */
+    public static isIdentifierNode (node: ITreeNode): node is IIdentifierNode {
+        return node.type === 'Identifier';
+    }
+}

src/Obfuscator.ts

@@ -3,6 +3,7 @@ import * as estraverse from 'estraverse';
 import { INode } from './interfaces/INode';
 import { INodeObfuscator } from './interfaces/INodeObfuscator';
 import { INodesGroup } from './interfaces/INodesGroup';
+import { ITreeNode } from './interfaces/nodes/ITreeNode';
 
 import { AppendState } from './enums/AppendState';
 
@@ -60,7 +61,7 @@ export class Obfuscator {
     /**
      * @param node
      */
-    public obfuscateNode (node: any): void {
+    public obfuscateNode (node: ITreeNode): void {
         if (this.options['rotateUnicodeArray']) {
             this.setNodesGroup(new UnicodeArrayNodesGroup(node));
         } else {
@@ -73,11 +74,11 @@ export class Obfuscator {
         this.beforeObfuscation(node);
 
         estraverse.replace(node, {
-            enter: (node, parent) => this.nodeControllerFirstPass(node, parent)
+            enter: (node: ITreeNode, parent: ITreeNode) => this.nodeControllerFirstPass(node, parent)
         });
 
         estraverse.replace(node, {
-            leave: (node, parent) => this.nodeControllerSecondPass(node, parent)
+            leave: (node: ITreeNode, parent: ITreeNode) => this.nodeControllerSecondPass(node, parent)
         });
 
         this.afterObfuscation(node);
@@ -105,7 +106,7 @@ export class Obfuscator {
     /**
      * @param node
      */
-    private afterObfuscation (node: any): void {
+    private afterObfuscation (node: ITreeNode): void {
         this.nodes.forEach((node: INode) => {
             if (node.getAppendState() === AppendState.AfterObfuscation) {
                 node.appendNode();
@@ -116,7 +117,7 @@ export class Obfuscator {
     /**
      * @param node
      */
-    private beforeObfuscation (node: any): void {
+    private beforeObfuscation (node: ITreeNode): void {
         this.nodes.forEach((node: INode) => {
             if (node.getAppendState() === AppendState.BeforeObfuscation) {
                 node.appendNode();
@@ -128,7 +129,7 @@ export class Obfuscator {
      * @param node
      * @param parent
      */
-    private nodeControllerFirstPass (node, parent): void {
+    private nodeControllerFirstPass (node: ITreeNode, parent: ITreeNode): void {
         Object.defineProperty(node, 'parentNode', {
             enumerable: true,
             configurable: true,
@@ -141,7 +142,7 @@ export class Obfuscator {
      * @param node
      * @param parent
      */
-    private nodeControllerSecondPass (node, parent): void {
+    private nodeControllerSecondPass (node: ITreeNode, parent: ITreeNode): void {
         switch (node.type) {
             default:
                 this.initializeNodeObfuscators(node, parent);
@@ -152,7 +153,7 @@ export class Obfuscator {
      * @param node
      * @param parent
      */
-    private initializeNodeObfuscators (node: any, parent: any): void {
+    private initializeNodeObfuscators (node: ITreeNode, parent: ITreeNode): void {
         if (!this.nodeObfuscators.has(node.type)) {
             return;
         }

src/Utils.ts

@@ -3,9 +3,9 @@ export class Utils {
      * @param array
      * @param times
      * @param reverse
-     * @returns {any[]}
+     * @returns any[]
      */
-    public static arrayRotate (array: any[], times: number, reverse: boolean = false) {
+    public static arrayRotate (array: any[], times: number, reverse: boolean = false): any[] {
         if (times < 0) {
             return;
         }
@@ -45,7 +45,7 @@ export class Utils {
 
     /**
      * @param length
-     * @returns {any}
+     * @returns any
      */
     public static getRandomVariableName (length: number = 6): string {
         const prefix = '_0x';

src/interfaces/INode.ts

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

src/interfaces/INodeObfuscator.ts

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

src/interfaces/nodes/IArrowFunctionExpressionNode.ts

@@ -0,0 +1,3 @@
+import { IFunctionNode } from "./IFunctionNode";
+
+export interface IArrowFunctionExpressionNode extends IFunctionNode {}

src/interfaces/nodes/IBlockStatementNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/IBlockStatementNode.ts

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

src/interfaces/nodes/ICatchClauseNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/ICatchClauseNode.ts

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

src/interfaces/nodes/IFunctionDeclarationNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/IFunctionDeclarationNode.ts

@@ -0,0 +1,3 @@
+import { IFunctionNode } from "./IFunctionNode";
+
+export interface IFunctionDeclarationNode extends IFunctionNode {}

src/interfaces/nodes/IFunctionExpressionNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/IFunctionExpressionNode.ts

@@ -0,0 +1,3 @@
+import { IFunctionNode } from "./IFunctionNode";
+
+export interface IFunctionExpressionNode extends IFunctionNode {}

src/interfaces/nodes/IFunctionNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/IFunctionNode.ts

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

src/interfaces/nodes/IIdentifierNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/IIdentifierNode.ts

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

src/interfaces/nodes/IProgramNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/IProgramNode.ts

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

src/interfaces/nodes/ITreeNode.js

@@ -0,0 +1 @@
+"use strict";

src/interfaces/nodes/ITreeNode.ts

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

src/node-groups/UnicodeArrayNodesGroup.ts

@@ -1,3 +1,5 @@
+import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+
 import { INode } from '../interfaces/INode';
 
 import { NodesGroup } from './NodesGroup';
@@ -15,7 +17,7 @@ export class UnicodeArrayNodesGroup extends NodesGroup {
     /**
      * @param astTree
      */
-    constructor (astTree: any) {
+    constructor (astTree: ITreeNode) {
         super();
 
         let unicodeArrayName: string = Utils.getRandomVariableName(UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH),

src/node-obfuscators/CatchClauseObfuscator.js

@@ -1,6 +1,7 @@
 "use strict";
 const estraverse = require('estraverse');
 const NodeObfuscator_1 = require('./NodeObfuscator');
+const NodeUtils_1 = require("../NodeUtils");
 const Utils_1 = require('../Utils');
 class CatchClauseObfuscator extends NodeObfuscator_1.NodeObfuscator {
     constructor(...args) {
@@ -14,11 +15,12 @@ class CatchClauseObfuscator extends NodeObfuscator_1.NodeObfuscator {
     replaceCatchClauseParam(catchClauseNode) {
         estraverse.replace(catchClauseNode.param, {
             leave: (node, parentNode) => {
-                if (node.type !== 'Identifier') {
-                    return estraverse.VisitorOption.Skip;
+                if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
+                    this.catchClauseParam.set(node.name, Utils_1.Utils.getRandomVariableName());
+                    node.name = this.catchClauseParam.get(node.name);
+                    return;
                 }
-                this.catchClauseParam.set(node.name, Utils_1.Utils.getRandomVariableName());
-                node.name = this.catchClauseParam.get(node.name);
+                return estraverse.VisitorOption.Skip;
             }
         });
     }

src/node-obfuscators/CatchClauseObfuscator.ts

@@ -1,6 +1,10 @@
 import * as estraverse from 'estraverse';
 
+import { ICatchClauseNode } from "../interfaces/nodes/ICatchClauseNode";
+import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+
 import { NodeObfuscator } from './NodeObfuscator';
+import { NodeUtils } from "../NodeUtils";
 import { Utils } from '../Utils';
 
 /**
@@ -20,7 +24,7 @@ export class CatchClauseObfuscator extends NodeObfuscator {
     /**
      * @param catchClauseNode
      */
-    public obfuscateNode (catchClauseNode: any): void {
+    public obfuscateNode (catchClauseNode: ICatchClauseNode): void {
         this.replaceCatchClauseParam(catchClauseNode);
         this.replaceCatchClauseParamInBlock(catchClauseNode);
     }
@@ -28,15 +32,17 @@ export class CatchClauseObfuscator extends NodeObfuscator {
     /**
      * @param catchClauseNode
      */
-    private replaceCatchClauseParam (catchClauseNode: any): void {
+    private replaceCatchClauseParam (catchClauseNode: ICatchClauseNode): void {
         estraverse.replace(catchClauseNode.param, {
-            leave: (node, parentNode) => {
-                if (node.type !== 'Identifier') {
-                    return estraverse.VisitorOption.Skip;
+            leave: (node: ITreeNode, parentNode: ITreeNode) => {
+                if (NodeUtils.isIdentifierNode(node)) {
+                    this.catchClauseParam.set(node.name, Utils.getRandomVariableName());
+                    node.name = this.catchClauseParam.get(node.name);
+
+                    return;
                 }
 
-                this.catchClauseParam.set(node.name, Utils.getRandomVariableName());
-                node.name = this.catchClauseParam.get(node.name);
+                return estraverse.VisitorOption.Skip;
             }
         });
     }
@@ -44,11 +50,11 @@ export class CatchClauseObfuscator extends NodeObfuscator {
     /**
      * @param catchClauseNode
      */
-    private replaceCatchClauseParamInBlock (catchClauseNode: any): void {
+    private replaceCatchClauseParamInBlock (catchClauseNode: ICatchClauseNode): void {
         estraverse.replace(catchClauseNode.body, {
-            leave: (node, parentNode) => {
+            leave: (node: ITreeNode, parentNode: ITreeNode) => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.catchClauseParam);
             }
         });
     }
-}
+}

src/node-obfuscators/FunctionDeclarationObfuscator.js

@@ -18,11 +18,12 @@ class FunctionDeclarationObfuscator extends NodeObfuscator_1.NodeObfuscator {
     replaceFunctionName(functionDeclarationNode) {
         estraverse.replace(functionDeclarationNode.id, {
             leave: (node) => {
-                if (node.type !== 'Identifier') {
-                    return estraverse.VisitorOption.Skip;
+                if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
+                    this.functionName.set(node.name, Utils_1.Utils.getRandomVariableName());
+                    node.name = this.functionName.get(node.name);
+                    return;
                 }
-                this.functionName.set(node.name, Utils_1.Utils.getRandomVariableName());
-                node.name = this.functionName.get(node.name);
+                return estraverse.VisitorOption.Skip;
             }
         });
     }

src/node-obfuscators/FunctionDeclarationObfuscator.ts

@@ -1,5 +1,8 @@
 import * as estraverse from 'estraverse';
 
+import { IFunctionDeclarationNode } from "../interfaces/nodes/IFunctionDeclarationNode";
+import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+
 import { NodeObfuscator } from './NodeObfuscator';
 import { NodeUtils } from "../NodeUtils";
 import { Utils } from '../Utils';
@@ -23,7 +26,7 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
      * @param functionDeclarationNode
      * @param parentNode
      */
-    public obfuscateNode (functionDeclarationNode: any, parentNode: any): void {
+    public obfuscateNode (functionDeclarationNode: IFunctionDeclarationNode, parentNode: ITreeNode): void {
         if (parentNode.type === 'Program') {
             return;
         }
@@ -35,15 +38,17 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
     /**
      * @param functionDeclarationNode
      */
-    private replaceFunctionName (functionDeclarationNode: any): void {
+    private replaceFunctionName (functionDeclarationNode: IFunctionDeclarationNode): void {
         estraverse.replace(functionDeclarationNode.id, {
-            leave: (node) => {
-                if (node.type !== 'Identifier') {
-                    return estraverse.VisitorOption.Skip;
+            leave: (node: ITreeNode) => {
+                if (NodeUtils.isIdentifierNode(node)) {
+                    this.functionName.set(node.name, Utils.getRandomVariableName());
+                    node.name = this.functionName.get(node.name);
+
+                    return;
                 }
 
-                this.functionName.set(node.name, Utils.getRandomVariableName());
-                node.name = this.functionName.get(node.name);
+                return estraverse.VisitorOption.Skip;
             }
         });
     }
@@ -51,13 +56,13 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
     /**
      * @param functionDeclarationNode
      */
-    private replaceFunctionCalls (functionDeclarationNode: any): void {
-        let scopeNode: any = NodeUtils.getNodeScope(
+    private replaceFunctionCalls (functionDeclarationNode: IFunctionDeclarationNode): void {
+        let scopeNode: ITreeNode = NodeUtils.getNodeScope(
             functionDeclarationNode
         );
 
         estraverse.replace(scopeNode, {
-            enter: (node, parentNode) => {
+            enter: (node: ITreeNode, parentNode: ITreeNode) => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionName);
             }
         });

src/node-obfuscators/FunctionObfuscator.js

@@ -1,6 +1,7 @@
 "use strict";
 const estraverse = require('estraverse');
 const NodeObfuscator_1 = require('./NodeObfuscator');
+const NodeUtils_1 = require("../NodeUtils");
 const Utils_1 = require('../Utils');
 class FunctionObfuscator extends NodeObfuscator_1.NodeObfuscator {
     constructor(...args) {
@@ -15,11 +16,12 @@ class FunctionObfuscator extends NodeObfuscator_1.NodeObfuscator {
         functionNode.params.forEach((paramsNode) => {
             estraverse.replace(paramsNode, {
                 leave: (node) => {
-                    if (node.type !== 'Identifier') {
-                        return estraverse.VisitorOption.Skip;
+                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
+                        this.functionParams.set(node.name, Utils_1.Utils.getRandomVariableName());
+                        node.name = this.functionParams.get(node.name);
+                        return;
                     }
-                    this.functionParams.set(node.name, Utils_1.Utils.getRandomVariableName());
-                    node.name = this.functionParams.get(node.name);
+                    return estraverse.VisitorOption.Skip;
                 }
             });
         });

src/node-obfuscators/FunctionObfuscator.ts

@@ -1,6 +1,10 @@
 import * as estraverse from 'estraverse';
 
+import { IFunctionNode } from "../interfaces/nodes/IFunctionNode";
+import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+
 import { NodeObfuscator } from './NodeObfuscator';
+import { NodeUtils } from "../NodeUtils";
 import { Utils } from '../Utils';
 
 /**
@@ -20,7 +24,7 @@ export class FunctionObfuscator extends NodeObfuscator {
     /**
      * @param functionNode
      */
-    public obfuscateNode (functionNode: any): void {
+    public obfuscateNode (functionNode: IFunctionNode): void {
         this.replaceFunctionParams(functionNode);
         this.replaceFunctionParamsInBody(functionNode);
     }
@@ -28,16 +32,18 @@ export class FunctionObfuscator extends NodeObfuscator {
     /**
      * @param functionNode
      */
-    private replaceFunctionParams (functionNode: any): void {
+    private replaceFunctionParams (functionNode: IFunctionNode): void {
         functionNode.params.forEach((paramsNode) => {
             estraverse.replace(paramsNode, {
-                leave: (node) => {
-                    if (node.type !== 'Identifier') {
-                        return estraverse.VisitorOption.Skip;
+                leave: (node: ITreeNode) => {
+                    if (NodeUtils.isIdentifierNode(node)) {
+                        this.functionParams.set(node.name, Utils.getRandomVariableName());
+                        node.name = this.functionParams.get(node.name);
+
+                        return;
                     }
 
-                    this.functionParams.set(node.name, Utils.getRandomVariableName());
-                    node.name = this.functionParams.get(node.name);
+                    return estraverse.VisitorOption.Skip;
                 }
             });
         });
@@ -46,9 +52,9 @@ export class FunctionObfuscator extends NodeObfuscator {
     /**
      * @param functionNode
      */
-    private replaceFunctionParamsInBody (functionNode: any): void {
+    private replaceFunctionParamsInBody (functionNode: IFunctionNode): void {
         estraverse.replace(functionNode.body, {
-            leave: (node, parentNode) => {
+            leave: (node: ITreeNode, parentNode: ITreeNode) => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionParams);
             }
         });

src/nodes/Node.ts

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

src/nodes/UnicodeArrayNode.ts

@@ -1,6 +1,9 @@
 import * as escodegen from 'escodegen';
 import * as estraverse from 'estraverse';
 
+import { IProgramNode } from '../interfaces/nodes/IProgramNode';
+import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+
 import { Node } from './Node';
 import { Utils } from '../Utils';
 
@@ -18,9 +21,9 @@ export class UnicodeArrayNode extends Node {
     protected appendState: AppendState = AppendState.AfterObfuscation;
 
     /**
-     * @type any
+     * @type {ITreeNode}
      */
-    private astTree: any;
+    private astTree: ITreeNode;
 
     /**
      * @type {string[]}
@@ -38,16 +41,16 @@ export class UnicodeArrayNode extends Node {
     private unicodeArrayRotateValue: number;
 
     /**
-     * @type any
+     * @type {ITreeNode}
      */
-    protected node: any;
+    protected node: ITreeNode;
 
     /**
      * @param astTree
      * @param unicodeArrayName
      * @param unicodeArrayRotateValue
      */
-    constructor (astTree: any, unicodeArrayName: string, unicodeArrayRotateValue: number = 0) {
+    constructor (astTree: ITreeNode, unicodeArrayName: string, unicodeArrayRotateValue: number = 0) {
         super();
 
         this.astTree = astTree;
@@ -58,10 +61,10 @@ export class UnicodeArrayNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node, parent) => {
+            leave: (node: ITreeNode, parent: ITreeNode) => {
                 switch (node.type) {
                     case 'Program':
-                        node.body.unshift(this.getNode());
+                        (<IProgramNode>node).body.unshift(this.getNode());
 
                         break;
                 }
@@ -84,9 +87,9 @@ export class UnicodeArrayNode extends Node {
     }
 
     /**
-     * @returns any
+     * @returns {ITreeNode}
      */
-    public getNode (): any {
+    public getNode (): ITreeNode {
         Utils.arrayRotate(this.unicodeArray, this.unicodeArrayRotateValue);
 
         this.updateNode();

src/nodes/UnicodeArrayRotateFunctionCallNode.ts

@@ -1,12 +1,15 @@
 import * as estraverse from 'estraverse';
 
+import { IProgramNode } from "../interfaces/nodes/IProgramNode";
+import { ITreeNode } from "../interfaces/nodes/ITreeNode";
+
 import { Node } from './Node';
 
 export class UnicodeArrayRotateFunctionCallNode extends Node {
     /**
-     * @type any
+     * @type {ITreeNode}
      */
-    private astTree: any;
+    private astTree: ITreeNode;
 
     /**
      * @type {string}
@@ -24,9 +27,9 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
     private unicodeArrayRotateFunctionName: string;
 
     /**
-     * @type any
+     * @type {ITreeNode}
      */
-    protected node: any;
+    protected node: ITreeNode;
 
     /**
      * @param astTree
@@ -35,7 +38,7 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
      * @param unicodeArrayRotateValue
      */
     constructor (
-        astTree: any,
+        astTree: ITreeNode,
         unicodeArrayRotateFunctionName: string,
         unicodeArrayName: string,
         unicodeArrayRotateValue: number
@@ -51,10 +54,10 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node, parent) => {
+            leave: (node: ITreeNode, parent: ITreeNode) => {
                 switch (node.type) {
                     case 'Program':
-                        node.body.unshift(this.getNode());
+                        (<IProgramNode>node).body.unshift(this.getNode());
 
                         break;
                 }

src/nodes/UnicodeArrayRotateFunctionNode.ts

@@ -1,13 +1,16 @@
 import * as estraverse from 'estraverse';
 
+import { IProgramNode } from '../interfaces/nodes/IProgramNode';
+import { ITreeNode } from '../interfaces/nodes/ITreeNode';
+
 import { Node } from './Node';
 import { Utils } from '../Utils';
 
 export class UnicodeArrayRotateFunctionNode extends Node {
     /**
-     * @type any
+     * @type {ITreeNode}
      */
-    private astTree: any;
+    private astTree: ITreeNode;
     /**
      * @type {string}
      */
@@ -19,9 +22,9 @@ export class UnicodeArrayRotateFunctionNode extends Node {
     private unicodeArrayRotateFunctionName: string;
 
     /**
-     * @type any
+     * @type {ITreeNode}
      */
-    protected node: any;
+    protected node: ITreeNode;
 
     /**
      * @param astTree
@@ -29,7 +32,7 @@ export class UnicodeArrayRotateFunctionNode extends Node {
      * @param unicodeArrayName
      */
     constructor (
-        astTree: any,
+        astTree: ITreeNode,
         unicodeArrayRotateFunctionName: string,
         unicodeArrayName: string
     ) {
@@ -43,10 +46,10 @@ export class UnicodeArrayRotateFunctionNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node, parent) => {
+            leave: (node: ITreeNode, parent: ITreeNode) => {
                 switch (node.type) {
                     case 'Program':
-                        node.body.push(this.getNode());
+                        (<IProgramNode>node).body.push(this.getNode());
 
                         break;
                 }