refactoring

dist/index.js

@@ -965,12 +965,11 @@ var AbstractCustomNodesFactory = function () {
 
     _createClass(AbstractCustomNodesFactory, [{
         key: "syncCustomNodesWithNodesFactory",
-        value: function syncCustomNodesWithNodesFactory(obfuscationEventEmitter, customNodes) {
+        value: function syncCustomNodesWithNodesFactory(customNodes) {
             var _this = this;
 
-            customNodes.forEach(function (node) {
-                node.setAppendEvent(_this.appendEvent);
-                obfuscationEventEmitter.on(node.getAppendEvent(), node.appendNode.bind(node));
+            customNodes.forEach(function (customNode) {
+                customNode.setAppendEvent(_this.appendEvent);
             });
             return customNodes;
         }
@@ -1576,9 +1575,12 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 var esprima = __webpack_require__(27);
 var escodegen = __webpack_require__(11);
 var chance_1 = __webpack_require__(26);
+var CustomNodesStorage_1 = __webpack_require__(78);
+var ObfuscationEventEmitter_1 = __webpack_require__(53);
 var ObfuscationResult_1 = __webpack_require__(20);
 var Obfuscator_1 = __webpack_require__(31);
 var SourceMapCorrector_1 = __webpack_require__(32);
+var StackTraceAnalyzer_1 = __webpack_require__(72);
 var Utils_1 = __webpack_require__(0);
 
 var JavaScriptObfuscatorInternal = function () {
@@ -1600,7 +1602,7 @@ var JavaScriptObfuscatorInternal = function () {
                 Utils_1.Utils.setRandomGenerator(new chance_1.Chance(this.options.seed));
             }
             var astTree = esprima.parse(sourceCode, JavaScriptObfuscatorInternal.esprimaParams);
-            var obfuscatedAstTree = new Obfuscator_1.Obfuscator(this.options).obfuscateAstTree(astTree);
+            var obfuscatedAstTree = new Obfuscator_1.Obfuscator(new ObfuscationEventEmitter_1.ObfuscationEventEmitter(), new StackTraceAnalyzer_1.StackTraceAnalyzer(), new CustomNodesStorage_1.CustomNodesStorage(this.options), this.options).obfuscateAstTree(astTree);
             var generatorOutput = JavaScriptObfuscatorInternal.generateCode(sourceCode, obfuscatedAstTree, this.options);
             return this.getObfuscationResult(generatorOutput);
         }
@@ -1651,36 +1653,38 @@ var ObfuscationEvents_1 = __webpack_require__(1);
 var VisitorDirection_1 = __webpack_require__(52);
 var NodeControlFlowTransformersFactory_1 = __webpack_require__(57);
 var NodeObfuscatorsFactory_1 = __webpack_require__(67);
-var CustomNodesStorage_1 = __webpack_require__(78);
 var Node_1 = __webpack_require__(2);
 var NodeUtils_1 = __webpack_require__(8);
-var StackTraceAnalyzer_1 = __webpack_require__(72);
-var ObfuscationEventEmitter_1 = __webpack_require__(53);
 
 var Obfuscator = function () {
-    function Obfuscator(options) {
+    function Obfuscator(obfuscationEventEmitter, stackTraceAnalyzer, customNodesStorage, options) {
         _classCallCheck(this, Obfuscator);
 
+        this.obfuscationEventEmitter = obfuscationEventEmitter;
+        this.stackTraceAnalyzer = stackTraceAnalyzer;
+        this.customNodesStorage = customNodesStorage;
         this.options = options;
     }
 
     _createClass(Obfuscator, [{
         key: 'obfuscateAstTree',
         value: function obfuscateAstTree(astTree) {
+            var _this = this;
+
             if (Node_1.Node.isProgramNode(astTree) && !astTree.body.length) {
                 return astTree;
             }
             NodeUtils_1.NodeUtils.parentize(astTree);
-            var obfuscationEventEmitter = new ObfuscationEventEmitter_1.ObfuscationEventEmitter();
-            var stackTraceAnalyzer = new StackTraceAnalyzer_1.StackTraceAnalyzer();
-            var customNodesStorage = new CustomNodesStorage_1.CustomNodesStorage(this.options);
-            customNodesStorage.initialize(obfuscationEventEmitter, stackTraceAnalyzer.analyze(astTree.body));
-            obfuscationEventEmitter.emit(ObfuscationEvents_1.ObfuscationEvents.BeforeObfuscation, astTree);
+            this.customNodesStorage.initialize(this.stackTraceAnalyzer.analyze(astTree.body));
+            this.customNodesStorage.getStorage().forEach(function (customNode) {
+                _this.obfuscationEventEmitter.on(customNode.getAppendEvent(), customNode.appendNode.bind(customNode));
+            });
+            this.obfuscationEventEmitter.emit(ObfuscationEvents_1.ObfuscationEvents.BeforeObfuscation, astTree);
             if (this.options.controlFlowFlattening) {
-                this.transformAstTree(astTree, VisitorDirection_1.VisitorDirection.leave, new NodeControlFlowTransformersFactory_1.NodeControlFlowTransformersFactory(customNodesStorage, this.options));
+                this.transformAstTree(astTree, VisitorDirection_1.VisitorDirection.leave, new NodeControlFlowTransformersFactory_1.NodeControlFlowTransformersFactory(this.customNodesStorage, this.options));
             }
-            this.transformAstTree(astTree, VisitorDirection_1.VisitorDirection.enter, new NodeObfuscatorsFactory_1.NodeObfuscatorsFactory(customNodesStorage, this.options));
-            obfuscationEventEmitter.emit(ObfuscationEvents_1.ObfuscationEvents.AfterObfuscation, astTree);
+            this.transformAstTree(astTree, VisitorDirection_1.VisitorDirection.enter, new NodeObfuscatorsFactory_1.NodeObfuscatorsFactory(this.customNodesStorage, this.options));
+            this.obfuscationEventEmitter.emit(ObfuscationEvents_1.ObfuscationEvents.AfterObfuscation, astTree);
             return astTree;
         }
     }, {
@@ -2087,13 +2091,13 @@ var ConsoleOutputCustomNodesFactory = function (_AbstractCustomNodesF) {
 
     _createClass(ConsoleOutputCustomNodesFactory, [{
         key: 'initializeCustomNodes',
-        value: function initializeCustomNodes(obfuscationEventEmitter, stackTraceData) {
+        value: function initializeCustomNodes(stackTraceData) {
             if (!this.options.disableConsoleOutput) {
                 return;
             }
             var callsControllerFunctionName = Utils_1.Utils.getRandomVariableName();
             var randomStackTraceIndex = NodeAppender_1.NodeAppender.getRandomStackTraceIndex(stackTraceData.length);
-            return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, new Map([['consoleOutputDisableExpressionNode', new ConsoleOutputDisableExpressionNode_1.ConsoleOutputDisableExpressionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)], ['ConsoleOutputNodeCallsControllerFunctionNode', new NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)]]));
+            return this.syncCustomNodesWithNodesFactory(new Map([['consoleOutputDisableExpressionNode', new ConsoleOutputDisableExpressionNode_1.ConsoleOutputDisableExpressionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)], ['ConsoleOutputNodeCallsControllerFunctionNode', new NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)]]));
         }
     }]);
 
@@ -2462,7 +2466,7 @@ var DebugProtectionCustomNodesFactory = function (_AbstractCustomNodesF) {
 
     _createClass(DebugProtectionCustomNodesFactory, [{
         key: 'initializeCustomNodes',
-        value: function initializeCustomNodes(obfuscationEventEmitter, stackTraceData) {
+        value: function initializeCustomNodes(stackTraceData) {
             if (!this.options.debugProtection) {
                 return;
             }
@@ -2471,7 +2475,7 @@ var DebugProtectionCustomNodesFactory = function (_AbstractCustomNodesF) {
             if (this.options.debugProtectionInterval) {
                 customNodes.set('debugProtectionFunctionIntervalNode', new DebugProtectionFunctionIntervalNode_1.DebugProtectionFunctionIntervalNode(debugProtectionFunctionName, this.options));
             }
-            return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, customNodes);
+            return this.syncCustomNodesWithNodesFactory(customNodes);
         }
     }]);
 
@@ -2578,13 +2582,13 @@ var DomainLockCustomNodesFactory = function (_AbstractCustomNodesF) {
 
     _createClass(DomainLockCustomNodesFactory, [{
         key: 'initializeCustomNodes',
-        value: function initializeCustomNodes(obfuscationEventEmitter, stackTraceData) {
+        value: function initializeCustomNodes(stackTraceData) {
             if (!this.options.domainLock.length) {
                 return;
             }
             var callsControllerFunctionName = Utils_1.Utils.getRandomVariableName();
             var randomStackTraceIndex = NodeAppender_1.NodeAppender.getRandomStackTraceIndex(stackTraceData.length);
-            return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, new Map([['DomainLockNode', new DomainLockNode_1.DomainLockNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)], ['DomainLockNodeCallsControllerFunctionNode', new NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)]]));
+            return this.syncCustomNodesWithNodesFactory(new Map([['DomainLockNode', new DomainLockNode_1.DomainLockNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)], ['DomainLockNodeCallsControllerFunctionNode', new NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)]]));
         }
     }]);
 
@@ -2690,13 +2694,13 @@ var SelfDefendingCustomNodesFactory = function (_AbstractCustomNodesF) {
 
     _createClass(SelfDefendingCustomNodesFactory, [{
         key: 'initializeCustomNodes',
-        value: function initializeCustomNodes(obfuscationEventEmitter, stackTraceData) {
+        value: function initializeCustomNodes(stackTraceData) {
             if (!this.options.selfDefending) {
                 return;
             }
             var callsControllerFunctionName = Utils_1.Utils.getRandomVariableName();
             var randomStackTraceIndex = NodeAppender_1.NodeAppender.getRandomStackTraceIndex(stackTraceData.length);
-            return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, new Map([['selfDefendingUnicodeNode', new SelfDefendingUnicodeNode_1.SelfDefendingUnicodeNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)], ['SelfDefendingNodeCallsControllerFunctionNode', new NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)]]));
+            return this.syncCustomNodesWithNodesFactory(new Map([['selfDefendingUnicodeNode', new SelfDefendingUnicodeNode_1.SelfDefendingUnicodeNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)], ['SelfDefendingNodeCallsControllerFunctionNode', new NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode(stackTraceData, callsControllerFunctionName, randomStackTraceIndex, this.options)]]));
         }
     }]);
 
@@ -3012,7 +3016,7 @@ var StringArrayCustomNodesFactory = function (_AbstractCustomNodesF) {
 
     _createClass(StringArrayCustomNodesFactory, [{
         key: 'initializeCustomNodes',
-        value: function initializeCustomNodes(obfuscationEventEmitter, stackTraceData) {
+        value: function initializeCustomNodes(stackTraceData) {
             if (!this.options.stringArray) {
                 return;
             }
@@ -3027,7 +3031,7 @@ var StringArrayCustomNodesFactory = function (_AbstractCustomNodesF) {
             if (this.options.rotateStringArray) {
                 customNodes.set('stringArrayRotateFunctionNode', new StringArrayRotateFunctionNode_1.StringArrayRotateFunctionNode(this.stringArrayName, stringArray, this.stringArrayRotateValue, this.options));
             }
-            return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, customNodes);
+            return this.syncCustomNodesWithNodesFactory(customNodes);
         }
     }]);
 
@@ -4825,12 +4829,12 @@ var CustomNodesStorage = function (_MapStorage_1$MapStor) {
 
     _createClass(CustomNodesStorage, [{
         key: 'initialize',
-        value: function initialize(obfuscationEventEmitter, stackTraceData) {
+        value: function initialize(stackTraceData) {
             var _this2 = this;
 
             var customNodes = [];
             CustomNodesStorage.customNodesFactories.forEach(function (customNodesFactoryConstructor) {
-                var customNodesFactory = new customNodesFactoryConstructor(_this2.options).initializeCustomNodes(obfuscationEventEmitter, stackTraceData);
+                var customNodesFactory = new customNodesFactoryConstructor(_this2.options).initializeCustomNodes(stackTraceData);
                 if (!customNodesFactory) {
                     return;
                 }

src/JavaScriptObfuscatorInternal.ts

@@ -8,9 +8,12 @@ import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
 import { IObfuscationResult } from './interfaces/IObfuscationResult';
 import { IOptions } from './interfaces/IOptions';
 
+import { CustomNodesStorage } from './storages/custom-nodes/CustomNodesStorage';
+import { ObfuscationEventEmitter } from './event-emitters/ObfuscationEventEmitter';
 import { ObfuscationResult } from './ObfuscationResult';
 import { Obfuscator } from './Obfuscator';
 import { SourceMapCorrector } from './SourceMapCorrector';
+import { StackTraceAnalyzer } from './stack-trace-analyzer/StackTraceAnalyzer';
 import { Utils } from './Utils';
 
 export class JavaScriptObfuscatorInternal {
@@ -92,13 +95,20 @@ export class JavaScriptObfuscatorInternal {
             Utils.setRandomGenerator(new Chance(this.options.seed));
         }
 
+        // parse AST tree
         const astTree: ESTree.Program = esprima.parse(sourceCode, JavaScriptObfuscatorInternal.esprimaParams);
-        const obfuscatedAstTree: ESTree.Program = new Obfuscator(this.options).obfuscateAstTree(astTree);
-        const generatorOutput: IGeneratorOutput = JavaScriptObfuscatorInternal.generateCode(
-            sourceCode,
-            obfuscatedAstTree,
+
+        // obfuscate AST tree
+        const obfuscatedAstTree: ESTree.Program = new Obfuscator(
+            new ObfuscationEventEmitter(),
+            new StackTraceAnalyzer(),
+            new CustomNodesStorage(this.options),
             this.options
-        );
+        ).obfuscateAstTree(astTree);
+
+        // generate code
+        const generatorOutput: IGeneratorOutput = JavaScriptObfuscatorInternal
+            .generateCode(sourceCode, obfuscatedAstTree, this.options);
 
         return this.getObfuscationResult(generatorOutput);
     }

src/Obfuscator.ts

@@ -18,22 +18,44 @@ import { VisitorDirection } from './enums/VisitorDirection';
 import { NodeControlFlowTransformersFactory } from './node-transformers/node-control-flow-transformers/factory/NodeControlFlowTransformersFactory';
 import { NodeObfuscatorsFactory } from './node-transformers/node-obfuscators/factory/NodeObfuscatorsFactory';
 
-import { CustomNodesStorage } from './storages/custom-nodes/CustomNodesStorage';
 import { Node } from './node/Node';
 import { NodeUtils } from './node/NodeUtils';
-import { StackTraceAnalyzer } from './stack-trace-analyzer/StackTraceAnalyzer';
-import { ObfuscationEventEmitter } from './event-emitters/ObfuscationEventEmitter';
 
 export class Obfuscator implements IObfuscator {
+    /**
+     * @type {IStorage<ICustomNode>}
+     */
+    private readonly customNodesStorage: IStorage<ICustomNode>;
+    /**
+     * @type {IObfuscationEventEmitter}
+     */
+    private readonly obfuscationEventEmitter: IObfuscationEventEmitter;
+
     /**
      * @type {IOptions}
      */
     private readonly options: IOptions;
 
     /**
+     * @type {IStackTraceAnalyzer}
+     */
+    private readonly stackTraceAnalyzer: IStackTraceAnalyzer;
+
+    /**
+     * @param obfuscationEventEmitter
+     * @param stackTraceAnalyzer
+     * @param customNodesStorage
      * @param options
      */
-    constructor (options: IOptions) {
+    constructor (
+        obfuscationEventEmitter: IObfuscationEventEmitter,
+        stackTraceAnalyzer: IStackTraceAnalyzer,
+        customNodesStorage: IStorage<ICustomNode>,
+        options: IOptions
+    ) {
+        this.obfuscationEventEmitter = obfuscationEventEmitter;
+        this.stackTraceAnalyzer = stackTraceAnalyzer;
+        this.customNodesStorage = customNodesStorage;
         this.options = options;
     }
 
@@ -46,31 +68,34 @@ export class Obfuscator implements IObfuscator {
             return astTree;
         }
 
+        // zero pass: parentize all nodes
         NodeUtils.parentize(astTree);
 
-        const obfuscationEventEmitter: IObfuscationEventEmitter = new ObfuscationEventEmitter();
-        const stackTraceAnalyzer: IStackTraceAnalyzer = new StackTraceAnalyzer();
-        const customNodesStorage: IStorage<ICustomNode> = new CustomNodesStorage(this.options);
-
-        customNodesStorage.initialize(obfuscationEventEmitter, stackTraceAnalyzer.analyze(astTree.body));
+        // prepare custom nodes
+        this.customNodesStorage.initialize(this.stackTraceAnalyzer.analyze(astTree.body));
+        this.customNodesStorage
+            .getStorage()
+            .forEach((customNode: ICustomNode) => {
+                this.obfuscationEventEmitter.on(customNode.getAppendEvent(), customNode.appendNode.bind(customNode));
+            });
 
-        obfuscationEventEmitter.emit(ObfuscationEvents.BeforeObfuscation, astTree);
+        this.obfuscationEventEmitter.emit(ObfuscationEvents.BeforeObfuscation, astTree);
 
         // first pass: control flow flattening
         if (this.options.controlFlowFlattening) {
             this.transformAstTree(astTree, VisitorDirection.leave, new NodeControlFlowTransformersFactory(
-                customNodesStorage,
+                this.customNodesStorage,
                 this.options
             ));
         }
 
         // second pass: nodes obfuscation
         this.transformAstTree(astTree, VisitorDirection.enter, new NodeObfuscatorsFactory(
-            customNodesStorage,
+            this.customNodesStorage,
             this.options
         ));
 
-        obfuscationEventEmitter.emit(ObfuscationEvents.AfterObfuscation, astTree);
+        this.obfuscationEventEmitter.emit(ObfuscationEvents.AfterObfuscation, astTree);
 
         return astTree;
     }

src/custom-nodes/AbstractCustomNodesFactory.ts

@@ -2,7 +2,6 @@ import { TObfuscationEvent } from '../types/TObfuscationEvent';
 
 import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode';
 import { ICustomNodesFactory } from '../interfaces/ICustomNodesFactory';
-import { IObfuscationEventEmitter } from '../interfaces/IObfuscationEventEmitter';
 import { IOptions } from '../interfaces/IOptions';
 import { IStackTraceData } from '../interfaces/stack-trace-analyzer/IStackTraceData';
 
@@ -32,28 +31,18 @@ export abstract class AbstractCustomNodesFactory implements ICustomNodesFactory
     }
 
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceData
      * @returns {Map<string, ICustomNode> | undefined}
      */
-    public abstract initializeCustomNodes (
-        obfuscationEventEmitter: IObfuscationEventEmitter,
-        stackTraceData: IStackTraceData[]
-    ): Map <string, ICustomNode> | undefined;
+    public abstract initializeCustomNodes (stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined;
 
     /**
-     * @param obfuscationEventEmitter
      * @param customNodes
      * @returns {Map<string, ICustomNode>}
      */
-    protected syncCustomNodesWithNodesFactory (
-        obfuscationEventEmitter: IObfuscationEventEmitter,
-        customNodes: Map <string, ICustomNode>
-    ): Map <string, ICustomNode> {
-        customNodes.forEach((node: ICustomNode) => {
-            node.setAppendEvent(this.appendEvent);
-
-            obfuscationEventEmitter.on(node.getAppendEvent(), node.appendNode.bind(node));
+    protected syncCustomNodesWithNodesFactory (customNodes: Map <string, ICustomNode>): Map <string, ICustomNode> {
+        customNodes.forEach((customNode: ICustomNode) => {
+            customNode.setAppendEvent(this.appendEvent);
         });
 
         return customNodes;

src/custom-nodes/console-output-nodes/factory/ConsoleOutputCustomNodesFactory.ts

@@ -1,5 +1,4 @@
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IObfuscationEventEmitter } from '../../../interfaces/IObfuscationEventEmitter';
 import { IStackTraceData } from '../../../interfaces/stack-trace-analyzer/IStackTraceData';
 
 import { ConsoleOutputDisableExpressionNode } from '../ConsoleOutputDisableExpressionNode';
@@ -11,14 +10,10 @@ import { Utils } from '../../../Utils';
 
 export class ConsoleOutputCustomNodesFactory extends AbstractCustomNodesFactory {
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceData
      * @returns {Map<string, ICustomNode>}
      */
-    public initializeCustomNodes (
-        obfuscationEventEmitter: IObfuscationEventEmitter,
-        stackTraceData: IStackTraceData[]
-    ): Map <string, ICustomNode> | undefined {
+    public initializeCustomNodes (stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined {
         if (!this.options.disableConsoleOutput) {
             return;
         }
@@ -26,7 +21,7 @@ export class ConsoleOutputCustomNodesFactory extends AbstractCustomNodesFactory
         const callsControllerFunctionName: string = Utils.getRandomVariableName();
         const randomStackTraceIndex: number = NodeAppender.getRandomStackTraceIndex(stackTraceData.length);
 
-        return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, new Map <string, ICustomNode> ([
+        return this.syncCustomNodesWithNodesFactory(new Map <string, ICustomNode> ([
             [
                 'consoleOutputDisableExpressionNode',
                 new ConsoleOutputDisableExpressionNode(

src/custom-nodes/debug-protection-nodes/factory/DebugProtectionCustomNodesFactory.ts

@@ -1,5 +1,4 @@
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IObfuscationEventEmitter } from '../../../interfaces/IObfuscationEventEmitter';
 import { IStackTraceData } from '../../../interfaces/stack-trace-analyzer/IStackTraceData';
 
 import { DebugProtectionFunctionCallNode } from '../DebugProtectionFunctionCallNode';
@@ -11,14 +10,10 @@ import { Utils } from '../../../Utils';
 
 export class DebugProtectionCustomNodesFactory extends AbstractCustomNodesFactory {
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceData
      * @returns {Map<string, ICustomNode>}
      */
-    public initializeCustomNodes (
-        obfuscationEventEmitter: IObfuscationEventEmitter,
-        stackTraceData: IStackTraceData[]
-    ): Map <string, ICustomNode> | undefined {
+    public initializeCustomNodes (stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined {
         if (!this.options.debugProtection) {
             return;
         }
@@ -42,6 +37,6 @@ export class DebugProtectionCustomNodesFactory extends AbstractCustomNodesFactor
             );
         }
 
-        return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, customNodes);
+        return this.syncCustomNodesWithNodesFactory(customNodes);
     }
 }

src/custom-nodes/domain-lock-nodes/factory/DomainLockCustomNodesFactory.ts

@@ -1,5 +1,4 @@
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IObfuscationEventEmitter } from '../../../interfaces/IObfuscationEventEmitter';
 import { IStackTraceData } from '../../../interfaces/stack-trace-analyzer/IStackTraceData';
 
 import { DomainLockNode } from '../DomainLockNode';
@@ -11,14 +10,10 @@ import { Utils } from '../../../Utils';
 
 export class DomainLockCustomNodesFactory extends AbstractCustomNodesFactory {
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceData
      * @returns {Map<string, ICustomNode>}
      */
-    public initializeCustomNodes (
-        obfuscationEventEmitter: IObfuscationEventEmitter,
-        stackTraceData: IStackTraceData[]
-    ): Map <string, ICustomNode> | undefined {
+    public initializeCustomNodes (stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined {
         if (!this.options.domainLock.length) {
             return;
         }
@@ -26,7 +21,7 @@ export class DomainLockCustomNodesFactory extends AbstractCustomNodesFactory {
         const callsControllerFunctionName: string = Utils.getRandomVariableName();
         const randomStackTraceIndex: number = NodeAppender.getRandomStackTraceIndex(stackTraceData.length);
 
-        return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, new Map <string, ICustomNode> ([
+        return this.syncCustomNodesWithNodesFactory(new Map <string, ICustomNode> ([
             [
                 'DomainLockNode',
                 new DomainLockNode(

src/custom-nodes/self-defending-nodes/factory/SelfDefendingCustomNodesFactory.ts

@@ -1,7 +1,6 @@
 import { TObfuscationEvent } from '../../../types/TObfuscationEvent';
 
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IObfuscationEventEmitter } from '../../../interfaces/IObfuscationEventEmitter';
 import { IStackTraceData } from '../../../interfaces/stack-trace-analyzer/IStackTraceData';
 
 import { ObfuscationEvents } from '../../../enums/ObfuscationEvents';
@@ -20,14 +19,10 @@ export class SelfDefendingCustomNodesFactory extends AbstractCustomNodesFactory
     protected appendEvent: TObfuscationEvent = ObfuscationEvents.AfterObfuscation;
 
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceData
      * @returns {Map<string, ICustomNode>}
      */
-    public initializeCustomNodes (
-        obfuscationEventEmitter: IObfuscationEventEmitter,
-        stackTraceData: IStackTraceData[]
-    ): Map <string, ICustomNode> | undefined {
+    public initializeCustomNodes (stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined {
         if (!this.options.selfDefending) {
             return;
         }
@@ -35,7 +30,7 @@ export class SelfDefendingCustomNodesFactory extends AbstractCustomNodesFactory
         const callsControllerFunctionName: string = Utils.getRandomVariableName();
         const randomStackTraceIndex: number = NodeAppender.getRandomStackTraceIndex(stackTraceData.length);
 
-        return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, new Map <string, ICustomNode> ([
+        return this.syncCustomNodesWithNodesFactory(new Map <string, ICustomNode> ([
             [
                 'selfDefendingUnicodeNode',
                 new SelfDefendingUnicodeNode(

src/custom-nodes/string-array-nodes/factory/StringArrayCustomNodesFactory.ts

@@ -1,7 +1,6 @@
 import { TObfuscationEvent } from '../../../types/TObfuscationEvent';
 
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IObfuscationEventEmitter } from '../../../interfaces/IObfuscationEventEmitter';
 import { IStackTraceData } from '../../../interfaces/stack-trace-analyzer/IStackTraceData';
 
 import { ObfuscationEvents } from '../../../enums/ObfuscationEvents';
@@ -37,14 +36,10 @@ export class StringArrayCustomNodesFactory extends AbstractCustomNodesFactory {
     private stringArrayRotateValue: number;
 
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceData
      * @returns {Map<string, ICustomNode>}
      */
-    public initializeCustomNodes (
-        obfuscationEventEmitter: IObfuscationEventEmitter,
-        stackTraceData: IStackTraceData[]
-    ): Map <string, ICustomNode> | undefined {
+    public initializeCustomNodes (stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined {
         if (!this.options.stringArray) {
             return;
         }
@@ -89,6 +84,6 @@ export class StringArrayCustomNodesFactory extends AbstractCustomNodesFactory {
             );
         }
 
-        return this.syncCustomNodesWithNodesFactory(obfuscationEventEmitter, customNodes);
+        return this.syncCustomNodesWithNodesFactory(customNodes);
     }
 }

src/interfaces/ICustomNodesFactory.d.ts

@@ -7,5 +7,5 @@ export interface ICustomNodesFactory {
     /**
      * @returns {Map <string, ICustomNode> | undefined}
      */
-    initializeCustomNodes (eventEmitter: EventEmitter, stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined;
+    initializeCustomNodes (stackTraceData: IStackTraceData[]): Map <string, ICustomNode> | undefined;
 }

src/interfaces/IObfuscator.d.ts

@@ -1,5 +1,13 @@
 import * as ESTree from 'estree';
 
+import { ICustomNode } from './custom-nodes/ICustomNode';
+import { IObfuscationEventEmitter } from './IObfuscationEventEmitter';
+import { IStorage } from './IStorage';
+
 export interface IObfuscator {
-    obfuscateAstTree (node: ESTree.Program): ESTree.Program;
+    obfuscateAstTree (
+        astTree: ESTree.Program,
+        obfuscationEventEmitter: IObfuscationEventEmitter,
+        customNodesStorage: IStorage<ICustomNode>
+    ): ESTree.Program;
 }

src/storages/custom-nodes/CustomNodesStorage.ts

@@ -1,7 +1,6 @@
 import { TCustomNodesFactory } from '../../types/TCustomNodesFactory';
 
 import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
-import { IObfuscationEventEmitter } from '../../interfaces/IObfuscationEventEmitter';
 import { IOptions } from '../../interfaces/IOptions';
 import { IStackTraceData } from '../../interfaces/stack-trace-analyzer/IStackTraceData';
 
@@ -38,19 +37,15 @@ export class CustomNodesStorage extends MapStorage <ICustomNode> {
         this.options = options;
     }
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceData
      */
-    public initialize (obfuscationEventEmitter: IObfuscationEventEmitter, stackTraceData: IStackTraceData[]): void {
+    public initialize (stackTraceData: IStackTraceData[]): void {
         const customNodes: [string, ICustomNode][] = [];
 
         CustomNodesStorage.customNodesFactories.forEach((customNodesFactoryConstructor: TCustomNodesFactory) => {
             const customNodesFactory: Map <string, ICustomNode> | undefined = new customNodesFactoryConstructor(
                 this.options
-            ).initializeCustomNodes(
-                obfuscationEventEmitter,
-                stackTraceData
-            );
+            ).initializeCustomNodes(stackTraceData);
 
             if (!customNodesFactory) {
                 return;