Added NodeMetadata class

.babelrc

@@ -11,6 +11,6 @@
     }]
   ],
   "plugins": [
-    "@babel/transform-runtime"
+    "@babel/plugin-transform-runtime"
   ]
 }

CHANGELOG.md

@@ -3,6 +3,7 @@ Change Log
 v0.15.0
 ---
 * **Breaking change:** dropped `node@4` and `node@5` support.
+* **Breaking change:** renamed `extension` value of `target` option on `browser-no-eval`.
 * **New CLI option:** `exclude` allows to exclude specific files or directories from obfuscation.
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/217
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/210

README.md

@@ -333,7 +333,7 @@ Following options are available for the JS Obfuscator:
     --string-array <boolean>
     --string-array-encoding <boolean|string> [true, false, base64, rc4]
     --string-array-threshold <number>
-    --target <string> [browser, extension, node]
+    --target <string> [browser, browser-no-eval, node]
     --transform-object-keys <boolean>
     --unicode-escape-sequence <boolean>
 ```
@@ -721,11 +721,11 @@ Allows to set target environment for obfuscated code.
 
 Available values: 
 * `browser`;
-* `extension`;
+* `browser-no-eval`;
 * `node`.
 
 Currently output code for `browser` and `node` targets is identical.
-Output code for `extension` target is not using `eval`.
+Output code for `browser-no-eval` target is not using `eval`.
 
 ### `transformObjectKeys`
 Type: `boolean` Default: `false`

package.json

@@ -19,11 +19,11 @@
     "javascript-obfuscator": "./bin/javascript-obfuscator"
   },
   "dependencies": {
-    "@babel/runtime": "7.0.0-beta.40",
+    "@babel/runtime": "7.0.0-beta.41",
     "chalk": "2.3.2",
     "chance": "1.0.13",
     "class-validator": "0.8.1",
-    "commander": "2.14.1",
+    "commander": "2.15.0",
     "escodegen-wallaby": "1.6.18",
     "esprima": "4.0.0",
     "estraverse": "4.2.0",
@@ -40,9 +40,10 @@
     "tslib": "1.9.0"
   },
   "devDependencies": {
-    "@babel/core": "7.0.0-beta.40",
-    "@babel/plugin-transform-runtime": "7.0.0-beta.40",
-    "@babel/preset-env": "7.0.0-beta.40",
+    "@babel/cli": "7.0.0-beta.41",
+    "@babel/core": "7.0.0-beta.41",
+    "@babel/plugin-transform-runtime": "7.0.0-beta.41",
+    "@babel/preset-env": "7.0.0-beta.41",
     "@types/chai": "4.1.2",
     "@types/chance": "1.0.0",
     "@types/escodegen": "0.0.6",
@@ -53,13 +54,12 @@
     "@types/mkdirp": "0.5.2",
     "@types/mocha": "2.2.48",
     "@types/multimatch": "2.1.2",
-    "@types/node": "9.4.6",
+    "@types/node": "9.4.7",
     "@types/rimraf": "2.0.2",
     "@types/sinon": "4.3.0",
     "@types/string-template": "1.0.2",
     "@types/webpack-env": "1.13.5",
-    "awesome-typescript-loader": "5.0.0-0",
-    "babel-cli": "7.0.0-beta.3",
+    "awesome-typescript-loader": "5.0.0-1",
     "babel-loader": "8.0.0-beta.2",
     "chai": "4.1.2",
     "coveralls": "3.0.0",
@@ -67,16 +67,16 @@
     "mocha": "5.0.4",
     "pre-commit": "1.2.2",
     "rimraf": "2.6.2",
-    "sinon": "4.4.2",
+    "sinon": "4.4.6",
     "threads": "0.10.1",
     "ts-node": "5.0.1",
     "tslint": "5.9.1",
     "tslint-eslint-rules": "5.1.0",
     "tslint-language-service": "0.9.8",
     "tslint-webpack-plugin": "1.2.0",
-    "typescript": "2.7.2",
+    "typescript": "2.8.0-dev.20180315 ",
     "webpack": "4.1.1",
-    "webpack-cli": "2.0.10",
+    "webpack-cli": "2.0.12",
     "webpack-node-externals": "1.6.0"
   },
   "repository": {

src/JavaScriptObfuscator.ts

@@ -49,6 +49,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.LabeledStatementTransformer,
         NodeTransformer.LiteralTransformer,
         NodeTransformer.MemberExpressionTransformer,
+        NodeTransformer.MetadataTransformer,
         NodeTransformer.MethodDefinitionTransformer,
         NodeTransformer.ObfuscatingGuardsTransformer,
         NodeTransformer.ObjectExpressionKeysTransformer,

src/cli/sanitizers/IdentifierNamesGeneratorSanitizer.ts

@@ -9,8 +9,8 @@ import { IdentifierNamesGenerator } from '../../enums/generators/identifier-name
 export const IdentifierNamesGeneratorSanitizer: TCLISanitizer <string> = (value: string): string => {
     const isCorrectIdentifierNamesGenerator: boolean = Object
         .keys(IdentifierNamesGenerator)
-        .some((key: any): boolean => {
-            return IdentifierNamesGenerator[key] === value;
+        .some((key: string): boolean => {
+            return IdentifierNamesGenerator[<keyof typeof IdentifierNamesGenerator>key] === value;
         });
 
     if (!isCorrectIdentifierNamesGenerator) {

src/cli/sanitizers/ObfuscatingTargetSanitizer.ts

@@ -9,8 +9,8 @@ import { ObfuscationTarget } from '../../enums/ObfuscationTarget';
 export const ObfuscationTargetSanitizer: TCLISanitizer <string> = (value: string): string => {
     const isCorrectTarget: boolean = Object
         .keys(ObfuscationTarget)
-        .some((key: any): boolean => {
-            return ObfuscationTarget[key] === value;
+        .some((key: string): boolean => {
+            return ObfuscationTarget[<keyof typeof ObfuscationTarget>key] === value;
         });
 
     if (!isCorrectTarget) {

src/cli/sanitizers/SourceMapModeSanitizer.ts

@@ -9,8 +9,8 @@ import { SourceMapMode } from '../../enums/source-map/SourceMapMode';
 export const SourceMapModeSanitizer: TCLISanitizer <string> = (value: string): string => {
     const isCorrectSourceMapMode: boolean = Object
         .keys(SourceMapMode)
-        .some((key: any): boolean => {
-            return SourceMapMode[key] === value;
+        .some((key: string): boolean => {
+            return SourceMapMode[<keyof typeof SourceMapMode>key] === value;
         });
 
     if (!isCorrectSourceMapMode) {

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

@@ -13,6 +13,7 @@ import { CommentsTransformer } from '../../../node-transformers/preparing-transf
 import { ConditionalCommentObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard';
 import { CustomNodesTransformer } from '../../../node-transformers/preparing-transformers/CustomNodesTransformer';
 import { EvalCallExpressionTransformer } from '../../../node-transformers/preparing-transformers/EvaCallExpressionTransformer';
+import { MetadataTransformer } from '../../../node-transformers/preparing-transformers/MetadataTransformer';
 import { ObfuscatingGuardsTransformer } from '../../../node-transformers/preparing-transformers/ObfuscatingGuardsTransformer';
 import { ParentificationTransformer } from '../../../node-transformers/preparing-transformers/ParentificationTransformer';
 
@@ -30,6 +31,10 @@ export const preparingTransformersModule: interfaces.ContainerModule = new Conta
         .to(EvalCallExpressionTransformer)
         .whenTargetNamed(NodeTransformer.EvalCallExpressionTransformer);
 
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(MetadataTransformer)
+        .whenTargetNamed(NodeTransformer.MetadataTransformer);
+
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(ObfuscatingGuardsTransformer)
         .whenTargetNamed(NodeTransformer.ObfuscatingGuardsTransformer);

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

@@ -59,7 +59,7 @@ export class ConsoleOutputDisableExpressionNode extends AbstractCustomNode {
      * @returns {string}
      */
     protected getTemplate (): string {
-        const globalVariableTemplate: string = this.options.target !== ObfuscationTarget.Extension
+        const globalVariableTemplate: string = this.options.target !== ObfuscationTarget.BrowserNoEval
             ? this.getGlobalVariableTemplate()
             : GlobalVariableNoEvalTemplate();
 

src/custom-nodes/control-flow-flattening-nodes/BinaryExpressionFunctionNode.ts

@@ -12,7 +12,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../AbstractCustomNode';
-import { Nodes } from '../../node/Nodes';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -48,18 +48,18 @@ export class BinaryExpressionFunctionNode extends AbstractCustomNode {
      * @returns {TStatement[]}
      */
     protected getNodeStructure (): TStatement[] {
-        const structure: TStatement = Nodes.getExpressionStatementNode(
-            Nodes.getFunctionExpressionNode(
+        const structure: TStatement = NodeFactory.expressionStatementNode(
+            NodeFactory.functionExpressionNode(
                 [
-                    Nodes.getIdentifierNode('x'),
-                    Nodes.getIdentifierNode('y')
+                    NodeFactory.identifierNode('x'),
+                    NodeFactory.identifierNode('y')
                 ],
-                Nodes.getBlockStatementNode([
-                    Nodes.getReturnStatementNode(
-                        Nodes.getBinaryExpressionNode(
+                NodeFactory.blockStatementNode([
+                    NodeFactory.returnStatementNode(
+                        NodeFactory.binaryExpressionNode(
                             this.operator,
-                            Nodes.getIdentifierNode('x'),
-                            Nodes.getIdentifierNode('y')
+                            NodeFactory.identifierNode('x'),
+                            NodeFactory.identifierNode('y')
                         )
                     )
                 ])

src/custom-nodes/control-flow-flattening-nodes/BlockStatementControlFlowFlatteningNode.ts

@@ -12,8 +12,8 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../AbstractCustomNode';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
-import { Nodes } from '../../node/Nodes';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -71,36 +71,36 @@ export class BlockStatementControlFlowFlatteningNode extends AbstractCustomNode
     protected getNodeStructure (): TStatement[] {
         const controllerIdentifierName: string = this.randomGenerator.getRandomString(6);
         const indexIdentifierName: string = this.randomGenerator.getRandomString(6);
-        const structure: ESTree.BlockStatement = Nodes.getBlockStatementNode([
-            Nodes.getVariableDeclarationNode([
-                Nodes.getVariableDeclaratorNode(
-                    Nodes.getIdentifierNode(controllerIdentifierName),
-                    Nodes.getCallExpressionNode(
-                        Nodes.getMemberExpressionNode(
-                            Nodes.getLiteralNode(
+        const structure: ESTree.BlockStatement = NodeFactory.blockStatementNode([
+            NodeFactory.variableDeclarationNode([
+                NodeFactory.variableDeclaratorNode(
+                    NodeFactory.identifierNode(controllerIdentifierName),
+                    NodeFactory.callExpressionNode(
+                        NodeFactory.memberExpressionNode(
+                            NodeFactory.literalNode(
                                 this.originalKeysIndexesInShuffledArray.join('|')
                             ),
-                            Nodes.getIdentifierNode('split')
+                            NodeFactory.identifierNode('split')
                         ),
                         [
-                            Nodes.getLiteralNode('|')
+                            NodeFactory.literalNode('|')
                         ]
                     )
                 ),
-                Nodes.getVariableDeclaratorNode(
-                    Nodes.getIdentifierNode(indexIdentifierName),
-                    Nodes.getLiteralNode(0)
+                NodeFactory.variableDeclaratorNode(
+                    NodeFactory.identifierNode(indexIdentifierName),
+                    NodeFactory.literalNode(0)
                 )
             ]),
-            Nodes.getWhileStatementNode(
-                Nodes.getLiteralNode(true),
-                Nodes.getBlockStatementNode([
-                    Nodes.getSwitchStatementNode(
-                        Nodes.getMemberExpressionNode(
-                            Nodes.getIdentifierNode(controllerIdentifierName),
-                            Nodes.getUpdateExpressionNode(
+            NodeFactory.whileStatementNode(
+                NodeFactory.literalNode(true),
+                NodeFactory.blockStatementNode([
+                    NodeFactory.switchStatementNode(
+                        NodeFactory.memberExpressionNode(
+                            NodeFactory.identifierNode(controllerIdentifierName),
+                            NodeFactory.updateExpressionNode(
                                 '++',
-                                Nodes.getIdentifierNode(indexIdentifierName)
+                                NodeFactory.identifierNode(indexIdentifierName)
                             ),
                             true
                         ),
@@ -113,16 +113,16 @@ export class BlockStatementControlFlowFlatteningNode extends AbstractCustomNode
                              * to prevent `unreachable code after return statement` warnings
                              */
                             if (!NodeGuards.isReturnStatementNode(statement)) {
-                                consequent.push(Nodes.getContinueStatement());
+                                consequent.push(NodeFactory.continueStatement());
                             }
 
-                            return Nodes.getSwitchCaseNode(
-                                Nodes.getLiteralNode(String(index)),
+                            return NodeFactory.switchCaseNode(
+                                NodeFactory.literalNode(String(index)),
                                 consequent
                             );
                         })
                     ),
-                    Nodes.getBreakStatement()
+                    NodeFactory.breakStatement()
                 ])
             )
         ]);

src/custom-nodes/control-flow-flattening-nodes/CallExpressionFunctionNode.ts

@@ -12,7 +12,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../AbstractCustomNode';
-import { Nodes } from '../../node/Nodes';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -48,23 +48,23 @@ export class CallExpressionFunctionNode extends AbstractCustomNode {
      * @returns {TStatement[]}
      */
     protected getNodeStructure (): TStatement[] {
-        const calleeIdentifier: ESTree.Identifier = Nodes.getIdentifierNode('callee');
+        const calleeIdentifier: ESTree.Identifier = NodeFactory.identifierNode('callee');
         const params: ESTree.Identifier[] = [];
         const argumentsLength: number = this.expressionArguments.length;
 
         for (let i: number = 0; i < argumentsLength; i++) {
-            params.push(Nodes.getIdentifierNode(`param${i + 1}`));
+            params.push(NodeFactory.identifierNode(`param${i + 1}`));
         }
 
-        const structure: TStatement = Nodes.getExpressionStatementNode(
-            Nodes.getFunctionExpressionNode(
+        const structure: TStatement = NodeFactory.expressionStatementNode(
+            NodeFactory.functionExpressionNode(
                 [
                     calleeIdentifier,
                     ...params
                 ],
-                Nodes.getBlockStatementNode([
-                    Nodes.getReturnStatementNode(
-                        Nodes.getCallExpressionNode(
+                NodeFactory.blockStatementNode([
+                    NodeFactory.returnStatementNode(
+                        NodeFactory.callExpressionNode(
                             calleeIdentifier,
                             params
                         )

src/custom-nodes/control-flow-flattening-nodes/LogicalExpressionFunctionNode.ts

@@ -12,7 +12,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../AbstractCustomNode';
-import { Nodes } from '../../node/Nodes';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -48,18 +48,18 @@ export class LogicalExpressionFunctionNode extends AbstractCustomNode {
      * @returns {TStatement[]}
      */
     protected getNodeStructure (): TStatement[] {
-        const structure: TStatement = Nodes.getExpressionStatementNode(
-            Nodes.getFunctionExpressionNode(
+        const structure: TStatement = NodeFactory.expressionStatementNode(
+            NodeFactory.functionExpressionNode(
                 [
-                    Nodes.getIdentifierNode('x'),
-                    Nodes.getIdentifierNode('y')
+                    NodeFactory.identifierNode('x'),
+                    NodeFactory.identifierNode('y')
                 ],
-                Nodes.getBlockStatementNode([
-                    Nodes.getReturnStatementNode(
-                        Nodes.getLogicalExpressionNode(
+                NodeFactory.blockStatementNode([
+                    NodeFactory.returnStatementNode(
+                        NodeFactory.logicalExpressionNode(
                             this.operator,
-                            Nodes.getIdentifierNode('x'),
-                            Nodes.getIdentifierNode('y')
+                            NodeFactory.identifierNode('x'),
+                            NodeFactory.identifierNode('y')
                         )
                     )
                 ])

src/custom-nodes/control-flow-flattening-nodes/StringLiteralNode.ts

@@ -10,7 +10,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../AbstractCustomNode';
-import { Nodes } from '../../node/Nodes';
+import { NodeFactory } from '../../node/NodeFactory';
 
 @injectable()
 export class StringLiteralNode extends AbstractCustomNode {
@@ -45,8 +45,8 @@ export class StringLiteralNode extends AbstractCustomNode {
      * @returns {TStatement[]}
      */
     protected getNodeStructure (): TStatement[] {
-        const structure: TStatement = Nodes.getExpressionStatementNode(
-            Nodes.getLiteralNode(this.literalValue)
+        const structure: TStatement = NodeFactory.expressionStatementNode(
+            NodeFactory.literalNode(this.literalValue)
         );
 
         return [structure];

src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/CallExpressionControlFlowStorageCallNode.ts

@@ -13,7 +13,7 @@ import { IRandomGenerator } from "../../../interfaces/utils/IRandomGenerator";
 import { initializable } from '../../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../../AbstractCustomNode';
-import { Nodes } from '../../../node/Nodes';
+import { NodeFactory } from '../../../node/NodeFactory';
 import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
@@ -75,11 +75,11 @@ export class CallExpressionControlFlowStorageCallNode extends AbstractCustomNode
     }
 
     protected getNodeStructure (): TStatement[] {
-        const structure: TStatement = Nodes.getExpressionStatementNode(
-            Nodes.getCallExpressionNode(
-                Nodes.getMemberExpressionNode(
-                    Nodes.getIdentifierNode(this.controlFlowStorageName),
-                    Nodes.getIdentifierNode(this.controlFlowStorageKey)
+        const structure: TStatement = NodeFactory.expressionStatementNode(
+            NodeFactory.callExpressionNode(
+                NodeFactory.memberExpressionNode(
+                    NodeFactory.identifierNode(this.controlFlowStorageName),
+                    NodeFactory.identifierNode(this.controlFlowStorageKey)
                 ),
                 [
                     this.callee,

src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ControlFlowStorageNode.ts

@@ -14,8 +14,8 @@ import { IStorage } from '../../../interfaces/storages/IStorage';
 import { initializable } from '../../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../../AbstractCustomNode';
+import { NodeFactory } from '../../../node/NodeFactory';
 import { NodeGuards } from '../../../node/NodeGuards';
-import { Nodes } from '../../../node/Nodes';
 import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
@@ -60,16 +60,16 @@ export class ControlFlowStorageNode extends AbstractCustomNode {
                     throw new Error('Function node for control flow storage object should be passed inside the `ExpressionStatement` node!');
                 }
 
-                return Nodes.getPropertyNode(
-                    Nodes.getIdentifierNode(key),
+                return NodeFactory.propertyNode(
+                    NodeFactory.identifierNode(key),
                     node.expression
                 );
             });
 
-        let structure: ESTree.Node = Nodes.getVariableDeclarationNode([
-            Nodes.getVariableDeclaratorNode(
-                Nodes.getIdentifierNode(this.controlFlowStorage.getStorageId()),
-                Nodes.getObjectExpressionNode(propertyNodes)
+        let structure: ESTree.Node = NodeFactory.variableDeclarationNode([
+            NodeFactory.variableDeclaratorNode(
+                NodeFactory.identifierNode(this.controlFlowStorage.getStorageId()),
+                NodeFactory.objectExpressionNode(propertyNodes)
             )
         ]);
 

src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ExpressionWithOperatorControlFlowStorageCallNode.ts

@@ -12,7 +12,7 @@ import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../../AbstractCustomNode';
-import { Nodes } from '../../../node/Nodes';
+import { NodeFactory } from '../../../node/NodeFactory';
 import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
@@ -74,11 +74,11 @@ export class ExpressionWithOperatorControlFlowStorageCallNode extends AbstractCu
     }
 
     protected getNodeStructure (): TStatement[] {
-        const structure: TStatement = Nodes.getExpressionStatementNode(
-            Nodes.getCallExpressionNode(
-                Nodes.getMemberExpressionNode(
-                    Nodes.getIdentifierNode(this.controlFlowStorageName),
-                    Nodes.getIdentifierNode(this.controlFlowStorageKey)
+        const structure: TStatement = NodeFactory.expressionStatementNode(
+            NodeFactory.callExpressionNode(
+                NodeFactory.memberExpressionNode(
+                    NodeFactory.identifierNode(this.controlFlowStorageName),
+                    NodeFactory.identifierNode(this.controlFlowStorageKey)
                 ),
                 [
                     this.leftValue,

src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/StringLiteralControlFlowStorageCallNode.ts

@@ -10,7 +10,7 @@ import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../../AbstractCustomNode';
-import { Nodes } from '../../../node/Nodes';
+import { NodeFactory } from '../../../node/NodeFactory';
 import { NodeUtils } from '../../../node/NodeUtils';
 
 @injectable()
@@ -54,10 +54,10 @@ export class StringLiteralControlFlowStorageCallNode extends AbstractCustomNode
     }
 
     protected getNodeStructure (): TStatement[] {
-        const structure: TStatement = Nodes.getExpressionStatementNode(
-            Nodes.getMemberExpressionNode(
-                Nodes.getIdentifierNode(this.controlFlowStorageName),
-                Nodes.getIdentifierNode(this.controlFlowStorageKey)
+        const structure: TStatement = NodeFactory.expressionStatementNode(
+            NodeFactory.memberExpressionNode(
+                NodeFactory.identifierNode(this.controlFlowStorageName),
+                NodeFactory.identifierNode(this.controlFlowStorageKey)
             )
         );
 

src/custom-nodes/dead-code-injection-nodes/BlockStatementDeadCodeInjectionNode.ts

@@ -12,7 +12,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { initializable } from '../../decorators/Initializable';
 
 import { AbstractCustomNode } from '../AbstractCustomNode';
-import { Nodes } from '../../node/Nodes';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -70,12 +70,12 @@ export class BlockStatementDeadCodeInjectionNode extends AbstractCustomNode {
             ? [this.blockStatementNode, this.deadCodeInjectionRootAstHostNode]
             : [this.deadCodeInjectionRootAstHostNode, this.blockStatementNode];
 
-        const structure: BlockStatement = Nodes.getBlockStatementNode([
-            Nodes.getIfStatementNode(
-                Nodes.getBinaryExpressionNode(
+        const structure: BlockStatement = NodeFactory.blockStatementNode([
+            NodeFactory.ifStatementNode(
+                NodeFactory.binaryExpressionNode(
                     operator,
-                    Nodes.getLiteralNode(leftString),
-                    Nodes.getLiteralNode(rightString)
+                    NodeFactory.literalNode(leftString),
+                    NodeFactory.literalNode(rightString)
                 ),
                 consequent,
                 alternate

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

@@ -60,7 +60,7 @@ export class DebugProtectionFunctionNode extends AbstractCustomNode {
      * @returns {string}
      */
     protected getTemplate (): string {
-        const debuggerTemplate: string = this.options.target !== ObfuscationTarget.Extension
+        const debuggerTemplate: string = this.options.target !== ObfuscationTarget.BrowserNoEval
             ? DebuggerTemplate()
             : DebuggerTemplateNoEval();
 

src/custom-nodes/domain-lock-nodes/DomainLockNode.ts

@@ -74,7 +74,7 @@ export class DomainLockNode extends AbstractCustomNode {
             domainsString,
             domainsString.length * 3
         );
-        const globalVariableTemplate: string = this.options.target !== ObfuscationTarget.Extension
+        const globalVariableTemplate: string = this.options.target !== ObfuscationTarget.BrowserNoEval
             ? this.getGlobalVariableTemplate()
             : GlobalVariableNoEvalTemplate();
 

src/custom-nodes/string-array-nodes/StringArrayCallsWrapper.ts

@@ -109,7 +109,7 @@ export class StringArrayCallsWrapper extends AbstractCustomNode {
      * @returns {string}
      */
     private getDecodeStringArrayTemplate (): string {
-        const globalVariableTemplate: string = this.options.target !== ObfuscationTarget.Extension
+        const globalVariableTemplate: string = this.options.target !== ObfuscationTarget.BrowserNoEval
             ? this.getGlobalVariableTemplate()
             : GlobalVariableNoEvalTemplate();
         const atobPolyfill: string = format(AtobTemplate(), { globalVariableTemplate });

src/declarations/ESTree.d.ts

@@ -4,21 +4,33 @@ import * as escodegen from 'escodegen-wallaby';
 import * as ESTree from 'estree';
 
 declare module 'estree' {
-    interface BaseNode {
+    export interface BaseNodeMetadata {
         ignoredNode?: boolean;
         obfuscatedNode?: boolean;
+    }
+
+    export interface IdentifierNodeMetadata extends BaseNodeMetadata {
+        renamedIdentifier?: boolean;
+    }
+
+    interface BaseNode {
+        metadata?: BaseNodeMetadata;
         parentNode?: ESTree.Node;
     }
 
-    interface ExpressionStatement extends ESTree.BaseStatement {
+    interface Identifier extends BaseNode {
+        metadata?: IdentifierNodeMetadata;
+    }
+
+    interface ExpressionStatement extends BaseNode {
         directive?: 'use strict';
     }
 
-    interface SimpleLiteral extends ESTree.BaseNode, ESTree.BaseExpression {
+    interface SimpleLiteral extends BaseNode {
         'x-verbatim-property'?: escodegen.XVerbatimProperty;
     }
 
-    interface RegExpLiteral extends ESTree.BaseNode, ESTree.BaseExpression {
+    interface RegExpLiteral extends BaseNode {
         'x-verbatim-property'?: escodegen.XVerbatimProperty;
     }
 }

src/enums/ObfuscationTarget.ts

@@ -1,5 +1,5 @@
 export enum ObfuscationTarget {
     Browser = 'browser',
-    Extension = 'extension',
+    BrowserNoEval = 'browser-no-eval',
     Node = 'node'
 }

src/enums/node-transformers/NodeTransformer.ts

@@ -12,6 +12,7 @@ export enum NodeTransformer {
     LabeledStatementTransformer = 'LabeledStatementTransformer',
     LiteralTransformer = 'LiteralTransformer',
     MemberExpressionTransformer = 'MemberExpressionTransformer',
+    MetadataTransformer = 'MetadataTransformer',
     MethodDefinitionTransformer = 'MethodDefinitionTransformer',
     ObfuscatingGuardsTransformer = 'ObfuscatingGuardsTransformer',
     ObjectExpressionKeysTransformer = 'ObjectExpressionKeysTransformer',

src/node-transformers/TransformersRunner.ts

@@ -17,6 +17,7 @@ import { TransformationStage } from '../enums/node-transformers/TransformationSt
 import { VisitorDirection } from '../enums/node-transformers/VisitorDirection';
 
 import { NodeGuards } from '../node/NodeGuards';
+import { NodeMetadata } from '../node/NodeMetadata';
 
 @injectable()
 export class TransformersRunner implements ITransformersRunner {
@@ -96,7 +97,7 @@ export class TransformersRunner implements ITransformersRunner {
         }
 
         return (node: ESTree.Node, parentNode: ESTree.Node | null) => {
-            if (node.ignoredNode) {
+            if (NodeMetadata.isIgnoredNode(node)) {
                 return estraverse.VisitorOption.Skip;
             }
 

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

@@ -21,8 +21,9 @@ import { NodeType } from '../../enums/node/NodeType';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
 import { NodeAppender } from '../../node/NodeAppender';
+import { NodeGuards } from '../../node/NodeGuards';
+import { NodeMetadata } from '../../node/NodeMetadata';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -223,7 +224,7 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
     private transformFunctionBody (functionNodeBody: ESTree.BlockStatement, controlFlowStorage: IStorage<ICustomNode>): void {
         estraverse.replace(functionNodeBody, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): estraverse.VisitorOption | ESTree.Node => {
-                if (node.ignoredNode) {
+                if (NodeMetadata.isIgnoredNode(node)) {
                     return estraverse.VisitorOption.Skip;
                 }
 

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

@@ -7,10 +7,10 @@ import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { NodeType } from '../../enums/node/NodeType';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
 
 @injectable()
@@ -69,11 +69,7 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
             }
 
             memberExpressionNode.computed = true;
-            memberExpressionNode.property = {
-                type: NodeType.Literal,
-                value: memberExpressionNode.property.name,
-                raw: `'${memberExpressionNode.property.name}'`
-            };
+            memberExpressionNode.property = NodeFactory.literalNode(memberExpressionNode.property.name);
         }
 
         return memberExpressionNode;

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

@@ -7,10 +7,10 @@ import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { NodeType } from '../../enums/node/NodeType';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
 
 /**
@@ -82,11 +82,7 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
             methodDefinitionNode.computed === false
         ) {
             methodDefinitionNode.computed = true;
-            methodDefinitionNode.key = {
-                type: NodeType.Literal,
-                value: methodDefinitionNode.key.name,
-                raw: `'${methodDefinitionNode.key.name}'`
-            };
+            methodDefinitionNode.key = NodeFactory.literalNode(methodDefinitionNode.key.name);
         }
 
         return methodDefinitionNode;

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

@@ -13,8 +13,8 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeAppender } from '../../node/NodeAppender';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
-import { Nodes } from '../../node/Nodes';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -191,12 +191,12 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
             const shouldCreateLiteralNode: boolean = !property.computed
                 || (property.computed && NodeGuards.isLiteralNode(property.key));
             const memberExpressionProperty: ESTree.Expression = shouldCreateLiteralNode
-                ? Nodes.getLiteralNode(propertyKeyName)
-                : Nodes.getIdentifierNode(propertyKeyName);
-            const memberExpressionNode: ESTree.MemberExpression = Nodes
-                .getMemberExpressionNode(memberExpressionObject, memberExpressionProperty, true);
-            const expressionStatementNode: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(
-                Nodes.getAssignmentExpressionNode('=', memberExpressionNode, propertyValue)
+                ? NodeFactory.literalNode(propertyKeyName)
+                : NodeFactory.identifierNode(propertyKeyName);
+            const memberExpressionNode: ESTree.MemberExpression = NodeFactory
+                .memberExpressionNode(memberExpressionObject, memberExpressionProperty, true);
+            const expressionStatementNode: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(
+                NodeFactory.assignmentExpressionNode('=', memberExpressionNode, propertyValue)
             );
 
             /**

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

@@ -14,8 +14,8 @@ import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
-import { Nodes } from '../../node/Nodes';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -79,7 +79,7 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
         let nodes: ESTree.Expression[] = [];
 
         templateLiteralNode.quasis.forEach((templateElement: ESTree.TemplateElement) => {
-            nodes.push(Nodes.getLiteralNode(templateElement.value.cooked));
+            nodes.push(NodeFactory.literalNode(templateElement.value.cooked));
 
             const expression: ESTree.Expression | undefined = templateLiteralExpressions.shift();
 
@@ -100,18 +100,18 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
             !TemplateLiteralTransformer.isLiteralNodeWithStringValue(nodes[0]) &&
             !TemplateLiteralTransformer.isLiteralNodeWithStringValue(nodes[1])
         ) {
-            nodes.unshift(Nodes.getLiteralNode(''));
+            nodes.unshift(NodeFactory.literalNode(''));
         }
 
         if (nodes.length > 1) {
-            let root: ESTree.BinaryExpression = Nodes.getBinaryExpressionNode(
+            let root: ESTree.BinaryExpression = NodeFactory.binaryExpressionNode(
                 '+',
                 <ESTree.Literal>nodes.shift(),
                 <ESTree.Expression>nodes.shift()
             );
 
             nodes.forEach((node: ESTree.Literal | ESTree.Expression) => {
-                root = Nodes.getBinaryExpressionNode('+', root, <ESTree.Literal | ESTree.Expression>node);
+                root = NodeFactory.binaryExpressionNode('+', root, <ESTree.Literal | ESTree.Expression>node);
             });
 
             return root;

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

@@ -20,8 +20,8 @@ import { NodeType } from '../../enums/node/NodeType';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
-import { Nodes } from '../../node/Nodes';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -128,7 +128,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
         }
 
         const slicedBody: ESTree.Statement[] = scopeBody.slice(0, indexInScope);
-        const hostBlockStatementNode: ESTree.BlockStatement = Nodes.getBlockStatementNode(slicedBody);
+        const hostBlockStatementNode: ESTree.BlockStatement = NodeFactory.blockStatementNode(slicedBody);
         const functionDeclarationName: string = targetNode.id.name;
 
         let isScopeHoistedFunctionDeclaration: boolean = false;
@@ -359,8 +359,8 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
          * with function declaration node. This function declaration node will create block scope for all identifiers
          * inside random block statement node and this identifiers won't affect identifiers of the rest AST tree.
          */
-        const deadCodeInjectionRootAstHostNode: ESTree.BlockStatement = Nodes.getBlockStatementNode([
-            Nodes.getFunctionDeclarationNode(
+        const deadCodeInjectionRootAstHostNode: ESTree.BlockStatement = NodeFactory.blockStatementNode([
+            NodeFactory.functionDeclarationNode(
                 DeadCodeInjectionTransformer.deadCodeInjectionRootAstHostNodeName,
                 [],
                 randomBlockStatementNode

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

@@ -16,6 +16,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
+import { NodeMetadata } from '../../node/NodeMetadata';
 
 /**
  * replaces:
@@ -108,7 +109,8 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
-                        node.obfuscatedNode = true;
+
+                        NodeMetadata.set(node, { renamedIdentifier: true });
                     }
                 }
             }

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

@@ -18,6 +18,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
+import { NodeMetadata } from '../../node/NodeMetadata';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -146,14 +147,18 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(blockScopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
-                if (parentNode && !node.obfuscatedNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
+                if (
+                    parentNode
+                    && NodeGuards.isReplaceableIdentifierNode(node, parentNode)
+                    && !NodeMetadata.isRenamedIdentifier(node)
+                ) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
                         .replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
-                        node.obfuscatedNode = true;
+                        NodeMetadata.set(node, { renamedIdentifier: true });
                     } else {
                         storedReplaceableIdentifiers.push(node);
                     }

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

@@ -20,6 +20,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
+import { NodeMetadata } from '../../node/NodeMetadata';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -167,14 +168,18 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(blockScopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
-                if (parentNode && !node.obfuscatedNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
+                if (
+                    parentNode
+                    && NodeGuards.isReplaceableIdentifierNode(node, parentNode)
+                    && !NodeMetadata.isRenamedIdentifier(node)
+                ) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
                         .replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
-                        node.obfuscatedNode = true;
+                        NodeMetadata.set(node, { renamedIdentifier: true });
                     } else {
                         const storedReplaceableIdentifiers: ESTree.Identifier[] = storedReplaceableIdentifiersNamesMap.get(node.name) || [];
 

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

@@ -16,6 +16,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
+import { NodeMetadata } from '../../node/NodeMetadata';
 
 /**
  * replaces:
@@ -157,7 +158,7 @@ export class FunctionTransformer extends AbstractNodeTransformer {
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
-                        node.obfuscatedNode = true;
+                        NodeMetadata.set(node, { renamedIdentifier: true });
                     }
                 }
             }

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

@@ -14,6 +14,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
+import { NodeMetadata } from '../../node/NodeMetadata';
 
 @injectable()
 export class LiteralTransformer extends AbstractNodeTransformer {
@@ -47,7 +48,7 @@ export class LiteralTransformer extends AbstractNodeTransformer {
             case TransformationStage.Obfuscating:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
-                        if (parentNode && NodeGuards.isLiteralNode(node) && !node.obfuscatedNode) {
+                        if (parentNode && NodeGuards.isLiteralNode(node) && !NodeMetadata.isObfuscatedNode(node)) {
                             return this.transformNode(node, parentNode);
                         }
                     }

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

@@ -7,10 +7,10 @@ import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { NodeType } from '../../enums/node/NodeType';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
 
 /**
@@ -33,18 +33,6 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
         super(randomGenerator, options);
     }
 
-    /**
-     * @param {Identifier} node
-     * @returns {Literal}
-     */
-    private static transformIdentifierPropertyKey (node: ESTree.Identifier): ESTree.Literal {
-        return {
-            type: NodeType.Literal,
-            value: node.name,
-            raw: `'${node.name}'`
-        };
-    }
-
     /**
      * @param {TransformationStage} transformationStage
      * @returns {IVisitor | null}
@@ -82,7 +70,7 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
                 }
 
                 if (NodeGuards.isIdentifierNode(property.key)) {
-                    property.key = ObjectExpressionTransformer.transformIdentifierPropertyKey(property.key);
+                    property.key = NodeFactory.literalNode(property.key.name);
                 }
             });
 

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

@@ -20,6 +20,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
+import { NodeMetadata } from '../../node/NodeMetadata';
 import { NodeUtils } from '../../node/NodeUtils';
 
 /**
@@ -186,13 +187,17 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(blockScopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
-                if (parentNode && !node.obfuscatedNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
+                if (
+                    parentNode
+                    && NodeGuards.isReplaceableIdentifierNode(node, parentNode)
+                    && !NodeMetadata.isRenamedIdentifier(node)
+                ) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer.replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
-                        node.obfuscatedNode = true;
+                        NodeMetadata.set(node, { renamedIdentifier: true });
                     } else {
                         const storedReplaceableIdentifiers: ESTree.Identifier[] = storedReplaceableIdentifiersNamesMap.get(node.name) || [];
 

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

@@ -10,7 +10,7 @@ import { IIdentifierObfuscatingReplacer } from '../../../../interfaces/node-tran
 import { IOptions } from '../../../../interfaces/options/IOptions';
 
 import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { Nodes } from '../../../../node/Nodes';
+import { NodeFactory } from '../../../../node/NodeFactory';
 
 @injectable()
 export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplacer implements IIdentifierObfuscatingReplacer {
@@ -50,7 +50,7 @@ export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplac
             nodeValue = <string>this.namesMap.get(mapKey);
         }
 
-        return Nodes.getIdentifierNode(nodeValue);
+        return NodeFactory.identifierNode(nodeValue);
     }
 
     /**

src/node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/BooleanLiteralObfuscatingReplacer.ts

@@ -6,7 +6,7 @@ import * as ESTree from 'estree';
 import { IOptions } from '../../../../interfaces/options/IOptions';
 
 import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { Nodes } from '../../../../node/Nodes';
+import { NodeFactory } from '../../../../node/NodeFactory';
 
 @injectable()
 export class BooleanLiteralObfuscatingReplacer extends AbstractObfuscatingReplacer {
@@ -23,7 +23,7 @@ export class BooleanLiteralObfuscatingReplacer extends AbstractObfuscatingReplac
      * @return {ESTree.UnaryExpression}
      */
     private static getTrueUnaryExpressionNode (): ESTree.UnaryExpression {
-        return Nodes.getUnaryExpressionNode(
+        return NodeFactory.unaryExpressionNode(
             '!',
             BooleanLiteralObfuscatingReplacer.getFalseUnaryExpressionNode()
         );
@@ -33,9 +33,9 @@ export class BooleanLiteralObfuscatingReplacer extends AbstractObfuscatingReplac
      * @return {ESTree.UnaryExpression}
      */
     private static getFalseUnaryExpressionNode (): ESTree.UnaryExpression {
-        return Nodes.getUnaryExpressionNode(
+        return NodeFactory.unaryExpressionNode(
             '!',
-            Nodes.getArrayExpressionNode()
+            NodeFactory.arrayExpressionNode()
         );
     }
 

src/node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/NumberLiteralObfuscatingReplacer.ts

@@ -6,7 +6,7 @@ import * as ESTree from 'estree';
 import { IOptions } from '../../../../interfaces/options/IOptions';
 
 import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { Nodes } from '../../../../node/Nodes';
+import { NodeFactory } from '../../../../node/NodeFactory';
 import { Utils } from '../../../../utils/Utils';
 
 @injectable()
@@ -44,6 +44,6 @@ export class NumberLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
             this.numberLiteralCache.set(nodeValue, rawValue);
         }
 
-        return Nodes.getLiteralNode(nodeValue, rawValue);
+        return NodeFactory.literalNode(nodeValue, rawValue);
     }
 }

src/node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer.ts

@@ -14,7 +14,8 @@ import { IStringArrayIndexData } from '../../../../interfaces/node-transformers/
 import { StringArrayEncoding } from '../../../../enums/StringArrayEncoding';
 
 import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { Nodes } from '../../../../node/Nodes';
+import { NodeMetadata } from '../../../../node/NodeMetadata';
+import { NodeFactory } from '../../../../node/NodeFactory';
 import { Utils } from '../../../../utils/Utils';
 
 @injectable()
@@ -106,9 +107,9 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
      * @returns {Literal}
      */
     private static getHexadecimalLiteralNode (hexadecimalIndex: string): ESTree.Literal {
-        const hexadecimalLiteralNode: ESTree.Literal = Nodes.getLiteralNode(hexadecimalIndex);
+        const hexadecimalLiteralNode: ESTree.Literal = NodeFactory.literalNode(hexadecimalIndex);
 
-        hexadecimalLiteralNode.obfuscatedNode = true;
+        NodeMetadata.set(hexadecimalLiteralNode, { obfuscatedNode: true });
 
         return hexadecimalLiteralNode;
     }
@@ -118,9 +119,9 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
      * @returns {Literal}
      */
     private static getRc4KeyLiteralNode (literalValue: string): ESTree.Literal {
-        const rc4KeyLiteralNode: ESTree.Literal = Nodes.getLiteralNode(literalValue);
+        const rc4KeyLiteralNode: ESTree.Literal = NodeFactory.literalNode(literalValue);
 
-        rc4KeyLiteralNode.obfuscatedNode = true;
+        NodeMetadata.set(rc4KeyLiteralNode, { obfuscatedNode: true });
 
         return rc4KeyLiteralNode;
     }
@@ -215,7 +216,7 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
      * @returns {Node}
      */
     private replaceWithLiteralNode (value: string): ESTree.Node {
-        return Nodes.getLiteralNode(
+        return NodeFactory.literalNode(
             this.escapeSequenceEncoder.encode(value, this.options.unicodeEscapeSequence)
         );
     }
@@ -250,12 +251,12 @@ export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplace
             ));
         }
 
-        const stringArrayIdentifierNode: ESTree.Identifier = Nodes.getIdentifierNode(stringArrayStorageCallsWrapperName);
+        const stringArrayIdentifierNode: ESTree.Identifier = NodeFactory.identifierNode(stringArrayStorageCallsWrapperName);
 
         // prevent obfuscation of this identifier
-        stringArrayIdentifierNode.obfuscatedNode = true;
+        NodeMetadata.set(stringArrayIdentifierNode, { obfuscatedNode: true });
 
-        return Nodes.getCallExpressionNode(
+        return NodeFactory.callExpressionNode(
             stringArrayIdentifierNode,
             callExpressionArgs
         );

src/node-transformers/preparing-transformers/EvaCallExpressionTransformer.ts

@@ -13,8 +13,8 @@ import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
-import { Nodes } from '../../node/Nodes';
 import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
@@ -146,8 +146,8 @@ export class EvalCallExpressionTransformer extends AbstractNodeTransformer {
          * we should wrap AST-tree into the parent function expression node (ast root host node).
          * This function expression node will help to correctly transform AST-tree.
          */
-        const evalRootAstHostNode: ESTree.FunctionExpression = Nodes
-            .getFunctionExpressionNode([], Nodes.getBlockStatementNode(<any>ast));
+        const evalRootAstHostNode: ESTree.FunctionExpression = NodeFactory
+            .functionExpressionNode([], NodeFactory.blockStatementNode(<any>ast));
 
         /**
          * we should store that host node and then extract AST-tree on the `finalizing` stage
@@ -166,10 +166,10 @@ export class EvalCallExpressionTransformer extends AbstractNodeTransformer {
         const targetAst: ESTree.Statement[] = evalRootAstHostNode.body.body;
         const obfuscatedCode: string = NodeUtils.convertStructureToCode(targetAst);
 
-        return Nodes.getCallExpressionNode(
-            Nodes.getIdentifierNode('eval'),
+        return NodeFactory.callExpressionNode(
+            NodeFactory.identifierNode('eval'),
             [
-                Nodes.getLiteralNode(jsStringEscape(obfuscatedCode))
+                NodeFactory.literalNode(jsStringEscape(obfuscatedCode))
             ]
         );
     }

src/node-transformers/preparing-transformers/MetadataTransformer.ts

@@ -0,0 +1,62 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+
+import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
+
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeMetadata } from '../../node/NodeMetadata';
+
+/**
+ * Adds metadata properties to each node
+ */
+@injectable()
+export class MetadataTransformer extends AbstractNodeTransformer {
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(randomGenerator, options);
+    }
+
+    /**
+     * @param {TransformationStage} transformationStage
+     * @returns {IVisitor | null}
+     */
+    public getVisitor (transformationStage: TransformationStage): IVisitor | null {
+        switch (transformationStage) {
+            case TransformationStage.Preparing:
+                return {
+                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
+                        return this.transformNode(node, parentNode);
+                    }
+                };
+
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * @param {Node} node
+     * @param {Node} parentNode
+     * @returns {Node}
+     */
+    public transformNode (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node {
+        NodeMetadata.set(node, {
+            ignoredNode: false,
+            obfuscatedNode: false
+        });
+
+        return node;
+    }
+}

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

@@ -14,6 +14,7 @@ import { ObfuscatingGuard } from '../../enums/node-transformers/preparing-transf
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeMetadata } from '../../node/NodeMetadata';
 
 /**
  * Adds `ignoredNode` properties to each node
@@ -75,7 +76,9 @@ export class ObfuscatingGuardsTransformer extends AbstractNodeTransformer {
         const obfuscationAllowed: boolean = this.obfuscatingGuards
             .every((nodeGuard: IObfuscatingGuard) => nodeGuard.check(node));
 
-        node.ignoredNode = !obfuscationAllowed;
+        NodeMetadata.set(node, {
+            ignoredNode: !obfuscationAllowed
+        });
 
         return node;
     }

src/node/Nodes.ts → src/node/NodeFactory.ts

@@ -1,3 +1,5 @@
+/* tslint:disable:max-file-line-count */
+
 import * as escodegen from 'escodegen-wallaby';
 import * as ESTree from 'estree';
 
@@ -5,17 +7,20 @@ import { TStatement } from '../types/node/TStatement';
 
 import { NodeType } from '../enums/node/NodeType';
 
-export class Nodes {
+export class NodeFactory {
     /**
      * @param {TStatement[]} body
      * @returns {Program}
      */
-    public static getProgramNode (body: TStatement[] = []): ESTree.Program {
+    public static programNode (body: TStatement[] = []): ESTree.Program {
         return {
             type: NodeType.Program,
             body,
             sourceType: 'script',
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -23,12 +28,16 @@ export class Nodes {
      * @param {(Expression | SpreadElement)[]} elements
      * @returns {ArrayExpression}
      */
-    public static getArrayExpressionNode (
+    public static arrayExpressionNode (
         elements: (ESTree.Expression | ESTree.SpreadElement)[] = []
     ): ESTree.ArrayExpression {
         return {
             type: NodeType.ArrayExpression,
-            elements
+            elements,
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -38,7 +47,7 @@ export class Nodes {
      * @param {Expression} right
      * @returns {AssignmentExpression}
      */
-    public static getAssignmentExpressionNode (
+    public static assignmentExpressionNode (
         operator: ESTree.AssignmentOperator,
         left: ESTree.Pattern | ESTree.MemberExpression,
         right: ESTree.Expression
@@ -48,7 +57,10 @@ export class Nodes {
             operator,
             left,
             right,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -58,7 +70,7 @@ export class Nodes {
      * @param {Expression} right
      * @returns {BinaryExpression}
      */
-    public static getBinaryExpressionNode (
+    public static binaryExpressionNode (
         operator: ESTree.BinaryOperator,
         left: ESTree.Expression,
         right: ESTree.Expression,
@@ -68,7 +80,10 @@ export class Nodes {
             operator,
             left,
             right,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -76,11 +91,14 @@ export class Nodes {
      * @param {Statement[]} body
      * @returns {BlockStatement}
      */
-    public static getBlockStatementNode (body: ESTree.Statement[] = []): ESTree.BlockStatement {
+    public static blockStatementNode (body: ESTree.Statement[] = []): ESTree.BlockStatement {
         return {
             type: NodeType.BlockStatement,
             body,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -88,10 +106,13 @@ export class Nodes {
      * @param {Identifier} label
      * @returns {BreakStatement}
      */
-    public static getBreakStatement (label?: ESTree.Identifier): ESTree.BreakStatement {
+    public static breakStatement (label?: ESTree.Identifier): ESTree.BreakStatement {
         const breakStatementNode: ESTree.BreakStatement = {
             type: NodeType.BreakStatement,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
 
         if (label) {
@@ -106,7 +127,7 @@ export class Nodes {
      * @param {(Expression | SpreadElement)[]} args
      * @returns {CallExpression}
      */
-    public static getCallExpressionNode (
+    public static callExpressionNode (
         callee: ESTree.Expression,
         args: (ESTree.Expression | ESTree.SpreadElement)[] = []
     ): ESTree.CallExpression {
@@ -114,7 +135,10 @@ export class Nodes {
             type: NodeType.CallExpression,
             callee,
             arguments: args,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -122,10 +146,13 @@ export class Nodes {
      * @param {Identifier} label
      * @returns {ContinueStatement}
      */
-    public static getContinueStatement (label?: ESTree.Identifier): ESTree.ContinueStatement {
+    public static continueStatement (label?: ESTree.Identifier): ESTree.ContinueStatement {
         const continueStatementNode: ESTree.ContinueStatement = {
             type: NodeType.ContinueStatement,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
 
         if (label) {
@@ -139,11 +166,14 @@ export class Nodes {
      * @param {Expression} expression
      * @returns {ExpressionStatement}
      */
-    public static getExpressionStatementNode (expression: ESTree.Expression): ESTree.ExpressionStatement {
+    public static expressionStatementNode (expression: ESTree.Expression): ESTree.ExpressionStatement {
         return {
             type: NodeType.ExpressionStatement,
             expression,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -153,18 +183,21 @@ export class Nodes {
      * @param {BlockStatement} body
      * @returns {FunctionDeclaration}
      */
-    public static getFunctionDeclarationNode (
+    public static functionDeclarationNode (
         functionName: string,
         params: ESTree.Identifier[],
         body: ESTree.BlockStatement
     ): ESTree.FunctionDeclaration {
         return {
             type: NodeType.FunctionDeclaration,
-            id: Nodes.getIdentifierNode(functionName),
+            id: NodeFactory.identifierNode(functionName),
             params,
             body,
             generator: false,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -173,7 +206,7 @@ export class Nodes {
      * @param {BlockStatement} body
      * @returns {FunctionExpression}
      */
-    public static getFunctionExpressionNode (
+    public static functionExpressionNode (
         params: ESTree.Identifier[],
         body: ESTree.BlockStatement
     ): ESTree.FunctionExpression {
@@ -182,7 +215,10 @@ export class Nodes {
             params,
             body,
             generator: false,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -192,7 +228,7 @@ export class Nodes {
      * @param {BlockStatement} alternate
      * @returns {IfStatement}
      */
-    public static getIfStatementNode (
+    public static ifStatementNode (
         test: ESTree.Expression,
         consequent: ESTree.BlockStatement,
         alternate?: ESTree.BlockStatement
@@ -202,7 +238,10 @@ export class Nodes {
             test,
             consequent,
             ...alternate && { alternate },
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -210,11 +249,14 @@ export class Nodes {
      * @param {string} name
      * @returns {Identifier}
      */
-    public static getIdentifierNode (name: string): ESTree.Identifier {
+    public static identifierNode (name: string): ESTree.Identifier {
         return {
             type: NodeType.Identifier,
             name,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -223,7 +265,7 @@ export class Nodes {
      * @param {string} raw
      * @returns {Literal}
      */
-    public static getLiteralNode (value: boolean | number | string, raw?: string): ESTree.Literal {
+    public static literalNode (value: boolean | number | string, raw?: string): ESTree.Literal {
         raw = raw !== undefined ? raw : `'${value}'`;
 
         return {
@@ -234,7 +276,10 @@ export class Nodes {
                 content: raw,
                 precedence: escodegen.Precedence.Primary
             },
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -244,7 +289,7 @@ export class Nodes {
      * @param {Expression} right
      * @returns {LogicalExpression}
      */
-    public static getLogicalExpressionNode (
+    public static logicalExpressionNode (
         operator: ESTree.LogicalOperator,
         left: ESTree.Expression,
         right: ESTree.Expression,
@@ -254,7 +299,10 @@ export class Nodes {
             operator,
             left,
             right,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -264,7 +312,7 @@ export class Nodes {
      * @param {boolean} computed
      * @returns {MemberExpression}
      */
-    public static getMemberExpressionNode (
+    public static memberExpressionNode (
         object: ESTree.Expression | ESTree.Super,
         property: ESTree.Expression,
         computed: boolean = false
@@ -274,7 +322,10 @@ export class Nodes {
             computed,
             object,
             property,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -285,7 +336,7 @@ export class Nodes {
      * @param {boolean} computed
      * @returns {MethodDefinition}
      */
-    public static getMethodDefinitionNode (
+    public static methodDefinitionNode (
         key: ESTree.Expression,
         value: ESTree.FunctionExpression,
         kind: 'constructor' | 'method' | 'get' | 'set',
@@ -298,7 +349,10 @@ export class Nodes {
             kind,
             computed,
             static: false,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -306,11 +360,14 @@ export class Nodes {
      * @param {Property[]} properties
      * @returns {ObjectExpression}
      */
-    public static getObjectExpressionNode (properties: ESTree.Property[]): ESTree.ObjectExpression {
+    public static objectExpressionNode (properties: ESTree.Property[]): ESTree.ObjectExpression {
         return {
             type: NodeType.ObjectExpression,
             properties,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -320,7 +377,7 @@ export class Nodes {
      * @param {boolean} computed
      * @returns {Property}
      */
-    public static getPropertyNode (
+    public static propertyNode (
         key: ESTree.Expression,
         value: ESTree.Expression | ESTree.Pattern,
         computed: boolean = false
@@ -333,27 +390,10 @@ export class Nodes {
             method: false,
             shorthand: false,
             computed,
-            obfuscatedNode: false
-        };
-    }
-
-    /**
-     * @param {UnaryOperator} operator
-     * @param {Expression} argument
-     * @param {true} prefix
-     * @returns {UnaryExpression}
-     */
-    public static getUnaryExpressionNode (
-        operator: ESTree.UnaryOperator,
-        argument: ESTree.Expression,
-        prefix: true = true
-    ): ESTree.UnaryExpression {
-        return {
-            type: NodeType.UnaryExpression,
-            operator,
-            argument,
-            prefix,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -361,11 +401,14 @@ export class Nodes {
      * @param {Expression} argument
      * @returns {ReturnStatement}
      */
-    public static getReturnStatementNode (argument: ESTree.Expression): ESTree.ReturnStatement {
+    public static returnStatementNode (argument: ESTree.Expression): ESTree.ReturnStatement {
         return {
             type: NodeType.ReturnStatement,
             argument,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -374,7 +417,7 @@ export class Nodes {
      * @param {SwitchCase[]} cases
      * @returns {SwitchStatement}
      */
-    public static getSwitchStatementNode (
+    public static switchStatementNode (
         discriminant: ESTree.Expression,
         cases: ESTree.SwitchCase[]
     ): ESTree.SwitchStatement {
@@ -382,7 +425,10 @@ export class Nodes {
             type: NodeType.SwitchStatement,
             discriminant,
             cases,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -391,12 +437,38 @@ export class Nodes {
      * @param {Statement[]} consequent
      * @returns {SwitchCase}
      */
-    public static getSwitchCaseNode (test: ESTree.Expression, consequent: ESTree.Statement[]): ESTree.SwitchCase {
+    public static switchCaseNode (test: ESTree.Expression, consequent: ESTree.Statement[]): ESTree.SwitchCase {
         return {
             type: NodeType.SwitchCase,
             test,
             consequent,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
+        };
+    }
+
+    /**
+     * @param {UnaryOperator} operator
+     * @param {Expression} argument
+     * @param {true} prefix
+     * @returns {UnaryExpression}
+     */
+    public static unaryExpressionNode (
+        operator: ESTree.UnaryOperator,
+        argument: ESTree.Expression,
+        prefix: true = true
+    ): ESTree.UnaryExpression {
+        return {
+            type: NodeType.UnaryExpression,
+            operator,
+            argument,
+            prefix,
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -405,13 +477,16 @@ export class Nodes {
      * @param {Expression} argumentExpr
      * @returns {UpdateExpression}
      */
-    public static getUpdateExpressionNode (operator: ESTree.UpdateOperator, argumentExpr: ESTree.Expression): ESTree.UpdateExpression {
+    public static updateExpressionNode (operator: ESTree.UpdateOperator, argumentExpr: ESTree.Expression): ESTree.UpdateExpression {
         return {
             type: NodeType.UpdateExpression,
             operator,
             argument: argumentExpr,
             prefix: false,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -420,7 +495,7 @@ export class Nodes {
      * @param {string} kind
      * @returns {VariableDeclaration}
      */
-    public static getVariableDeclarationNode (
+    public static variableDeclarationNode (
         declarations: ESTree.VariableDeclarator[] = [],
         kind: 'var' | 'let' | 'const' = 'var'
     ): ESTree.VariableDeclaration {
@@ -428,7 +503,10 @@ export class Nodes {
             type: NodeType.VariableDeclaration,
             declarations,
             kind,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -437,12 +515,15 @@ export class Nodes {
      * @param {Expression | null} init
      * @returns {VariableDeclarator}
      */
-    public static getVariableDeclaratorNode (id: ESTree.Identifier, init: ESTree.Expression | null): ESTree.VariableDeclarator {
+    public static variableDeclaratorNode (id: ESTree.Identifier, init: ESTree.Expression | null): ESTree.VariableDeclarator {
         return {
             type: NodeType.VariableDeclarator,
             id,
             init,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 
@@ -451,12 +532,15 @@ export class Nodes {
      * @param {Statement} body
      * @returns {WhileStatement}
      */
-    public static getWhileStatementNode (test: ESTree.Expression, body: ESTree.Statement): ESTree.WhileStatement {
+    public static whileStatementNode (test: ESTree.Expression, body: ESTree.Statement): ESTree.WhileStatement {
         return {
             type: NodeType.WhileStatement,
             test,
             body,
-            obfuscatedNode: false
+            metadata: {
+                ignoredNode: false,
+                obfuscatedNode: false
+            }
         };
     }
 }

src/node/NodeMetadata.ts

@@ -0,0 +1,49 @@
+import * as ESTree from 'estree';
+
+export class NodeMetadata {
+    /**
+     * @param {Node} node
+     * @param {BaseNodeMetadata} metadata
+     */
+    public static set <T extends ESTree.Node = ESTree.Node> (node: T, metadata: Partial<T['metadata']>): void {
+        node.metadata = Object.assign(node.metadata || {}, metadata);
+    }
+
+    /**
+     * @param {Node} node
+     * @param {BaseNodeMetadata} metadataKey
+     * @returns {T | undefined}
+     */
+    public static get <T extends U[keyof U], U extends ESTree.BaseNodeMetadata> (
+        node: ESTree.Node,
+        metadataKey: keyof U
+    ): T | undefined {
+        return node.metadata !== undefined
+            ? <T>(<U>node.metadata)[metadataKey]
+            : undefined;
+    }
+
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isIgnoredNode (node: ESTree.Node): boolean {
+        return NodeMetadata.get(node, 'ignoredNode') === true;
+    }
+
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isObfuscatedNode (node: ESTree.Node): boolean {
+        return NodeMetadata.get(node, 'obfuscatedNode') === true;
+    }
+
+    /**
+     * @param {Node} identifierNode
+     * @returns {boolean}
+     */
+    public static isRenamedIdentifier (identifierNode: ESTree.Identifier): boolean {
+        return NodeMetadata.get<boolean, ESTree.IdentifierNodeMetadata>(identifierNode, 'renamedIdentifier') === true;
+    }
+}

src/node/NodeUtils.ts

@@ -9,6 +9,7 @@ import { TObject } from '../types/TObject';
 import { TStatement } from '../types/node/TStatement';
 
 import { NodeGuards } from './NodeGuards';
+import { NodeMetadata } from './NodeMetadata';
 
 export class NodeUtils {
     /**
@@ -48,6 +49,17 @@ export class NodeUtils {
         structure = NodeUtils.addXVerbatimPropertyToLiterals(structure);
         structure = NodeUtils.parentize(structure);
 
+        estraverse.replace(structure, {
+            enter: (node: ESTree.Node): ESTree.Node => {
+                NodeMetadata.set(node, {
+                    ignoredNode: false,
+                    obfuscatedNode: false
+                });
+
+                return node;
+            }
+        });
+
         return structure.body;
     }
 
@@ -136,7 +148,6 @@ export class NodeUtils {
      */
     public static parentizeNode <T extends ESTree.Node = ESTree.Node> (node: T, parentNode: ESTree.Node | null): T {
         node.parentNode = parentNode || node;
-        node.obfuscatedNode = false;
 
         return node;
     }

src/options/Options.ts

@@ -211,7 +211,7 @@ export class Options implements IOptions {
     /**
      * @type {ObfuscationTarget}
      */
-    @IsIn([ObfuscationTarget.Browser, ObfuscationTarget.Extension, ObfuscationTarget.Node])
+    @IsIn([ObfuscationTarget.Browser, ObfuscationTarget.BrowserNoEval, ObfuscationTarget.Node])
     public readonly target!: ObfuscationTarget;
 
     /**

src/utils/Utils.ts

@@ -67,7 +67,7 @@ export class Utils {
         return Array
             .from(string)
             .map((character: string): string => {
-                return JSFuck[<any>character] || character;
+                return JSFuck[<keyof typeof JSFuck>character] || character;
             })
             .join(' + ');
     }

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

@@ -16,8 +16,8 @@ import { IStackTraceData } from '../../../../src/interfaces/analyzers/stack-trac
 import { readFileAsString } from '../../../helpers/readFileAsString';
 
 import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
+import { NodeFactory } from '../../../../src/node/NodeFactory';
 import { NodeGuards } from '../../../../src/node/NodeGuards';
-import { Nodes } from '../../../../src/node/Nodes';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
 
 /**
@@ -165,7 +165,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #1: basic-1', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/basic-1.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -215,7 +215,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #2: basic-2', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/basic-2.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -254,7 +254,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #3: deep conditions nesting', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/deep-conditions-nesting.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -293,7 +293,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #4: call before declaration', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/call-before-declaration.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -316,7 +316,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #5: call expression of object member #1', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/call-expression-of-object-member-1.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -375,7 +375,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #5: call expression of object member #2', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/call-expression-of-object-member-2.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -403,7 +403,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #6: no call expressions', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/no-call-expressions.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -420,7 +420,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #7: only call expression', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/only-call-expression.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -437,7 +437,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #8: self-invoking functions', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/self-invoking-functions.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 
@@ -472,7 +472,7 @@ describe('StackTraceAnalyzer', () => {
         describe('Variant #9: no recursion', () => {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/no-recursion.js');
-                const astTree: TNodeWithBlockScope = Nodes.getProgramNode(
+                const astTree: TNodeWithBlockScope = NodeFactory.programNode(
                     NodeUtils.convertCodeToStructure(code)
                 );
 

test/functional-tests/templates/debug-protection-nodes/DebugProtectionFunctionCallTemplate.spec.ts

@@ -115,7 +115,7 @@ describe('DebugProtectionFunctionCallTemplate (): string', () => {
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     debugProtection: true,
-                    target: ObfuscationTarget.Extension
+                    target: ObfuscationTarget.BrowserNoEval
                 }
             );
 

test/unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec.ts

@@ -11,8 +11,9 @@ import { IInversifyContainerFacade } from '../../../../src/interfaces/container/
 import { INodeTransformer } from '../../../../src/interfaces/node-transformers/INodeTransformer';
 
 import { NodeTransformer } from '../../../../src/enums/node-transformers/NodeTransformer';
-import { Nodes } from '../../../../src/node/Nodes';
+import { NodeFactory } from '../../../../src/node/NodeFactory';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
+import { NodeMetadata } from '../../../../src/node/NodeMetadata';
 
 describe('ObfuscatingGuardsTransformer', () => {
     describe('transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node', () => {
@@ -28,7 +29,7 @@ describe('ObfuscatingGuardsTransformer', () => {
         });
 
         describe('Variant #1: valid node', () => {
-            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
+            const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
 
             const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
 
@@ -37,7 +38,7 @@ describe('ObfuscatingGuardsTransformer', () => {
             before(() => {
                 identifier.parentNode = identifier;
 
-                expectedResult.ignoredNode = false;
+                NodeMetadata.set(expectedResult, { ignoredNode: false });
 
                 result = <ESTree.Identifier>obfuscatingGuardsTransformer.transformNode(identifier, identifier);
             });
@@ -48,8 +49,8 @@ describe('ObfuscatingGuardsTransformer', () => {
         });
 
         describe('Variant #2: invalid node', () => {
-            const expressionStatement: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(
-                Nodes.getIdentifierNode('foo')
+            const expressionStatement: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(
+                NodeFactory.identifierNode('foo')
             );
 
             const expectedResult: ESTree.ExpressionStatement = NodeUtils.clone(expressionStatement);
@@ -63,7 +64,7 @@ describe('ObfuscatingGuardsTransformer', () => {
 
                 expectedResult.directive = 'use strict';
                 expectedResult.parentNode = expectedResult;
-                expectedResult.ignoredNode = true;
+                NodeMetadata.set(expectedResult, { ignoredNode: true });
 
                 result = <ESTree.ExpressionStatement>obfuscatingGuardsTransformer
                     .transformNode(expressionStatement, expressionStatement);

test/unit-tests/node/node-appender/NodeAppender.spec.ts

@@ -16,7 +16,7 @@ import { readFileAsString } from '../../../helpers/readFileAsString';
 
 import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
 import { NodeAppender } from '../../../../src/node/NodeAppender';
-import { Nodes } from '../../../../src/node/Nodes';
+import { NodeFactory } from '../../../../src/node/NodeFactory';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
 
 /**
@@ -34,7 +34,7 @@ const convertCodeToStructure: (fixturePath: string) => TStatement[] = (fixturePa
  * @return {ESTree.Program}
  */
 const convertCodeToAst: (fixturePath: string) => ESTree.Program = (fixturePath) => {
-    return Nodes.getProgramNode(convertCodeToStructure(fixturePath));
+    return NodeFactory.programNode(convertCodeToStructure(fixturePath));
 };
 
 describe('NodeAppender', () => {

test/unit-tests/node/node-guards/NodeGuards.spec.ts

@@ -2,8 +2,8 @@ import * as ESTree from 'estree';
 
 import { assert } from 'chai';
 
-import { Nodes } from '../../../../src/node/Nodes';
 import { NodeGuards } from '../../../../src/node/NodeGuards';
+import { NodeFactory } from '../../../../src/node/NodeFactory';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
 
 describe('NodeGuards', () => {
@@ -11,8 +11,8 @@ describe('NodeGuards', () => {
         describe('truthful checks', () => {
             describe('Variant #1: block statement of function declaration', () => {
                 const expectedResult: boolean = true;
-                const node: ESTree.Node = Nodes.getBlockStatementNode();
-                const parentNode: ESTree.FunctionDeclaration = Nodes.getFunctionDeclarationNode(
+                const node: ESTree.Node = NodeFactory.blockStatementNode();
+                const parentNode: ESTree.FunctionDeclaration = NodeFactory.functionDeclarationNode(
                     'foo',
                     [],
                     node
@@ -32,8 +32,8 @@ describe('NodeGuards', () => {
 
             describe('Variant #2: block statement of function expression', () => {
                 const expectedResult: boolean = true;
-                const node: ESTree.Node = Nodes.getBlockStatementNode();
-                const parentNode: ESTree.FunctionExpression = Nodes.getFunctionExpressionNode(
+                const node: ESTree.Node = NodeFactory.blockStatementNode();
+                const parentNode: ESTree.FunctionExpression = NodeFactory.functionExpressionNode(
                     [],
                     node
                 );
@@ -54,20 +54,20 @@ describe('NodeGuards', () => {
         describe('false checks', () => {
             describe('Variant #1: switch-case node', () => {
                 const expectedResult: boolean = false;
-                const node: ESTree.Node = Nodes.getSwitchCaseNode(
-                    Nodes.getLiteralNode(1),
+                const node: ESTree.Node = NodeFactory.switchCaseNode(
+                    NodeFactory.literalNode(1),
                     []
                 );
-                const parentNode: ESTree.FunctionDeclaration = Nodes.getFunctionDeclarationNode(
+                const parentNode: ESTree.FunctionDeclaration = NodeFactory.functionDeclarationNode(
                     'foo',
                     [],
-                    Nodes.getBlockStatementNode([
-                        Nodes.getSwitchStatementNode(
-                            Nodes.getMemberExpressionNode(
-                                Nodes.getIdentifierNode('bar'),
-                                Nodes.getUpdateExpressionNode(
+                    NodeFactory.blockStatementNode([
+                        NodeFactory.switchStatementNode(
+                            NodeFactory.memberExpressionNode(
+                                NodeFactory.identifierNode('bar'),
+                                NodeFactory.updateExpressionNode(
                                     '++',
-                                    Nodes.getIdentifierNode('baz')
+                                    NodeFactory.identifierNode('baz')
                                 ),
                                 true
                             ),
@@ -90,14 +90,14 @@ describe('NodeGuards', () => {
 
             describe('Variant #2: literal node', () => {
                 const expectedResult: boolean = false;
-                const node: ESTree.Node = Nodes.getLiteralNode(1);
-                const parentNode: ESTree.FunctionDeclaration = Nodes.getFunctionDeclarationNode(
+                const node: ESTree.Node = NodeFactory.literalNode(1);
+                const parentNode: ESTree.FunctionDeclaration = NodeFactory.functionDeclarationNode(
                     'foo',
                     [],
-                    Nodes.getBlockStatementNode([
-                        Nodes.getExpressionStatementNode(
-                            Nodes.getCallExpressionNode(
-                                Nodes.getIdentifierNode('bar'),
+                    NodeFactory.blockStatementNode([
+                        NodeFactory.expressionStatementNode(
+                            NodeFactory.callExpressionNode(
+                                NodeFactory.identifierNode('bar'),
                                 [node]
                             )
                         )
@@ -118,9 +118,9 @@ describe('NodeGuards', () => {
 
             describe('Variant #3: block statement of if statement', () => {
                 const expectedResult: boolean = false;
-                const node: ESTree.Node = Nodes.getBlockStatementNode();
-                const parentNode: ESTree.IfStatement = Nodes.getIfStatementNode(
-                    Nodes.getIdentifierNode('foo'),
+                const node: ESTree.Node = NodeFactory.blockStatementNode();
+                const parentNode: ESTree.IfStatement = NodeFactory.ifStatementNode(
+                    NodeFactory.identifierNode('foo'),
                     node
                 );
 
@@ -142,7 +142,7 @@ describe('NodeGuards', () => {
         describe('truthful checks', () => {
             describe('Variant #1: program node', () => {
                 const expectedResult: boolean = true;
-                const node: ESTree.Node = Nodes.getProgramNode();
+                const node: ESTree.Node = NodeFactory.programNode();
 
                 let result: boolean;
 
@@ -157,7 +157,7 @@ describe('NodeGuards', () => {
 
             describe('Variant #2: block statement node', () => {
                 const expectedResult: boolean = true;
-                const node: ESTree.Node = Nodes.getBlockStatementNode();
+                const node: ESTree.Node = NodeFactory.blockStatementNode();
 
                 let result: boolean;
 
@@ -172,8 +172,8 @@ describe('NodeGuards', () => {
 
             describe('Variant #3: switch case node', () => {
                 const expectedResult: boolean = true;
-                const node: ESTree.Node = Nodes.getSwitchCaseNode(
-                    Nodes.getLiteralNode(1),
+                const node: ESTree.Node = NodeFactory.switchCaseNode(
+                    NodeFactory.literalNode(1),
                     []
                 );
 
@@ -192,7 +192,7 @@ describe('NodeGuards', () => {
         describe('false checks', () => {
             describe('Variant #1: literal node', () => {
                 const expectedResult: boolean = false;
-                const node: ESTree.Node = Nodes.getLiteralNode(1);
+                const node: ESTree.Node = NodeFactory.literalNode(1);
 
                 let result: boolean;
 
@@ -207,7 +207,7 @@ describe('NodeGuards', () => {
 
             describe('Variant #2: identifier node', () => {
                 const expectedResult: boolean = false;
-                const node: ESTree.Node = Nodes.getIdentifierNode('foo');
+                const node: ESTree.Node = NodeFactory.identifierNode('foo');
 
                 let result: boolean;
 
@@ -222,9 +222,9 @@ describe('NodeGuards', () => {
 
             describe('Variant #3: if-statement node', () => {
                 const expectedResult: boolean = false;
-                const node: ESTree.Node = Nodes.getIfStatementNode(
-                    Nodes.getIdentifierNode('foo'),
-                    Nodes.getBlockStatementNode()
+                const node: ESTree.Node = NodeFactory.ifStatementNode(
+                    NodeFactory.identifierNode('foo'),
+                    NodeFactory.blockStatementNode()
                 );
 
                 let result: boolean;
@@ -240,8 +240,8 @@ describe('NodeGuards', () => {
 
             describe('Variant #4: switch-statement node', () => {
                 const expectedResult: boolean = false;
-                const node: ESTree.Node = Nodes.getSwitchStatementNode(
-                    Nodes.getIdentifierNode('foo'),
+                const node: ESTree.Node = NodeFactory.switchStatementNode(
+                    NodeFactory.identifierNode('foo'),
                     []
                 );
 
@@ -262,11 +262,11 @@ describe('NodeGuards', () => {
         describe('truthful checks', () => {
             describe('Variant #1: parent node is function declaration node', () => {
                 const expectedResult: boolean = true;
-                const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-                const parentNode: ESTree.Node = Nodes.getFunctionDeclarationNode(
+                const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+                const parentNode: ESTree.Node = NodeFactory.functionDeclarationNode(
                     'bar',
                     [identifier],
-                    Nodes.getBlockStatementNode()
+                    NodeFactory.blockStatementNode()
                 );
 
                 let result: boolean;
@@ -283,10 +283,10 @@ describe('NodeGuards', () => {
 
             describe('Variant #2: parent node is computed property node', () => {
                 const expectedResult: boolean = true;
-                const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-                const parentNode: ESTree.Node = Nodes.getPropertyNode(
+                const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+                const parentNode: ESTree.Node = NodeFactory.propertyNode(
                     identifier,
-                    Nodes.getLiteralNode('bar'),
+                    NodeFactory.literalNode('bar'),
                     true
                 );
 
@@ -304,9 +304,9 @@ describe('NodeGuards', () => {
 
             describe('Variant #4: parent node is computed member expression node', () => {
                 const expectedResult: boolean = true;
-                const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-                const parentNode: ESTree.Node = Nodes.getMemberExpressionNode(
-                    Nodes.getIdentifierNode('bar'),
+                const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+                const parentNode: ESTree.Node = NodeFactory.memberExpressionNode(
+                    NodeFactory.identifierNode('bar'),
                     identifier,
                     true
                 );
@@ -325,10 +325,10 @@ describe('NodeGuards', () => {
 
             describe('Variant #4: parent node is computed method definition node', () => {
                 const expectedResult: boolean = true;
-                const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-                const parentNode: ESTree.Node = Nodes.getMethodDefinitionNode(
+                const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+                const parentNode: ESTree.Node = NodeFactory.methodDefinitionNode(
                     identifier,
-                    Nodes.getFunctionExpressionNode([], Nodes.getBlockStatementNode()),
+                    NodeFactory.functionExpressionNode([], NodeFactory.blockStatementNode()),
                     'method',
                     true
                 );
@@ -349,10 +349,10 @@ describe('NodeGuards', () => {
         describe('false checks', () => {
             describe('Variant #1: node isn\'t an identifier', () => {
                 const expectedResult: boolean = false;
-                const literal: ESTree.Literal = Nodes.getLiteralNode(1);
-                const parentNode: ESTree.Node = Nodes.getExpressionStatementNode(
-                    Nodes.getCallExpressionNode(
-                        Nodes.getIdentifierNode('foo'),
+                const literal: ESTree.Literal = NodeFactory.literalNode(1);
+                const parentNode: ESTree.Node = NodeFactory.expressionStatementNode(
+                    NodeFactory.callExpressionNode(
+                        NodeFactory.identifierNode('foo'),
                         [literal]
                     )
                 );
@@ -371,10 +371,10 @@ describe('NodeGuards', () => {
 
             describe('Variant #2: parent node isn\'t computed property node', () => {
                 const expectedResult: boolean = false;
-                const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-                const parentNode: ESTree.Node = Nodes.getPropertyNode(
+                const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+                const parentNode: ESTree.Node = NodeFactory.propertyNode(
                     identifier,
-                    Nodes.getLiteralNode('bar'),
+                    NodeFactory.literalNode('bar'),
                     false
                 );
 
@@ -392,9 +392,9 @@ describe('NodeGuards', () => {
 
             describe('Variant #3: parent node isn\'t computed member expression node', () => {
                 const expectedResult: boolean = false;
-                const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-                const parentNode: ESTree.Node = Nodes.getMemberExpressionNode(
-                    Nodes.getIdentifierNode('bar'),
+                const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+                const parentNode: ESTree.Node = NodeFactory.memberExpressionNode(
+                    NodeFactory.identifierNode('bar'),
                     identifier,
                     false
                 );
@@ -413,10 +413,10 @@ describe('NodeGuards', () => {
 
             describe('Variant #4: parent node isn\'t computed method definition node', () => {
                 const expectedResult: boolean = false;
-                const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-                const parentNode: ESTree.Node = Nodes.getMethodDefinitionNode(
+                const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+                const parentNode: ESTree.Node = NodeFactory.methodDefinitionNode(
                     identifier,
-                    Nodes.getFunctionExpressionNode([], Nodes.getBlockStatementNode()),
+                    NodeFactory.functionExpressionNode([], NodeFactory.blockStatementNode()),
                     'method',
                     false
                 );

test/unit-tests/node/node-utils/NodeUtils.spec.ts

@@ -4,7 +4,7 @@ import { assert } from 'chai';
 
 import { TStatement } from '../../../../src/types/node/TStatement';
 
-import { Nodes } from '../../../../src/node/Nodes';
+import { NodeFactory } from '../../../../src/node/NodeFactory';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
 
 describe('NodeUtils', () => {
@@ -13,10 +13,10 @@ describe('NodeUtils', () => {
             expectedLiteralNode: ESTree.Literal;
 
         before(() => {
-            literalNode = Nodes.getLiteralNode('value');
+            literalNode = NodeFactory.literalNode('value');
             delete literalNode['x-verbatim-property'];
 
-            expectedLiteralNode = Nodes.getLiteralNode('value');
+            expectedLiteralNode = NodeFactory.literalNode('value');
 
             NodeUtils.addXVerbatimPropertyToLiterals(literalNode);
         });
@@ -33,40 +33,40 @@ describe('NodeUtils', () => {
 
             before(() => {
                 // actual AST tree
-                const expressionStatementNode1: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
-                const expressionStatementNode2: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
+                const expressionStatementNode1: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
+                const expressionStatementNode2: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
 
-                const ifStatementBlockStatementNode1: ESTree.BlockStatement = Nodes.getBlockStatementNode([
+                const ifStatementBlockStatementNode1: ESTree.BlockStatement = NodeFactory.blockStatementNode([
                     expressionStatementNode1,
                     expressionStatementNode2
                 ]);
 
-                const ifStatementNode1: ESTree.IfStatement = Nodes.getIfStatementNode(
-                    Nodes.getLiteralNode(true),
+                const ifStatementNode1: ESTree.IfStatement = NodeFactory.ifStatementNode(
+                    NodeFactory.literalNode(true),
                     ifStatementBlockStatementNode1
                 );
 
                 // expected AST tree
-                const expressionStatementNode3: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
-                const expressionStatementNode4: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
+                const expressionStatementNode3: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
+                const expressionStatementNode4: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
 
-                const ifStatementBlockStatementNode2: ESTree.BlockStatement = Nodes.getBlockStatementNode([
+                const ifStatementBlockStatementNode2: ESTree.BlockStatement = NodeFactory.blockStatementNode([
                     expressionStatementNode3,
                     expressionStatementNode4
                 ]);
 
-                const ifStatementNode2: ESTree.IfStatement = Nodes.getIfStatementNode(
-                    Nodes.getLiteralNode(true),
+                const ifStatementNode2: ESTree.IfStatement = NodeFactory.ifStatementNode(
+                    NodeFactory.literalNode(true),
                     ifStatementBlockStatementNode2
                 );
 
                 programNode = NodeUtils.clone(
-                    Nodes.getProgramNode([
+                    NodeFactory.programNode([
                         ifStatementNode1
                     ])
                 );
                 expectedProgramNode = NodeUtils.parentize(
-                    Nodes.getProgramNode([
+                    NodeFactory.programNode([
                         ifStatementNode2
                     ])
                 );
@@ -83,34 +83,34 @@ describe('NodeUtils', () => {
 
             before(() => {
                 // actual AST tree
-                const arrayExpressionNode: ESTree.ArrayExpression = Nodes.getArrayExpressionNode([
-                    Nodes.getLiteralNode(1),
-                    Nodes.getLiteralNode(2),
+                const arrayExpressionNode: ESTree.ArrayExpression = NodeFactory.arrayExpressionNode([
+                    NodeFactory.literalNode(1),
+                    NodeFactory.literalNode(2),
                     <any>null,
-                    Nodes.getLiteralNode(4)
+                    NodeFactory.literalNode(4)
                 ]);
-                const expressionStatementNode: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(
+                const expressionStatementNode: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(
                     arrayExpressionNode
                 );
 
                 // expected AST tree
-                const expectedArrayExpressionNode: ESTree.ArrayExpression = Nodes.getArrayExpressionNode([
-                    Nodes.getLiteralNode(1),
-                    Nodes.getLiteralNode(2),
+                const expectedArrayExpressionNode: ESTree.ArrayExpression = NodeFactory.arrayExpressionNode([
+                    NodeFactory.literalNode(1),
+                    NodeFactory.literalNode(2),
                     <any>null,
-                    Nodes.getLiteralNode(4)
+                    NodeFactory.literalNode(4)
                 ]);
-                const expectedExpressionStatementNode: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(
+                const expectedExpressionStatementNode: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(
                     expectedArrayExpressionNode
                 );
 
                 programNode = NodeUtils.clone(
-                    Nodes.getProgramNode([
+                    NodeFactory.programNode([
                         expressionStatementNode
                     ])
                 );
                 expectedProgramNode = NodeUtils.parentize(
-                    Nodes.getProgramNode([
+                    NodeFactory.programNode([
                         expectedExpressionStatementNode
                     ])
                 );
@@ -131,13 +131,13 @@ describe('NodeUtils', () => {
                 var abc = 'cde';
             `;
 
-            const identifierNode: ESTree.Identifier = Nodes.getIdentifierNode('abc');
-            const literalNode: ESTree.Literal = Nodes.getLiteralNode('cde');
-            const variableDeclaratorNode: ESTree.VariableDeclarator = Nodes.getVariableDeclaratorNode(identifierNode, literalNode);
-            const variableDeclarationNode: ESTree.VariableDeclaration = Nodes.getVariableDeclarationNode([
+            const identifierNode: ESTree.Identifier = NodeFactory.identifierNode('abc');
+            const literalNode: ESTree.Literal = NodeFactory.literalNode('cde');
+            const variableDeclaratorNode: ESTree.VariableDeclarator = NodeFactory.variableDeclaratorNode(identifierNode, literalNode);
+            const variableDeclarationNode: ESTree.VariableDeclaration = NodeFactory.variableDeclarationNode([
                 variableDeclaratorNode
             ]);
-            const programNode: ESTree.Program = Nodes.getProgramNode([
+            const programNode: ESTree.Program = NodeFactory.programNode([
                 variableDeclarationNode
             ]);
 
@@ -162,11 +162,11 @@ describe('NodeUtils', () => {
 
         before(() => {
             structure = [
-                Nodes.getProgramNode([
-                    Nodes.getVariableDeclarationNode([
-                        Nodes.getVariableDeclaratorNode(
-                            Nodes.getIdentifierNode('abc'),
-                            Nodes.getLiteralNode('cde')
+                NodeFactory.programNode([
+                    NodeFactory.variableDeclarationNode([
+                        NodeFactory.variableDeclaratorNode(
+                            NodeFactory.identifierNode('abc'),
+                            NodeFactory.literalNode('cde')
                         )
                     ])
                 ])
@@ -192,37 +192,37 @@ describe('NodeUtils', () => {
             programNode: ESTree.Program;
 
         before(() => {
-            expressionStatementNode1 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
-            expressionStatementNode2 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
-            expressionStatementNode3 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
+            expressionStatementNode1 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
+            expressionStatementNode2 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
+            expressionStatementNode3 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
 
-            ifStatementBlockStatementNode2 = Nodes.getBlockStatementNode([
+            ifStatementBlockStatementNode2 = NodeFactory.blockStatementNode([
                 expressionStatementNode2,
                 expressionStatementNode3
             ]);
 
-            ifStatementNode2 = Nodes.getIfStatementNode(
-                Nodes.getLiteralNode(true),
+            ifStatementNode2 = NodeFactory.ifStatementNode(
+                NodeFactory.literalNode(true),
                 ifStatementBlockStatementNode2
             );
 
-            ifStatementBlockStatementNode1 = Nodes.getBlockStatementNode([
+            ifStatementBlockStatementNode1 = NodeFactory.blockStatementNode([
                 ifStatementNode2
             ]);
 
-            ifStatementNode1 = Nodes.getIfStatementNode(
-                Nodes.getLiteralNode(true),
+            ifStatementNode1 = NodeFactory.ifStatementNode(
+                NodeFactory.literalNode(true),
                 ifStatementBlockStatementNode1
             );
 
-            functionDeclarationBlockStatementNode = Nodes.getBlockStatementNode([
+            functionDeclarationBlockStatementNode = NodeFactory.blockStatementNode([
                 expressionStatementNode1,
                 ifStatementNode1
             ]);
 
-            functionDeclarationNode = Nodes.getFunctionDeclarationNode('test', [], functionDeclarationBlockStatementNode);
+            functionDeclarationNode = NodeFactory.functionDeclarationNode('test', [], functionDeclarationBlockStatementNode);
 
-            programNode = Nodes.getProgramNode([
+            programNode = NodeFactory.programNode([
                 functionDeclarationNode
             ]);
 
@@ -301,17 +301,17 @@ describe('NodeUtils', () => {
                 statementNode3: ESTree.Statement;
 
             before(() => {
-                statementNode1 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('a')
+                statementNode1 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('a')
                 );
-                statementNode2 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('b')
+                statementNode2 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('b')
                 );
-                statementNode3 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('c')
+                statementNode3 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('c')
                 );
 
-                const blockStatementNode: ESTree.BlockStatement = Nodes.getBlockStatementNode([
+                const blockStatementNode: ESTree.BlockStatement = NodeFactory.blockStatementNode([
                     statementNode1,
                     statementNode2,
                     statementNode3
@@ -341,18 +341,18 @@ describe('NodeUtils', () => {
                 statementNode3: ESTree.Statement;
 
             before(() => {
-                statementNode1 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('a')
+                statementNode1 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('a')
                 );
-                statementNode2 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('b')
+                statementNode2 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('b')
                 );
-                statementNode3 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('c')
+                statementNode3 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('c')
                 );
 
-                const switchCaseNode: ESTree.SwitchCase = Nodes.getSwitchCaseNode(
-                    Nodes.getLiteralNode(true),
+                const switchCaseNode: ESTree.SwitchCase = NodeFactory.switchCaseNode(
+                    NodeFactory.literalNode(true),
                     [
                         statementNode1,
                         statementNode2,
@@ -386,17 +386,17 @@ describe('NodeUtils', () => {
                 statementNode3: ESTree.Statement;
 
             before(() => {
-                statementNode1 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('a')
+                statementNode1 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('a')
                 );
-                statementNode2 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('b')
+                statementNode2 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('b')
                 );
-                statementNode3 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('c')
+                statementNode3 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('c')
                 );
 
-                const blockStatementNode: ESTree.BlockStatement = Nodes.getBlockStatementNode([
+                const blockStatementNode: ESTree.BlockStatement = NodeFactory.blockStatementNode([
                     statementNode1,
                     statementNode2,
                     statementNode3
@@ -426,18 +426,18 @@ describe('NodeUtils', () => {
                 statementNode3: ESTree.Statement;
 
             before(() => {
-                statementNode1 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('a')
+                statementNode1 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('a')
                 );
-                statementNode2 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('b')
+                statementNode2 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('b')
                 );
-                statementNode3 = Nodes.getExpressionStatementNode(
-                    Nodes.getIdentifierNode('c')
+                statementNode3 = NodeFactory.expressionStatementNode(
+                    NodeFactory.identifierNode('c')
                 );
 
-                const switchCaseNode: ESTree.SwitchCase = Nodes.getSwitchCaseNode(
-                    Nodes.getLiteralNode(true),
+                const switchCaseNode: ESTree.SwitchCase = NodeFactory.switchCaseNode(
+                    NodeFactory.literalNode(true),
                     [
                         statementNode1,
                         statementNode2,
@@ -481,59 +481,59 @@ describe('NodeUtils', () => {
             programNode: ESTree.Program;
 
         before(() => {
-            expressionStatementNode1 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
-            expressionStatementNode2 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
-            expressionStatementNode3 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
+            expressionStatementNode1 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
+            expressionStatementNode2 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
+            expressionStatementNode3 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
 
-            ifStatementBlockStatementNode3 = Nodes.getBlockStatementNode([
+            ifStatementBlockStatementNode3 = NodeFactory.blockStatementNode([
                 expressionStatementNode2,
                 expressionStatementNode3
             ]);
 
-            ifStatementNode3 = Nodes.getIfStatementNode(
-                Nodes.getLiteralNode(true),
+            ifStatementNode3 = NodeFactory.ifStatementNode(
+                NodeFactory.literalNode(true),
                 ifStatementBlockStatementNode3
             );
 
-            ifStatementBlockStatementNode2 = Nodes.getBlockStatementNode();
+            ifStatementBlockStatementNode2 = NodeFactory.blockStatementNode();
 
-            ifStatementBlockStatementNode1 = Nodes.getBlockStatementNode([
+            ifStatementBlockStatementNode1 = NodeFactory.blockStatementNode([
                 ifStatementNode3
             ]);
 
-            ifStatementNode2 = Nodes.getIfStatementNode(
-                Nodes.getLiteralNode(true),
+            ifStatementNode2 = NodeFactory.ifStatementNode(
+                NodeFactory.literalNode(true),
                 ifStatementBlockStatementNode2
             );
 
-            ifStatementNode1 = Nodes.getIfStatementNode(
-                Nodes.getLiteralNode(true),
+            ifStatementNode1 = NodeFactory.ifStatementNode(
+                NodeFactory.literalNode(true),
                 ifStatementBlockStatementNode1
             );
 
-            switchCaseNode = Nodes.getSwitchCaseNode(
-                Nodes.getLiteralNode(1),
+            switchCaseNode = NodeFactory.switchCaseNode(
+                NodeFactory.literalNode(1),
                 [
                     ifStatementNode2
                 ]
             );
 
-            switchStatementNode = Nodes.getSwitchStatementNode(
-                Nodes.getLiteralNode(1),
+            switchStatementNode = NodeFactory.switchStatementNode(
+                NodeFactory.literalNode(1),
                 [
                     switchCaseNode
                 ]
             );
 
-            functionDeclarationBlockStatementNode = Nodes.getBlockStatementNode([
+            functionDeclarationBlockStatementNode = NodeFactory.blockStatementNode([
                 expressionStatementNode1,
                 ifStatementNode1,
                 switchStatementNode
             ]);
 
-            functionDeclarationNode = Nodes.getFunctionDeclarationNode('test', [], functionDeclarationBlockStatementNode);
+            functionDeclarationNode = NodeFactory.functionDeclarationNode('test', [], functionDeclarationBlockStatementNode);
 
-            programNode = Nodes.getProgramNode([
+            programNode = NodeFactory.programNode([
                 functionDeclarationNode
             ]);
 
@@ -610,11 +610,11 @@ describe('NodeUtils', () => {
             unaryExpressionArgumentNode: ESTree.Node;
 
         before(() => {
-            const literalNode: ESTree.Literal = Nodes.getLiteralNode('test');
-            const unaryExpressionNode2: ESTree.UnaryExpression = Nodes.getUnaryExpressionNode('!', literalNode);
-            const unaryExpressionNode1: ESTree.UnaryExpression = Nodes.getUnaryExpressionNode('!', unaryExpressionNode2);
-            const expressionStatementNode: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(unaryExpressionNode1);
-            const programNode: ESTree.Program = Nodes.getProgramNode([
+            const literalNode: ESTree.Literal = NodeFactory.literalNode('test');
+            const unaryExpressionNode2: ESTree.UnaryExpression = NodeFactory.unaryExpressionNode('!', literalNode);
+            const unaryExpressionNode1: ESTree.UnaryExpression = NodeFactory.unaryExpressionNode('!', unaryExpressionNode2);
+            const expressionStatementNode: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(unaryExpressionNode1);
+            const programNode: ESTree.Program = NodeFactory.programNode([
                 expressionStatementNode
             ]);
 
@@ -641,23 +641,23 @@ describe('NodeUtils', () => {
             programNode: ESTree.Program;
 
         beforeEach(() => {
-            expressionStatementNode1 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
-            expressionStatementNode2 = Nodes.getExpressionStatementNode(Nodes.getIdentifierNode('identifier'));
+            expressionStatementNode1 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
+            expressionStatementNode2 = NodeFactory.expressionStatementNode(NodeFactory.identifierNode('identifier'));
 
-            ifStatementBlockStatementNode = Nodes.getBlockStatementNode([
+            ifStatementBlockStatementNode = NodeFactory.blockStatementNode([
                 expressionStatementNode1,
                 expressionStatementNode2
             ]);
 
-            ifStatementNode = Nodes.getIfStatementNode(
-                Nodes.getLiteralNode(true),
+            ifStatementNode = NodeFactory.ifStatementNode(
+                NodeFactory.literalNode(true),
                 ifStatementBlockStatementNode
             );
         });
 
         describe('Variant #1: parentize AST-tree with `ProgramNode` as root node', () => {
             beforeEach(() => {
-                programNode = Nodes.getProgramNode([
+                programNode = NodeFactory.programNode([
                     ifStatementNode
                 ]);
 
@@ -710,8 +710,8 @@ describe('NodeUtils', () => {
 
     describe('parentizeNode <T extends ESTree.Node = ESTree.Program> (node: T, parentNode: ESTree.Node): T', () => {
         describe('Variant #1: node with parent node', () => {
-            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-            const breakStatement: ESTree.BreakStatement = Nodes.getBreakStatement(identifier);
+            const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');
+            const breakStatement: ESTree.BreakStatement = NodeFactory.breakStatement(identifier);
 
             const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
 
@@ -729,7 +729,7 @@ describe('NodeUtils', () => {
         });
 
         describe('Variant #2: node without parent node', () => {
-            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('Foo');
+            const identifier: ESTree.Identifier = NodeFactory.identifierNode('Foo');
             const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
 
             let result: ESTree.Identifier;