ArrayStorage refactoring

package.json

@@ -30,6 +30,7 @@
     "estraverse": "4.2.0",
     "inversify": "3.0.0",
     "lodash": "4.17.4",
+    "merge-estraverse-visitors": "^1.0.0",
     "mkdirp": "0.5.1",
     "reflect-metadata": "0.1.9",
     "source-map-support": "0.4.9",

src/Obfuscator.ts

@@ -5,21 +5,17 @@ import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { TNodeTransformersFactory } from './types/container/TNodeTransformersFactory';
-import { TVisitorDirection } from './types/TVisitorDirection';
 
 import { ICustomNodeGroup } from './interfaces/custom-nodes/ICustomNodeGroup';
 import { IObfuscationEventEmitter } from './interfaces/event-emitters/IObfuscationEventEmitter';
 import { IObfuscator } from './interfaces/IObfuscator';
 import { IOptions } from './interfaces/options/IOptions';
-import { INodeTransformer } from './interfaces/node-transformers/INodeTransformer';
 import { IStackTraceAnalyzer } from './interfaces/stack-trace-analyzer/IStackTraceAnalyzer';
 import { IStackTraceData } from './interfaces/stack-trace-analyzer/IStackTraceData';
 import { IStorage } from './interfaces/storages/IStorage';
 
 import { NodeTransformers } from './enums/container/NodeTransformers';
-import { NodeType } from './enums/NodeType';
 import { ObfuscationEvents } from './enums/ObfuscationEvents';
-import { VisitorDirection } from './enums/VisitorDirection';
 
 import { Node } from './node/Node';
 import { NodeUtils } from './node/NodeUtils';
@@ -27,40 +23,47 @@ import { NodeUtils } from './node/NodeUtils';
 @injectable()
 export class Obfuscator implements IObfuscator {
     /**
-     * @type {Map<string, NodeTransformers[]>}
+     * @type {NodeTransformers[]}
      */
-    private static readonly controlFlowTransformersMap: Map <string, NodeTransformers[]> = new Map([
-        [NodeType.BlockStatement, [NodeTransformers.BlockStatementControlFlowTransformer]],
-        [NodeType.FunctionDeclaration, [NodeTransformers.FunctionControlFlowTransformer]],
-        [NodeType.FunctionExpression, [NodeTransformers.FunctionControlFlowTransformer]]
-    ]);
+    private static readonly controlFlowTransformersList: NodeTransformers[] = [
+        NodeTransformers.BlockStatementControlFlowTransformer,
+        NodeTransformers.FunctionControlFlowTransformer,
+        NodeTransformers.FunctionControlFlowTransformer
+    ];
 
     /**
-     * @type {Map<string, NodeTransformers[]>}
+     * @type {NodeTransformers[]}
      */
-    private static readonly convertingTransformersMap: Map <string, NodeTransformers[]> = new Map([
-        [NodeType.MemberExpression, [NodeTransformers.MemberExpressionTransformer]],
-        [NodeType.MethodDefinition, [NodeTransformers.MethodDefinitionTransformer]],
-        [NodeType.TemplateLiteral, [NodeTransformers.TemplateLiteralTransformer]],
-    ]);
+    private static readonly convertingTransformersList: NodeTransformers[] = [
+        NodeTransformers.MemberExpressionTransformer,
+        NodeTransformers.MethodDefinitionTransformer,
+        NodeTransformers.TemplateLiteralTransformer
+    ];
 
     /**
-     * @type {Map<string, NodeTransformers[]>}
+     * @type {NodeTransformers[]}
      */
-    private static readonly obfuscatingTransformersMap: Map <string, NodeTransformers[]> = new Map([
-        [NodeType.ArrowFunctionExpression, [NodeTransformers.FunctionTransformer]],
-        [NodeType.ClassDeclaration, [NodeTransformers.FunctionDeclarationTransformer]],
-        [NodeType.CatchClause, [NodeTransformers.CatchClauseTransformer]],
-        [NodeType.FunctionDeclaration, [
-            NodeTransformers.FunctionDeclarationTransformer,
-            NodeTransformers.FunctionTransformer
-        ]],
-        [NodeType.FunctionExpression, [NodeTransformers.FunctionTransformer]],
-        [NodeType.ObjectExpression, [NodeTransformers.ObjectExpressionTransformer]],
-        [NodeType.VariableDeclaration, [NodeTransformers.VariableDeclarationTransformer]],
-        [NodeType.LabeledStatement, [NodeTransformers.LabeledStatementTransformer]],
-        [NodeType.Literal, [NodeTransformers.LiteralTransformer]]
-    ]);
+    private static readonly obfuscatingTransformersList: NodeTransformers[] = [
+        NodeTransformers.FunctionTransformer,
+        NodeTransformers.FunctionDeclarationTransformer,
+        NodeTransformers.CatchClauseTransformer,
+        NodeTransformers.FunctionDeclarationTransformer,
+        NodeTransformers.FunctionTransformer,
+        NodeTransformers.FunctionTransformer,
+        NodeTransformers.ObjectExpressionTransformer,
+        NodeTransformers.VariableDeclarationTransformer,
+        NodeTransformers.LiteralTransformer
+    ];
+
+    /**
+     * @type {Map<string, estraverse.Visitor[]>}
+     */
+    private readonly cachedEnterVisitors: Map<string, estraverse.Visitor[]> = new Map();
+
+    /**
+     * @type {Map<string, estraverse.Visitor[]>}
+     */
+    private readonly cachedLeaveVisitors: Map<string, estraverse.Visitor[]> = new Map();
 
     /**
      * @type {IStorage<ICustomNodeGroup>}
@@ -139,22 +142,20 @@ export class Obfuscator implements IObfuscator {
         if (this.options.controlFlowFlattening) {
             astTree = this.transformAstTree(
                 astTree,
-                VisitorDirection.leave,
-                this.nodeTransformersFactory(Obfuscator.controlFlowTransformersMap)
+                Obfuscator.controlFlowTransformersList
             );
         }
 
         // second pass: nodes obfuscation
+        console.time();
         astTree = this.transformAstTree(
             astTree,
-            VisitorDirection.enter,
-            this.nodeTransformersFactory(
-                new Map([
-                    ...Obfuscator.convertingTransformersMap,
-                    ...Obfuscator.obfuscatingTransformersMap
-                ])
-            )
+            [
+                ...Obfuscator.convertingTransformersList,
+                ...Obfuscator.obfuscatingTransformersList
+            ]
         );
+        console.timeEnd();
 
         this.obfuscationEventEmitter.emit(ObfuscationEvents.AfterObfuscation, astTree, stackTraceData);
 
@@ -163,26 +164,78 @@ export class Obfuscator implements IObfuscator {
 
     /**
      * @param astTree
-     * @param direction
-     * @param nodeTransformersConcreteFactory
+     * @param nodeTransformers
      */
     private transformAstTree (
         astTree: ESTree.Program,
-        direction: TVisitorDirection,
-        nodeTransformersConcreteFactory: (nodeType: string) => INodeTransformer[]
+        nodeTransformers: NodeTransformers[]
     ): ESTree.Program {
-        estraverse.replace(astTree, {
-            [direction]: (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node => {
-                const nodeTransformers: INodeTransformer[] = nodeTransformersConcreteFactory(node.type);
+        const mergedVisitors: estraverse.Visitor = this.mergeTransformerVisitors(
+            nodeTransformers.map((nodeTransformer: NodeTransformers): estraverse.Visitor => {
+                return this.nodeTransformersFactory(nodeTransformer).getVisitor();
+            })
+        );
 
-                nodeTransformers.forEach((nodeTransformer: INodeTransformer) => {
-                    node = nodeTransformer.transformNode(node, parentNode);
-                });
+        estraverse.replace(astTree, mergedVisitors);
 
-                return node;
-            }
+        return astTree;
+    }
+
+    /**
+     * @param visitors
+     * @return {estraverse.Visitor}
+     */
+    private mergeTransformerVisitors (visitors: estraverse.Visitor[]): estraverse.Visitor {
+        const enterVisitors: any[] = visitors.filter((visitor: estraverse.Visitor) => {
+            return visitor.enter !== undefined;
+        }).map((visitor: estraverse.Visitor) => {
+            return visitor.enter;
+        });
+        const leaveVisitors: any[] = visitors.filter((visitor: estraverse.Visitor) => {
+            return visitor.leave !== undefined;
+        }).map((visitor: estraverse.Visitor) => {
+            return visitor.leave;
         });
 
-        return astTree;
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                let nodeVisitors: estraverse.Visitor[];
+                let saveToCache: boolean = true;
+
+                if (this.cachedEnterVisitors.has(node.type)) {
+                    nodeVisitors = <estraverse.Visitor[]>this.cachedEnterVisitors.get(node.type);
+                    saveToCache = false;
+                } else {
+                    nodeVisitors = enterVisitors;
+                }
+
+                nodeVisitors.forEach((visitor: any) => {
+                    visitor.call(this, node, parentNode);
+                });
+
+                if (saveToCache) {
+                    this.cachedEnterVisitors.set(node.type, nodeVisitors);
+                }
+            },
+            leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                let nodeVisitors: estraverse.Visitor[];
+                let saveToCache: boolean = true;
+
+                if (this.cachedLeaveVisitors.has(node.type)) {
+                    nodeVisitors = <estraverse.Visitor[]>this.cachedLeaveVisitors.get(node.type);
+                    saveToCache = false;
+                } else {
+                    nodeVisitors = leaveVisitors;
+                }
+
+                nodeVisitors.forEach((visitor: any) => {
+                    visitor.call(this, node, parentNode);
+                });
+
+                if (saveToCache) {
+                    this.cachedLeaveVisitors.set(node.type, nodeVisitors);
+                }
+            }
+        };
     }
 }

src/container/modules/node-transformers/NodeTransformersModule.ts

@@ -72,31 +72,24 @@ export const nodeTransformersModule: interfaces.ContainerModule = new ContainerM
         .whenTargetNamed(NodeTransformers.VariableDeclarationTransformer);
 
     // node transformers factory
-    bind<INodeTransformer[]>(ServiceIdentifiers.Factory__INodeTransformer)
-        .toFactory<INodeTransformer[]>((context: interfaces.Context) => {
+    bind<INodeTransformer>(ServiceIdentifiers.Factory__INodeTransformer)
+        .toFactory<INodeTransformer>((context: interfaces.Context) => {
             const cache: Map <NodeTransformers, INodeTransformer> = new Map();
 
-            return (nodeTransformersMap: Map<string, NodeTransformers[]>) => (nodeType: string) => {
-                const nodeTransformers: NodeTransformers[] = nodeTransformersMap.get(nodeType) || [];
-                const instancesArray: INodeTransformer[] = [];
+            return (nodeTransformerName: NodeTransformers) => {
+                if (cache.has(nodeTransformerName)) {
+                    return <INodeTransformer>cache.get(nodeTransformerName);
+                }
 
-                nodeTransformers.forEach((transformer: NodeTransformers) => {
-                    let nodeTransformer: INodeTransformer;
+                const nodeTransformer: INodeTransformer = context.container
+                    .getNamed<INodeTransformer>(
+                        ServiceIdentifiers.INodeTransformer,
+                        nodeTransformerName
+                    );
 
-                    if (cache.has(transformer)) {
-                        nodeTransformer = <INodeTransformer>cache.get(transformer);
-                    } else {
-                        nodeTransformer = context.container.getNamed<INodeTransformer>(
-                            ServiceIdentifiers.INodeTransformer,
-                            transformer
-                        );
-                        cache.set(transformer, nodeTransformer);
-                    }
+                cache.set(nodeTransformerName, nodeTransformer);
 
-                    instancesArray.push(nodeTransformer);
-                });
-
-                return instancesArray;
+                return nodeTransformer;
             };
         });
 });

src/enums/VisitorDirection.ts

@@ -1,6 +0,0 @@
-import { Utils } from '../utils/Utils';
-
-export const VisitorDirection: any = Utils.strEnumify({
-    enter: 'enter',
-    leave: 'leave'
-});

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

@@ -1,10 +1,8 @@
-import * as ESTree from 'estree';
+import * as estraverse from 'estraverse';
 
 export interface INodeTransformer {
     /**
-     * @param node
-     * @param parentNode
-     * @returns {ESTree.Node}
+     * @returns {estraverse.Visitor}
      */
-    transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node;
+    getVisitor (): estraverse.Visitor;
 }

src/node-transformers/AbstractNodeTransformer.ts

@@ -1,7 +1,7 @@
 import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
 
-import * as ESTree from 'estree';
+import * as estraverse from 'estraverse';
 
 import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
 import { IOptions } from '../interfaces/options/IOptions';
@@ -30,9 +30,7 @@ export abstract class AbstractNodeTransformer implements INodeTransformer {
     }
 
     /**
-     * @param node
-     * @param parentNode
-     * @returns {ESTree.Node}
+     * @returns {estraverse.Visitor}
      */
-    public abstract transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node;
+    public abstract getVisitor (): estraverse.Visitor;
 }

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

@@ -1,6 +1,7 @@
 import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
+import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { TCustomNodeFactory } from '../../types/container/TCustomNodeFactory';
@@ -49,11 +50,25 @@ export class BlockStatementControlFlowTransformer extends AbstractNodeTransforme
         });
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isBlockStatementNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param blockStatementNode
+     * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (blockStatementNode: ESTree.BlockStatement): ESTree.Node {
+    private transformNode (blockStatementNode: ESTree.BlockStatement, parentNode: ESTree.Node): ESTree.Node {
         if (
             RandomGeneratorUtils.getRandomFloat(0, 1) > this.options.controlFlowFlatteningThreshold ||
             BlockStatementControlFlowTransformer.blockStatementHasProhibitedStatements(blockStatementNode)

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

@@ -112,11 +112,25 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
         return RandomGeneratorUtils.getRandomGenerator().pickone(blockScopesOfNode);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isFunctionDeclarationNode(node) || Node.isFunctionExpressionNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param functionNode
+     * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (functionNode: ESTree.Function): ESTree.Node {
+    private transformNode (functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Node {
         if (Node.isArrowFunctionExpressionNode(functionNode)) {
             return functionNode;
         }

src/node-transformers/converting-transformers/MemberExpressionTransformer.ts

@@ -1,6 +1,7 @@
 import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
+import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
@@ -21,6 +22,19 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
         super(options);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isMemberExpressionNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * replaces:
      *     object.identifier = 1;
@@ -34,9 +48,10 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
      * Literal node will be obfuscated by LiteralTransformer
      *
      * @param memberExpressionNode
+     * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (memberExpressionNode: ESTree.MemberExpression): ESTree.Node {
+    private transformNode (memberExpressionNode: ESTree.MemberExpression, parentNode: ESTree.Node): ESTree.Node {
         if (Node.isIdentifierNode(memberExpressionNode.property)) {
             if (memberExpressionNode.computed) {
                 return memberExpressionNode;

src/node-transformers/converting-transformers/MethodDefinitionTransformer.ts

@@ -1,6 +1,7 @@
 import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
+import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
@@ -35,6 +36,19 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
         super(options);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isMethodDefinitionNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * replaces:
      *     object.identifier = 1;
@@ -50,7 +64,7 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
      * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
+    private transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
         if (
             Node.isIdentifierNode(methodDefinitionNode.key) &&
             !MethodDefinitionTransformer.ignoredNames.includes(methodDefinitionNode.key.name) &&

src/node-transformers/converting-transformers/TemplateLiteralTransformer.ts

@@ -1,6 +1,7 @@
 import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
+import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
@@ -32,12 +33,25 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
         return node && Node.isLiteralNode(node) && typeof node.value === 'string';
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isTemplateLiteralNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param templateLiteralNode
      * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
+    private transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
         const templateLiteralExpressions: ESTree.Expression[] = templateLiteralNode.expressions;
 
         let nodes: (ESTree.Literal | ESTree.Expression)[] = [];

src/node-transformers/obfuscating-transformers/CatchClauseTransformer.ts

@@ -41,11 +41,25 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
         this.identifierReplacer = <IObfuscationReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isCatchClauseNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param catchClauseNode
+     * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (catchClauseNode: ESTree.CatchClause): ESTree.Node {
+    private transformNode (catchClauseNode: ESTree.CatchClause, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
 
         this.storeCatchClauseParam(catchClauseNode, nodeIdentifier);

src/node-transformers/obfuscating-transformers/FunctionDeclarationTransformer.ts

@@ -51,12 +51,25 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
         this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isFunctionDeclarationNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param functionDeclarationNode
      * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (functionDeclarationNode: ESTree.FunctionDeclaration, parentNode: ESTree.Node): ESTree.Node {
+    private transformNode (functionDeclarationNode: ESTree.FunctionDeclaration, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
         const blockScopeOfFunctionDeclarationNode: TNodeWithBlockStatement = NodeUtils
             .getBlockScopesOfNode(functionDeclarationNode)[0];

src/node-transformers/obfuscating-transformers/FunctionTransformer.ts

@@ -41,11 +41,29 @@ export class FunctionTransformer extends AbstractNodeTransformer {
         this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (
+                    Node.isFunctionDeclarationNode(node) ||
+                    Node.isFunctionExpressionNode(node) ||
+                    Node.isArrowFunctionExpressionNode(node)
+                ) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param functionNode
+     * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (functionNode: ESTree.Function): ESTree.Node {
+    private transformNode (functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
 
         this.storeFunctionParams(functionNode, nodeIdentifier);

src/node-transformers/obfuscating-transformers/LabeledStatementTransformer.ts

@@ -49,11 +49,25 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
         this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isLabeledStatementNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param labeledStatementNode
+     * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (labeledStatementNode: ESTree.LabeledStatement): ESTree.Node {
+    private transformNode (labeledStatementNode: ESTree.LabeledStatement, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
 
         this.storeLabeledStatementName(labeledStatementNode, nodeIdentifier);

src/node-transformers/obfuscating-transformers/LiteralTransformer.ts

@@ -2,6 +2,7 @@ import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
 import * as escodegen from 'escodegen';
+import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
@@ -32,12 +33,25 @@ export class LiteralTransformer extends AbstractNodeTransformer {
         this.replacersFactory = replacersFactory;
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isLiteralNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param literalNode
      * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
+    private transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
         if (Node.isPropertyNode(parentNode) && parentNode.key === literalNode) {
             return literalNode;
         }

src/node-transformers/obfuscating-transformers/ObjectExpressionTransformer.ts

@@ -2,6 +2,7 @@ import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
 import * as escodegen from 'escodegen';
+import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
@@ -64,11 +65,25 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
         };
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isObjectExpressionNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param objectExpressionNode
+     * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (objectExpressionNode: ESTree.ObjectExpression): ESTree.Node {
+    private transformNode (objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
         objectExpressionNode.properties
             .forEach((property: ESTree.Property) => {
                 if (property.shorthand) {

src/node-transformers/obfuscating-transformers/VariableDeclarationTransformer.ts

@@ -52,12 +52,25 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
         this.identifierReplacer = <IObfuscationReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
+    /**
+     * @return {estraverse.Visitor}
+     */
+    public getVisitor (): estraverse.Visitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
+                if (Node.isVariableDeclarationNode(node)) {
+                    this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
     /**
      * @param variableDeclarationNode
      * @param parentNode
      * @returns {ESTree.Node}
      */
-    public transformNode (variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): ESTree.Node {
+    private transformNode (variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): ESTree.Node {
         const blockScopeOfVariableDeclarationNode: TNodeWithBlockStatement = NodeUtils
             .getBlockScopesOfNode(variableDeclarationNode)[0];
 

src/node-transformers/obfuscating-transformers/replacers/StringLiteralReplacer.ts

@@ -102,10 +102,10 @@ export class StringLiteralReplacer extends AbstractReplacer {
             return <string>this.stringLiteralHexadecimalIndexCache.get(value);
         }
 
-        const indexOfValue: number = this.stringArrayStorage.getLength();
-        const hexadecimalIndex: string = `${Utils.hexadecimalPrefix}${Utils.decToHex(indexOfValue)}`;
+        const stringArrayStorageLength: number = this.stringArrayStorage.getLength();
+        const hexadecimalIndex: string = `${Utils.hexadecimalPrefix}${Utils.decToHex(stringArrayStorageLength)}`;
 
-        this.stringArrayStorage.set(this.stringArrayStorage.getLength(), value);
+        this.stringArrayStorage.set(stringArrayStorageLength, value);
         this.stringLiteralHexadecimalIndexCache.set(value, hexadecimalIndex);
 
         return hexadecimalIndex;

src/node/Node.ts

@@ -45,6 +45,14 @@ export class Node {
         return node.type === NodeType.CallExpression;
     }
 
+    /**
+     * @param node
+     * @returns {boolean}
+     */
+    public static isCatchClauseNode (node: ESTree.Node): node is ESTree.CatchClause {
+        return node.type === NodeType.CatchClause;
+    }
+
     /**
      * @param node
      * @returns {boolean}
@@ -130,6 +138,14 @@ export class Node {
         return node.type === NodeType.MemberExpression;
     }
 
+    /**
+     * @param node
+     * @returns {boolean}
+     */
+    public static isMethodDefinitionNode (node: ESTree.Node): node is ESTree.MethodDefinition {
+        return node.type === NodeType.MethodDefinition;
+    }
+
     /**
      * @param node
      * @returns {boolean}
@@ -184,6 +200,15 @@ export class Node {
         return !parentNodeIsPropertyNode && !parentNodeIsMemberExpressionNode && !Node.isLabelIdentifierNode(node, parentNode);
     }
 
+    /**
+     *
+     * @param node
+     * @returns {boolean}
+     */
+    public static isTemplateLiteralNode (node: ESTree.Node): node is ESTree.TemplateLiteral {
+        return node.type === NodeType.TemplateLiteral;
+    }
+
     /**
      *
      * @param node

src/types/container/TNodeTransformersFactory.d.ts

@@ -2,4 +2,4 @@ import { INodeTransformer } from '../../interfaces/node-transformers/INodeTransf
 
 import { NodeTransformers } from '../../enums/container/NodeTransformers';
 
-export type TNodeTransformersFactory = (nodeTransformersMap: Map<string, NodeTransformers[]>) => (nodeType: string) => INodeTransformer[];
+export type TNodeTransformersFactory = (nodeTransformerName: NodeTransformers) => INodeTransformer;