inversify test integration WIP

src/JavaScriptObfuscatorInternal.ts

@@ -7,11 +7,13 @@ import * as ESTree from 'estree';
 
 import { Chance } from 'chance';
 
+import { ICustomNode } from './interfaces/custom-nodes/ICustomNode';
 import { IObfuscationResult } from './interfaces/IObfuscationResult';
 import { IObfuscator } from './interfaces/IObfuscator';
 import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
 import { IInputOptions } from './interfaces/IInputOptions';
 import { IOptions } from './interfaces/IOptions';
+import { IStorage } from './interfaces/IStorage';
 
 import { ObfuscationResult } from './ObfuscationResult';
 import { SourceMapCorrector } from './SourceMapCorrector';
@@ -33,6 +35,11 @@ export class JavaScriptObfuscatorInternal {
         loc: true
     };
 
+    /**
+     * @types {IStorage<ICustomNode>}
+     */
+    private readonly customNodesStorage: IStorage<ICustomNode>;
+
     /**
      * @types {InversifyContainerFacade}
      */
@@ -54,8 +61,14 @@ export class JavaScriptObfuscatorInternal {
     constructor (inputOptions: IInputOptions) {
         this.inversifyContainerFacade = new InversifyContainerFacade(inputOptions);
 
-        this.obfuscator = this.inversifyContainerFacade.get<IObfuscator>(ServiceIdentifiers.IObfuscator);
-        this.options = this.inversifyContainerFacade.get<IOptions>(ServiceIdentifiers.IOptions);
+        this.obfuscator = this.inversifyContainerFacade
+            .get<IObfuscator>(ServiceIdentifiers.IObfuscator);
+
+        this.customNodesStorage = this.inversifyContainerFacade
+            .get<IStorage<ICustomNode>>(ServiceIdentifiers['IStorage<ICustomNode>']);
+
+        this.options = this.inversifyContainerFacade
+            .get<IOptions>(ServiceIdentifiers.IOptions);
     }
 
     /**
@@ -112,7 +125,7 @@ export class JavaScriptObfuscatorInternal {
         const astTree: ESTree.Program = esprima.parse(sourceCode, JavaScriptObfuscatorInternal.esprimaParams);
 
         // obfuscate AST tree
-        const obfuscatedAstTree: ESTree.Program = this.obfuscator.obfuscateAstTree(astTree);
+        const obfuscatedAstTree: ESTree.Program = this.obfuscator.obfuscateAstTree(astTree, this.customNodesStorage);
 
         // generate code
         const generatorOutput: IGeneratorOutput = this.generateCode(sourceCode, obfuscatedAstTree);

src/Obfuscator.ts

@@ -11,25 +11,50 @@ import { IObfuscationEventEmitter } from './interfaces/IObfuscationEventEmitter'
 import { IObfuscator } from './interfaces/IObfuscator';
 import { IOptions } from './interfaces/IOptions';
 import { INodeTransformer } from './interfaces/INodeTransformer';
-import { INodeTransformersFactory } from './interfaces/INodeTransformersFactory';
 import { IStackTraceAnalyzer } from './interfaces/stack-trace-analyzer/IStackTraceAnalyzer';
 import { IStorage } from './interfaces/IStorage';
 
+import { NodeType } from './enums/NodeType';
 import { ObfuscationEvents } from './enums/ObfuscationEvents';
 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 { Node } from './node/Node';
 import { NodeUtils } from './node/NodeUtils';
 
 @injectable()
 export class Obfuscator implements IObfuscator {
     /**
-     * @type {IStorage<ICustomNode>}
+     * @type {Map<string, string[]>}
+     */
+    private static readonly nodeControlFlowTransformersMap: Map <string, string[]> = new Map <string, string[]> ([
+        [NodeType.FunctionDeclaration, ['FunctionControlFlowTransformer']],
+        [NodeType.FunctionExpression, ['FunctionControlFlowTransformer']]
+    ]);
+
+    /**
+     * @type {Map<string, string[]>}
      */
-    private readonly customNodesStorage: IStorage<ICustomNode>;
+    private static readonly nodeObfuscatorsMap: Map <string, string[]> = new Map <string, string[]> ([
+        [NodeType.ArrowFunctionExpression, ['FunctionObfuscator']],
+        [NodeType.ClassDeclaration, ['FunctionDeclarationObfuscator']],
+        [NodeType.CatchClause, ['CatchClauseObfuscator']],
+        [NodeType.FunctionDeclaration, [
+            'FunctionDeclarationObfuscator',
+            'FunctionObfuscator'
+        ]],
+        [NodeType.FunctionExpression, ['FunctionObfuscator']],
+        [NodeType.MemberExpression, ['MemberExpressionObfuscator']],
+        [NodeType.MethodDefinition, ['MethodDefinitionObfuscator']],
+        [NodeType.ObjectExpression, ['ObjectExpressionObfuscator']],
+        [NodeType.VariableDeclaration, ['VariableDeclarationObfuscator']],
+        [NodeType.LabeledStatement, ['LabeledStatementObfuscator']],
+        [NodeType.Literal, ['LiteralObfuscator']]
+    ]);
+
+    /**
+     * @type {(nodeTransformersMap: Map<string, string[]>) => (nodeType: string) => INodeTransformer[],}
+     */
+    private readonly nodeTransformersFactory: (nodeTransformersMap: Map<string, string[]>) => (nodeType: string) => INodeTransformer[];
 
     /**
      * @type {IObfuscationEventEmitter}
@@ -47,38 +72,38 @@ export class Obfuscator implements IObfuscator {
     private readonly stackTraceAnalyzer: IStackTraceAnalyzer;
 
     /**
-     * @param obfuscationEventEmitter
      * @param stackTraceAnalyzer
-     * @param customNodesStorage
+     * @param obfuscationEventEmitter
+     * @param nodeTransformersFactory
      * @param options
      */
     constructor (
-        @inject(ServiceIdentifiers.IObfuscationEventEmitter) obfuscationEventEmitter: IObfuscationEventEmitter,
         @inject(ServiceIdentifiers.IStackTraceAnalyzer) stackTraceAnalyzer: IStackTraceAnalyzer,
-        @inject(ServiceIdentifiers.IStorage) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IObfuscationEventEmitter) obfuscationEventEmitter: IObfuscationEventEmitter,
+        @inject(ServiceIdentifiers['Factory<INodeTransformer[]>']) nodeTransformersFactory: (nodeTransformersMap: Map<string, string[]>) => (nodeType: string) => INodeTransformer[],
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
-        this.obfuscationEventEmitter = obfuscationEventEmitter;
         this.stackTraceAnalyzer = stackTraceAnalyzer;
-        this.customNodesStorage = customNodesStorage;
+        this.obfuscationEventEmitter = obfuscationEventEmitter;
+        this.nodeTransformersFactory = nodeTransformersFactory;
         this.options = options;
     }
 
     /**
      * @param astTree
+     * @param customNodesStorage
      * @returns {ESTree.Program}
      */
-    public obfuscateAstTree (astTree: ESTree.Program): ESTree.Program {
+    public obfuscateAstTree (astTree: ESTree.Program, customNodesStorage: IStorage<ICustomNode>): ESTree.Program {
         if (Node.isProgramNode(astTree) && !astTree.body.length) {
             return astTree;
         }
 
-        // zero pass: parentize all nodes
         NodeUtils.parentize(astTree);
 
         // prepare custom nodes
-        this.customNodesStorage.initialize(this.stackTraceAnalyzer.analyze(astTree.body));
-        this.customNodesStorage
+        customNodesStorage.initialize(this.stackTraceAnalyzer.analyze(astTree.body));
+        customNodesStorage
             .getStorage()
             .forEach((customNode: ICustomNode) => {
                 this.obfuscationEventEmitter.once(customNode.getAppendEvent(), customNode.appendNode.bind(customNode));
@@ -88,17 +113,19 @@ export class Obfuscator implements IObfuscator {
 
         // first pass: control flow flattening
         if (this.options.controlFlowFlattening) {
-            this.transformAstTree(astTree, VisitorDirection.leave, new NodeControlFlowTransformersFactory(
-                this.customNodesStorage,
-                this.options
-            ));
+            this.transformAstTree(
+                astTree,
+                VisitorDirection.leave,
+                this.nodeTransformersFactory(Obfuscator.nodeControlFlowTransformersMap)
+            );
         }
 
         // second pass: nodes obfuscation
-        this.transformAstTree(astTree, VisitorDirection.enter, new NodeObfuscatorsFactory(
-            this.customNodesStorage,
-            this.options
-        ));
+        this.transformAstTree(
+            astTree,
+            VisitorDirection.enter,
+            this.nodeTransformersFactory(Obfuscator.nodeObfuscatorsMap)
+        );
 
         this.obfuscationEventEmitter.emit(ObfuscationEvents.AfterObfuscation, astTree);
 
@@ -113,11 +140,11 @@ export class Obfuscator implements IObfuscator {
     private transformAstTree (
         astTree: ESTree.Program,
         direction: TVisitorDirection,
-        nodeTransformersFactory: INodeTransformersFactory
+        nodeTransformersFactory: (nodeType: string) => INodeTransformer[]
     ): void {
         estraverse.traverse(astTree, {
             [direction]: (node: ESTree.Node, parentNode: ESTree.Node): void => {
-                const nodeTransformers: INodeTransformer[] = nodeTransformersFactory.initializeNodeTransformers(node.type);
+                const nodeTransformers: INodeTransformer[] = nodeTransformersFactory(node.type);
 
                 nodeTransformers.forEach((nodeTransformer: INodeTransformer) => {
                     nodeTransformer.transformNode(node, parentNode);

src/container/InversifyContainerFacade.ts

@@ -1,8 +1,12 @@
 import { Container, interfaces } from 'inversify';
 import { ServiceIdentifiers } from './ServiceIdentifiers';
 
+import { nodeControlFlowTransformersModule } from './modules/NodeControlFlowTransformersModule';
+import { nodeObfuscatorsModule } from './modules/NodeObfuscatorsModule';
+
 import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode';
 import { IInputOptions } from '../interfaces/IInputOptions';
+import { INodeTransformer } from '../interfaces/INodeTransformer';
 import { IObfuscationEventEmitter } from '../interfaces/IObfuscationEventEmitter';
 import { IObfuscator } from '../interfaces/IObfuscator';
 import { IOptions } from '../interfaces/IOptions';
@@ -21,9 +25,15 @@ export class InversifyContainerFacade {
      */
     private container: interfaces.Container;
 
+    /**
+     * @param options
+     */
     constructor (options: IInputOptions) {
         this.container = new Container();
 
+        this.container.load(nodeControlFlowTransformersModule);
+        this.container.load(nodeObfuscatorsModule);
+
         this.container
             .bind<IOptions>(ServiceIdentifiers.IOptions)
             .toDynamicValue(() => {
@@ -46,9 +56,26 @@ export class InversifyContainerFacade {
             .inSingletonScope();
 
         this.container
-            .bind<IStorage<ICustomNode>>(ServiceIdentifiers.IStorage)
+            .bind<IStorage<ICustomNode>>(ServiceIdentifiers['IStorage<ICustomNode>'])
             .to(CustomNodesStorage)
             .inSingletonScope();
+
+        this.container
+            .bind<INodeTransformer[]>(ServiceIdentifiers['Factory<INodeTransformer[]>'])
+            .toFactory<INodeTransformer[]>((context: interfaces.Context) => {
+                return (nodeTransformersMap: Map<string, string[]>) => (nodeType: string) => {
+                    const nodeTransformers: string[] = nodeTransformersMap.get(nodeType) || [];
+                    const instancesArray: INodeTransformer[] = [];
+
+                    nodeTransformers.forEach((transformer: string) => {
+                        instancesArray.push(
+                            context.container.getNamed<INodeTransformer>('INodeTransformer', transformer)
+                        );
+                    });
+
+                    return instancesArray;
+                };
+            });
     }
 
     /**

src/container/ServiceIdentifiers.ts

@@ -1,11 +1,13 @@
 import { IContainerServiceIdentifiers } from '../interfaces/IContainerServiceIdentifiers';
 
 let ServiceIdentifiers: IContainerServiceIdentifiers = {
+    'Factory<INodeTransformer[]>': Symbol('INodeTransformersFactory'),
+    INodeTransformersFactory: Symbol('INodeTransformersFactory'),
     IObfuscationEventEmitter: Symbol('IObfuscationEventEmitter'),
     IObfuscator: Symbol('IObfuscator'),
     IOptions: Symbol('IOptions'),
     IStackTraceAnalyzer: Symbol('IStackTraceAnalyzer'),
-    IStorage: Symbol('IStorage')
+    'IStorage<ICustomNode>': Symbol('IStorage<ICustomNode>')
 };
 
 export { ServiceIdentifiers };

src/container/modules/NodeControlFlowTransformersModule.ts

@@ -0,0 +1,11 @@
+import { ContainerModule, interfaces } from 'inversify';
+
+import { INodeTransformer } from '../../interfaces/INodeTransformer';
+
+import { FunctionControlFlowTransformer } from '../../node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer';
+
+export const nodeControlFlowTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    bind<INodeTransformer>('INodeTransformer')
+        .to(FunctionControlFlowTransformer)
+        .whenTargetNamed('FunctionControlFlowTransformer');
+});

src/container/modules/NodeObfuscatorsModule.ts

@@ -0,0 +1,51 @@
+import { ContainerModule, interfaces } from 'inversify';
+
+import { INodeTransformer } from '../../interfaces/INodeTransformer';
+
+import { CatchClauseObfuscator } from '../../node-transformers/node-obfuscators/CatchClauseObfuscator';
+import { FunctionDeclarationObfuscator } from '../../node-transformers/node-obfuscators/FunctionDeclarationObfuscator';
+import { FunctionObfuscator } from '../../node-transformers/node-obfuscators/FunctionObfuscator';
+import { LabeledStatementObfuscator } from '../../node-transformers/node-obfuscators/LabeledStatementObfuscator';
+import { LiteralObfuscator } from '../../node-transformers/node-obfuscators/LiteralObfuscator';
+import { MemberExpressionObfuscator } from '../../node-transformers/node-obfuscators/MemberExpressionObfuscator';
+import { MethodDefinitionObfuscator } from '../../node-transformers/node-obfuscators/MethodDefinitionObfuscator';
+import { ObjectExpressionObfuscator } from '../../node-transformers/node-obfuscators/ObjectExpressionObfuscator';
+import { VariableDeclarationObfuscator } from '../../node-transformers/node-obfuscators/VariableDeclarationObfuscator';
+
+export const nodeObfuscatorsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    bind<INodeTransformer>('INodeTransformer')
+        .to(CatchClauseObfuscator)
+        .whenTargetNamed('CatchClauseObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(FunctionDeclarationObfuscator)
+        .whenTargetNamed('FunctionDeclarationObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(FunctionObfuscator)
+        .whenTargetNamed('FunctionObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(LabeledStatementObfuscator)
+        .whenTargetNamed('LabeledStatementObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(LiteralObfuscator)
+        .whenTargetNamed('LiteralObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(MemberExpressionObfuscator)
+        .whenTargetNamed('MemberExpressionObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(MethodDefinitionObfuscator)
+        .whenTargetNamed('MethodDefinitionObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(ObjectExpressionObfuscator)
+        .whenTargetNamed('ObjectExpressionObfuscator');
+
+    bind<INodeTransformer>('INodeTransformer')
+        .to(VariableDeclarationObfuscator)
+        .whenTargetNamed('VariableDeclarationObfuscator');
+});

src/interfaces/IContainerServiceIdentifiers.d.ts

@@ -1,10 +1,12 @@
 import { interfaces } from 'inversify';
 
 export interface IContainerServiceIdentifiers {
+    'Factory<INodeTransformer[]>': interfaces.ServiceIdentifier<any>;
+    INodeTransformersFactory: interfaces.ServiceIdentifier<any>;
     IObfuscationEventEmitter: interfaces.ServiceIdentifier<any>;
     IObfuscator: interfaces.ServiceIdentifier<any>;
     IOptions: interfaces.ServiceIdentifier<any>;
     IStackTraceAnalyzer: interfaces.ServiceIdentifier<any>;
-    IStorage: interfaces.ServiceIdentifier<any>;
+    'IStorage<ICustomNode>': interfaces.ServiceIdentifier<any>;
     [key: string]: interfaces.ServiceIdentifier<any>;
 }

src/node-transformers/AbstractNodeTransformer.ts

@@ -1,10 +1,14 @@
+import { injectable, inject } from 'inversify';
+
 import * as ESTree from 'estree';
 
 import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode';
 import { INodeTransformer } from '../interfaces/INodeTransformer';
 import { IOptions } from '../interfaces/IOptions';
 import { IStorage } from '../interfaces/IStorage';
+import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
 
+@injectable()
 export abstract class AbstractNodeTransformer implements INodeTransformer {
     /**
      * @type IStorage<ICustomNode>
@@ -20,7 +24,10 @@ export abstract class AbstractNodeTransformer implements INodeTransformer {
      * @param customNodesStorage
      * @param options
      */
-    constructor (customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
+    constructor (
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
         this.customNodesStorage = customNodesStorage;
         this.options = options;
     }

src/node-transformers/AbstractNodeTransformersFactory.ts

@@ -1,50 +0,0 @@
-import { TNodeTransformer } from '../types/TNodeTransformer';
-
-import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode';
-import { INodeTransformer } from '../interfaces/INodeTransformer';
-import { INodeTransformersFactory } from '../interfaces/INodeTransformersFactory';
-import { IOptions } from '../interfaces/IOptions';
-import { IStorage } from '../interfaces/IStorage';
-
-export abstract class AbstractNodeTransformersFactory implements INodeTransformersFactory {
-    /**
-     * @type {Map<string, TNodeTransformer[]>}
-     */
-    protected abstract readonly nodeTransformers: Map <string, TNodeTransformer[]>;
-
-    /**
-     * @type IStorage<ICustomNode>
-     */
-    protected readonly customNodesStorage: IStorage<ICustomNode>;
-
-    /**
-     * @type {IOptions}
-     */
-    protected readonly options: IOptions;
-
-    /**
-     * @param customNodesStorage
-     * @param options
-     */
-    constructor (customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
-        this.customNodesStorage = customNodesStorage;
-        this.options = options;
-    }
-
-    /**
-     * @param nodeType
-     * @returns {INodeTransformer[]}
-     */
-    public initializeNodeTransformers (nodeType: string): INodeTransformer[] {
-        const nodeTransformers: TNodeTransformer[] = this.nodeTransformers.get(nodeType) || [];
-        const instancesArray: INodeTransformer[] = [];
-
-        nodeTransformers.forEach((transformer: TNodeTransformer) => {
-            instancesArray.push(
-                new transformer(this.customNodesStorage, this.options)
-            );
-        });
-
-        return instancesArray;
-    }
-}

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

@@ -1,3 +1,6 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
@@ -19,6 +22,7 @@ import { NodeAppender } from '../../node/NodeAppender';
 import { Utils } from '../../Utils';
 import { NodeUtils } from '../../node/NodeUtils';
 
+@injectable()
 export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
     /**
      * @type {Map <string, IReplacer>}
@@ -31,7 +35,10 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
      * @param customNodesStorage
      * @param options
      */
-    constructor (customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
+    constructor (
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
         super(customNodesStorage, options);
     }
 

src/node-transformers/node-control-flow-transformers/factory/NodeControlFlowTransformersFactory.ts

@@ -1,16 +0,0 @@
-import { TNodeTransformer } from '../../../types/TNodeTransformer';
-
-import { NodeType } from '../../../enums/NodeType';
-
-import { FunctionControlFlowTransformer } from '../FunctionControlFlowTransformer';
-import { AbstractNodeTransformersFactory } from '../../AbstractNodeTransformersFactory';
-
-export class NodeControlFlowTransformersFactory extends AbstractNodeTransformersFactory {
-    /**
-     * @type {Map<string, TNodeTransformer[]>}
-     */
-    protected readonly nodeTransformers: Map <string, TNodeTransformer[]> = new Map <string, TNodeTransformer[]> ([
-        [NodeType.FunctionDeclaration, [FunctionControlFlowTransformer]],
-        [NodeType.FunctionExpression, [FunctionControlFlowTransformer]]
-    ]);
-}

src/node-transformers/node-obfuscators/CatchClauseObfuscator.ts

@@ -1,3 +1,6 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
@@ -20,6 +23,7 @@ import { NodeUtils } from '../../node/NodeUtils';
  *     try {} catch (_0x12d45f) { console.log(_0x12d45f); };
  *
  */
+@injectable()
 export class CatchClauseObfuscator extends AbstractNodeTransformer {
     /**
      * @type {IdentifierReplacer}
@@ -30,7 +34,10 @@ export class CatchClauseObfuscator extends AbstractNodeTransformer {
      * @param customNodesStorage
      * @param options
      */
-    constructor(customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
         super(customNodesStorage, options);
 
         this.identifierReplacer = new IdentifierReplacer(this.customNodesStorage, this.options);

src/node-transformers/node-obfuscators/FunctionDeclarationObfuscator.ts

@@ -1,3 +1,6 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
@@ -23,6 +26,7 @@ import { NodeUtils } from '../../node/NodeUtils';
  *     function _0x12d45f () { //... };
  *     _0x12d45f();
  */
+@injectable()
 export class FunctionDeclarationObfuscator extends AbstractNodeTransformer {
     /**
      * @type {IdentifierReplacer}
@@ -33,7 +37,10 @@ export class FunctionDeclarationObfuscator extends AbstractNodeTransformer {
      * @param customNodesStorage
      * @param options
      */
-    constructor(customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
         super(customNodesStorage, options);
 
         this.identifierReplacer = new IdentifierReplacer(this.customNodesStorage, this.options);

src/node-transformers/node-obfuscators/FunctionObfuscator.ts

@@ -1,3 +1,6 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
@@ -20,6 +23,7 @@ import { NodeUtils } from '../../node/NodeUtils';
  *     function foo (_0x12d45f) { return _0x12d45f; };
  *
  */
+@injectable()
 export class FunctionObfuscator extends AbstractNodeTransformer {
     /**
      * @type {IdentifierReplacer}
@@ -30,7 +34,10 @@ export class FunctionObfuscator extends AbstractNodeTransformer {
      * @param customNodesStorage
      * @param options
      */
-    constructor(customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
         super(customNodesStorage, options);
 
         this.identifierReplacer = new IdentifierReplacer(this.customNodesStorage, this.options);

src/node-transformers/node-obfuscators/LabeledStatementObfuscator.ts

@@ -1,3 +1,6 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
@@ -28,6 +31,7 @@ import { NodeUtils } from '../../node/NodeUtils';
  *     }
  *
  */
+@injectable()
 export class LabeledStatementObfuscator extends AbstractNodeTransformer {
     /**
      * @type {IdentifierReplacer}
@@ -38,7 +42,10 @@ export class LabeledStatementObfuscator extends AbstractNodeTransformer {
      * @param customNodesStorage
      * @param options
      */
-    constructor(customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
         super(customNodesStorage, options);
 
         this.identifierReplacer = new IdentifierReplacer(this.customNodesStorage, this.options);

src/node-transformers/node-obfuscators/LiteralObfuscator.ts

@@ -1,13 +1,32 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as escodegen from 'escodegen';
 import * as ESTree from 'estree';
 
+import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
+import { IOptions } from '../../interfaces/IOptions';
+import { IStorage } from '../../interfaces/IStorage';
+
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { BooleanLiteralReplacer } from './replacers/BooleanLiteralReplacer';
 import { Node } from '../../node/Node';
 import { NumberLiteralReplacer } from './replacers/NumberLiteralReplacer';
 import { StringLiteralReplacer } from './replacers/StringLiteralReplacer';
 
+@injectable()
 export class LiteralObfuscator extends AbstractNodeTransformer {
+    /**
+     * @param customNodesStorage
+     * @param options
+     */
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(customNodesStorage, options);
+    }
+
     /**
      * @param literalNode
      * @param parentNode

src/node-transformers/node-obfuscators/MemberExpressionObfuscator.ts

@@ -1,14 +1,33 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as escodegen from 'escodegen';
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
+import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
+import { IOptions } from '../../interfaces/IOptions';
+import { IStorage } from '../../interfaces/IStorage';
+
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { Node } from '../../node/Node';
 import { StringLiteralReplacer } from './replacers/StringLiteralReplacer';
 
+@injectable()
 export class MemberExpressionObfuscator extends AbstractNodeTransformer {
+    /**
+     * @param customNodesStorage
+     * @param options
+     */
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(customNodesStorage, options);
+    }
+
     /**
      * @param memberExpressionNode
      */

src/node-transformers/node-obfuscators/MethodDefinitionObfuscator.ts

@@ -1,6 +1,13 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
+import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
+import { IOptions } from '../../interfaces/IOptions';
+import { IStorage } from '../../interfaces/IStorage';
+
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { Node } from '../../node/Node';
 import { Utils } from '../../Utils';
@@ -13,12 +20,24 @@ import { StringLiteralReplacer } from './replacers/StringLiteralReplacer';
  * on:
  *     [_0x9a4e('0x0')] { //... };
  */
+@injectable()
 export class MethodDefinitionObfuscator extends AbstractNodeTransformer {
     /**
      * @type {string[]}
      */
     private static readonly ignoredNames: string[] = ['constructor'];
 
+    /**
+     * @param customNodesStorage
+     * @param options
+     */
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(customNodesStorage, options);
+    }
+
     /**
      * @param methodDefinitionNode
      * @param parentNode

src/node-transformers/node-obfuscators/ObjectExpressionObfuscator.ts

@@ -1,7 +1,14 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as escodegen from 'escodegen';
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
+import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
+import { IOptions } from '../../interfaces/IOptions';
+import { IStorage } from '../../interfaces/IStorage';
+
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -18,7 +25,19 @@ import { Utils } from '../../Utils';
  * on:
  *     var object = { '\u0050\u0053\u0045\u0055\u0044\u004f': 1 };
  */
+@injectable()
 export class ObjectExpressionObfuscator extends AbstractNodeTransformer {
+    /**
+     * @param customNodesStorage
+     * @param options
+     */
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(customNodesStorage, options);
+    }
+
     /**
      * @param objectExpressionNode
      */

src/node-transformers/node-obfuscators/VariableDeclarationObfuscator.ts

@@ -1,3 +1,6 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
@@ -24,6 +27,7 @@ import { NodeUtils } from '../../node/NodeUtils';
  *     _0x12d45f++;
  *
  */
+@injectable()
 export class VariableDeclarationObfuscator extends AbstractNodeTransformer {
     /**
      * @type {IdentifierReplacer}
@@ -34,7 +38,10 @@ export class VariableDeclarationObfuscator extends AbstractNodeTransformer {
      * @param customNodesStorage
      * @param options
      */
-    constructor(customNodesStorage: IStorage<ICustomNode>, options: IOptions) {
+    constructor(
+        @inject(ServiceIdentifiers['IStorage<ICustomNode>']) customNodesStorage: IStorage<ICustomNode>,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
         super(customNodesStorage, options);
 
         this.identifierReplacer = new IdentifierReplacer(this.customNodesStorage, this.options);

src/node-transformers/node-obfuscators/factory/NodeObfuscatorsFactory.ts

@@ -1,36 +0,0 @@
-import { TNodeTransformer } from '../../../types/TNodeTransformer';
-
-import { NodeType } from '../../../enums/NodeType';
-
-import { CatchClauseObfuscator } from '../CatchClauseObfuscator';
-import { FunctionDeclarationObfuscator } from '../FunctionDeclarationObfuscator';
-import { FunctionObfuscator } from '../FunctionObfuscator';
-import { LabeledStatementObfuscator } from '../LabeledStatementObfuscator';
-import { LiteralObfuscator } from '../LiteralObfuscator';
-import { MemberExpressionObfuscator } from '../MemberExpressionObfuscator';
-import { MethodDefinitionObfuscator } from '../MethodDefinitionObfuscator';
-import { ObjectExpressionObfuscator } from '../ObjectExpressionObfuscator';
-import { VariableDeclarationObfuscator } from '../VariableDeclarationObfuscator';
-import { AbstractNodeTransformersFactory } from '../../AbstractNodeTransformersFactory';
-
-export class NodeObfuscatorsFactory extends AbstractNodeTransformersFactory {
-    /**
-     * @type {Map<string, TNodeTransformer[]>}
-     */
-    protected readonly nodeTransformers: Map <string, TNodeTransformer[]> = new Map <string, TNodeTransformer[]> ([
-        [NodeType.ArrowFunctionExpression, [FunctionObfuscator]],
-        [NodeType.ClassDeclaration, [FunctionDeclarationObfuscator]],
-        [NodeType.CatchClause, [CatchClauseObfuscator]],
-        [NodeType.FunctionDeclaration, [
-            FunctionDeclarationObfuscator,
-            FunctionObfuscator
-        ]],
-        [NodeType.FunctionExpression, [FunctionObfuscator]],
-        [NodeType.MemberExpression, [MemberExpressionObfuscator]],
-        [NodeType.MethodDefinition, [MethodDefinitionObfuscator]],
-        [NodeType.ObjectExpression, [ObjectExpressionObfuscator]],
-        [NodeType.VariableDeclaration, [VariableDeclarationObfuscator]],
-        [NodeType.LabeledStatement, [LabeledStatementObfuscator]],
-        [NodeType.Literal, [LiteralObfuscator]]
-    ]);
-}

test/index.spec.ts

@@ -1,7 +1,7 @@
 import { BabelPolyfill } from './polyfills/BabelPolyfill';
+import 'reflect-metadata';
 
 require('source-map-support').install();
-
 BabelPolyfill.append();
 
 /**