formatting

index.ts

@@ -8,6 +8,9 @@ import { IProgramNode } from './src/interfaces/nodes/IProgramNode';
 import { Obfuscator } from './src/Obfuscator';
 
 export class JavaScriptObfuscator {
+    /**
+     * @type any
+     */
     private static defaultOptions: any = {
         compact: true,
         rotateUnicodeArray: true
@@ -50,4 +53,4 @@ export class JavaScriptObfuscator {
     }
 }
 
-module.exports = JavaScriptObfuscator;
+module.exports = JavaScriptObfuscator;

src/NodeUtils.ts

@@ -39,7 +39,7 @@ export class NodeUtils {
             return NodeUtils.getScopeOfNode(node.parentNode);
         }
 
-        return node; // BlockStatement of scopeNodes
+        return node; // blocks statement of scopeNodes
     }
 
     /**

src/Obfuscator.js

@@ -74,10 +74,10 @@ class Obfuscator {
     ;
     nodeControllerFirstPass(node, parent) {
         Object.defineProperty(node, 'parentNode', {
-            enumerable: true,
             configurable: true,
-            writable: true,
-            value: parent || node
+            enumerable: true,
+            value: parent || node,
+            writable: true
         });
     }
     nodeControllerSecondPass(node, parent) {

src/Obfuscator.ts

@@ -72,11 +72,11 @@ export class Obfuscator {
         this.beforeObfuscation(node);
 
         estraverse.replace(node, {
-            enter: (node: ITreeNode, parent: ITreeNode) => this.nodeControllerFirstPass(node, parent)
+            enter: (node: ITreeNode, parent: ITreeNode): any => this.nodeControllerFirstPass(node, parent)
         });
 
         estraverse.replace(node, {
-            leave: (node: ITreeNode, parent: ITreeNode) => this.nodeControllerSecondPass(node, parent)
+            leave: (node: ITreeNode, parent: ITreeNode): any => this.nodeControllerSecondPass(node, parent)
         });
 
         this.afterObfuscation(node);
@@ -129,10 +129,10 @@ export class Obfuscator {
      */
     private nodeControllerFirstPass (node: ITreeNode, parent: ITreeNode): void {
         Object.defineProperty(node, 'parentNode', {
-            enumerable: true,
             configurable: true,
-            writable: true,
-            value: parent || node
+            enumerable: true,
+            value: parent || node,
+            writable: true
         });
     }
 
@@ -160,4 +160,4 @@ export class Obfuscator {
             new (<INodeObfuscator> obfuscator(this.nodes)).obfuscateNode(node, parent);
         });
     }
-}
+}

src/Utils.ts

@@ -60,8 +60,8 @@ export class Utils {
      * @returns {string}
      */
     public static stringToUnicode (string: string): string {
-        return `'${string.replace(/[\s\S]/g, (escape) => {
+        return `'${string.replace(/[\s\S]/g, (escape: string): string => {
             return `\\u${('0000' + escape.charCodeAt(0).toString(16)).slice(-4)}`;
         })}'`;
     }
-}
+}

src/enums/AppendState.js

@@ -1,6 +1,6 @@
 "use strict";
 (function (AppendState) {
-    AppendState[AppendState["BeforeObfuscation"] = 0] = "BeforeObfuscation";
-    AppendState[AppendState["AfterObfuscation"] = 1] = "AfterObfuscation";
+    AppendState[AppendState["AfterObfuscation"] = 0] = "AfterObfuscation";
+    AppendState[AppendState["BeforeObfuscation"] = 1] = "BeforeObfuscation";
 })(exports.AppendState || (exports.AppendState = {}));
 var AppendState = exports.AppendState;

src/enums/AppendState.ts

@@ -1 +1,4 @@
-export enum AppendState {BeforeObfuscation, AfterObfuscation}
+export enum AppendState {
+    AfterObfuscation,
+    BeforeObfuscation
+}

src/interfaces/INode.ts

@@ -31,4 +31,4 @@ export interface INode {
     setNode (node: ITreeNode): void;
 
     updateNode (): void;
-}
+}

src/interfaces/INodeObfuscator.ts

@@ -6,4 +6,4 @@ export interface INodeObfuscator {
      * @param parentNode
      */
     obfuscateNode (node: ITreeNode, parentNode?: ITreeNode): void;
-}
+}

src/interfaces/INodesGroup.ts

@@ -5,4 +5,4 @@ export interface INodesGroup {
      * @returns {Map <string, INode>}
      */
     getNodes (): Map <string, INode>;
-}
+}

src/interfaces/nodes/IArrowFunctionExpressionNode.ts

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

src/interfaces/nodes/IBlockStatementNode.ts

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

src/interfaces/nodes/ICatchClauseNode.ts

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

src/interfaces/nodes/IFunctionDeclarationNode.ts

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

src/interfaces/nodes/IFunctionExpressionNode.ts

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

src/interfaces/nodes/IFunctionNode.ts

@@ -7,4 +7,4 @@ export interface IFunctionNode extends ITreeNode {
     body: ITreeNode[];
     generator: boolean;
     expression: boolean;
-}
+}

src/interfaces/nodes/IIdentifierNode.ts

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

src/interfaces/nodes/ILiteralNode.ts

@@ -4,4 +4,4 @@ export interface ILiteralNode extends ITreeNode {
     value: boolean|number|string;
     raw: string;
     'x-verbatim-property': any;
-}
+}

src/interfaces/nodes/IMemberExpressionNode.ts

@@ -6,4 +6,4 @@ export interface IMemberExpressionNode extends ITreeNode {
     computed: boolean;
     object: IIdentifierNode;
     property: IIdentifierNode|ILiteralNode;
-}
+}

src/interfaces/nodes/IMethodDefinitionNode.ts

@@ -9,4 +9,4 @@ export interface IMethodDefinitionNode extends ITreeNode {
     value: IFunctionExpressionNode;
     kind: string;
     static: boolean;
-}
+}

src/interfaces/nodes/IObjectExpressionNode.ts

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

src/interfaces/nodes/IProgramNode.ts

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

src/interfaces/nodes/IPropertyNode.ts

@@ -9,4 +9,4 @@ export interface IPropertyNode extends ITreeNode {
     kind: string;
     method: boolean;
     shorthand: boolean;
-}
+}

src/interfaces/nodes/ITreeNode.ts

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

src/interfaces/nodes/IVariableDeclarationNode.ts

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

src/interfaces/nodes/IVariableDeclaratorNode.ts

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

src/node-groups/NodesGroup.ts

@@ -14,4 +14,4 @@ export abstract class NodesGroup implements INodesGroup {
     public getNodes (): Map <string, INode> {
         return this.nodes;
     }
-}
+}

src/node-groups/UnicodeArrayNodesGroup.ts

@@ -49,6 +49,6 @@ export class UnicodeArrayNodesGroup extends NodesGroup {
                     unicodeArrayRotateValue
                 )
             ]
-        ])
+        ]);
     }
-}
+}

src/node-obfuscators/CatchClauseObfuscator.ts

@@ -34,7 +34,7 @@ export class CatchClauseObfuscator extends NodeObfuscator {
      */
     private replaceCatchClauseParam (catchClauseNode: ICatchClauseNode): void {
         estraverse.replace(catchClauseNode.param, {
-            leave: (node: ITreeNode, parentNode: ITreeNode) => {
+            leave: (node: ITreeNode, parentNode: ITreeNode): 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) => {
+            leave: (node: ITreeNode, parentNode: ITreeNode): any => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.catchClauseParam);
             }
         });

src/node-obfuscators/FunctionDeclarationObfuscator.ts

@@ -40,7 +40,7 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
      */
     private replaceFunctionName (functionDeclarationNode: IFunctionDeclarationNode): void {
         estraverse.replace(functionDeclarationNode.id, {
-            leave: (node: ITreeNode) => {
+            leave: (node: ITreeNode): any => {
                 if (NodeUtils.isIdentifierNode(node)) {
                     this.functionName.set(node.name, Utils.getRandomVariableName());
                     node.name = this.functionName.get(node.name);
@@ -62,9 +62,9 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
         );
 
         estraverse.replace(scopeNode, {
-            enter: (node: ITreeNode, parentNode: ITreeNode) => {
+            enter: (node: ITreeNode, parentNode: ITreeNode): any => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionName);
             }
         });
     }
-}
+}

src/node-obfuscators/FunctionObfuscator.ts

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

src/node-obfuscators/LiteralObfuscator.js

@@ -17,6 +17,8 @@ class LiteralObfuscator extends NodeObfuscator_1.NodeObfuscator {
                     precedence: escodegen.Precedence.Primary
                 };
                 break;
+            default:
+                break;
         }
     }
 }

src/node-obfuscators/LiteralObfuscator.ts

@@ -28,6 +28,9 @@ export class LiteralObfuscator extends NodeObfuscator {
                 };
 
                 break;
+
+            default:
+                break;
         }
     }
-}
+}

src/node-obfuscators/MemberExpressionObfuscator.js

@@ -23,13 +23,13 @@ class MemberExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator {
     }
     identifierNodeController(node) {
         let nodeValue = node.name, literalNode = {
-            type: 'Literal',
-            value: nodeValue,
             raw: `'${nodeValue}'`,
             'x-verbatim-property': {
                 content: this.replaceLiteralStringByArrayElement(nodeValue),
                 precedence: escodegen.Precedence.Primary
-            }
+            },
+            type: 'Literal',
+            value: nodeValue
         };
         delete node.name;
         Object.assign(node, literalNode);
@@ -45,6 +45,8 @@ class MemberExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator {
                     precedence: escodegen.Precedence.Primary
                 };
                 break;
+            default:
+                break;
         }
     }
 }

src/node-obfuscators/MemberExpressionObfuscator.ts

@@ -6,7 +6,7 @@ import { ILiteralNode } from "../interfaces/nodes/ILiteralNode";
 import { IMemberExpressionNode } from "../interfaces/nodes/IMemberExpressionNode";
 import { ITreeNode } from "../interfaces/nodes/ITreeNode";
 
-import { NodeObfuscator } from './NodeObfuscator'
+import { NodeObfuscator } from './NodeObfuscator';
 import { NodeUtils } from "../NodeUtils";
 
 export class MemberExpressionObfuscator extends NodeObfuscator {
@@ -15,7 +15,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
      */
     public obfuscateNode (memberExpressionNode: IMemberExpressionNode): void {
         estraverse.replace(memberExpressionNode.property, {
-            leave: (node: ITreeNode, parentNode: ITreeNode) => {
+            leave: (node: ITreeNode, parentNode: ITreeNode): any => {
                 if (NodeUtils.isLiteralNode(node)) {
                     this.literalNodeController(node);
 
@@ -49,13 +49,13 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
     private identifierNodeController (node: IIdentifierNode): void {
         let nodeValue: string = node.name,
             literalNode: ILiteralNode = {
-                type: 'Literal',
-                value: nodeValue,
                 raw: `'${nodeValue}'`,
                 'x-verbatim-property': {
                     content : this.replaceLiteralStringByArrayElement(nodeValue),
                     precedence: escodegen.Precedence.Primary
-                }
+                },
+                type: 'Literal',
+                value: nodeValue
             };
 
         delete node.name;
@@ -85,6 +85,9 @@ export class MemberExpressionObfuscator extends NodeObfuscator {
                 };
 
                 break;
+
+            default:
+                break;
         }
     }
-}
+}

src/node-obfuscators/MethodDefinitionObfuscator.js

@@ -18,6 +18,7 @@ class MethodDefinitionObfuscator extends NodeObfuscator_1.NodeObfuscator {
                     methodDefinitionNode.computed === false) {
                     methodDefinitionNode.computed = true;
                     node.name = this.replaceLiteralStringByArrayElement(node.name);
+                    return;
                 }
                 return estraverse.VisitorOption.Skip;
             }

src/node-obfuscators/MethodDefinitionObfuscator.ts

@@ -34,7 +34,7 @@ export class MethodDefinitionObfuscator extends NodeObfuscator {
      */
     private replaceMethodName (methodDefinitionNode: IMethodDefinitionNode): void {
         estraverse.replace(methodDefinitionNode.key, {
-            leave: (node: ITreeNode) => {
+            leave: (node: ITreeNode): any => {
                 if (
                     NodeUtils.isIdentifierNode(node) &&
                     this.ignoredNames.indexOf(node.name) < 0 &&
@@ -42,10 +42,12 @@ export class MethodDefinitionObfuscator extends NodeObfuscator {
                 ) {
                     methodDefinitionNode.computed = true;
                     node.name = this.replaceLiteralStringByArrayElement(node.name);
+
+                    return;
                 }
 
                 return estraverse.VisitorOption.Skip;
             }
         });
     }
-}
+}

src/node-obfuscators/NodeObfuscator.ts

@@ -29,7 +29,7 @@ export abstract class NodeObfuscator implements INodeObfuscator {
      * @param parentNode
      * @param namesMap
      */
-    protected replaceNodeIdentifierByNewValue (node: ITreeNode, parentNode: ITreeNode, namesMap: Map <string, string>) {
+    protected replaceNodeIdentifierByNewValue (node: ITreeNode, parentNode: ITreeNode, namesMap: Map <string, string>): void {
         if (NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) {
             if (
                 (NodeUtils.isPropertyNode(parentNode) && parentNode.key === node) ||
@@ -61,4 +61,4 @@ export abstract class NodeObfuscator implements INodeObfuscator {
 
         return `${this.nodes.get('unicodeArrayNode').getNodeIdentifier()}[${index}]`;
     }
-}
+}

src/node-obfuscators/ObjectExpressionObfuscator.js

@@ -31,17 +31,19 @@ class ObjectExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator {
                     precedence: escodegen.Precedence.Primary
                 };
                 break;
+            default:
+                break;
         }
     }
     identifierNodeController(node) {
         let nodeValue = node.name, literalNode = {
-            type: 'Literal',
-            value: nodeValue,
             raw: `'${nodeValue}'`,
             'x-verbatim-property': {
                 content: Utils_1.Utils.stringToUnicode(nodeValue),
                 precedence: escodegen.Precedence.Primary
-            }
+            },
+            type: 'Literal',
+            value: nodeValue
         };
         delete node.name;
         Object.assign(node, literalNode);

src/node-obfuscators/ObjectExpressionObfuscator.ts

@@ -6,9 +6,10 @@ import { ILiteralNode } from "../interfaces/nodes/ILiteralNode";
 import { IObjectExpressionNode } from "../interfaces/nodes/IObjectExpressionNode";
 import { ITreeNode } from "../interfaces/nodes/ITreeNode";
 
-import { NodeObfuscator } from './NodeObfuscator'
+import { NodeObfuscator } from './NodeObfuscator';
 import { NodeUtils } from "../NodeUtils";
 import { Utils } from '../Utils';
+import {IPropertyNode} from "../interfaces/nodes/IPropertyNode";
 
 /**
  * replaces:
@@ -25,9 +26,9 @@ export class ObjectExpressionObfuscator extends NodeObfuscator {
      * @param objectExpressionNode
      */
     public obfuscateNode (objectExpressionNode: IObjectExpressionNode): void {
-        objectExpressionNode.properties.forEach((property) => {
+        objectExpressionNode.properties.forEach((property: IPropertyNode) => {
             estraverse.replace(property.key, {
-                leave: (node: ITreeNode, parentNode: ITreeNode) => {
+                leave: (node: ITreeNode, parentNode: ITreeNode): any => {
                     if (NodeUtils.isLiteralNode(node)) {
                         this.literalNodeController(node);
 
@@ -58,6 +59,9 @@ export class ObjectExpressionObfuscator extends NodeObfuscator {
                 };
 
                 break;
+
+            default:
+                break;
         }
     }
 
@@ -67,17 +71,17 @@ export class ObjectExpressionObfuscator extends NodeObfuscator {
     private identifierNodeController (node: IIdentifierNode): void {
         let nodeValue: string = node.name,
             literalNode: ILiteralNode = {
-                type: 'Literal',
-                value: nodeValue,
                 raw: `'${nodeValue}'`,
                 'x-verbatim-property': {
                     content : Utils.stringToUnicode(nodeValue),
                     precedence: escodegen.Precedence.Primary
-                }
+                },
+                type: 'Literal',
+                value: nodeValue
             };
 
         delete node.name;
 
         Object.assign(node, literalNode);
     }
-}
+}

src/node-obfuscators/VariableDeclarationObfuscator.ts

@@ -41,12 +41,12 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
      * @param variableDeclarationNode
      */
     private replaceVariableName (variableDeclarationNode: IVariableDeclarationNode): void {
-        variableDeclarationNode.declarations.forEach((declarationNode) => {
+        variableDeclarationNode.declarations.forEach((declarationNode: ITreeNode) => {
             estraverse.replace(declarationNode, {
-                enter: (node: ITreeNode) => {
+                enter: (node: ITreeNode): any => {
                     if (NodeUtils.isVariableDeclaratorNode(node)) {
                         estraverse.replace(node.id, {
-                            enter: (node: IIdentifierNode) => {
+                            enter: (node: IIdentifierNode): any => {
                                 this.variableNames.set(node.name, Utils.getRandomVariableName());
                                 node.name = this.variableNames.get(node.name);
                             }
@@ -75,7 +75,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
         let isNodeAfterVariableDeclaratorFlag: boolean = false;
 
         estraverse.replace(scopeNode, {
-            enter: (node: ITreeNode, parentNode: ITreeNode) => {
+            enter: (node: ITreeNode, parentNode: ITreeNode): any => {
                 const functionNodes: string[] = [
                     'ArrowFunctionExpression',
                     'FunctionDeclaration',
@@ -84,7 +84,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
 
                 if (functionNodes.indexOf(node.type) >= 0) {
                     estraverse.replace(node, {
-                        enter: (node: ITreeNode, parentNode: ITreeNode) => {
+                        enter: (node: ITreeNode, parentNode: ITreeNode): any => {
                             this.replaceNodeIdentifierByNewValue(node, parentNode, this.variableNames);
                         }
                     });

src/nodes/UnicodeArrayNode.js

@@ -21,6 +21,8 @@ class UnicodeArrayNode extends Node_1.Node {
                     case 'Program':
                         node.body.unshift(this.getNode());
                         break;
+                    default:
+                        break;
                 }
             }
         });

src/nodes/UnicodeArrayNode.ts

@@ -20,6 +20,11 @@ export class UnicodeArrayNode extends Node {
      */
     protected appendState: AppendState = AppendState.AfterObfuscation;
 
+    /**
+     * @type {ITreeNode}
+     */
+    protected node: ITreeNode;
+
     /**
      * @type {ITreeNode}
      */
@@ -40,11 +45,6 @@ export class UnicodeArrayNode extends Node {
      */
     private unicodeArrayRotateValue: number;
 
-    /**
-     * @type {ITreeNode}
-     */
-    protected node: ITreeNode;
-
     /**
      * @param astTree
      * @param unicodeArrayName
@@ -61,12 +61,15 @@ export class UnicodeArrayNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode) => {
+            leave: (node: ITreeNode, parent: ITreeNode): any => {
                 switch (node.type) {
                     case 'Program':
                         (<IProgramNode>node).body.unshift(this.getNode());
 
                         break;
+
+                    default:
+                        break;
                 }
             }
         });
@@ -112,7 +115,7 @@ export class UnicodeArrayNode extends Node {
                     },
                     'init': {
                         'type': 'ArrayExpression',
-                        'elements': this.unicodeArray.map((value) => {
+                        'elements': this.unicodeArray.map((value: string) => {
                             return {
                                 'type': 'Literal',
                                 'value': value,
@@ -129,4 +132,4 @@ export class UnicodeArrayNode extends Node {
             'kind': 'var'
         };
     }
-}
+}

src/nodes/UnicodeArrayRotateFunctionCallNode.js

@@ -17,6 +17,8 @@ class UnicodeArrayRotateFunctionCallNode extends Node_1.Node {
                     case 'Program':
                         node.body.unshift(this.getNode());
                         break;
+                    default:
+                        break;
                 }
             }
         });

src/nodes/UnicodeArrayRotateFunctionCallNode.ts

@@ -6,6 +6,11 @@ import { ITreeNode } from "../interfaces/nodes/ITreeNode";
 import { Node } from './Node';
 
 export class UnicodeArrayRotateFunctionCallNode extends Node {
+    /**
+     * @type {ITreeNode}
+     */
+    protected node: ITreeNode;
+
     /**
      * @type {ITreeNode}
      */
@@ -26,11 +31,6 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
      */
     private unicodeArrayRotateFunctionName: string;
 
-    /**
-     * @type {ITreeNode}
-     */
-    protected node: ITreeNode;
-
     /**
      * @param astTree
      * @param unicodeArrayRotateFunctionName
@@ -54,12 +54,15 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode) => {
+            leave: (node: ITreeNode, parent: ITreeNode): any => {
                 switch (node.type) {
                     case 'Program':
                         (<IProgramNode>node).body.unshift(this.getNode());
 
                         break;
+
+                    default:
+                        break;
                 }
             }
         });
@@ -96,4 +99,4 @@ export class UnicodeArrayRotateFunctionCallNode extends Node {
             }
         };
     }
-}
+}

src/nodes/UnicodeArrayRotateFunctionNode.js

@@ -17,6 +17,8 @@ class UnicodeArrayRotateFunctionNode extends Node_1.Node {
                     case 'Program':
                         node.body.push(this.getNode());
                         break;
+                    default:
+                        break;
                 }
             }
         });

src/nodes/UnicodeArrayRotateFunctionNode.ts

@@ -7,6 +7,11 @@ import { Node } from './Node';
 import { Utils } from '../Utils';
 
 export class UnicodeArrayRotateFunctionNode extends Node {
+    /**
+     * @type {ITreeNode}
+     */
+    protected node: ITreeNode;
+
     /**
      * @type {ITreeNode}
      */
@@ -21,11 +26,6 @@ export class UnicodeArrayRotateFunctionNode extends Node {
      */
     private unicodeArrayRotateFunctionName: string;
 
-    /**
-     * @type {ITreeNode}
-     */
-    protected node: ITreeNode;
-
     /**
      * @param astTree
      * @param unicodeArrayRotateFunctionName
@@ -46,12 +46,15 @@ export class UnicodeArrayRotateFunctionNode extends Node {
 
     public appendNode (): void {
         estraverse.replace(this.astTree, {
-            leave: (node: ITreeNode, parent: ITreeNode) => {
+            leave: (node: ITreeNode, parent: ITreeNode): any => {
                 switch (node.type) {
                     case 'Program':
                         (<IProgramNode>node).body.push(this.getNode());
 
                         break;
+
+                    default:
+                        break;
                 }
             }
         });
@@ -307,4 +310,4 @@ export class UnicodeArrayRotateFunctionNode extends Node {
             'expression': false
         };
     }
-}
+}

tslint.json

@@ -0,0 +1,153 @@
+{
+  "rules": {
+    "align": [
+      true,
+      "parameters",
+      "arguments",
+      "statements"
+    ],
+    "ban": [
+      true,
+      [ "_", "forEach" ],
+      [ "_", "each" ],
+      [ "$", "each" ],
+      [ "angular", "forEach" ]
+    ],
+    "class-name": true,
+    "comment-format": [
+      true,
+      "check-space",
+      "check-lowercase"
+    ],
+    "curly": true,
+    "eofline": true,
+    "forin": true,
+    "indent": [
+      true,
+      "spaces"
+    ],
+    "interface-name": [
+      true,
+      "always-prefix"
+    ],
+    "jsdoc-format": true,
+    "label-position": true,
+    "label-undefined": true,
+    "max-line-length": [
+      true,
+      140
+    ],
+    "member-access": true,
+    "member-ordering": [
+      true,
+      { "order": "fields-first" }
+    ],
+    "new-parens": true,
+    "no-angle-bracket-type-assertion": false,
+    "no-any": false,
+    "no-arg": true,
+    "no-bitwise": true,
+    "no-conditional-assignment": true,
+    "no-consecutive-blank-lines": false,
+    "no-console": [
+      true,
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
+    "no-construct": true,
+    "no-constructor-vars": true,
+    "no-debugger": true,
+    "no-default-export": true,
+    "no-duplicate-key": true,
+    "no-duplicate-variable": true,
+    "no-empty": false,
+    "no-eval": true,
+    "no-inferrable-types": false,
+    "no-internal-module": true,
+    "no-invalid-this": [
+      true,
+      "check-function-in-method"
+    ],
+    "no-null-keyword": false,
+    "no-reference": true,
+    "no-require-imports": true,
+    "no-shadowed-variable": false,
+    "no-string-literal": false,
+    "no-switch-case-fall-through": true,
+    "no-trailing-whitespace": false,
+    "no-unreachable": true,
+    "no-unused-expression": true,
+    "no-unused-variable": true,
+    "no-use-before-declare": true,
+    "no-var-keyword": true,
+    "no-var-requires": true,
+    "object-literal-sort-keys": true,
+    "one-line": [
+      true,
+      "check-open-brace",
+      "check-catch",
+      "check-else",
+      "check-finally",
+      "check-whitespace"
+    ],
+    "one-variable-per-declaration": false,
+    "quotemark": false,
+    "radix": true,
+    "semicolon": [true, "always"],
+    "switch-default": true,
+    "trailing-comma": false,
+    "triple-equals": [
+      true,
+      "allow-null-check",
+      "allow-undefined-check"
+    ],
+    "typedef": [
+      true,
+      "call-signature",
+      "parameter",
+      "arrow-parameter",
+      "property-declaration",
+      "variable-declaration",
+      "member-variable-declaration"
+    ],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      },
+      {
+        "call-signature": "space",
+        "index-signature": "space",
+        "parameter": "space",
+        "property-declaration": "space",
+        "variable-declaration": "space"
+      }
+    ],
+    "use-isnan": true,
+    "use-strict": [
+      true,
+      "check-module",
+      "check-function"
+    ],
+    "variable-name": [
+      true,
+      "check-format",
+      "allow-leading-underscore"
+    ],
+    "whitespace": [
+      true,
+      "check-branch",
+      "check-decl",
+      "check-operator",
+      "check-separator",
+      "check-type"
+    ]
+  }
+}