Project structure reorganized part 2

src/JavaScriptObfuscator.ts

@@ -21,10 +21,10 @@ import { IStorage } from './interfaces/storages/IStorage';
 import { ITransformersRunner } from './interfaces/node-transformers/ITransformersRunner';
 
 import { LoggingMessage } from './enums/logger/LoggingMessage';
-import { NodeTransformer } from './enums/container/node-transformers/NodeTransformer';
+import { NodeTransformer } from './enums/node-transformers/NodeTransformer';
 import { ObfuscationEvent } from './enums/event-emitters/ObfuscationEvent';
 
-import { Node } from './node/Node';
+import { NodeGuards } from './node/NodeGuards';
 
 @injectable()
 export class JavaScriptObfuscator implements IJavaScriptObfuscator {
@@ -78,8 +78,8 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @type {NodeTransformer[]}
      */
     private static readonly preparingTransformersList: NodeTransformer[] = [
-        NodeTransformer.ParentizeTransformer,
-        NodeTransformer.NodeGuardTransformer
+        NodeTransformer.ObfuscatingGuardsTransformer,
+        NodeTransformer.ParentificationTransformer
     ];
 
     /**
@@ -192,7 +192,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @returns {Program}
      */
     private transformAstTree (astTree: ESTree.Program): ESTree.Program {
-        if (Node.isProgramNode(astTree) && !astTree.body.length) {
+        if (NodeGuards.isProgramNode(astTree) && !astTree.body.length) {
             this.logger.warn(LoggingMessage.EmptySourceCode);
 
             return astTree;

src/analyzers/stack-trace-analyzer/StackTraceAnalyzer.ts

@@ -10,9 +10,9 @@ import { ICalleeData } from '../../interfaces/analyzers/stack-trace-analyzer/ICa
 import { IStackTraceAnalyzer } from '../../interfaces/analyzers/stack-trace-analyzer/IStackTraceAnalyzer';
 import { IStackTraceData } from '../../interfaces/analyzers/stack-trace-analyzer/IStackTraceData';
 
-import { CalleeDataExtractor } from '../../enums/container/stack-trace-analyzer/CalleeDataExtractor';
+import { CalleeDataExtractor } from '../../enums/analyzers/stack-trace-analyzer/CalleeDataExtractor';
 
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -110,7 +110,7 @@ export class StackTraceAnalyzer implements IStackTraceAnalyzer {
     }
 
     /**
-     * @param {Node[]} blockScopeBody
+     * @param {NodeGuards[]} blockScopeBody
      * @returns {IStackTraceData[]}
      */
     private analyzeRecursive (blockScopeBody: ESTree.Node[]): IStackTraceData[] {
@@ -127,7 +127,7 @@ export class StackTraceAnalyzer implements IStackTraceAnalyzer {
 
             estraverse.traverse(blockScopeBodyNode, {
                 enter: (node: ESTree.Node): any => {
-                    if (!Node.isCallExpressionNode(node)) {
+                    if (!NodeGuards.isCallExpressionNode(node)) {
                         return;
                     }
 
@@ -145,7 +145,7 @@ export class StackTraceAnalyzer implements IStackTraceAnalyzer {
 
     /**
      * @param {IStackTraceData[]} stackTraceData
-     * @param {Node[]} blockScopeBody
+     * @param {NodeGuards[]} blockScopeBody
      * @param {CallExpression} callExpressionNode
      */
     private analyzeCallExpressionNode (

src/analyzers/stack-trace-analyzer/callee-data-extractors/FunctionDeclarationCalleeDataExtractor.ts

@@ -6,18 +6,18 @@ import * as ESTree from 'estree';
 import { ICalleeData } from '../../../interfaces/analyzers/stack-trace-analyzer/ICalleeData';
 
 import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
-import { Node } from '../../../node/Node';
+import { NodeGuards } from '../../../node/NodeGuards';
 import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
 export class FunctionDeclarationCalleeDataExtractor extends AbstractCalleeDataExtractor {
     /**
-     * @param {Node[]} blockScopeBody
+     * @param {NodeGuards[]} blockScopeBody
      * @param {Identifier} callee
      * @returns {ICalleeData}
      */
     public extract (blockScopeBody: ESTree.Node[], callee: ESTree.Identifier): ICalleeData | null {
-        if (!Node.isIdentifierNode(callee)) {
+        if (!NodeGuards.isIdentifierNode(callee)) {
             return null;
         }
 
@@ -37,7 +37,7 @@ export class FunctionDeclarationCalleeDataExtractor extends AbstractCalleeDataEx
     }
 
     /**
-     * @param {Node} targetNode
+     * @param {NodeGuards} targetNode
      * @param {string} name
      * @returns {BlockStatement}
      */
@@ -46,7 +46,7 @@ export class FunctionDeclarationCalleeDataExtractor extends AbstractCalleeDataEx
 
         estraverse.traverse(targetNode, {
             enter: (node: ESTree.Node): any => {
-                if (Node.isFunctionDeclarationNode(node) && node.id.name === name) {
+                if (NodeGuards.isFunctionDeclarationNode(node) && node.id.name === name) {
                     calleeBlockStatement = node.body;
 
                     return estraverse.VisitorOption.Break;

src/analyzers/stack-trace-analyzer/callee-data-extractors/FunctionExpressionCalleeDataExtractor.ts

@@ -6,27 +6,27 @@ import * as ESTree from 'estree';
 import { ICalleeData } from '../../../interfaces/analyzers/stack-trace-analyzer/ICalleeData';
 
 import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
-import { Node } from '../../../node/Node';
+import { NodeGuards } from '../../../node/NodeGuards';
 import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
 export class FunctionExpressionCalleeDataExtractor extends AbstractCalleeDataExtractor {
     /**
-     * @param {Node[]} blockScopeBody
+     * @param {NodeGuards[]} blockScopeBody
      * @param {Identifier} callee
      * @returns {ICalleeData}
      */
     public extract (blockScopeBody: ESTree.Node[], callee: ESTree.Identifier): ICalleeData | null {
         let calleeBlockStatement: ESTree.BlockStatement | null = null;
 
-        if (Node.isIdentifierNode(callee)) {
+        if (NodeGuards.isIdentifierNode(callee)) {
             calleeBlockStatement = this.getCalleeBlockStatement(
                 NodeUtils.getBlockScopesOfNode(blockScopeBody[0])[0],
                 callee.name
             );
         }
 
-        if (Node.isFunctionExpressionNode(callee)) {
+        if (NodeGuards.isFunctionExpressionNode(callee)) {
             calleeBlockStatement = callee.body;
         }
 
@@ -41,7 +41,7 @@ export class FunctionExpressionCalleeDataExtractor extends AbstractCalleeDataExt
     }
 
     /**
-     * @param {Node} targetNode
+     * @param {NodeGuards} targetNode
      * @param {string} name
      * @returns {BlockStatement}
      */
@@ -51,9 +51,9 @@ export class FunctionExpressionCalleeDataExtractor extends AbstractCalleeDataExt
         estraverse.traverse(targetNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
                 if (
-                    Node.isFunctionExpressionNode(node) &&
-                    Node.isVariableDeclaratorNode(parentNode) &&
-                    Node.isIdentifierNode(parentNode.id) &&
+                    NodeGuards.isFunctionExpressionNode(node) &&
+                    NodeGuards.isVariableDeclaratorNode(parentNode) &&
+                    NodeGuards.isIdentifierNode(parentNode.id) &&
                     parentNode.id.name === name
                 ) {
                     calleeBlockStatement = node.body;

src/analyzers/stack-trace-analyzer/callee-data-extractors/ObjectExpressionCalleeDataExtractor.ts

@@ -7,19 +7,19 @@ import { TObjectMembersCallsChain } from '../../../types/analyzers/stack-trace-a
 
 import { ICalleeData } from '../../../interfaces/analyzers/stack-trace-analyzer/ICalleeData';
 
-import { Node } from '../../../node/Node';
-import { NodeUtils } from '../../../node/NodeUtils';
 import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
+import { NodeGuards } from '../../../node/NodeGuards';
+import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
 export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtractor {
     /**
-     * @param {Node[]} blockScopeBody
+     * @param {NodeGuards[]} blockScopeBody
      * @param {MemberExpression} callee
      * @returns {ICalleeData}
      */
     public extract (blockScopeBody: ESTree.Node[], callee: ESTree.MemberExpression): ICalleeData | null {
-        if (!Node.isMemberExpressionNode(callee)) {
+        if (!NodeGuards.isMemberExpressionNode(callee)) {
             return null;
         }
 
@@ -59,10 +59,10 @@ export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtra
         memberExpression: ESTree.MemberExpression
     ): TObjectMembersCallsChain {
         // first step: processing memberExpression `property` property
-        if (Node.isIdentifierNode(memberExpression.property) && memberExpression.computed === false) {
+        if (NodeGuards.isIdentifierNode(memberExpression.property) && memberExpression.computed === false) {
             currentChain.unshift(memberExpression.property.name);
         } else if (
-            Node.isLiteralNode(memberExpression.property) &&
+            NodeGuards.isLiteralNode(memberExpression.property) &&
             (
                 typeof memberExpression.property.value === 'string' ||
                 typeof memberExpression.property.value === 'number'
@@ -74,9 +74,9 @@ export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtra
         }
 
         // second step: processing memberExpression `object` property
-        if (Node.isMemberExpressionNode(memberExpression.object)) {
+        if (NodeGuards.isMemberExpressionNode(memberExpression.object)) {
             return this.createObjectMembersCallsChain(currentChain, memberExpression.object);
-        } else if (Node.isIdentifierNode(memberExpression.object)) {
+        } else if (NodeGuards.isIdentifierNode(memberExpression.object)) {
             currentChain.unshift(memberExpression.object.name);
         }
 
@@ -84,7 +84,7 @@ export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtra
     }
 
     /**
-     * @param {Node} targetNode
+     * @param {NodeGuards} targetNode
      * @param {TObjectMembersCallsChain} objectMembersCallsChain
      * @returns {BlockStatement}
      */
@@ -103,10 +103,10 @@ export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtra
         estraverse.traverse(targetNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
                 if (
-                    Node.isVariableDeclaratorNode(node) &&
-                    Node.isIdentifierNode(node.id) &&
+                    NodeGuards.isVariableDeclaratorNode(node) &&
+                    NodeGuards.isIdentifierNode(node.id) &&
                     node.init &&
-                    Node.isObjectExpressionNode(node.init) &&
+                    NodeGuards.isObjectExpressionNode(node.init) &&
                     node.id.name === objectName
                 ) {
                     calleeBlockStatement = this.findCalleeBlockStatement(node.init.properties, objectMembersCallsChain);
@@ -136,9 +136,9 @@ export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtra
 
         for (const propertyNode of objectExpressionProperties) {
             const isTargetPropertyNodeWithIdentifierKey: boolean =
-                Node.isIdentifierNode(propertyNode.key) && propertyNode.key.name === nextItemInCallsChain;
+                NodeGuards.isIdentifierNode(propertyNode.key) && propertyNode.key.name === nextItemInCallsChain;
             const isTargetPropertyNodeWithLiteralKey: boolean =
-                Node.isLiteralNode(propertyNode.key) &&
+                NodeGuards.isLiteralNode(propertyNode.key) &&
                 Boolean(propertyNode.key.value) &&
                 propertyNode.key.value === nextItemInCallsChain;
 
@@ -146,11 +146,11 @@ export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtra
                 continue;
             }
 
-            if (Node.isObjectExpressionNode(propertyNode.value)) {
+            if (NodeGuards.isObjectExpressionNode(propertyNode.value)) {
                 return this.findCalleeBlockStatement(propertyNode.value.properties, objectMembersCallsChain);
             }
 
-            if (Node.isFunctionExpressionNode(propertyNode.value)) {
+            if (NodeGuards.isFunctionExpressionNode(propertyNode.value)) {
                 return propertyNode.value.body;
             }
         }

src/container/InversifyContainerFacade.ts

@@ -3,10 +3,11 @@ import { ServiceIdentifiers } from './ServiceIdentifiers';
 
 import { analyzersModule } from './modules/analyzers/AnalyzersModule';
 import { controlFlowTransformersModule } from './modules/node-transformers/ControlFlowTransformersModule';
+import { convertingTransformersModule } from './modules/node-transformers/ConvertingTransformersModule';
 import { customNodesModule } from './modules/custom-nodes/CustomNodesModule';
-import { nodeGuardsModule } from './modules/node-guards/NodeGuardsModule';
 import { nodeTransformersModule } from './modules/node-transformers/NodeTransformersModule';
 import { obfuscatingTransformersModule } from './modules/node-transformers/ObfuscatingTransformersModule';
+import { preparingTransformersModule } from './modules/node-transformers/PreparingTransformersModule';
 import { storagesModule } from './modules/storages/StoragesModule';
 import { utilsModule } from './modules/utils/UtilsModule';
 
@@ -194,10 +195,11 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
         // modules
         this.container.load(analyzersModule);
         this.container.load(controlFlowTransformersModule);
+        this.container.load(convertingTransformersModule);
         this.container.load(customNodesModule);
-        this.container.load(nodeGuardsModule);
         this.container.load(nodeTransformersModule);
         this.container.load(obfuscatingTransformersModule);
+        this.container.load(preparingTransformersModule);
         this.container.load(storagesModule);
         this.container.load(utilsModule);
     }

src/container/modules/analyzers/AnalyzersModule.ts

@@ -5,7 +5,7 @@ import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 import { ICalleeDataExtractor } from '../../../interfaces/analyzers/stack-trace-analyzer/ICalleeDataExtractor';
 import { IStackTraceAnalyzer } from '../../../interfaces/analyzers/stack-trace-analyzer/IStackTraceAnalyzer';
 
-import { CalleeDataExtractor } from '../../../enums/container/stack-trace-analyzer/CalleeDataExtractor';
+import { CalleeDataExtractor } from '../../../enums/analyzers/stack-trace-analyzer/CalleeDataExtractor';
 import { FunctionDeclarationCalleeDataExtractor } from '../../../analyzers/stack-trace-analyzer/callee-data-extractors/FunctionDeclarationCalleeDataExtractor';
 import { FunctionExpressionCalleeDataExtractor } from '../../../analyzers/stack-trace-analyzer/callee-data-extractors/FunctionExpressionCalleeDataExtractor';
 import { ObjectExpressionCalleeDataExtractor } from '../../../analyzers/stack-trace-analyzer/callee-data-extractors/ObjectExpressionCalleeDataExtractor';

src/container/modules/custom-nodes/CustomNodesModule.ts

@@ -5,9 +5,9 @@ import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
 import { ICustomNodeGroup } from '../../../interfaces/custom-nodes/ICustomNodeGroup';
 
-import { ControlFlowCustomNode } from "../../../enums/container/custom-nodes/ControlFlowCustomNode";
-import { CustomNode } from '../../../enums/container/custom-nodes/CustomNode';
-import { CustomNodeGroup } from '../../../enums/container/custom-nodes/CustomNodeGroup';
+import { ControlFlowCustomNode } from "../../../enums/custom-nodes/ControlFlowCustomNode";
+import { CustomNode } from '../../../enums/custom-nodes/CustomNode';
+import { CustomNodeGroup } from '../../../enums/custom-nodes/CustomNodeGroup';
 
 import { ConsoleOutputCustomNodeGroup } from '../../../custom-nodes/console-output-nodes/group/ConsoleOutputCustomNodeGroup';
 import { DebugProtectionCustomNodeGroup } from '../../../custom-nodes/debug-protection-nodes/group/DebugProtectionCustomNodeGroup';

src/container/modules/node-guards/NodeGuardsModule.ts

@@ -1,30 +0,0 @@
-import { InversifyContainerFacade } from '../../InversifyContainerFacade';
-import { ContainerModule, interfaces } from 'inversify';
-import { ServiceIdentifiers } from '../../ServiceIdentifiers';
-
-import { INodeGuard } from '../../../interfaces/node-guards/INodeGuard';
-
-import { NodeGuard } from '../../../enums/container/node-guards/NodeGuard';
-
-import { BlackListNodeGuard } from '../../../node-guards/BlackListNodeGuard';
-import { ConditionalCommentNodeGuard } from '../../../node-guards/ConditionalCommentNodeGuard';
-
-export const nodeGuardsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    // node guards
-    bind<INodeGuard>(ServiceIdentifiers.INodeGuard)
-        .to(BlackListNodeGuard)
-        .inSingletonScope()
-        .whenTargetNamed(NodeGuard.BlackListNodeGuard);
-
-    bind<INodeGuard>(ServiceIdentifiers.INodeGuard)
-        .to(ConditionalCommentNodeGuard)
-        .inSingletonScope()
-        .whenTargetNamed(NodeGuard.ConditionalCommentNodeGuard);
-
-    // node guards factory
-    bind<INodeGuard>(ServiceIdentifiers.Factory__INodeGuard)
-        .toFactory<INodeGuard>(InversifyContainerFacade
-            .getCacheFactory<NodeGuard, INodeGuard>(
-                ServiceIdentifiers.INodeGuard
-            ));
-});

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

@@ -3,15 +3,34 @@ import { ContainerModule, interfaces } from 'inversify';
 import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 
 import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
 
-import { ControlFlowReplacer } from '../../../enums/container/node-transformers/ControlFlowReplacer';
+import { ControlFlowReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/ControlFlowReplacer';
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
 import { BinaryExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer';
+import { BlockStatementControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer';
 import { CallExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer';
+import { DeadCodeInjectionTransformer } from '../../../node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer';
+import { FunctionControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/FunctionControlFlowTransformer';
 import { LogicalExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer';
 import { StringLiteralControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/StringLiteralControlFlowReplacer';
 
 export const controlFlowTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // control flow transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(BlockStatementControlFlowTransformer)
+        .whenTargetNamed(NodeTransformer.BlockStatementControlFlowTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(DeadCodeInjectionTransformer)
+        .whenTargetNamed(NodeTransformer.DeadCodeInjectionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(FunctionControlFlowTransformer)
+        .whenTargetNamed(NodeTransformer.FunctionControlFlowTransformer);
+
+    // control flow replacers
     bind<IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer)
         .to(BinaryExpressionControlFlowReplacer)
         .whenTargetNamed(ControlFlowReplacer.BinaryExpressionControlFlowReplacer);
@@ -28,6 +47,7 @@ export const controlFlowTransformersModule: interfaces.ContainerModule = new Con
         .to(StringLiteralControlFlowReplacer)
         .whenTargetNamed(ControlFlowReplacer.StringLiteralControlFlowReplacer);
 
+    // control flow replacer factory
     bind<IControlFlowReplacer>(ServiceIdentifiers.Factory__IControlFlowReplacer)
         .toFactory<IControlFlowReplacer>(InversifyContainerFacade
             .getCacheFactory<ControlFlowReplacer, IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer));

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

@@ -0,0 +1,25 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { MemberExpressionTransformer } from '../../../node-transformers/converting-transformers/MemberExpressionTransformer';
+import { MethodDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodDefinitionTransformer';
+import { TemplateLiteralTransformer } from '../../../node-transformers/converting-transformers/TemplateLiteralTransformer';
+
+export const convertingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // converting transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(MemberExpressionTransformer)
+        .whenTargetNamed(NodeTransformer.MemberExpressionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(MethodDefinitionTransformer)
+        .whenTargetNamed(NodeTransformer.MethodDefinitionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(TemplateLiteralTransformer)
+        .whenTargetNamed(NodeTransformer.TemplateLiteralTransformer);
+});

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

@@ -4,95 +4,9 @@ import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 
 import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
 
-import { NodeTransformer } from '../../../enums/container/node-transformers/NodeTransformer';
-
-import { FunctionControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/FunctionControlFlowTransformer';
-
-import { BlockStatementControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer';
-import { DeadCodeInjectionTransformer } from '../../../node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer';
-import { CatchClauseTransformer } from '../../../node-transformers/obfuscating-transformers/CatchClauseTransformer';
-import { ClassDeclarationTransformer } from '../../../node-transformers/obfuscating-transformers/ClassDeclarationTransformer';
-import { FunctionDeclarationTransformer } from '../../../node-transformers/obfuscating-transformers/FunctionDeclarationTransformer';
-import { FunctionTransformer } from '../../../node-transformers/obfuscating-transformers/FunctionTransformer';
-import { LabeledStatementTransformer } from '../../../node-transformers/obfuscating-transformers/LabeledStatementTransformer';
-import { LiteralTransformer } from '../../../node-transformers/obfuscating-transformers/LiteralTransformer';
-import { MemberExpressionTransformer } from '../../../node-transformers/converting-transformers/MemberExpressionTransformer';
-import { MethodDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodDefinitionTransformer';
-import { ObjectExpressionTransformer } from '../../../node-transformers/obfuscating-transformers/ObjectExpressionTransformer';
-import { ParentizeTransformer } from '../../../node-transformers/preparing-transformers/ParentizeTransformer';
-import { TemplateLiteralTransformer } from '../../../node-transformers/converting-transformers/TemplateLiteralTransformer';
-import { VariableDeclarationTransformer } from '../../../node-transformers/obfuscating-transformers/VariableDeclarationTransformer';
-import { NodeGuardTransformer } from '../../../node-transformers/preparing-transformers/NodeGuardTransformer';
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
 export const nodeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    // preparing transformers
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ParentizeTransformer)
-        .whenTargetNamed(NodeTransformer.ParentizeTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(NodeGuardTransformer)
-        .whenTargetNamed(NodeTransformer.NodeGuardTransformer);
-
-    // control flow transformers
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(BlockStatementControlFlowTransformer)
-        .whenTargetNamed(NodeTransformer.BlockStatementControlFlowTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(DeadCodeInjectionTransformer)
-        .whenTargetNamed(NodeTransformer.DeadCodeInjectionTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(FunctionControlFlowTransformer)
-        .whenTargetNamed(NodeTransformer.FunctionControlFlowTransformer);
-
-    // converting transformers
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(MemberExpressionTransformer)
-        .whenTargetNamed(NodeTransformer.MemberExpressionTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(MethodDefinitionTransformer)
-        .whenTargetNamed(NodeTransformer.MethodDefinitionTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(TemplateLiteralTransformer)
-        .whenTargetNamed(NodeTransformer.TemplateLiteralTransformer);
-
-    // obfuscation transformers
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(CatchClauseTransformer)
-        .whenTargetNamed(NodeTransformer.CatchClauseTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ClassDeclarationTransformer)
-        .whenTargetNamed(NodeTransformer.ClassDeclarationTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(FunctionDeclarationTransformer)
-        .whenTargetNamed(NodeTransformer.FunctionDeclarationTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(FunctionTransformer)
-        .whenTargetNamed(NodeTransformer.FunctionTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(LabeledStatementTransformer)
-        .whenTargetNamed(NodeTransformer.LabeledStatementTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(LiteralTransformer)
-        .whenTargetNamed(NodeTransformer.LiteralTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ObjectExpressionTransformer)
-        .whenTargetNamed(NodeTransformer.ObjectExpressionTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(VariableDeclarationTransformer)
-        .whenTargetNamed(NodeTransformer.VariableDeclarationTransformer);
-
     // node transformers factory
     bind<INodeTransformer>(ServiceIdentifiers.Factory__INodeTransformer)
         .toFactory<INodeTransformer>(InversifyContainerFacade

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

@@ -2,18 +2,61 @@ import { InversifyContainerFacade } from '../../InversifyContainerFacade';
 import { ContainerModule, interfaces } from 'inversify';
 import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 
-import { IIdentifierObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
-import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/IObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IObfuscatingReplacer';
 
-import { IdentifierObfuscatingReplacer } from '../../../enums/container/node-transformers/IdentifierObfuscatingReplacer';
-import { LiteralObfuscatingReplacer } from '../../../enums/container/node-transformers/LiteralObfuscatingReplacer';
+import { IdentifierObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
+import { LiteralObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/LiteralObfuscatingReplacer';
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
 import { BaseIdentifierObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/identifier-obfuscating-replacers/BaseIdentifierObfuscatingReplacer';
 import { BooleanLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/BooleanLiteralObfuscatingReplacer';
+import { CatchClauseTransformer } from '../../../node-transformers/obfuscating-transformers/CatchClauseTransformer';
+import { ClassDeclarationTransformer } from '../../../node-transformers/obfuscating-transformers/ClassDeclarationTransformer';
+import { FunctionDeclarationTransformer } from '../../../node-transformers/obfuscating-transformers/FunctionDeclarationTransformer';
+import { FunctionTransformer } from '../../../node-transformers/obfuscating-transformers/FunctionTransformer';
+import { LabeledStatementTransformer } from '../../../node-transformers/obfuscating-transformers/LabeledStatementTransformer';
+import { LiteralTransformer } from '../../../node-transformers/obfuscating-transformers/LiteralTransformer';
 import { NumberLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/NumberLiteralObfuscatingReplacer';
+import { ObjectExpressionTransformer } from '../../../node-transformers/obfuscating-transformers/ObjectExpressionTransformer';
 import { StringLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer';
+import { VariableDeclarationTransformer } from '../../../node-transformers/obfuscating-transformers/VariableDeclarationTransformer';
 
 export const obfuscatingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // obfuscating transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(CatchClauseTransformer)
+        .whenTargetNamed(NodeTransformer.CatchClauseTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ClassDeclarationTransformer)
+        .whenTargetNamed(NodeTransformer.ClassDeclarationTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(FunctionDeclarationTransformer)
+        .whenTargetNamed(NodeTransformer.FunctionDeclarationTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(FunctionTransformer)
+        .whenTargetNamed(NodeTransformer.FunctionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(LabeledStatementTransformer)
+        .whenTargetNamed(NodeTransformer.LabeledStatementTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(LiteralTransformer)
+        .whenTargetNamed(NodeTransformer.LiteralTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ObjectExpressionTransformer)
+        .whenTargetNamed(NodeTransformer.ObjectExpressionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(VariableDeclarationTransformer)
+        .whenTargetNamed(NodeTransformer.VariableDeclarationTransformer);
+
     // literal obfuscating replacers
     bind<IObfuscatingReplacer>(ServiceIdentifiers.IObfuscatingReplacer)
         .to(BooleanLiteralObfuscatingReplacer)

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

@@ -0,0 +1,43 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+import { ObfuscatingGuard } from '../../../enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard';
+
+import { BlackListObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/BlackListObfuscatingGuard';
+import { ConditionalCommentObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard';
+import { ObfuscatingGuardsTransformer } from '../../../node-transformers/preparing-transformers/ObfuscatingGuardsTransformer';
+import { ParentificationTransformer } from '../../../node-transformers/preparing-transformers/ParentificationTransformer';
+
+export const preparingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // preparing transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ObfuscatingGuardsTransformer)
+        .whenTargetNamed(NodeTransformer.ObfuscatingGuardsTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ParentificationTransformer)
+        .whenTargetNamed(NodeTransformer.ParentificationTransformer);
+
+    // obfuscating guards
+    bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
+        .to(BlackListObfuscatingGuard)
+        .inSingletonScope()
+        .whenTargetNamed(ObfuscatingGuard.BlackListNodeGuard);
+
+    bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
+        .to(ConditionalCommentObfuscatingGuard)
+        .inSingletonScope()
+        .whenTargetNamed(ObfuscatingGuard.ConditionalCommentNodeGuard);
+
+    // obfuscating guards factory
+    bind<IObfuscatingGuard>(ServiceIdentifiers.Factory__INodeGuard)
+        .toFactory<IObfuscatingGuard>(InversifyContainerFacade
+            .getCacheFactory<ObfuscatingGuard, IObfuscatingGuard>(
+                ServiceIdentifiers.INodeGuard
+            ));
+});

src/custom-nodes/AbstractCustomNodeGroup.ts

@@ -9,7 +9,7 @@ import { IOptions } from '../interfaces/options/IOptions';
 import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
 import { IStackTraceData } from '../interfaces/analyzers/stack-trace-analyzer/IStackTraceData';
 
-import { CustomNode } from '../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../enums/custom-nodes/CustomNode';
 import { ObfuscationEvent } from '../enums/event-emitters/ObfuscationEvent';
 
 @injectable()

src/custom-nodes/console-output-nodes/group/ConsoleOutputCustomNodeGroup.ts

@@ -12,7 +12,7 @@ import { IStackTraceData } from '../../../interfaces/analyzers/stack-trace-analy
 
 import { initializable } from '../../../decorators/Initializable';
 
-import { CustomNode } from '../../../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../../../enums/custom-nodes/CustomNode';
 import { ObfuscationEvent } from '../../../enums/event-emitters/ObfuscationEvent';
 
 import { AbstractCustomNodeGroup } from '../../AbstractCustomNodeGroup';

src/custom-nodes/debug-protection-nodes/group/DebugProtectionCustomNodeGroup.ts

@@ -12,7 +12,7 @@ import { IStackTraceData } from '../../../interfaces/analyzers/stack-trace-analy
 
 import { initializable } from '../../../decorators/Initializable';
 
-import { CustomNode } from '../../../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../../../enums/custom-nodes/CustomNode';
 import { ObfuscationEvent } from '../../../enums/event-emitters/ObfuscationEvent';
 
 import { AbstractCustomNodeGroup } from '../../AbstractCustomNodeGroup';

src/custom-nodes/domain-lock-nodes/group/DomainLockCustomNodeGroup.ts

@@ -12,7 +12,7 @@ import { IStackTraceData } from '../../../interfaces/analyzers/stack-trace-analy
 
 import { initializable } from '../../../decorators/Initializable';
 
-import { CustomNode } from '../../../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../../../enums/custom-nodes/CustomNode';
 import { ObfuscationEvent } from '../../../enums/event-emitters/ObfuscationEvent';
 
 import { AbstractCustomNodeGroup } from '../../AbstractCustomNodeGroup';

src/custom-nodes/self-defending-nodes/group/SelfDefendingCustomNodeGroup.ts

@@ -12,7 +12,7 @@ import { IStackTraceData } from '../../../interfaces/analyzers/stack-trace-analy
 
 import { initializable } from '../../../decorators/Initializable';
 
-import { CustomNode } from '../../../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../../../enums/custom-nodes/CustomNode';
 import { ObfuscationEvent } from '../../../enums/event-emitters/ObfuscationEvent';
 
 import { AbstractCustomNodeGroup } from '../../AbstractCustomNodeGroup';

src/custom-nodes/string-array-nodes/group/StringArrayCustomNodeGroup.ts

@@ -13,7 +13,7 @@ import { IStorage } from '../../../interfaces/storages/IStorage';
 
 import { initializable } from '../../../decorators/Initializable';
 
-import { CustomNode } from '../../../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../../../enums/custom-nodes/CustomNode';
 import { ObfuscationEvent } from '../../../enums/event-emitters/ObfuscationEvent';
 
 import { AbstractCustomNodeGroup } from '../../AbstractCustomNodeGroup';

src/enums/container/node-transformers/NodeTransformer.ts → src/enums/node-transformers/NodeTransformer.ts

@@ -10,9 +10,9 @@ export enum NodeTransformer {
     LiteralTransformer,
     MemberExpressionTransformer,
     MethodDefinitionTransformer,
-    NodeGuardTransformer,
+    ObfuscatingGuardsTransformer,
     ObjectExpressionTransformer,
-    ParentizeTransformer,
+    ParentificationTransformer,
     TemplateLiteralTransformer,
     VariableDeclarationTransformer
 }

src/enums/container/node-guards/NodeGuard.ts → src/enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard.ts

@@ -1,4 +1,4 @@
-export enum NodeGuard {
+export enum ObfuscatingGuard {
     BlackListNodeGuard,
     ConditionalCommentNodeGuard
 }

src/interfaces/custom-nodes/ICustomNodeGroup.d.ts

@@ -4,7 +4,7 @@ import { ICustomNode } from './ICustomNode';
 import { IInitializable } from '../IInitializable';
 import { IStackTraceData } from '../analyzers/stack-trace-analyzer/IStackTraceData';
 
-import { CustomNode } from '../../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../../enums/custom-nodes/CustomNode';
 import { ObfuscationEvent } from '../../enums/event-emitters/ObfuscationEvent';
 
 export interface ICustomNodeGroup extends IInitializable {

src/interfaces/node-guards/INodeGuard.ts

@@ -1,9 +0,0 @@
-import { TNodeGuard } from '../../types/node/TNodeGuard';
-
-export interface INodeGuard {
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
-    check: TNodeGuard;
-}

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

@@ -1,6 +1,6 @@
 import * as ESTree from 'estree';
 
-import { NodeTransformer } from '../../enums/container/node-transformers/NodeTransformer';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 
 export interface ITransformersRunner {
     /**

src/interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard.ts

@@ -0,0 +1,9 @@
+import { TNodeGuard } from '../../../../types/node/TNodeGuard';
+
+export interface IObfuscatingGuard {
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    check: TNodeGuard;
+}

src/node-transformers/TransformersRunner.ts

@@ -12,10 +12,10 @@ import { TVisitorResult } from '../types/node-transformers/TVisitorResult';
 import { ITransformersRunner } from '../interfaces/node-transformers/ITransformersRunner';
 import { IVisitor } from '../interfaces/node-transformers/IVisitor';
 
-import { NodeTransformer } from '../enums/container/node-transformers/NodeTransformer';
+import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
 import { VisitorDirection } from '../enums/node-transformers/VisitorDirection';
 
-import { Node } from '../node/Node';
+import { NodeGuards } from '../node/NodeGuards';
 
 @injectable()
 export class TransformersRunner implements ITransformersRunner {
@@ -98,7 +98,7 @@ export class TransformersRunner implements ITransformersRunner {
 
                 const visitorResult: TVisitorResult = visitorFunction(node, parentNode);
 
-                if (!visitorResult || !Node.isNode(visitorResult)) {
+                if (!visitorResult || !NodeGuards.isNode(visitorResult)) {
                     continue;
                 }
 

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

@@ -12,10 +12,10 @@ import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { ControlFlowCustomNode } from '../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../enums/custom-nodes/ControlFlowCustomNode';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 @injectable()
 export class BlockStatementControlFlowTransformer extends AbstractNodeTransformer {
@@ -54,11 +54,11 @@ export class BlockStatementControlFlowTransformer extends AbstractNodeTransforme
      */
     private static blockStatementHasProhibitedStatements (blockStatementNode: ESTree.BlockStatement): boolean {
         return blockStatementNode.body.some((statement: ESTree.Statement) => {
-            const isBreakOrContinueStatement: boolean = Node.isBreakStatementNode(statement) || Node.isContinueStatementNode(statement);
-            const isVariableDeclarationWithLetOrConstKind: boolean = Node.isVariableDeclarationNode(statement)
+            const isBreakOrContinueStatement: boolean = NodeGuards.isBreakStatementNode(statement) || NodeGuards.isContinueStatementNode(statement);
+            const isVariableDeclarationWithLetOrConstKind: boolean = NodeGuards.isVariableDeclarationNode(statement)
                 && (statement.kind === 'const' || statement.kind === 'let');
 
-            return Node.isFunctionDeclarationNode(statement) || isBreakOrContinueStatement || isVariableDeclarationWithLetOrConstKind;
+            return NodeGuards.isFunctionDeclarationNode(statement) || isBreakOrContinueStatement || isVariableDeclarationWithLetOrConstKind;
         });
     }
 
@@ -71,12 +71,12 @@ export class BlockStatementControlFlowTransformer extends AbstractNodeTransforme
 
         estraverse.traverse(blockStatementNode, {
             enter: (node: ESTree.Node): any => {
-                if (Node.isWhileStatementNode(node)) {
+                if (NodeGuards.isWhileStatementNode(node)) {
                     return estraverse.VisitorOption.Skip;
                 }
 
                 if (
-                    Node.isBlockStatementNode(node)
+                    NodeGuards.isBlockStatementNode(node)
                     && BlockStatementControlFlowTransformer.blockStatementHasProhibitedStatements(node)
                 ) {
                     canTransform = false;
@@ -97,7 +97,7 @@ export class BlockStatementControlFlowTransformer extends AbstractNodeTransforme
     public getVisitor (): IVisitor {
         return {
             leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isBlockStatementNode(node)) {
+                if (NodeGuards.isBlockStatementNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -106,8 +106,8 @@ export class BlockStatementControlFlowTransformer extends AbstractNodeTransforme
 
     /**
      * @param {BlockStatement} blockStatementNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (blockStatementNode: ESTree.BlockStatement, parentNode: ESTree.Node): ESTree.Node {
         if (

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

@@ -15,13 +15,13 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IStorage } from '../../interfaces/storages/IStorage';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { ControlFlowCustomNode } from '../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../enums/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/ControlFlowReplacer';
 import { NodeType } from '../../enums/node/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 import { NodeAppender } from '../../node/NodeAppender';
-import { ControlFlowReplacer } from '../../enums/container/node-transformers/ControlFlowReplacer';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -107,9 +107,9 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
         return {
             leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
                 if (
-                    Node.isFunctionDeclarationNode(node) ||
-                    Node.isFunctionExpressionNode(node) ||
-                    Node.isArrowFunctionExpressionNode(node)
+                    NodeGuards.isFunctionDeclarationNode(node) ||
+                    NodeGuards.isFunctionExpressionNode(node) ||
+                    NodeGuards.isArrowFunctionExpressionNode(node)
                 ) {
                     return this.transformNode(node, parentNode);
                 }
@@ -119,13 +119,13 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {Function} functionNode
-     * @param {Node} parentNode
+     * @param {NodeGuards} parentNode
      * @returns {Function}
      */
     public transformNode (functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Function {
         this.visitedFunctionNodes.add(functionNode);
 
-        if (!Node.isBlockStatementNode(functionNode.body)) {
+        if (!NodeGuards.isBlockStatementNode(functionNode.body)) {
             return functionNode;
         }
 
@@ -195,14 +195,14 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} node
+     * @param {NodeGuards} node
      * @returns {boolean}
      */
     private isVisitedFunctionNode (node: ESTree.Node): boolean {
         return (
-            Node.isFunctionDeclarationNode(node) ||
-            Node.isFunctionExpressionNode(node) ||
-            Node.isArrowFunctionExpressionNode(node)
+            NodeGuards.isFunctionDeclarationNode(node) ||
+            NodeGuards.isFunctionExpressionNode(node) ||
+            NodeGuards.isArrowFunctionExpressionNode(node)
         ) && this.visitedFunctionNodes.has(node);
     }
 

src/node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.ts

@@ -10,7 +10,7 @@ import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { IStorage } from '../../../interfaces/storages/IStorage';
 
-import { ControlFlowCustomNode } from '../../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
 
 import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
 

src/node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer.ts

@@ -11,10 +11,10 @@ import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { IStorage } from '../../../interfaces/storages/IStorage';
 
-import { ControlFlowCustomNode } from '../../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
 
 import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
-import { Node } from '../../../node/Node';
+import { NodeGuards } from '../../../node/NodeGuards';
 
 @injectable()
 export class CallExpressionControlFlowReplacer extends AbstractControlFlowReplacer {
@@ -39,9 +39,9 @@ export class CallExpressionControlFlowReplacer extends AbstractControlFlowReplac
 
     /**
      * @param {CallExpression} callExpressionNode
-     * @param {Node} parentNode
+     * @param {NodeGuards} parentNode
      * @param {IStorage<ICustomNode>} controlFlowStorage
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     public replace (
         callExpressionNode: ESTree.CallExpression,
@@ -50,7 +50,7 @@ export class CallExpressionControlFlowReplacer extends AbstractControlFlowReplac
     ): ESTree.Node {
         const callee: ESTree.Expression = <ESTree.Expression>callExpressionNode.callee;
 
-        if (!Node.isIdentifierNode(callee)) {
+        if (!NodeGuards.isIdentifierNode(callee)) {
             return callExpressionNode;
         }
 
@@ -82,7 +82,7 @@ export class CallExpressionControlFlowReplacer extends AbstractControlFlowReplac
      * @param {string} storageKey
      * @param {Expression} callee
      * @param {(Expression | SpreadElement)[]} expressionArguments
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     protected getControlFlowStorageCallNode (
         controlFlowStorageId: string,
@@ -98,7 +98,7 @@ export class CallExpressionControlFlowReplacer extends AbstractControlFlowReplac
 
         const statementNode: TStatement = controlFlowStorageCallCustomNode.getNode()[0];
 
-        if (!statementNode || !Node.isExpressionStatementNode(statementNode)) {
+        if (!statementNode || !NodeGuards.isExpressionStatementNode(statementNode)) {
             throw new Error(`\`controlFlowStorageCallCustomNode.getNode()[0]\` should returns array with \`ExpressionStatement\` node`);
         }
 

src/node-transformers/control-flow-transformers/control-flow-replacers/ExpressionWithOperatorControlFlowReplacer.ts

@@ -10,10 +10,10 @@ import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 
-import { ControlFlowCustomNode } from '../../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
 
 import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
-import { Node } from '../../../node/Node';
+import { NodeGuards } from '../../../node/NodeGuards';
 
 @injectable()
 export abstract class ExpressionWithOperatorControlFlowReplacer extends AbstractControlFlowReplacer {
@@ -46,7 +46,7 @@ export abstract class ExpressionWithOperatorControlFlowReplacer extends Abstract
      * @param {string} storageKey
      * @param {Expression} leftExpression
      * @param {Expression} rightExpression
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     protected getControlFlowStorageCallNode (
         controlFlowStorageId: string,
@@ -62,7 +62,7 @@ export abstract class ExpressionWithOperatorControlFlowReplacer extends Abstract
 
         const statementNode: TStatement = controlFlowStorageCallCustomNode.getNode()[0];
 
-        if (!statementNode || !Node.isExpressionStatementNode(statementNode)) {
+        if (!statementNode || !NodeGuards.isExpressionStatementNode(statementNode)) {
             throw new Error(`\`controlFlowStorageCallCustomNode.getNode()[0]\` should returns array with \`ExpressionStatement\` node`);
         }
 

src/node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.ts

@@ -10,10 +10,10 @@ import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { IStorage } from '../../../interfaces/storages/IStorage';
 
-import { ControlFlowCustomNode } from '../../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
 
 import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
-import { Node } from '../../../node/Node';
+import { NodeGuards } from '../../../node/NodeGuards';
 import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
@@ -39,9 +39,9 @@ export class LogicalExpressionControlFlowReplacer extends ExpressionWithOperator
 
     /**
      * @param {LogicalExpression} logicalExpressionNode
-     * @param {Node} parentNode
+     * @param {NodeGuards} parentNode
      * @param {IStorage<ICustomNode>} controlFlowStorage
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     public replace (
         logicalExpressionNode: ESTree.LogicalExpression,
@@ -83,16 +83,16 @@ export class LogicalExpressionControlFlowReplacer extends ExpressionWithOperator
         return [leftExpression, rightExpression].some((expressionNode: ESTree.Node | ESTree.Expression): boolean => {
             let nodeForCheck: ESTree.Node | ESTree.Expression;
 
-            if (!Node.isUnaryExpressionNode(expressionNode)) {
+            if (!NodeGuards.isUnaryExpressionNode(expressionNode)) {
                 nodeForCheck = expressionNode;
             } else {
                 nodeForCheck = NodeUtils.getUnaryExpressionArgumentNode(expressionNode);
             }
 
-            return !Node.isLiteralNode(nodeForCheck) &&
-                !Node.isIdentifierNode(nodeForCheck) &&
-                !Node.isObjectExpressionNode(nodeForCheck) &&
-                !Node.isExpressionStatementNode(nodeForCheck);
+            return !NodeGuards.isLiteralNode(nodeForCheck) &&
+                !NodeGuards.isIdentifierNode(nodeForCheck) &&
+                !NodeGuards.isObjectExpressionNode(nodeForCheck) &&
+                !NodeGuards.isExpressionStatementNode(nodeForCheck);
         });
     }
 }

src/node-transformers/control-flow-transformers/control-flow-replacers/StringLiteralControlFlowReplacer.ts

@@ -11,10 +11,10 @@ import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { IStorage } from '../../../interfaces/storages/IStorage';
 
-import { ControlFlowCustomNode } from '../../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
 
 import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
-import { Node } from '../../../node/Node';
+import { NodeGuards } from '../../../node/NodeGuards';
 
 @injectable()
 export class StringLiteralControlFlowReplacer extends AbstractControlFlowReplacer {
@@ -39,16 +39,16 @@ export class StringLiteralControlFlowReplacer extends AbstractControlFlowReplace
 
     /**
      * @param {Literal} literalNode
-     * @param {Node} parentNode
+     * @param {NodeGuards} parentNode
      * @param {IStorage<ICustomNode>} controlFlowStorage
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     public replace (
         literalNode: ESTree.Literal,
         parentNode: ESTree.Node,
         controlFlowStorage: IStorage <ICustomNode>
     ): ESTree.Node {
-        if (Node.isPropertyNode(parentNode) && parentNode.key === literalNode) {
+        if (NodeGuards.isPropertyNode(parentNode) && parentNode.key === literalNode) {
             return literalNode;
         }
 
@@ -76,7 +76,7 @@ export class StringLiteralControlFlowReplacer extends AbstractControlFlowReplace
     /**
      * @param {string} controlFlowStorageId
      * @param {string} storageKey
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     protected getControlFlowStorageCallNode (
         controlFlowStorageId: string,
@@ -90,7 +90,7 @@ export class StringLiteralControlFlowReplacer extends AbstractControlFlowReplace
 
         const statementNode: TStatement = controlFlowStorageCallCustomNode.getNode()[0];
 
-        if (!statementNode || !Node.isExpressionStatementNode(statementNode)) {
+        if (!statementNode || !NodeGuards.isExpressionStatementNode(statementNode)) {
             throw new Error(`\`controlFlowStorageCallCustomNode.getNode()[0]\` should returns array with \`ExpressionStatement\` node`);
         }
 

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

@@ -10,7 +10,7 @@ import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { NodeType } from '../../enums/node/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 @injectable()
 export class MemberExpressionTransformer extends AbstractNodeTransformer {
@@ -31,7 +31,7 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isMemberExpressionNode(node)) {
+                if (NodeGuards.isMemberExpressionNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -51,11 +51,11 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
      * Literal node will be obfuscated by LiteralTransformer
      *
      * @param {MemberExpression} memberExpressionNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (memberExpressionNode: ESTree.MemberExpression, parentNode: ESTree.Node): ESTree.Node {
-        if (Node.isIdentifierNode(memberExpressionNode.property)) {
+        if (NodeGuards.isIdentifierNode(memberExpressionNode.property)) {
             if (memberExpressionNode.computed) {
                 return memberExpressionNode;
             }

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

@@ -10,7 +10,7 @@ import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { NodeType } from '../../enums/node/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 /**
  * replaces:
@@ -45,7 +45,7 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isMethodDefinitionNode(node)) {
+                if (NodeGuards.isMethodDefinitionNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -64,12 +64,12 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
      * Literal node will be obfuscated by LiteralTransformer
      *
      * @param {MethodDefinition} methodDefinitionNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
         if (
-            Node.isIdentifierNode(methodDefinitionNode.key) &&
+            NodeGuards.isIdentifierNode(methodDefinitionNode.key) &&
             !MethodDefinitionTransformer.ignoredNames.includes(methodDefinitionNode.key.name) &&
             methodDefinitionNode.computed === false
         ) {

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

@@ -8,7 +8,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 import { Nodes } from '../../node/Nodes';
 
 /**
@@ -29,11 +29,11 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} node
+     * @param {NodeGuards} node
      * @returns {boolean}
      */
     private static isLiteralNodeWithStringValue (node: ESTree.Node): boolean {
-        return node && Node.isLiteralNode(node) && typeof node.value === 'string';
+        return node && NodeGuards.isLiteralNode(node) && typeof node.value === 'string';
     }
 
     /**
@@ -42,7 +42,7 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isTemplateLiteralNode(node)) {
+                if (NodeGuards.isTemplateLiteralNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -51,8 +51,8 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {TemplateLiteral} templateLiteralNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
         const templateLiteralExpressions: ESTree.Expression[] = templateLiteralNode.expressions;
@@ -72,7 +72,7 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
         });
 
         nodes = nodes.filter((node: ESTree.Literal | ESTree.Expression) => {
-            return !(Node.isLiteralNode(node) && node.value === '');
+            return !(NodeGuards.isLiteralNode(node) && node.value === '');
         });
 
         // since `+` is left-to-right associative

src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.ts

@@ -9,7 +9,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 import { Nodes } from '../../node/Nodes';
 import { NodeUtils } from '../../node/NodeUtils';
 
@@ -52,14 +52,14 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isProgramNode(node)) {
+                if (NodeGuards.isProgramNode(node)) {
                     this.analyzeNode(node, parentNode);
 
                     return node;
                 }
             },
             leave: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isBlockStatementNode(node)) {
+                if (NodeGuards.isBlockStatementNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -67,13 +67,13 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} programNode
-     * @param {Node} parentNode
+     * @param {NodeGuards} programNode
+     * @param {NodeGuards} parentNode
      */
     public analyzeNode (programNode: ESTree.Node, parentNode: ESTree.Node): void {
         estraverse.traverse(programNode, {
             enter: (node: ESTree.Node): any => {
-                if (Node.isBlockStatementNode(node)) {
+                if (NodeGuards.isBlockStatementNode(node)) {
                     this.collectBlockStatementNodes(node, this.collectedBlockStatements);
                 }
             }
@@ -84,8 +84,8 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {BlockStatement} blockStatementNode
-     * @param {Node} parentNode
-     * @returns {Node | VisitorOption}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards | VisitorOption}
      */
     public transformNode (
         blockStatementNode: ESTree.BlockStatement,
@@ -133,7 +133,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
                 /**
                  * First step: count nested block statements in current block statement
                  */
-                if (Node.isBlockStatementNode(node)) {
+                if (NodeGuards.isBlockStatementNode(node)) {
                     nestedBlockStatementsCount++;
                 }
 
@@ -143,8 +143,8 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
                  */
                 if (
                     nestedBlockStatementsCount > DeadCodeInjectionTransformer.maxNestedBlockStatementsCount ||
-                    Node.isBreakStatementNode(node) ||
-                    Node.isContinueStatementNode(node)
+                    NodeGuards.isBreakStatementNode(node) ||
+                    NodeGuards.isContinueStatementNode(node)
                 ) {
                     isValidBlockStatementNode = false;
 
@@ -155,7 +155,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
                  * Second step: rename all identifiers (except identifiers in member expressions)
                  * in current block statement
                  */
-                if (Node.isIdentifierNode(node) && !Node.isMemberExpressionNode(parentNode)) {
+                if (NodeGuards.isIdentifierNode(node) && !NodeGuards.isMemberExpressionNode(parentNode)) {
                     node.name = this.randomGenerator.getRandomVariableName(6);
                 }
 

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

@@ -6,15 +6,15 @@ import * as ESTree from 'estree';
 
 import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from '../../enums/container/node-transformers/IdentifierObfuscatingReplacer';
+import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 /**
  * replaces:
@@ -55,7 +55,7 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isCatchClauseNode(node)) {
+                if (NodeGuards.isCatchClauseNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -64,8 +64,8 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {CatchClause} catchClauseNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (catchClauseNode: ESTree.CatchClause, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
@@ -81,7 +81,7 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
      * @param {number} nodeIdentifier
      */
     private storeCatchClauseParam (catchClauseNode: ESTree.CatchClause, nodeIdentifier: number): void {
-        if (Node.isIdentifierNode(catchClauseNode.param)) {
+        if (NodeGuards.isIdentifierNode(catchClauseNode.param)) {
             this.identifierObfuscatingReplacer.storeNames(catchClauseNode.param.name, nodeIdentifier);
         }
     }
@@ -93,7 +93,7 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
     private replaceCatchClauseParam (catchClauseNode: ESTree.CatchClause, nodeIdentifier: number): void {
         estraverse.replace(catchClauseNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (Node.isReplaceableIdentifierNode(node, parentNode)) {
+                if (NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer.replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 

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

@@ -7,16 +7,16 @@ import * as ESTree from 'estree';
 import { TIdentifierObfuscatingReplacerFactory } from "../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory";
 import { TNodeWithBlockStatement } from '../../types/node/TNodeWithBlockStatement';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from "../../enums/container/node-transformers/IdentifierObfuscatingReplacer";
+import { IdentifierObfuscatingReplacer } from "../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer";
 import { NodeType } from '../../enums/node/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -64,7 +64,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isClassDeclarationNode(node)) {
+                if (NodeGuards.isClassDeclarationNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -73,8 +73,8 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {ClassDeclaration} classDeclarationNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (classDeclarationNode: ESTree.ClassDeclaration, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
@@ -106,7 +106,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} scopeNode
+     * @param {NodeGuards} scopeNode
      * @param {number} nodeIdentifier
      */
     private replaceScopeCachedIdentifiers (scopeNode: ESTree.Node, nodeIdentifier: number): void {
@@ -120,7 +120,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} scopeNode
+     * @param {NodeGuards} scopeNode
      * @param {number} nodeIdentifier
      */
     private replaceScopeIdentifiers (scopeNode: ESTree.Node, nodeIdentifier: number): void {
@@ -128,7 +128,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(scopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (Node.isReplaceableIdentifierNode(node, parentNode)) {
+                if (NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer.replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 

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

@@ -7,16 +7,16 @@ import * as ESTree from 'estree';
 import { TIdentifierObfuscatingReplacerFactory } from "../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory";
 import { TNodeWithBlockStatement } from '../../types/node/TNodeWithBlockStatement';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from "../../enums/container/node-transformers/IdentifierObfuscatingReplacer";
+import { IdentifierObfuscatingReplacer } from "../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer";
 import { NodeType } from '../../enums/node/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -64,7 +64,7 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isFunctionDeclarationNode(node)) {
+                if (NodeGuards.isFunctionDeclarationNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -73,8 +73,8 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {FunctionDeclaration} functionDeclarationNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (functionDeclarationNode: ESTree.FunctionDeclaration, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
@@ -106,7 +106,7 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} scopeNode
+     * @param {NodeGuards} scopeNode
      * @param {number} nodeIdentifier
      */
     private replaceScopeCachedIdentifiers (scopeNode: ESTree.Node, nodeIdentifier: number): void {
@@ -120,7 +120,7 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} scopeNode
+     * @param {NodeGuards} scopeNode
      * @param {number} nodeIdentifier
      */
     private replaceScopeIdentifiers (scopeNode: ESTree.Node, nodeIdentifier: number): void {
@@ -128,7 +128,7 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(scopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (Node.isReplaceableIdentifierNode(node, parentNode)) {
+                if (NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer.replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 

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

@@ -6,15 +6,15 @@ import * as ESTree from 'estree';
 
 import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from '../../enums/container/node-transformers/IdentifierObfuscatingReplacer';
+import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 /**
  * replaces:
@@ -56,9 +56,9 @@ export class FunctionTransformer extends AbstractNodeTransformer {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
                 if (
-                    Node.isFunctionDeclarationNode(node) ||
-                    Node.isFunctionExpressionNode(node) ||
-                    Node.isArrowFunctionExpressionNode(node)
+                    NodeGuards.isFunctionDeclarationNode(node) ||
+                    NodeGuards.isFunctionExpressionNode(node) ||
+                    NodeGuards.isArrowFunctionExpressionNode(node)
                 ) {
                     return this.transformNode(node, parentNode);
                 }
@@ -68,8 +68,8 @@ export class FunctionTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {Function} functionNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
@@ -87,19 +87,19 @@ export class FunctionTransformer extends AbstractNodeTransformer {
     private storeFunctionParams (functionNode: ESTree.Function, nodeIdentifier: number): void {
         functionNode.params
             .forEach((paramsNode: ESTree.Node) => {
-                if (Node.isObjectPatternNode(paramsNode)) {
+                if (NodeGuards.isObjectPatternNode(paramsNode)) {
                     return estraverse.VisitorOption.Skip;
                 }
 
                 estraverse.traverse(paramsNode, {
                     enter: (node: ESTree.Node): any => {
-                        if (Node.isAssignmentPatternNode(node) && Node.isIdentifierNode(node.left)) {
+                        if (NodeGuards.isAssignmentPatternNode(node) && NodeGuards.isIdentifierNode(node.left)) {
                             this.identifierObfuscatingReplacer.storeNames(node.left.name, nodeIdentifier);
 
                             return estraverse.VisitorOption.Skip;
                         }
 
-                        if (Node.isIdentifierNode(node)) {
+                        if (NodeGuards.isIdentifierNode(node)) {
                             this.identifierObfuscatingReplacer.storeNames(node.name, nodeIdentifier);
                         }
                     }
@@ -114,7 +114,7 @@ export class FunctionTransformer extends AbstractNodeTransformer {
     private replaceFunctionParams (functionNode: ESTree.Function, nodeIdentifier: number): void {
         const replaceVisitor: estraverse.Visitor = {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (Node.isReplaceableIdentifierNode(node, parentNode)) {
+                if (NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer.replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 

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

@@ -6,15 +6,15 @@ import * as ESTree from 'estree';
 
 import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from '../../enums/container/node-transformers/IdentifierObfuscatingReplacer';
+import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 /**
  * replaces:
@@ -63,7 +63,7 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isLabeledStatementNode(node)) {
+                if (NodeGuards.isLabeledStatementNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -72,8 +72,8 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {LabeledStatement} labeledStatementNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (labeledStatementNode: ESTree.LabeledStatement, parentNode: ESTree.Node): ESTree.Node {
         const nodeIdentifier: number = this.nodeIdentifier++;
@@ -99,7 +99,7 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
     private replaceLabeledStatementName (labeledStatementNode: ESTree.LabeledStatement, nodeIdentifier: number): void {
         estraverse.replace(labeledStatementNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (Node.isLabelIdentifierNode(node, parentNode)) {
+                if (NodeGuards.isLabelIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer.replace(node.name, nodeIdentifier);
 
                     node.name = newIdentifier.name;

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

@@ -9,10 +9,10 @@ import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { LiteralObfuscatingReplacer } from '../../enums/container/node-transformers/LiteralObfuscatingReplacer';
+import { LiteralObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/LiteralObfuscatingReplacer';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 @injectable()
 export class LiteralTransformer extends AbstractNodeTransformer {
@@ -43,7 +43,7 @@ export class LiteralTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isLiteralNode(node) && !node.obfuscatedNode) {
+                if (NodeGuards.isLiteralNode(node) && !node.obfuscatedNode) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -52,11 +52,11 @@ export class LiteralTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {Literal} literalNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
-        if (Node.isPropertyNode(parentNode) && parentNode.key === literalNode) {
+        if (NodeGuards.isPropertyNode(parentNode) && parentNode.key === literalNode) {
             return literalNode;
         }
 

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

@@ -10,7 +10,7 @@ import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { NodeType } from '../../enums/node/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 
 /**
  * replaces:
@@ -50,7 +50,7 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isObjectExpressionNode(node)) {
+                if (NodeGuards.isObjectExpressionNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -59,8 +59,8 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
         objectExpressionNode.properties
@@ -69,7 +69,7 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
                     property.shorthand = false;
                 }
 
-                if (Node.isIdentifierNode(property.key)) {
+                if (NodeGuards.isIdentifierNode(property.key)) {
                     property.key = ObjectExpressionTransformer.transformIdentifierPropertyKey(property.key);
                 }
             });

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

@@ -7,16 +7,16 @@ import * as ESTree from 'estree';
 import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 import { TNodeWithBlockStatement } from '../../types/node/TNodeWithBlockStatement';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from "../../enums/container/node-transformers/IdentifierObfuscatingReplacer";
+import { IdentifierObfuscatingReplacer } from "../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer";
 import { NodeType } from '../../enums/node/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { Node } from '../../node/Node';
+import { NodeGuards } from '../../node/NodeGuards';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -65,7 +65,7 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
     public getVisitor (): IVisitor {
         return {
             enter: (node: ESTree.Node, parentNode: ESTree.Node) => {
-                if (Node.isVariableDeclarationNode(node)) {
+                if (NodeGuards.isVariableDeclarationNode(node)) {
                     return this.transformNode(node, parentNode);
                 }
             }
@@ -74,8 +74,8 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {VariableDeclaration} variableDeclarationNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
     public transformNode (variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): ESTree.Node {
         const blockScopeOfVariableDeclarationNode: TNodeWithBlockStatement = NodeUtils
@@ -109,7 +109,7 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
     private storeVariableNames (variableDeclarationNode: ESTree.VariableDeclaration, nodeIdentifier: number): void {
         variableDeclarationNode.declarations
             .forEach((declarationNode: ESTree.VariableDeclarator) => {
-                if (Node.isObjectPatternNode(declarationNode.id)) {
+                if (NodeGuards.isObjectPatternNode(declarationNode.id)) {
                     return estraverse.VisitorOption.Skip;
                 }
 
@@ -120,7 +120,7 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} scopeNode
+     * @param {NodeGuards} scopeNode
      * @param {number} nodeIdentifier
      */
     private replaceScopeCachedIdentifiers (scopeNode: ESTree.Node, nodeIdentifier: number): void {
@@ -134,7 +134,7 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Node} scopeNode
+     * @param {NodeGuards} scopeNode
      * @param {number} nodeIdentifier
      */
     private replaceScopeIdentifiers (scopeNode: ESTree.Node, nodeIdentifier: number): void {
@@ -142,7 +142,7 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(scopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (!node.obfuscatedNode && Node.isReplaceableIdentifierNode(node, parentNode)) {
+                if (!node.obfuscatedNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer.replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 

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

@@ -3,7 +3,7 @@ import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 
 import * as ESTree from 'estree';
 
-import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/IObfuscatingReplacer';
+import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IObfuscatingReplacer';
 import { IOptions } from '../../../interfaces/options/IOptions';
 
 @injectable()

src/node-transformers/obfuscating-transformers/obfuscating-replacers/identifier-obfuscating-replacers/BaseIdentifierObfuscatingReplacer.ts

@@ -3,7 +3,7 @@ import { ServiceIdentifiers } from '../../../../container/ServiceIdentifiers';
 
 import * as ESTree from 'estree';
 
-import { IIdentifierObfuscatingReplacer } from '../../../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../../interfaces/utils/IRandomGenerator';
 

src/node-transformers/preparing-transformers/NodeGuardTransformer.ts → src/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.ts

@@ -3,47 +3,48 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
 import * as ESTree from 'estree';
 
+import { TObfuscatingGuardFactory } from '../../types/container/node-transformers/TObfuscatingGuardFactory';
+
+import { IObfuscatingGuard } from '../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { NodeGuard } from '../../enums/container/node-guards/NodeGuard';
+import { ObfuscatingGuard } from '../../enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { TNodeGuardFactory } from '../../types/container/node-guards/TNodeGuardFactory';
-import { INodeGuard } from '../../interfaces/node-guards/INodeGuard';
 
 /**
- * Adds `parentNode` properties to each node
+ * Adds `ignoredNode` properties to each node
  */
 @injectable()
-export class NodeGuardTransformer extends AbstractNodeTransformer {
+export class ObfuscatingGuardsTransformer extends AbstractNodeTransformer {
     /**
-     * @type {NodeGuard[]}
+     * @type {ObfuscatingGuard[]}
      */
-    private static readonly nodeGuardsList: NodeGuard[] = [
-        NodeGuard.BlackListNodeGuard,
-        NodeGuard.ConditionalCommentNodeGuard
+    private static readonly obfuscatingGuardsList: ObfuscatingGuard[] = [
+        ObfuscatingGuard.BlackListNodeGuard,
+        ObfuscatingGuard.ConditionalCommentNodeGuard
     ];
 
     /**
-     * @type {INodeGuard[]}
+     * @type {IObfuscatingGuard[]}
      */
-    private readonly nodeGuards: INodeGuard[];
+    private readonly obfuscatingGuards: IObfuscatingGuard[];
 
     /**
-     * @param {TNodeGuardFactory} nodeGuardFactory
+     * @param {TObfuscatingGuardFactory} obfuscatingGuardFactory
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      */
     constructor (
-        @inject(ServiceIdentifiers.Factory__INodeGuard) nodeGuardFactory: TNodeGuardFactory,
+        @inject(ServiceIdentifiers.Factory__INodeGuard) obfuscatingGuardFactory: TObfuscatingGuardFactory,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(randomGenerator, options);
 
-        this.nodeGuards = NodeGuardTransformer.nodeGuardsList.map(nodeGuardFactory);
+        this.obfuscatingGuards = ObfuscatingGuardsTransformer.obfuscatingGuardsList.map(obfuscatingGuardFactory);
     }
 
     /**
@@ -63,7 +64,7 @@ export class NodeGuardTransformer extends AbstractNodeTransformer {
      * @returns {Node}
      */
     public transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node {
-        const obfuscationAllowed: boolean = this.nodeGuards.every((nodeGuard: INodeGuard) => nodeGuard.check(node));
+        const obfuscationAllowed: boolean = this.obfuscatingGuards.every((nodeGuard: IObfuscatingGuard) => nodeGuard.check(node));
 
         node.ignoredNode = !obfuscationAllowed;
 

src/node-transformers/preparing-transformers/ParentizeTransformer.ts → src/node-transformers/preparing-transformers/ParentificationTransformer.ts

@@ -13,7 +13,7 @@ import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
  * Adds `parentNode` properties to each node
  */
 @injectable()
-export class ParentizeTransformer extends AbstractNodeTransformer {
+export class ParentificationTransformer extends AbstractNodeTransformer {
     /**
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options

src/node-guards/BlackListNodeGuard.ts → src/node-transformers/preparing-transformers/obfuscating-guards/BlackListObfuscatingGuard.ts

@@ -2,19 +2,19 @@ import { injectable } from 'inversify';
 
 import * as ESTree from 'estree';
 
-import { TNodeGuard } from '../types/node/TNodeGuard';
+import { TNodeGuard } from '../../../types/node/TNodeGuard';
 
-import { INodeGuard } from '../interfaces/node-guards/INodeGuard';
+import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
 
-import { Node } from '../node/Node';
+import { NodeGuards } from '../../../node/NodeGuards';
 
 @injectable()
-export class BlackListNodeGuard implements INodeGuard {
+export class BlackListObfuscatingGuard implements IObfuscatingGuard {
     /**
      * @type {((node: Node) => boolean)[]}
      */
     private static readonly blackListGuards: TNodeGuard[] = [
-        Node.isUseStrictOperator
+        NodeGuards.isUseStrictOperator
     ];
 
     /**
@@ -23,7 +23,7 @@ export class BlackListNodeGuard implements INodeGuard {
     private readonly blackListGuardsLength: number;
 
     constructor () {
-        this.blackListGuardsLength = BlackListNodeGuard.blackListGuards.length;
+        this.blackListGuardsLength = BlackListObfuscatingGuard.blackListGuards.length;
     }
 
     /**
@@ -32,7 +32,7 @@ export class BlackListNodeGuard implements INodeGuard {
      */
     public check (node: ESTree.Node): boolean {
         for (let i: number = 0; i < this.blackListGuardsLength; i++) {
-            if (BlackListNodeGuard.blackListGuards[i](node)) {
+            if (BlackListObfuscatingGuard.blackListGuards[i](node)) {
                 return false;
             }
         }

src/node-guards/ConditionalCommentNodeGuard.ts → src/node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard.ts

@@ -2,10 +2,10 @@ import { injectable } from 'inversify';
 
 import * as ESTree from 'estree';
 
-import { INodeGuard } from '../interfaces/node-guards/INodeGuard';
+import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
 
 @injectable()
-export class ConditionalCommentNodeGuard implements INodeGuard {
+export class ConditionalCommentObfuscatingGuard implements IObfuscatingGuard {
     /**
      * @type {RegExp}
      */
@@ -66,13 +66,13 @@ export class ConditionalCommentNodeGuard implements INodeGuard {
         for (let i: number = 0; i < commentsLength; i++) {
             const comment: ESTree.Comment = comments[i];
 
-            if (ConditionalCommentNodeGuard.obfuscationEnableCommentRegExp.test(comment.value)) {
+            if (ConditionalCommentObfuscatingGuard.obfuscationEnableCommentRegExp.test(comment.value)) {
                 obfuscationAllowed = true;
 
                 continue;
             }
 
-            if (ConditionalCommentNodeGuard.obfuscationDisableCommentRegExp.test(comment.value)) {
+            if (ConditionalCommentObfuscatingGuard.obfuscationDisableCommentRegExp.test(comment.value)) {
                 obfuscationAllowed = false;
             }
         }

src/node/Node.ts → src/node/NodeGuards.ts

@@ -4,7 +4,7 @@ import { TNodeWithBlockStatement } from '../types/node/TNodeWithBlockStatement';
 
 import { NodeType } from '../enums/node/NodeType';
 
-export class Node {
+export class NodeGuards {
     /**
      * @param {Node} node
      * @returns {boolean}
@@ -115,9 +115,9 @@ export class Node {
      * @returns {boolean}
      */
     public static isLabelIdentifierNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
-        const parentNodeIsLabeledStatementNode: boolean = Node.isLabeledStatementNode(parentNode) && parentNode.label === node;
-        const parentNodeIsContinueStatementNode: boolean = Node.isContinueStatementNode(parentNode) && parentNode.label === node;
-        const parentNodeIsBreakStatementNode: boolean = Node.isBreakStatementNode(parentNode) && parentNode.label === node;
+        const parentNodeIsLabeledStatementNode: boolean = NodeGuards.isLabeledStatementNode(parentNode) && parentNode.label === node;
+        const parentNodeIsContinueStatementNode: boolean = NodeGuards.isContinueStatementNode(parentNode) && parentNode.label === node;
+        const parentNodeIsBreakStatementNode: boolean = NodeGuards.isBreakStatementNode(parentNode) && parentNode.label === node;
 
         return parentNodeIsLabeledStatementNode || parentNodeIsContinueStatementNode || parentNodeIsBreakStatementNode;
     }
@@ -208,18 +208,18 @@ export class Node {
      * @returns {boolean}
      */
     public static isReplaceableIdentifierNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
-        if (!Node.isIdentifierNode(node)) {
+        if (!NodeGuards.isIdentifierNode(node)) {
             return false;
         }
 
-        const parentNodeIsPropertyNode: boolean = Node.isPropertyNode(parentNode) && parentNode.key === node;
+        const parentNodeIsPropertyNode: boolean = NodeGuards.isPropertyNode(parentNode) && parentNode.key === node;
         const parentNodeIsMemberExpressionNode: boolean = (
-            Node.isMemberExpressionNode(parentNode) &&
+            NodeGuards.isMemberExpressionNode(parentNode) &&
             parentNode.computed === false &&
             parentNode.property === node
         );
 
-        return !parentNodeIsPropertyNode && !parentNodeIsMemberExpressionNode && !Node.isLabelIdentifierNode(node, parentNode);
+        return !parentNodeIsPropertyNode && !parentNodeIsMemberExpressionNode && !NodeGuards.isLabelIdentifierNode(node, parentNode);
     }
 
     /**

src/node/NodeUtils.ts

@@ -8,7 +8,7 @@ import { TStatement } from '../types/node/TStatement';
 
 import { NodeType } from '../enums/node/NodeType';
 
-import { Node } from './Node';
+import { NodeGuards } from './NodeGuards';
 
 export class NodeUtils {
     /**
@@ -96,7 +96,7 @@ export class NodeUtils {
     }
 
     /**
-     * @param {Node[]} structure
+     * @param {NodeGuards[]} structure
      * @returns {string}
      */
     public static convertStructureToCode (structure: ESTree.Node[]): string {
@@ -112,12 +112,12 @@ export class NodeUtils {
     }
 
     /**
-     * @param {Node} node
+     * @param {NodeGuards} node
      * @param {number} index
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     public static getBlockStatementNodeByIndex (node: ESTree.Node, index: number = 0): ESTree.Node {
-        if (Node.isNodeHasBlockStatement(node)) {
+        if (NodeGuards.isNodeHasBlockStatement(node)) {
             if (node.body[index] === undefined) {
                 throw new ReferenceError(`Wrong index \`${index}\`. Block-statement body length is \`${node.body.length}\``);
             }
@@ -129,7 +129,7 @@ export class NodeUtils {
     }
 
     /**
-     * @param {Node} node
+     * @param {NodeGuards} node
      * @param {TNodeWithBlockStatement[]} blockScopes
      * @returns {TNodeWithBlockStatement[]}
      */
@@ -140,7 +140,7 @@ export class NodeUtils {
             throw new ReferenceError('`parentNode` property of given node is `undefined`');
         }
 
-        if (Node.isBlockStatementNode(parentNode)) {
+        if (NodeGuards.isBlockStatementNode(parentNode)) {
             if (!parentNode.parentNode) {
                 throw new ReferenceError('`parentNode` property of `parentNode` of given node is `undefined`');
             }
@@ -154,7 +154,7 @@ export class NodeUtils {
             return NodeUtils.getBlockScopesOfNode(parentNode, blockScopes);
         }
 
-        if (Node.isNodeHasBlockStatement(parentNode)) {
+        if (NodeGuards.isNodeHasBlockStatement(parentNode)) {
             blockScopes.push(parentNode);
         }
 
@@ -162,7 +162,7 @@ export class NodeUtils {
     }
 
     /**
-     * @param {Node} node
+     * @param {NodeGuards} node
      * @param {number} depth
      * @returns {number}
      */
@@ -173,11 +173,11 @@ export class NodeUtils {
             throw new ReferenceError('`parentNode` property of given node is `undefined`');
         }
 
-        if (Node.isProgramNode(parentNode)) {
+        if (NodeGuards.isProgramNode(parentNode)) {
             return depth;
         }
 
-        if (Node.isBlockStatementNode(node) && NodeUtils.nodesWithBlockScope.includes(parentNode.type)) {
+        if (NodeGuards.isBlockStatementNode(node) && NodeUtils.nodesWithBlockScope.includes(parentNode.type)) {
             return NodeUtils.getNodeBlockScopeDepth(parentNode, ++depth);
         }
 
@@ -186,10 +186,10 @@ export class NodeUtils {
 
     /**
      * @param {UnaryExpression} unaryExpressionNode
-     * @returns {Node}
+     * @returns {NodeGuards}
      */
     public static getUnaryExpressionArgumentNode (unaryExpressionNode: ESTree.UnaryExpression): ESTree.Node {
-        if (Node.isUnaryExpressionNode(unaryExpressionNode.argument)) {
+        if (NodeGuards.isUnaryExpressionNode(unaryExpressionNode.argument)) {
             return NodeUtils.getUnaryExpressionArgumentNode(unaryExpressionNode.argument);
         }
 
@@ -212,7 +212,7 @@ export class NodeUtils {
     }
 
     /**
-     * @param {Node} astTree
+     * @param {NodeGuards} astTree
      * @param {string} nodeType
      * @param {visitor} visitor
      */
@@ -225,7 +225,7 @@ export class NodeUtils {
     }
 
     /**
-     * @param {Node} astTree
+     * @param {NodeGuards} astTree
      * @param {string} nodeType
      * @param {Visitor} visitor
      * @param {string} traverseType

src/storages/custom-node-group/CustomNodeGroupStorage.ts

@@ -7,7 +7,7 @@ import { ICustomNodeGroup } from '../../interfaces/custom-nodes/ICustomNodeGroup
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 
-import { CustomNodeGroup } from '../../enums/container/custom-nodes/CustomNodeGroup';
+import { CustomNodeGroup } from '../../enums/custom-nodes/CustomNodeGroup';
 
 import { MapStorage } from '../MapStorage';
 

src/types/container/custom-nodes/TControlFlowCustomNodeFactory.d.ts

@@ -1,5 +1,5 @@
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
 
-import { ControlFlowCustomNode } from '../../../enums/container/custom-nodes/ControlFlowCustomNode';
+import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
 
 export type TControlFlowCustomNodeFactory = (controlFlowCustomNodeName: ControlFlowCustomNode) => ICustomNode;

src/types/container/custom-nodes/TCustomNodeFactory.d.ts

@@ -1,5 +1,5 @@
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
 
-import { CustomNode } from '../../../enums/container/custom-nodes/CustomNode';
+import { CustomNode } from '../../../enums/custom-nodes/CustomNode';
 
 export type TCustomNodeFactory = (customNodeName: CustomNode) => ICustomNode;

src/types/container/custom-nodes/TCustomNodeGroupFactory.d.ts

@@ -1,5 +1,5 @@
 import { ICustomNodeGroup } from '../../../interfaces/custom-nodes/ICustomNodeGroup';
 
-import { CustomNodeGroup } from '../../../enums/container/custom-nodes/CustomNodeGroup';
+import { CustomNodeGroup } from '../../../enums/custom-nodes/CustomNodeGroup';
 
 export type TCustomNodeGroupFactory = (customNodeGroupName: CustomNodeGroup) => ICustomNodeGroup;

src/types/container/node-guards/TNodeGuardFactory.d.ts

@@ -1,5 +0,0 @@
-import { INodeGuard } from '../../../interfaces/node-guards/INodeGuard';
-
-import { NodeGuard } from '../../../enums/container/node-guards/NodeGuard';
-
-export type TNodeGuardFactory = (nodeGuard: NodeGuard) => INodeGuard;

src/types/container/node-transformers/TControlFlowReplacerFactory.d.ts

@@ -1,5 +1,5 @@
 import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
 
-import { ControlFlowReplacer } from '../../../enums/container/node-transformers/ControlFlowReplacer';
+import { ControlFlowReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/ControlFlowReplacer';
 
 export type TControlFlowReplacerFactory = (replacer: ControlFlowReplacer) => IControlFlowReplacer;

src/types/container/node-transformers/TIdentifierObfuscatingReplacerFactory.d.ts

@@ -1,5 +1,5 @@
-import { IIdentifierObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/IIdentifierObfuscatingReplacer';
+import { IIdentifierObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 
-import { IdentifierObfuscatingReplacer } from '../../../enums/container/node-transformers/IdentifierObfuscatingReplacer';
+import { IdentifierObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 
 export type TIdentifierObfuscatingReplacerFactory = (replacer: IdentifierObfuscatingReplacer) => IIdentifierObfuscatingReplacer;

src/types/container/node-transformers/TLiteralObfuscatingReplacerFactory.d.ts

@@ -1,5 +1,5 @@
-import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/IObfuscatingReplacer';
+import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IObfuscatingReplacer';
 
-import { LiteralObfuscatingReplacer } from '../../../enums/container/node-transformers/LiteralObfuscatingReplacer';
+import { LiteralObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/LiteralObfuscatingReplacer';
 
 export type TLiteralObfuscatingReplacerFactory = (replacer: LiteralObfuscatingReplacer) => IObfuscatingReplacer;

src/types/container/node-transformers/TNodeTransformerFactory.d.ts

@@ -1,5 +1,5 @@
 import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
 
-import { NodeTransformer } from '../../../enums/container/node-transformers/NodeTransformer';
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
 export type TNodeTransformerFactory = (nodeTransformerName: NodeTransformer) => INodeTransformer;

src/types/container/node-transformers/TObfuscatingGuardFactory.d.ts

@@ -0,0 +1,5 @@
+import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
+
+import { ObfuscatingGuard } from '../../../enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard';
+
+export type TObfuscatingGuardFactory = (nodeGuard: ObfuscatingGuard) => IObfuscatingGuard;

src/types/container/stack-trace-analyzer/TCalleeDataExtractorFactory.d.ts

@@ -1,5 +1,5 @@
 import { ICalleeDataExtractor } from '../../../interfaces/analyzers/stack-trace-analyzer/ICalleeDataExtractor';
 
-import { CalleeDataExtractor } from '../../../enums/container/stack-trace-analyzer/CalleeDataExtractor';
+import { CalleeDataExtractor } from '../../../enums/analyzers/stack-trace-analyzer/CalleeDataExtractor';
 
 export type TCalleeDataExtractorFactory = (calleeDataExtractorName: CalleeDataExtractor) => ICalleeDataExtractor;

test/functional-tests/analyzers/stack-trace-analyzer/StackTraceAnalyzer.spec.ts

@@ -16,7 +16,7 @@ import { IStackTraceData } from '../../../../src/interfaces/analyzers/stack-trac
 import { readFileAsString } from '../../../helpers/readFileAsString';
 
 import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
-import { Node } from '../../../../src/node/Node';
+import { NodeGuards } from '../../../../src/node/NodeGuards';
 import { Nodes } from '../../../../src/node/Nodes';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
 
@@ -31,8 +31,8 @@ function getFunctionDeclarationByName (astTree: ESTree.Node, name: string): ESTr
     estraverse.traverse(astTree, {
         enter: (node: ESTree.Node): any => {
             if (
-                Node.isFunctionDeclarationNode(node) &&
-                Node.isIdentifierNode(node.id) &&
+                NodeGuards.isFunctionDeclarationNode(node) &&
+                NodeGuards.isIdentifierNode(node.id) &&
                 node.id.name === name
             ) {
                 functionDeclarationNode = node;
@@ -56,10 +56,10 @@ function getFunctionExpressionByName (astTree: ESTree.Node, name: string): ESTre
     estraverse.traverse(astTree, {
         enter: (node: ESTree.Node): any => {
             if (
-                Node.isVariableDeclaratorNode(node) &&
+                NodeGuards.isVariableDeclaratorNode(node) &&
                 node.init &&
-                Node.isFunctionExpressionNode(node.init) &&
-                Node.isIdentifierNode(node.id) &&
+                NodeGuards.isFunctionExpressionNode(node.init) &&
+                NodeGuards.isIdentifierNode(node.id) &&
                 node.id.name === name
             ) {
                 functionExpressionNode = node.init;
@@ -83,9 +83,9 @@ function getFunctionExpressionById (astTree: ESTree.Node, id: string): ESTree.Fu
     estraverse.traverse(astTree, {
         enter: (node: ESTree.Node): any => {
             if (
-                Node.isFunctionExpressionNode(node) &&
+                NodeGuards.isFunctionExpressionNode(node) &&
                 node.id &&
-                Node.isIdentifierNode(node.id) &&
+                NodeGuards.isIdentifierNode(node.id) &&
                 node.id.name === id
             ) {
                 functionExpressionNode = node;
@@ -111,10 +111,10 @@ function getObjectFunctionExpressionByName (astTree: ESTree.Node, objectName: st
     estraverse.traverse(astTree, {
         enter: (node: ESTree.Node): any => {
             if (
-                Node.isVariableDeclaratorNode(node) &&
-                Node.isIdentifierNode(node.id) &&
+                NodeGuards.isVariableDeclaratorNode(node) &&
+                NodeGuards.isIdentifierNode(node.id) &&
                 node.init &&
-                Node.isObjectExpressionNode(node.init) &&
+                NodeGuards.isObjectExpressionNode(node.init) &&
                 node.id.name === objectName
             ) {
                 targetObjectExpressionNode = node.init;
@@ -131,11 +131,11 @@ function getObjectFunctionExpressionByName (astTree: ESTree.Node, objectName: st
     estraverse.traverse(targetObjectExpressionNode, {
         enter: (node: ESTree.Node): any => {
             if (
-                Node.isPropertyNode(node) &&
-                Node.isFunctionExpressionNode(node.value) &&
+                NodeGuards.isPropertyNode(node) &&
+                NodeGuards.isFunctionExpressionNode(node.value) &&
                 (
-                    (Node.isIdentifierNode(node.key) && node.key.name === name) ||
-                    (Node.isLiteralNode(node.key) && node.key.value === name)
+                    (NodeGuards.isIdentifierNode(node.key) && node.key.name === name) ||
+                    (NodeGuards.isLiteralNode(node.key) && node.key.value === name)
                 )
             ) {
                 functionExpressionNode = node.value;

test/functional-tests/node-guards/black-list-node-guard/BlackListNodeGuard.spec.ts → test/functional-tests/node-transformers/parentizing-transformers/obfuscating-guards/black-list-node-guard/BlackListObfuscatingGuard.spec.ts

@@ -1,14 +1,14 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscatorFacade';
+import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscatorFacade';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../../helpers/readFileAsString';
 
-describe('BlackListNodeGuard', () => {
+describe('BlackListObfuscatingGuard', () => {
     describe('check (node: ESTree.Node): boolean', () => {
         describe('`\'use strict\';` operator', () => {
             const useStrictOperatorRegExp: RegExp = /'use *strict';/;

test/index.spec.ts

@@ -39,7 +39,6 @@ import './functional-tests/custom-nodes/string-array-nodes/StringArrayCallsWrapp
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.spec';
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayNode.spec';
 import './functional-tests/javascript-obfuscator/JavaScriptObfuscator.spec';
-import './functional-tests/node-guards/black-list-node-guard/BlackListNodeGuard.spec';
 import './functional-tests/node-transformers/control-flow-transformers/block-statement-control-flow-transformer/BlockStatementControlFlowTransformer.spec';
 import './functional-tests/node-transformers/control-flow-transformers/function-control-flow-transformer/FunctionControlFlowTransformer.spec';
 import './functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/binary-expression-control-flow-replacer/BinaryExpressionControlFlowReplacer.spec';
@@ -58,6 +57,7 @@ import './functional-tests/node-transformers/obfuscating-transformers/labeled-st
 import './functional-tests/node-transformers/obfuscating-transformers/literal-transformer/LiteralTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/object-expression-transformer/ObjectExpressionTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/VariableDeclarationTransformer.spec';
+import './functional-tests/node-transformers/parentizing-transformers/obfuscating-guards/black-list-node-guard/BlackListObfuscatingGuard.spec';
 import './functional-tests/templates/custom-nodes/domain-lock-nodes/DomainLockNodeTemplate.spec';
 import './functional-tests/templates/custom-nodes/string-array-nodes/StringArrayCallsWrapperNodeTemplate.spec';