SB-6.1-PRE

2021-02-02 13:50:53 +00:00
1 parent 690169a409
commit 358a25f522
@@ -0,0 +1,233 @@
+import { Container, interfaces } from 'inversify';
+import { ServiceIdentifiers } from './ServiceIdentifiers';
+
+import { analyzersModule } from './modules/analyzers/AnalyzersModule';
+import { codeTransformersModule } from './modules/code-transformers/CodeTransformersModule';
+import { controlFlowTransformersModule } from './modules/node-transformers/ControlFlowTransformersModule';
+import { convertingTransformersModule } from './modules/node-transformers/ConvertingTransformersModule';
+import { customCodeHelpersModule } from './modules/custom-code-helpers/CustomCodeHelpersModule';
+import { customNodesModule } from './modules/custom-nodes/CustomNodesModule';
+import { deadCodeInjectionTransformersModule } from './modules/node-transformers/DeadCodeInjectionTransformersModule';
+import { finalizingTransformersModule } from './modules/node-transformers/FinalizingTransformersModule';
+import { generatorsModule } from './modules/generators/GeneratorsModule';
+import { initializingTransformersModule } from './modules/node-transformers/InitializingTransformersModule';
+import { nodeModule } from './modules/node/NodeModule';
+import { nodeTransformersModule } from './modules/node-transformers/NodeTransformersModule';
+import { optionsModule } from './modules/options/OptionsModule';
+import { preparingTransformersModule } from './modules/node-transformers/PreparingTransformersModule';
+import { renameIdentifiersTransformersModule } from './modules/node-transformers/RenameIdentifiersTransformersModule';
+import { renamePropertiesTransformersModule } from './modules/node-transformers/RenamePropertiesTransformersModule';
+import { simplifyingTransformersModule } from './modules/node-transformers/SimplifyingTransformersModule';
+import { storagesModule } from './modules/storages/StoragesModule';
+import { stringArrayTransformersModule } from './modules/node-transformers/StringArrayTransformersModule';
+import { utilsModule } from './modules/utils/UtilsModule';
+
+import { TInputOptions } from '../types/options/TInputOptions';
+
+import { ICodeTransformersRunner } from '../interfaces/code-transformers/ICodeTransformersRunner';
+import { IInversifyContainerFacade } from '../interfaces/container/IInversifyContainerFacade';
+import { IJavaScriptObfuscator } from '../interfaces/IJavaScriptObfsucator';
+import { ILogger } from '../interfaces/logger/ILogger';
+import { IObfuscationEventEmitter } from '../interfaces/event-emitters/IObfuscationEventEmitter';
+import { IObfuscatedCode } from '../interfaces/source-code/IObfuscatedCode';
+import { ISourceCode } from '../interfaces/source-code/ISourceCode';
+import { INodeTransformersRunner } from '../interfaces/node-transformers/INodeTransformersRunner';
+
+import { CodeTransformersRunner } from '../code-transformers/CodeTransformersRunner';
+import { JavaScriptObfuscator } from '../JavaScriptObfuscator';
+import { Logger } from '../logger/Logger';
+import { NodeTransformersRunner } from '../node-transformers/NodeTransformersRunner';
+import { ObfuscationEventEmitter } from '../event-emitters/ObfuscationEventEmitter';
+import { ObfuscatedCode } from '../source-code/ObfuscatedCode';
+import { SourceCode } from '../source-code/SourceCode';
+
+export class InversifyContainerFacade implements IInversifyContainerFacade {
+    /**
+     * @type {interfaces.Container}
+     */
+    private readonly container: interfaces.Container;
+
+    public constructor () {
+        this.container = new Container();
+    }
+
+    /**
+     * @param {interfaces.ServiceIdentifier<U>} serviceIdentifier
+     * @returns {U}
+     */
+    public static getFactory <T extends string, U> (
+        serviceIdentifier: interfaces.ServiceIdentifier<U>
+    ): (context: interfaces.Context) => (bindingName: T) => U {
+        return (context: interfaces.Context): (bindingName: T) => U => {
+            return (bindingName: T): U => {
+                return context.container.getNamed<U>(serviceIdentifier, bindingName);
+            };
+        };
+    }
+
+    /**
+     * @param {interfaces.ServiceIdentifier<U>} serviceIdentifier
+     * @returns {U}
+     */
+    public static getCacheFactory <T extends string, U> (
+        serviceIdentifier: interfaces.ServiceIdentifier<U>
+    ): (context: interfaces.Context) => (bindingName: T) => U {
+        return (context: interfaces.Context): (bindingName: T) => U => {
+            const cache: Map <T, U> = new Map();
+
+            return (bindingName: T): U => {
+                if (cache.has(bindingName)) {
+                    return <U>cache.get(bindingName);
+                }
+
+                const object: U = context.container.getNamed<U>(serviceIdentifier, bindingName);
+
+                cache.set(bindingName, object);
+
+                return object;
+            };
+        };
+    }
+
+    /**
+     * @param {interfaces.ServiceIdentifier<interfaces.Newable<U>>} serviceIdentifier
+     * @param {interfaces.ServiceIdentifier<interfaces.Newable<Object>>[]} dependencies
+     * @returns {U}
+     */
+    public static getConstructorFactory <T extends string, U> (
+        serviceIdentifier: interfaces.ServiceIdentifier<interfaces.Newable<U>>,
+        ...dependencies: interfaces.ServiceIdentifier<interfaces.Newable<Record<string, any>>>[]
+    ): (context: interfaces.Context) => (bindingName: T) => U {
+        return (context: interfaces.Context): (bindingName: T) => U => {
+            const cache: Map<T, interfaces.Newable<U>> = new Map();
+            const cachedDependencies: Record<string, any>[] = [];
+
+            return (bindingName: T): U => {
+                dependencies.forEach((
+                    dependency: interfaces.ServiceIdentifier<interfaces.Newable<Record<string, any>>>,
+                    index: number
+                ) => {
+                    if (!cachedDependencies[index]) {
+                        cachedDependencies[index] = context.container.get(dependency);
+                    }
+                });
+
+                if (cache.has(bindingName)) {
+                    return new (<interfaces.Newable<U>>cache.get(bindingName))(...cachedDependencies);
+                }
+
+                const constructor: interfaces.Newable<U> = context.container
+                    .getNamed<interfaces.Newable<U>>(
+                        serviceIdentifier,
+                        bindingName
+                    );
+
+                cache.set(bindingName, constructor);
+
+                return new constructor(...cachedDependencies);
+            };
+        };
+    }
+
+    /**
+     * @param {interfaces.ServiceIdentifier<T>} serviceIdentifier
+     * @returns {T}
+     */
+    public get <T> (serviceIdentifier: interfaces.ServiceIdentifier<T>): T {
+        return this.container.get<T>(serviceIdentifier);
+    }
+
+    /**
+     * @param {interfaces.ServiceIdentifier<T>} serviceIdentifier
+     * @param {string | number | symbol} named
+     * @returns {T}
+     */
+    public getNamed <T> (serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T {
+        return this.container.getNamed<T>(serviceIdentifier, named);
+    }
+
+    /**
+     * @param {string} sourceCode
+     * @param {string} sourceMap
+     * @param {TInputOptions} options
+     */
+    public load (sourceCode: string, sourceMap: string, options: TInputOptions): void {
+        this.container
+            .bind<ISourceCode>(ServiceIdentifiers.ISourceCode)
+            .toDynamicValue(() => new SourceCode(sourceCode, sourceMap))
+            .inSingletonScope();
+
+        this.container
+            .bind<TInputOptions>(ServiceIdentifiers.TInputOptions)
+            .toDynamicValue(() => options)
+            .inSingletonScope();
+
+        this.container
+            .bind<ILogger>(ServiceIdentifiers.ILogger)
+            .to(Logger)
+            .inSingletonScope();
+
+        this.container
+            .bind<IJavaScriptObfuscator>(ServiceIdentifiers.IJavaScriptObfuscator)
+            .to(JavaScriptObfuscator)
+            .inSingletonScope();
+
+        this.container
+            .bind<ICodeTransformersRunner>(ServiceIdentifiers.ICodeTransformersRunner)
+            .to(CodeTransformersRunner)
+            .inSingletonScope();
+
+        this.container
+            .bind<INodeTransformersRunner>(ServiceIdentifiers.INodeTransformersRunner)
+            .to(NodeTransformersRunner)
+            .inSingletonScope();
+
+        this.container
+            .bind<IObfuscatedCode>(ServiceIdentifiers.IObfuscatedCode)
+            .to(ObfuscatedCode);
+
+        this.container
+            .bind<IObfuscatedCode>(ServiceIdentifiers.Factory__IObfuscatedCode)
+            .toFactory<IObfuscatedCode>((context: interfaces.Context) => {
+                return (obfuscatedCodeAsString: string, sourceMapAsString: string): IObfuscatedCode => {
+                    const obfuscatedCode: IObfuscatedCode = context.container
+                        .get<IObfuscatedCode>(ServiceIdentifiers.IObfuscatedCode);
+
+                    obfuscatedCode.initialize(obfuscatedCodeAsString, sourceMapAsString);
+
+                    return obfuscatedCode;
+                };
+            });
+
+        this.container
+            .bind<IObfuscationEventEmitter>(ServiceIdentifiers.IObfuscationEventEmitter)
+            .to(ObfuscationEventEmitter)
+            .inSingletonScope();
+
+        // modules
+        this.container.load(analyzersModule);
+        this.container.load(codeTransformersModule);
+        this.container.load(controlFlowTransformersModule);
+        this.container.load(convertingTransformersModule);
+        this.container.load(customCodeHelpersModule);
+        this.container.load(customNodesModule);
+        this.container.load(deadCodeInjectionTransformersModule);
+        this.container.load(finalizingTransformersModule);
+        this.container.load(generatorsModule);
+        this.container.load(initializingTransformersModule);
+        this.container.load(nodeModule);
+        this.container.load(nodeTransformersModule);
+        this.container.load(optionsModule);
+        this.container.load(preparingTransformersModule);
+        this.container.load(renameIdentifiersTransformersModule);
+        this.container.load(renamePropertiesTransformersModule);
+        this.container.load(simplifyingTransformersModule);
+        this.container.load(storagesModule);
+        this.container.load(stringArrayTransformersModule);
+        this.container.load(utilsModule);
+    }
+
+    public unload (): void {
+        this.container.unbindAll();
+    }
+}
@@ -0,0 +1,64 @@
+export enum ServiceIdentifiers {
+    Factory__ICalleeDataExtractor = 'Factory<ICalleeDataExtractor>',
+    Factory__ICodeTransformer = 'Factory<ICodeTransformer[]>',
+    Factory__IControlFlowCustomNode = 'Factory<IControlFlowCustomNode>',
+    Factory__IControlFlowReplacer = 'Factory<IControlFlowReplacer>',
+    Factory__ICustomCodeHelper = 'Factory<ICustomCodeHelper>',
+    Factory__ICustomCodeHelperGroup = 'Factory<ICustomCodeHelperGroup>',
+    Factory__IDeadCodeInjectionCustomNode = 'Factory<IDeadCodeInjectionCustomNode>',
+    Factory__IIdentifierNamesGenerator = 'Factory<IIdentifierNamesGenerator>',
+    Factory__INodeGuard = 'Factory<INodeGuard>',
+    Factory__INodeTransformer = 'Factory<INodeTransformer[]>',
+    Factory__IObfuscatedCode = 'Factory<IObfuscatedCode>',
+    Factory__IObjectExpressionKeysTransformerCustomNode = 'Factory<IObjectExpressionKeysTransformerCustomNode>',
+    Factory__IObjectExpressionExtractor = 'Factory<IObjectExpressionExtractor>',
+    Factory__IStringArrayCustomNode = 'Factory<IStringArrayCustomNode>',
+    Factory__IStringArrayIndexNode = 'Factory<IStringArrayIndexNode>',
+    Factory__TControlFlowStorage = 'Factory<TControlFlowStorage>',
+    IArrayUtils = 'IArrayUtils',
+    ICalleeDataExtractor = 'ICalleeDataExtractor',
+    ICallsGraphAnalyzer = 'ICallsGraphAnalyzer',
+    ICodeTransformer = 'ICodeTransformer',
+    ICodeTransformerNamesGroupsBuilder = 'ICodeTransformerNamesGroupsBuilder',
+    ICodeTransformersRunner = 'ICodeTransformersRunner',
+    ICryptUtils = 'ICryptUtils',
+    ICryptUtilsSwappedAlphabet = 'ICryptUtilsSwappedAlphabet',
+    ICustomCodeHelper = 'ICustomCodeHelper',
+    ICustomCodeHelperGroup = 'ICustomCodeHelperGroup',
+    IControlFlowReplacer = 'IControlFlowReplacer',
+    ICustomCodeHelperFormatter = 'ICustomCodeHelperFormatter',
+    ICustomCodeHelperObfuscator = 'ICustomCodeHelperObfuscator',
+    IEscapeSequenceEncoder = 'IEscapeSequenceEncoder',
+    IIdentifierNamesGenerator = 'IIdentifierNamesGenerator',
+    IIdentifierReplacer = 'IIdentifierReplacer',
+    IJavaScriptObfuscator = 'IJavaScriptObfuscator',
+    ILevelledTopologicalSorter = 'ILevelledTopologicalSorter',
+    ILiteralNodesCacheStorage = 'ILiteralNodesCacheStorage',
+    ILogger = 'ILogger',
+    INodeGuard = 'INodeGuard',
+    INodeTransformer = 'INodeTransformer',
+    INodeTransformerNamesGroupsBuilder = 'INodeTransformerNamesGroupsBuilder',
+    INodeTransformersRunner = 'INodeTransformersRunner',
+    INumberNumericalExpressionAnalyzer = 'INumberNumericalExpressionAnalyzer',
+    IObfuscationEventEmitter = 'IObfuscationEventEmitter',
+    IObfuscatedCode = 'IObfuscatedCode',
+    IOptions = 'IOptions',
+    IOptionsNormalizer = 'IOptionsNormalizer',
+    IPrevailingKindOfVariablesAnalyzer = 'IPrevailingKindOfVariablesAnalyzer',
+    IObjectExpressionExtractor = 'IObjectExpressionExtractor',
+    IRandomGenerator = 'IRandomGenerator',
+    IRenamePropertiesReplacer = 'IRenamePropertiesReplacer',
+    IScopeIdentifiersTraverser = 'IScopeIdentifiersTraverser',
+    ISourceCode = 'ISourceCode',
+    IScopeAnalyzer = 'IScopeAnalyzer',
+    IStringArrayIndexNode = 'IStringArrayIndexNode',
+    IStringArrayScopeCallsWrapperLexicalScopeDataStorage = 'IStringArrayScopeCallsWrapperLexicalScopeDataStorage',
+    IStringArrayScopeCallsWrapperNamesDataStorage = 'IStringArrayScopeCallsWrapperNamesDataStorage',
+    IStringArrayStorage = 'IStringArrayStorage',
+    IStringArrayStorageAnalyzer = 'IStringArrayStorageAnalyzer',
+    IVisitedLexicalScopeNodesStackStorage = 'IVisitedLexicalScopeNodesStackStorage',
+    Newable__ICustomNode = 'Newable<ICustomNode>',
+    Newable__TControlFlowStorage = 'Newable<TControlFlowStorage>',
+    TCustomNodeGroupStorage = 'TCustomNodeGroupStorage',
+    TInputOptions = 'TInputOptions'
+}
@@ -0,0 +1,67 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { ICalleeDataExtractor } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeDataExtractor';
+import { ICallsGraphAnalyzer } from '../../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphAnalyzer';
+import { INumberNumericalExpressionAnalyzer } from '../../../interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer';
+import { IPrevailingKindOfVariablesAnalyzer } from '../../../interfaces/analyzers/calls-graph-analyzer/IPrevailingKindOfVariablesAnalyzer';
+import { IScopeAnalyzer } from '../../../interfaces/analyzers/scope-analyzer/IScopeAnalyzer';
+import { IStringArrayStorageAnalyzer } from '../../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
+
+import { CalleeDataExtractor } from '../../../enums/analyzers/calls-graph-analyzer/CalleeDataExtractor';
+import { CallsGraphAnalyzer } from '../../../analyzers/calls-graph-analyzer/CallsGraphAnalyzer';
+import { FunctionDeclarationCalleeDataExtractor } from '../../../analyzers/calls-graph-analyzer/callee-data-extractors/FunctionDeclarationCalleeDataExtractor';
+import { FunctionExpressionCalleeDataExtractor } from '../../../analyzers/calls-graph-analyzer/callee-data-extractors/FunctionExpressionCalleeDataExtractor';
+import { NumberNumericalExpressionAnalyzer } from '../../../analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer';
+import { ObjectExpressionCalleeDataExtractor } from '../../../analyzers/calls-graph-analyzer/callee-data-extractors/ObjectExpressionCalleeDataExtractor';
+import { PrevailingKindOfVariablesAnalyzer } from '../../../analyzers/prevailing-kind-of-variables-analyzer/PrevailingKindOfVariablesAnalyzer';
+import { ScopeAnalyzer } from '../../../analyzers/scope-analyzer/ScopeAnalyzer';
+import { StringArrayStorageAnalyzer } from '../../../analyzers/string-array-storage-analyzer/StringArrayStorageAnalyzer';
+
+export const analyzersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // calls graph analyzer
+    bind<ICallsGraphAnalyzer>(ServiceIdentifiers.ICallsGraphAnalyzer)
+        .to(CallsGraphAnalyzer)
+        .inSingletonScope();
+
+    // number numerical expression analyzer
+    bind<INumberNumericalExpressionAnalyzer>(ServiceIdentifiers.INumberNumericalExpressionAnalyzer)
+        .to(NumberNumericalExpressionAnalyzer)
+        .inSingletonScope();
+
+    // prevailing kind of variables analyzer
+    bind<IPrevailingKindOfVariablesAnalyzer>(ServiceIdentifiers.IPrevailingKindOfVariablesAnalyzer)
+        .to(PrevailingKindOfVariablesAnalyzer)
+        .inSingletonScope();
+
+    // scope analyzer
+    bind<IScopeAnalyzer>(ServiceIdentifiers.IScopeAnalyzer)
+        .to(ScopeAnalyzer)
+        .inSingletonScope();
+
+    // string array storage analyzer
+    bind<IStringArrayStorageAnalyzer>(ServiceIdentifiers.IStringArrayStorageAnalyzer)
+        .to(StringArrayStorageAnalyzer)
+        .inSingletonScope();
+
+    // callee data extractors
+    bind<ICalleeDataExtractor>(ServiceIdentifiers.ICalleeDataExtractor)
+        .to(FunctionDeclarationCalleeDataExtractor)
+        .whenTargetNamed(CalleeDataExtractor.FunctionDeclarationCalleeDataExtractor);
+
+    bind<ICalleeDataExtractor>(ServiceIdentifiers.ICalleeDataExtractor)
+        .to(FunctionExpressionCalleeDataExtractor)
+        .whenTargetNamed(CalleeDataExtractor.FunctionExpressionCalleeDataExtractor);
+
+    bind<ICalleeDataExtractor>(ServiceIdentifiers.ICalleeDataExtractor)
+        .to(ObjectExpressionCalleeDataExtractor)
+        .whenTargetNamed(CalleeDataExtractor.ObjectExpressionCalleeDataExtractor);
+
+    // callee data extractor factory
+    bind<ICalleeDataExtractor>(ServiceIdentifiers.Factory__ICalleeDataExtractor)
+        .toFactory<ICalleeDataExtractor>(InversifyContainerFacade
+            .getCacheFactory<CalleeDataExtractor, ICalleeDataExtractor>(
+                ServiceIdentifiers.ICalleeDataExtractor
+            ));
+});
@@ -0,0 +1,28 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { ICodeTransformer } from '../../../interfaces/code-transformers/ICodeTransformer';
+import { ITransformerNamesGroupsBuilder } from '../../../interfaces/utils/ITransformerNamesGroupsBuilder';
+
+import { CodeTransformer } from '../../../enums/code-transformers/CodeTransformer';
+
+import { CodeTransformerNamesGroupsBuilder } from '../../../code-transformers/CodeTransformerNamesGroupsBuilder';
+import { HashbangOperatorTransformer } from '../../../code-transformers/preparing-transformers/HashbangOperatorTransformer';
+
+export const codeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // code transformers factory
+    bind<ICodeTransformer>(ServiceIdentifiers.Factory__ICodeTransformer)
+        .toFactory<ICodeTransformer>(InversifyContainerFacade
+            .getCacheFactory<CodeTransformer, ICodeTransformer>(ServiceIdentifiers.ICodeTransformer));
+
+    // code transformer names groups builder
+    bind<ITransformerNamesGroupsBuilder<CodeTransformer, ICodeTransformer>>(ServiceIdentifiers.ICodeTransformerNamesGroupsBuilder)
+        .to(CodeTransformerNamesGroupsBuilder)
+        .inSingletonScope();
+
+    // preparing code transformers
+    bind<ICodeTransformer>(ServiceIdentifiers.ICodeTransformer)
+        .to(HashbangOperatorTransformer)
+        .whenTargetNamed(CodeTransformer.HashbangOperatorTransformer);
+});
@@ -0,0 +1,124 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { ICustomCodeHelper } from '../../../interfaces/custom-code-helpers/ICustomCodeHelper';
+import { ICustomCodeHelperFormatter } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { ICustomCodeHelperGroup } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperGroup';
+import { ICustomCodeHelperObfuscator } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperObfuscator';
+
+import { CustomCodeHelper } from '../../../enums/custom-code-helpers/CustomCodeHelper';
+import { CustomCodeHelperGroup } from '../../../enums/custom-code-helpers/CustomCodeHelperGroup';
+
+import { ConsoleOutputCodeHelperGroup } from '../../../custom-code-helpers/console-output/group/ConsoleOutputCodeHelperGroup';
+import { DebugProtectionCodeHelperGroup } from '../../../custom-code-helpers/debug-protection/group/DebugProtectionCodeHelperGroup';
+import { DomainLockCustomCodeHelperGroup } from '../../../custom-code-helpers/domain-lock/group/DomainLockCustomCodeHelperGroup';
+import { SelfDefendingCodeHelperGroup } from '../../../custom-code-helpers/self-defending/group/SelfDefendingCodeHelperGroup';
+import { StringArrayCodeHelperGroup } from '../../../custom-code-helpers/string-array/group/StringArrayCodeHelperGroup';
+
+import { ConsoleOutputDisableCodeHelper } from '../../../custom-code-helpers/console-output/ConsoleOutputDisableCodeHelper';
+import { CustomCodeHelperFormatter } from '../../../custom-code-helpers/CustomCodeHelperFormatter';
+import { CustomCodeHelperObfuscator } from '../../../custom-code-helpers/CustomCodeHelperObfuscator';
+import { DebugProtectionFunctionCallCodeHelper } from '../../../custom-code-helpers/debug-protection/DebugProtectionFunctionCallCodeHelper';
+import { DebugProtectionFunctionIntervalCodeHelper } from '../../../custom-code-helpers/debug-protection/DebugProtectionFunctionIntervalCodeHelper';
+import { DebugProtectionFunctionCodeHelper } from '../../../custom-code-helpers/debug-protection/DebugProtectionFunctionCodeHelper';
+import { DomainLockCodeHelper } from '../../../custom-code-helpers/domain-lock/DomainLockCodeHelper';
+import { CallsControllerFunctionCodeHelper } from '../../../custom-code-helpers/calls-controller/CallsControllerFunctionCodeHelper';
+import { SelfDefendingUnicodeCodeHelper } from '../../../custom-code-helpers/self-defending/SelfDefendingUnicodeCodeHelper';
+import { StringArrayCallsWrapperCodeHelper } from '../../../custom-code-helpers/string-array/StringArrayCallsWrapperCodeHelper';
+import { StringArrayCallsWrapperBase64CodeHelper } from '../../../custom-code-helpers/string-array/StringArrayCallsWrapperBase64CodeHelper';
+import { StringArrayCallsWrapperRc4CodeHelper } from '../../../custom-code-helpers/string-array/StringArrayCallsWrapperRc4CodeHelper';
+import { StringArrayCodeHelper } from '../../../custom-code-helpers/string-array/StringArrayCodeHelper';
+import { StringArrayRotateFunctionCodeHelper } from '../../../custom-code-helpers/string-array/StringArrayRotateFunctionCodeHelper';
+
+export const customCodeHelpersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // custom code helpers
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(ConsoleOutputDisableCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.ConsoleOutputDisable);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(DebugProtectionFunctionCallCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.DebugProtectionFunctionCall);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(DebugProtectionFunctionIntervalCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.DebugProtectionFunctionInterval);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(DebugProtectionFunctionCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.DebugProtectionFunction);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(DomainLockCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.DomainLock);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(CallsControllerFunctionCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.CallsControllerFunction);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(SelfDefendingUnicodeCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.SelfDefendingUnicode);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(StringArrayCallsWrapperCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.StringArrayCallsWrapper);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(StringArrayCallsWrapperBase64CodeHelper)
+        .whenTargetNamed(CustomCodeHelper.StringArrayCallsWrapperBase64);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(StringArrayCallsWrapperRc4CodeHelper)
+        .whenTargetNamed(CustomCodeHelper.StringArrayCallsWrapperRc4);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(StringArrayCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.StringArray);
+
+    bind<ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper)
+        .to(StringArrayRotateFunctionCodeHelper)
+        .whenTargetNamed(CustomCodeHelper.StringArrayRotateFunction);
+
+    // code helper groups
+    bind<ICustomCodeHelperGroup>(ServiceIdentifiers.ICustomCodeHelperGroup)
+        .to(ConsoleOutputCodeHelperGroup)
+        .whenTargetNamed(CustomCodeHelperGroup.ConsoleOutput);
+
+    bind<ICustomCodeHelperGroup>(ServiceIdentifiers.ICustomCodeHelperGroup)
+        .to(DebugProtectionCodeHelperGroup)
+        .whenTargetNamed(CustomCodeHelperGroup.DebugProtection);
+
+    bind<ICustomCodeHelperGroup>(ServiceIdentifiers.ICustomCodeHelperGroup)
+        .to(DomainLockCustomCodeHelperGroup)
+        .whenTargetNamed(CustomCodeHelperGroup.DomainLock);
+
+    bind<ICustomCodeHelperGroup>(ServiceIdentifiers.ICustomCodeHelperGroup)
+        .to(SelfDefendingCodeHelperGroup)
+        .whenTargetNamed(CustomCodeHelperGroup.SelfDefending);
+
+    bind<ICustomCodeHelperGroup>(ServiceIdentifiers.ICustomCodeHelperGroup)
+        .to(StringArrayCodeHelperGroup)
+        .whenTargetNamed(CustomCodeHelperGroup.StringArray);
+
+    // customCodeHelper factory
+    bind<ICustomCodeHelper>(ServiceIdentifiers.Factory__ICustomCodeHelper)
+        .toFactory<ICustomCodeHelper>(InversifyContainerFacade
+            .getFactory<CustomCodeHelper, ICustomCodeHelper>(ServiceIdentifiers.ICustomCodeHelper));
+
+    // customCodeHelperGroup factory
+    bind<ICustomCodeHelperGroup>(ServiceIdentifiers.Factory__ICustomCodeHelperGroup)
+        .toFactory<ICustomCodeHelperGroup>(InversifyContainerFacade
+            .getFactory<CustomCodeHelperGroup, ICustomCodeHelperGroup>(ServiceIdentifiers.ICustomCodeHelperGroup));
+
+    // custom code helper formatter
+    bind<ICustomCodeHelperFormatter>(ServiceIdentifiers.ICustomCodeHelperFormatter)
+        .to(CustomCodeHelperFormatter)
+        .inSingletonScope();
+
+    // custom code helper obfuscator
+    bind<ICustomCodeHelperObfuscator>(ServiceIdentifiers.ICustomCodeHelperObfuscator)
+        .to(CustomCodeHelperObfuscator)
+        .inSingletonScope();
+});
@@ -0,0 +1,154 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
+import { IStringArrayIndexNode } from '../../../interfaces/custom-nodes/string-array-nodes/IStringArrayIndexNode';
+
+import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
+import { DeadCodeInjectionCustomNode } from '../../../enums/custom-nodes/DeadCodeInjectionCustomNode';
+import { ObjectExpressionKeysTransformerCustomNode } from '../../../enums/custom-nodes/ObjectExpressionKeysTransformerCustomNode';
+import { StringArrayCustomNode } from '../../../enums/custom-nodes/StringArrayCustomNode';
+
+import { BinaryExpressionFunctionNode } from '../../../custom-nodes/control-flow-flattening-nodes/BinaryExpressionFunctionNode';
+import { BlockStatementControlFlowFlatteningNode } from '../../../custom-nodes/control-flow-flattening-nodes/BlockStatementControlFlowFlatteningNode';
+import { BlockStatementDeadCodeInjectionNode } from '../../../custom-nodes/dead-code-injection-nodes/BlockStatementDeadCodeInjectionNode';
+import { CallExpressionControlFlowStorageCallNode } from '../../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/CallExpressionControlFlowStorageCallNode';
+import { CallExpressionFunctionNode } from '../../../custom-nodes/control-flow-flattening-nodes/CallExpressionFunctionNode';
+import { ControlFlowStorageNode } from '../../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ControlFlowStorageNode';
+import { ExpressionWithOperatorControlFlowStorageCallNode } from '../../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ExpressionWithOperatorControlFlowStorageCallNode';
+import { LogicalExpressionFunctionNode } from '../../../custom-nodes/control-flow-flattening-nodes/LogicalExpressionFunctionNode';
+import { ObjectExpressionVariableDeclarationHostNode } from '../../../custom-nodes/object-expression-keys-transformer-nodes/ObjectExpressionVariableDeclarationHostNode';
+import { StringArrayCallNode } from '../../../custom-nodes/string-array-nodes/StringArrayCallNode';
+import { StringArrayHexadecimalNumberIndexNode } from '../../../custom-nodes/string-array-nodes/string-array-index-nodes/StringArrayHexadecimalNumberIndexNode';
+import { StringArrayHexadecimalNumericStringIndexNode } from '../../../custom-nodes/string-array-nodes/string-array-index-nodes/StringArrayHexadecimalNumericStringIndexNode';
+import { StringArrayIndexNode } from '../../../enums/custom-nodes/string-array-index-nodes/StringArrayIndexNode';
+import { StringArrayScopeCallsWrapperFunctionNode } from '../../../custom-nodes/string-array-nodes/StringArrayScopeCallsWrapperFunctionNode';
+import { StringArrayScopeCallsWrapperVariableNode } from '../../../custom-nodes/string-array-nodes/StringArrayScopeCallsWrapperVariableNode';
+import { StringLiteralControlFlowStorageCallNode } from '../../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/StringLiteralControlFlowStorageCallNode';
+import { StringLiteralNode } from '../../../custom-nodes/control-flow-flattening-nodes/StringLiteralNode';
+
+export const customNodesModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // control flow custom nodes
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(BinaryExpressionFunctionNode)
+        .whenTargetNamed(ControlFlowCustomNode.BinaryExpressionFunctionNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(BlockStatementControlFlowFlatteningNode)
+        .whenTargetNamed(ControlFlowCustomNode.BlockStatementControlFlowFlatteningNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(CallExpressionControlFlowStorageCallNode)
+        .whenTargetNamed(ControlFlowCustomNode.CallExpressionControlFlowStorageCallNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(CallExpressionFunctionNode)
+        .whenTargetNamed(ControlFlowCustomNode.CallExpressionFunctionNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(ControlFlowStorageNode)
+        .whenTargetNamed(ControlFlowCustomNode.ControlFlowStorageNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(ExpressionWithOperatorControlFlowStorageCallNode)
+        .whenTargetNamed(ControlFlowCustomNode.ExpressionWithOperatorControlFlowStorageCallNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(LogicalExpressionFunctionNode)
+        .whenTargetNamed(ControlFlowCustomNode.LogicalExpressionFunctionNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(StringLiteralNode)
+        .whenTargetNamed(ControlFlowCustomNode.StringLiteralNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(StringLiteralControlFlowStorageCallNode)
+        .whenTargetNamed(ControlFlowCustomNode.StringLiteralControlFlowStorageCallNode);
+
+    // dead code injection custom nodes
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(BlockStatementDeadCodeInjectionNode)
+        .whenTargetNamed(DeadCodeInjectionCustomNode.BlockStatementDeadCodeInjectionNode);
+
+    // object expression keys transformer nodes
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(ObjectExpressionVariableDeclarationHostNode)
+        .whenTargetNamed(ObjectExpressionKeysTransformerCustomNode.ObjectExpressionVariableDeclarationHostNode);
+
+    // string array nodes
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(StringArrayCallNode)
+        .whenTargetNamed(StringArrayCustomNode.StringArrayCallNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(StringArrayScopeCallsWrapperFunctionNode)
+        .whenTargetNamed(StringArrayCustomNode.StringArrayScopeCallsWrapperFunctionNode);
+
+    bind<interfaces.Newable<ICustomNode>>(ServiceIdentifiers.Newable__ICustomNode)
+        .toConstructor(StringArrayScopeCallsWrapperVariableNode)
+        .whenTargetNamed(StringArrayCustomNode.StringArrayScopeCallsWrapperVariableNode);
+
+    // string array index nodes
+    bind<IStringArrayIndexNode>(ServiceIdentifiers.IStringArrayIndexNode)
+        .to(StringArrayHexadecimalNumberIndexNode)
+        .inSingletonScope()
+        .whenTargetNamed(StringArrayIndexNode.StringArrayHexadecimalNumberIndexNode);
+
+    bind<IStringArrayIndexNode>(ServiceIdentifiers.IStringArrayIndexNode)
+        .to(StringArrayHexadecimalNumericStringIndexNode)
+        .inSingletonScope()
+        .whenTargetNamed(StringArrayIndexNode.StringArrayHexadecimalNumericStringIndexNode);
+
+    // control flow customNode constructor factory
+    bind<ICustomNode>(ServiceIdentifiers.Factory__IControlFlowCustomNode)
+        .toFactory<ICustomNode>(InversifyContainerFacade
+            .getConstructorFactory<ControlFlowCustomNode, ICustomNode>(
+                ServiceIdentifiers.Newable__ICustomNode,
+                ServiceIdentifiers.Factory__IIdentifierNamesGenerator,
+                ServiceIdentifiers.ICustomCodeHelperFormatter,
+                ServiceIdentifiers.IRandomGenerator,
+                ServiceIdentifiers.IOptions
+            ));
+
+    // dead code injection customNode constructor factory
+    bind<ICustomNode>(ServiceIdentifiers.Factory__IDeadCodeInjectionCustomNode)
+        .toFactory<ICustomNode>(InversifyContainerFacade
+            .getConstructorFactory<DeadCodeInjectionCustomNode, ICustomNode>(
+                ServiceIdentifiers.Newable__ICustomNode,
+                ServiceIdentifiers.Factory__IIdentifierNamesGenerator,
+                ServiceIdentifiers.ICustomCodeHelperFormatter,
+                ServiceIdentifiers.IRandomGenerator,
+                ServiceIdentifiers.IOptions
+            ));
+
+    // object expression keys transformer customNode constructor factory
+    bind<ICustomNode>(ServiceIdentifiers.Factory__IObjectExpressionKeysTransformerCustomNode)
+        .toFactory<ICustomNode>(InversifyContainerFacade
+            .getConstructorFactory<ObjectExpressionKeysTransformerCustomNode, ICustomNode>(
+                ServiceIdentifiers.Newable__ICustomNode,
+                ServiceIdentifiers.Factory__IIdentifierNamesGenerator,
+                ServiceIdentifiers.ICustomCodeHelperFormatter,
+                ServiceIdentifiers.IRandomGenerator,
+                ServiceIdentifiers.IOptions
+            ));
+
+    // string array customNode constructor factory
+    bind<ICustomNode>(ServiceIdentifiers.Factory__IStringArrayCustomNode)
+        .toFactory<ICustomNode>(InversifyContainerFacade
+            .getConstructorFactory<StringArrayCustomNode, ICustomNode>(
+                ServiceIdentifiers.Newable__ICustomNode,
+                ServiceIdentifiers.Factory__IIdentifierNamesGenerator,
+                ServiceIdentifiers.Factory__IStringArrayIndexNode,
+                ServiceIdentifiers.ICustomCodeHelperFormatter,
+                ServiceIdentifiers.IStringArrayStorage,
+                ServiceIdentifiers.IArrayUtils,
+                ServiceIdentifiers.IRandomGenerator,
+                ServiceIdentifiers.IOptions
+            ));
+
+    // string array index node factory
+    bind<IStringArrayIndexNode>(ServiceIdentifiers.Factory__IStringArrayIndexNode)
+        .toFactory<IStringArrayIndexNode>(InversifyContainerFacade
+            .getCacheFactory<StringArrayIndexNode, IStringArrayIndexNode>(ServiceIdentifiers.IStringArrayIndexNode));
+});
@@ -0,0 +1,87 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IIdentifierNamesGenerator } from '../../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
+import { IOptions } from '../../../interfaces/options/IOptions';
+
+import { IdentifierNamesGenerator } from '../../../enums/generators/identifier-names-generators/IdentifierNamesGenerator';
+
+import { DictionaryIdentifierNamesGenerator } from '../../../generators/identifier-names-generators/DictionaryIdentifierNamesGenerator';
+import { HexadecimalIdentifierNamesGenerator } from '../../../generators/identifier-names-generators/HexadecimalIdentifierNamesGenerator';
+import { MangledIdentifierNamesGenerator } from '../../../generators/identifier-names-generators/MangledIdentifierNamesGenerator';
+import { MangledShuffledIdentifierNamesGenerator } from '../../../generators/identifier-names-generators/MangledShuffledIdentifierNamesGenerator';
+
+export const generatorsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // identifier name generators
+    bind<IIdentifierNamesGenerator>(ServiceIdentifiers.IIdentifierNamesGenerator)
+        .to(DictionaryIdentifierNamesGenerator)
+        .inSingletonScope()
+        .whenTargetNamed(IdentifierNamesGenerator.DictionaryIdentifierNamesGenerator);
+
+    bind<IIdentifierNamesGenerator>(ServiceIdentifiers.IIdentifierNamesGenerator)
+        .to(HexadecimalIdentifierNamesGenerator)
+        .inSingletonScope()
+        .whenTargetNamed(IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator);
+
+    bind<IIdentifierNamesGenerator>(ServiceIdentifiers.IIdentifierNamesGenerator)
+        .to(MangledIdentifierNamesGenerator)
+        .inSingletonScope()
+        .whenTargetNamed(IdentifierNamesGenerator.MangledIdentifierNamesGenerator);
+
+    bind<IIdentifierNamesGenerator>(ServiceIdentifiers.IIdentifierNamesGenerator)
+        .to(MangledShuffledIdentifierNamesGenerator)
+        .inSingletonScope()
+        .whenTargetNamed(IdentifierNamesGenerator.MangledShuffledIdentifierNamesGenerator);
+
+    // identifier name generator factory
+    function identifierNameGeneratorFactory (): (context: interfaces.Context) => (options: IOptions) => IIdentifierNamesGenerator {
+        let cachedIdentifierNamesGenerator: IIdentifierNamesGenerator | null = null;
+
+        return (context: interfaces.Context): (options: IOptions) => IIdentifierNamesGenerator => (options: IOptions): IIdentifierNamesGenerator => {
+            if (cachedIdentifierNamesGenerator) {
+                return cachedIdentifierNamesGenerator;
+            }
+
+            let identifierNamesGenerator: IIdentifierNamesGenerator;
+
+            switch (options.identifierNamesGenerator) {
+                case IdentifierNamesGenerator.DictionaryIdentifierNamesGenerator:
+                    identifierNamesGenerator = context.container.getNamed<IIdentifierNamesGenerator>(
+                        ServiceIdentifiers.IIdentifierNamesGenerator,
+                        IdentifierNamesGenerator.DictionaryIdentifierNamesGenerator
+                    );
+
+                    break;
+
+                case IdentifierNamesGenerator.MangledIdentifierNamesGenerator:
+                    identifierNamesGenerator = context.container.getNamed<IIdentifierNamesGenerator>(
+                        ServiceIdentifiers.IIdentifierNamesGenerator,
+                        IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+                    );
+
+                    break;
+
+                case IdentifierNamesGenerator.MangledShuffledIdentifierNamesGenerator:
+                    identifierNamesGenerator = context.container.getNamed<IIdentifierNamesGenerator>(
+                        ServiceIdentifiers.IIdentifierNamesGenerator,
+                        IdentifierNamesGenerator.MangledShuffledIdentifierNamesGenerator
+                    );
+
+                    break;
+
+                case IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator:
+                default:
+                    identifierNamesGenerator = context.container.getNamed<IIdentifierNamesGenerator>(
+                        ServiceIdentifiers.IIdentifierNamesGenerator,
+                        IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator
+                    );
+            }
+
+            cachedIdentifierNamesGenerator = identifierNamesGenerator;
+
+            return identifierNamesGenerator;
+        };
+    }
+    bind<IIdentifierNamesGenerator>(ServiceIdentifiers.Factory__IIdentifierNamesGenerator)
+        .toFactory<IIdentifierNamesGenerator>(identifierNameGeneratorFactory());
+});
@@ -0,0 +1,49 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { ControlFlowReplacer } from '../../../enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer';
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { BinaryExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer';
+import { BlockStatementControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer';
+import { CallExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer';
+import { FunctionControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/FunctionControlFlowTransformer';
+import { LogicalExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer';
+import { StringLiteralControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/StringLiteralControlFlowReplacer';
+
+export const controlFlowTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // control flow transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(BlockStatementControlFlowTransformer)
+        .whenTargetNamed(NodeTransformer.BlockStatementControlFlowTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(FunctionControlFlowTransformer)
+        .whenTargetNamed(NodeTransformer.FunctionControlFlowTransformer);
+
+    // control flow replacers
+    bind<IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer)
+        .to(BinaryExpressionControlFlowReplacer)
+        .whenTargetNamed(ControlFlowReplacer.BinaryExpressionControlFlowReplacer);
+
+    bind<IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer)
+        .to(CallExpressionControlFlowReplacer)
+        .whenTargetNamed(ControlFlowReplacer.CallExpressionControlFlowReplacer);
+
+    bind<IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer)
+        .to(LogicalExpressionControlFlowReplacer)
+        .whenTargetNamed(ControlFlowReplacer.LogicalExpressionControlFlowReplacer);
+
+    bind<IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer)
+        .to(StringLiteralControlFlowReplacer)
+        .whenTargetNamed(ControlFlowReplacer.StringLiteralControlFlowReplacer);
+
+    // control flow replacer factory
+    bind<IControlFlowReplacer>(ServiceIdentifiers.Factory__IControlFlowReplacer)
+        .toFactory<IControlFlowReplacer>(InversifyContainerFacade
+            .getCacheFactory<ControlFlowReplacer, IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer));
+});
@@ -0,0 +1,86 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+import { IObjectExpressionExtractor } from '../../../interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractor';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+import { ObjectExpressionExtractor } from '../../../enums/node-transformers/converting-transformers/properties-extractors/ObjectExpressionExtractor';
+
+import { BasePropertiesExtractor } from '../../../node-transformers/converting-transformers/object-expression-extractors/BasePropertiesExtractor';
+import { BooleanLiteralTransformer } from '../../../node-transformers/converting-transformers/BooleanLiteralTransformer';
+import { ExportSpecifierTransformer } from '../../../node-transformers/converting-transformers/ExportSpecifierTransformer';
+import { MemberExpressionTransformer } from '../../../node-transformers/converting-transformers/MemberExpressionTransformer';
+import { MethodDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodDefinitionTransformer';
+import { NumberLiteralTransformer } from '../../../node-transformers/converting-transformers/NumberLiteralTransformer';
+import { NumberToNumericalExpressionTransformer } from '../../../node-transformers/converting-transformers/NumberToNumericalExpressionTransformer';
+import { ObjectExpressionKeysTransformer } from '../../../node-transformers/converting-transformers/ObjectExpressionKeysTransformer';
+import { ObjectExpressionToVariableDeclarationExtractor } from '../../../node-transformers/converting-transformers/object-expression-extractors/ObjectExpressionToVariableDeclarationExtractor';
+import { ObjectExpressionTransformer } from '../../../node-transformers/converting-transformers/ObjectExpressionTransformer';
+import { ObjectPatternPropertiesTransformer } from '../../../node-transformers/converting-transformers/ObjectPatternPropertiesTransformer';
+import { SplitStringTransformer } from '../../../node-transformers/converting-transformers/SplitStringTransformer';
+import { TemplateLiteralTransformer } from '../../../node-transformers/converting-transformers/TemplateLiteralTransformer';
+
+export const convertingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // converting transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(BooleanLiteralTransformer)
+        .whenTargetNamed(NodeTransformer.BooleanLiteralTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ExportSpecifierTransformer)
+        .whenTargetNamed(NodeTransformer.ExportSpecifierTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(MemberExpressionTransformer)
+        .whenTargetNamed(NodeTransformer.MemberExpressionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(MethodDefinitionTransformer)
+        .whenTargetNamed(NodeTransformer.MethodDefinitionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(NumberLiteralTransformer)
+        .whenTargetNamed(NodeTransformer.NumberLiteralTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(NumberToNumericalExpressionTransformer)
+        .whenTargetNamed(NodeTransformer.NumberToNumericalExpressionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ObjectExpressionKeysTransformer)
+        .whenTargetNamed(NodeTransformer.ObjectExpressionKeysTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ObjectExpressionTransformer)
+        .whenTargetNamed(NodeTransformer.ObjectExpressionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ObjectPatternPropertiesTransformer)
+        .whenTargetNamed(NodeTransformer.ObjectPatternPropertiesTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(SplitStringTransformer)
+        .whenTargetNamed(NodeTransformer.SplitStringTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(TemplateLiteralTransformer)
+        .whenTargetNamed(NodeTransformer.TemplateLiteralTransformer);
+
+    // object expression extractors
+    bind<IObjectExpressionExtractor>(ServiceIdentifiers.IObjectExpressionExtractor)
+        .to(ObjectExpressionToVariableDeclarationExtractor)
+        .whenTargetNamed(ObjectExpressionExtractor.ObjectExpressionToVariableDeclarationExtractor);
+
+    bind<IObjectExpressionExtractor>(ServiceIdentifiers.IObjectExpressionExtractor)
+        .to(BasePropertiesExtractor)
+        .whenTargetNamed(ObjectExpressionExtractor.BasePropertiesExtractor);
+
+    // object expression extractor factory
+    bind<IObjectExpressionExtractor>(ServiceIdentifiers.Factory__IObjectExpressionExtractor)
+        .toFactory<IObjectExpressionExtractor>(InversifyContainerFacade
+            .getCacheFactory<ObjectExpressionExtractor, IObjectExpressionExtractor>(
+                ServiceIdentifiers.IObjectExpressionExtractor
+            ));
+});
@@ -0,0 +1,15 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { DeadCodeInjectionTransformer } from '../../../node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer';
+
+export const deadCodeInjectionTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // dead code injection
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(DeadCodeInjectionTransformer)
+        .whenTargetNamed(NodeTransformer.DeadCodeInjectionTransformer);
+});
@@ -0,0 +1,15 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { EscapeSequenceTransformer } from '../../../node-transformers/finalizing-transformers/EscapeSequenceTransformer';
+
+export const finalizingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // finalizing transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(EscapeSequenceTransformer)
+        .whenTargetNamed(NodeTransformer.EscapeSequenceTransformer);
+});
@@ -0,0 +1,15 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { CommentsTransformer } from '../../../node-transformers/initializing-transformers/CommentsTransformer';
+
+export const initializingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // preparing transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(CommentsTransformer)
+        .whenTargetNamed(NodeTransformer.CommentsTransformer);
+});
@@ -0,0 +1,22 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+import { ITransformerNamesGroupsBuilder } from '../../../interfaces/utils/ITransformerNamesGroupsBuilder';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { NodeTransformerNamesGroupsBuilder } from '../../../node-transformers/NodeTransformerNamesGroupsBuilder';
+
+export const nodeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // node transformers factory
+    bind<INodeTransformer>(ServiceIdentifiers.Factory__INodeTransformer)
+        .toFactory<INodeTransformer>(InversifyContainerFacade
+            .getCacheFactory<NodeTransformer, INodeTransformer>(ServiceIdentifiers.INodeTransformer));
+
+    // node transformer names groups builder
+    bind<ITransformerNamesGroupsBuilder<NodeTransformer, INodeTransformer>>(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
+        .to(NodeTransformerNamesGroupsBuilder)
+        .inSingletonScope();
+});
@@ -0,0 +1,81 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+import { ObfuscatingGuard } from '../../../enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard';
+
+import { BlackListObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/BlackListObfuscatingGuard';
+import { ConditionalCommentObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard';
+import { CustomCodeHelpersTransformer } from '../../../node-transformers/preparing-transformers/CustomCodeHelpersTransformer';
+import { EvalCallExpressionTransformer } from '../../../node-transformers/preparing-transformers/EvalCallExpressionTransformer';
+import { ForceTransformStringObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ForceTransformStringObfuscatingGuard';
+import { IgnoredRequireImportObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/IgnoredRequireImportObfuscatingGuard';
+import { MetadataTransformer } from '../../../node-transformers/preparing-transformers/MetadataTransformer';
+import { ObfuscatingGuardsTransformer } from '../../../node-transformers/preparing-transformers/ObfuscatingGuardsTransformer';
+import { ParentificationTransformer } from '../../../node-transformers/preparing-transformers/ParentificationTransformer';
+import { ReservedStringObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ReservedStringObfuscatingGuard';
+import { VariablePreserveTransformer } from '../../../node-transformers/preparing-transformers/VariablePreserveTransformer';
+
+export const preparingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // preparing transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(CustomCodeHelpersTransformer)
+        .whenTargetNamed(NodeTransformer.CustomCodeHelpersTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(EvalCallExpressionTransformer)
+        .whenTargetNamed(NodeTransformer.EvalCallExpressionTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(MetadataTransformer)
+        .whenTargetNamed(NodeTransformer.MetadataTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ObfuscatingGuardsTransformer)
+        .whenTargetNamed(NodeTransformer.ObfuscatingGuardsTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ParentificationTransformer)
+        .whenTargetNamed(NodeTransformer.ParentificationTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(VariablePreserveTransformer)
+        .whenTargetNamed(NodeTransformer.VariablePreserveTransformer);
+
+    // obfuscating guards
+    bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
+        .to(BlackListObfuscatingGuard)
+        .inSingletonScope()
+        .whenTargetNamed(ObfuscatingGuard.BlackListObfuscatingGuard);
+
+    bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
+        .to(ConditionalCommentObfuscatingGuard)
+        .inSingletonScope()
+        .whenTargetNamed(ObfuscatingGuard.ConditionalCommentObfuscatingGuard);
+
+    bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
+        .to(ForceTransformStringObfuscatingGuard)
+        .inSingletonScope()
+        .whenTargetNamed(ObfuscatingGuard.ForceTransformStringObfuscatingGuard);
+
+    bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
+        .to(IgnoredRequireImportObfuscatingGuard)
+        .inSingletonScope()
+        .whenTargetNamed(ObfuscatingGuard.IgnoredRequireImportObfuscatingGuard);
+
+    bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
+        .to(ReservedStringObfuscatingGuard)
+        .inSingletonScope()
+        .whenTargetNamed(ObfuscatingGuard.ReservedStringObfuscatingGuard);
+
+    // obfuscating guards factory
+    bind<IObfuscatingGuard>(ServiceIdentifiers.Factory__INodeGuard)
+        .toFactory<IObfuscatingGuard>(InversifyContainerFacade
+            .getCacheFactory<ObfuscatingGuard, IObfuscatingGuard>(
+                ServiceIdentifiers.INodeGuard
+            ));
+});
@@ -0,0 +1,32 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IIdentifierReplacer } from '../../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { IdentifierReplacer } from '../../../node-transformers/rename-identifiers-transformers/replacer/IdentifierReplacer';
+import { LabeledStatementTransformer } from '../../../node-transformers/rename-identifiers-transformers/LabeledStatementTransformer';
+import { ScopeIdentifiersTransformer } from '../../../node-transformers/rename-identifiers-transformers/ScopeIdentifiersTransformer';
+import { ScopeThroughIdentifiersTransformer } from '../../../node-transformers/rename-identifiers-transformers/ScopeThroughIdentifiersTransformer';
+
+export const renameIdentifiersTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // rename identifiers transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(LabeledStatementTransformer)
+        .whenTargetNamed(NodeTransformer.LabeledStatementTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ScopeIdentifiersTransformer)
+        .whenTargetNamed(NodeTransformer.ScopeIdentifiersTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ScopeThroughIdentifiersTransformer)
+        .whenTargetNamed(NodeTransformer.ScopeThroughIdentifiersTransformer);
+
+    // identifier replacer
+    bind<IIdentifierReplacer>(ServiceIdentifiers.IIdentifierReplacer)
+        .to(IdentifierReplacer)
+        .inSingletonScope();
+});
@@ -0,0 +1,21 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IRenamePropertiesReplacer } from '../../../interfaces/node-transformers/rename-properties-transformers/replacer/IRenamePropertiesReplacer';
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { RenamePropertiesReplacer } from '../../../node-transformers/rename-properties-transformers/replacer/RenamePropertiesReplacer';
+import { RenamePropertiesTransformer } from '../../../node-transformers/rename-properties-transformers/RenamePropertiesTransformer';
+
+export const renamePropertiesTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // rename properties transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(RenamePropertiesTransformer)
+        .whenTargetNamed(NodeTransformer.RenamePropertiesTransformer);
+
+    // rename properties obfuscating replacer
+    bind<IRenamePropertiesReplacer>(ServiceIdentifiers.IRenamePropertiesReplacer)
+        .to(RenamePropertiesReplacer);
+});
@@ -0,0 +1,30 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { BlockStatementSimplifyTransformer } from '../../../node-transformers/simplifying-transformers/BlockStatementSimplifyTransformer';
+import { ExpressionStatementsMergeTransformer } from '../../../node-transformers/simplifying-transformers/ExpressionStatementsMergeTransformer';
+import { IfStatementSimplifyTransformer } from '../../../node-transformers/simplifying-transformers/IfStatementSimplifyTransformer';
+import { VariableDeclarationsMergeTransformer } from '../../../node-transformers/simplifying-transformers/VariableDeclarationsMergeTransformer';
+
+export const simplifyingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // simplifying transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(BlockStatementSimplifyTransformer)
+        .whenTargetNamed(NodeTransformer.BlockStatementSimplifyTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ExpressionStatementsMergeTransformer)
+        .whenTargetNamed(NodeTransformer.ExpressionStatementsMergeTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(IfStatementSimplifyTransformer)
+        .whenTargetNamed(NodeTransformer.IfStatementSimplifyTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(VariableDeclarationsMergeTransformer)
+        .whenTargetNamed(NodeTransformer.VariableDeclarationsMergeTransformer);
+});
@@ -0,0 +1,20 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { StringArrayScopeCallsWrapperTransformer } from '../../../node-transformers/string-array-transformers/StringArrayScopeCallsWrapperTransformer';
+import { StringArrayTransformer } from '../../../node-transformers/string-array-transformers/StringArrayTransformer';
+
+export const stringArrayTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // strings transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(StringArrayScopeCallsWrapperTransformer)
+        .whenTargetNamed(NodeTransformer.StringArrayScopeCallsWrapperTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(StringArrayTransformer)
+        .whenTargetNamed(NodeTransformer.StringArrayTransformer);
+});
@@ -0,0 +1,13 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IScopeIdentifiersTraverser } from '../../../interfaces/node/IScopeIdentifiersTraverser';
+
+import { ScopeIdentifiersTraverser } from '../../../node/ScopeIdentifiersTraverser';
+
+export const nodeModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // scope identifiers traverser
+    bind<IScopeIdentifiersTraverser>(ServiceIdentifiers.IScopeIdentifiersTraverser)
+        .to(ScopeIdentifiersTraverser)
+        .inSingletonScope();
+});
@@ -0,0 +1,18 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IOptionsNormalizer } from '../../../interfaces/options/IOptionsNormalizer';
+
+import { Options } from '../../../options/Options';
+import { OptionsNormalizer } from '../../../options/OptionsNormalizer';
+
+export const optionsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    bind<IOptions>(ServiceIdentifiers.IOptions)
+        .to(Options)
+        .inSingletonScope();
+
+    bind<IOptionsNormalizer>(ServiceIdentifiers.IOptionsNormalizer)
+        .to(OptionsNormalizer)
+        .inSingletonScope();
+});
@@ -0,0 +1,70 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { TCustomCodeHelperGroupStorage } from '../../../types/storages/TCustomCodeHelperGroupStorage';
+
+import { ILiteralNodesCacheStorage } from '../../../interfaces/storages/string-array-transformers/ILiteralNodesCacheStorage';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { IStringArrayScopeCallsWrapperLexicalScopeDataStorage } from '../../../interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrapperLexicalScopeDataStorage';
+import { IStringArrayScopeCallsWrapperNamesDataStorage } from '../../../interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrapperNamesDataStorage';
+import { IStringArrayStorage } from '../../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { IVisitedLexicalScopeNodesStackStorage } from '../../../interfaces/storages/string-array-transformers/IVisitedLexicalScopeNodesStackStorage';
+
+import { ControlFlowStorage } from '../../../storages/custom-nodes/ControlFlowStorage';
+import { CustomCodeHelperGroupStorage } from '../../../storages/custom-code-helpers/CustomCodeHelperGroupStorage';
+import { LiteralNodesCacheStorage } from '../../../storages/string-array-transformers/LiteralNodesCacheStorage';
+import { StringArrayScopeCallsWrapperLexicalScopeDataStorage } from '../../../storages/string-array-transformers/StringArrayScopeCallsWrapperLexicalScopeDataStorage';
+import { StringArrayScopeCallsWrapperNamesDataStorage } from '../../../storages/string-array-transformers/StringArrayScopeCallsWrapperNamesDataStorage';
+import { StringArrayStorage } from '../../../storages/string-array-transformers/StringArrayStorage';
+import { VisitedLexicalScopeNodesStackStorage } from '../../../storages/string-array-transformers/VisitedLexicalScopeNodesStackStorage';
+
+export const storagesModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // storages
+    bind<TCustomCodeHelperGroupStorage>(ServiceIdentifiers.TCustomNodeGroupStorage)
+        .to(CustomCodeHelperGroupStorage)
+        .inSingletonScope();
+
+    bind<ILiteralNodesCacheStorage>(ServiceIdentifiers.ILiteralNodesCacheStorage)
+        .to(LiteralNodesCacheStorage)
+        .inSingletonScope();
+
+    bind<IStringArrayStorage>(ServiceIdentifiers.IStringArrayStorage)
+        .to(StringArrayStorage)
+        .inSingletonScope();
+
+    bind<IStringArrayScopeCallsWrapperLexicalScopeDataStorage>(ServiceIdentifiers.IStringArrayScopeCallsWrapperLexicalScopeDataStorage)
+        .to(StringArrayScopeCallsWrapperLexicalScopeDataStorage)
+        .inSingletonScope();
+
+    bind<IStringArrayScopeCallsWrapperNamesDataStorage>(ServiceIdentifiers.IStringArrayScopeCallsWrapperNamesDataStorage)
+        .to(StringArrayScopeCallsWrapperNamesDataStorage)
+        .inSingletonScope();
+
+    bind<IVisitedLexicalScopeNodesStackStorage>(ServiceIdentifiers.IVisitedLexicalScopeNodesStackStorage)
+        .to(VisitedLexicalScopeNodesStackStorage)
+        .inSingletonScope();
+
+    bind<interfaces.Newable<TControlFlowStorage>>(ServiceIdentifiers.Newable__TControlFlowStorage)
+        .toConstructor(ControlFlowStorage);
+
+    // controlFlowStorage factory
+    bind<TControlFlowStorage>(ServiceIdentifiers.Factory__TControlFlowStorage)
+        .toFactory<TControlFlowStorage>((context: interfaces.Context) => {
+            return (): TControlFlowStorage => {
+                const constructor: interfaces.Newable<TControlFlowStorage> = context.container
+                    .get<interfaces.Newable<TControlFlowStorage>>(ServiceIdentifiers.Newable__TControlFlowStorage);
+                const randomGenerator: IRandomGenerator = context.container
+                    .get<IRandomGenerator>(ServiceIdentifiers.IRandomGenerator);
+                const options: IOptions = context.container
+                    .get<IOptions>(ServiceIdentifiers.IOptions);
+
+                const storage: TControlFlowStorage = new constructor(randomGenerator, options);
+
+                storage.initialize();
+
+                return storage;
+            };
+        });
+});
@@ -0,0 +1,47 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IArrayUtils } from '../../../interfaces/utils/IArrayUtils';
+import { ICryptUtils } from '../../../interfaces/utils/ICryptUtils';
+import { ICryptUtilsSwappedAlphabet } from '../../../interfaces/utils/ICryptUtilsSwappedAlphabet';
+import { IEscapeSequenceEncoder } from '../../../interfaces/utils/IEscapeSequenceEncoder';
+import { ILevelledTopologicalSorter } from '../../../interfaces/utils/ILevelledTopologicalSorter';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+
+import { ArrayUtils } from '../../../utils/ArrayUtils';
+import { CryptUtils } from '../../../utils/CryptUtils';
+import { CryptUtilsSwappedAlphabet } from '../../../utils/CryptUtilsSwappedAlphabet';
+import { EscapeSequenceEncoder } from '../../../utils/EscapeSequenceEncoder';
+import { LevelledTopologicalSorter } from '../../../utils/LevelledTopologicalSorter';
+import { RandomGenerator } from '../../../utils/RandomGenerator';
+
+export const utilsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // array utils
+    bind<IArrayUtils>(ServiceIdentifiers.IArrayUtils)
+        .to(ArrayUtils)
+        .inSingletonScope();
+
+    // random generator
+    bind<IRandomGenerator>(ServiceIdentifiers.IRandomGenerator)
+        .to(RandomGenerator)
+        .inSingletonScope();
+
+    // crypt utils
+    bind<ICryptUtils>(ServiceIdentifiers.ICryptUtils)
+        .to(CryptUtils)
+        .inSingletonScope();
+
+    // crypt utils with swapped alphabet
+    bind<ICryptUtilsSwappedAlphabet>(ServiceIdentifiers.ICryptUtilsSwappedAlphabet)
+        .to(CryptUtilsSwappedAlphabet)
+        .inSingletonScope();
+
+    // escape sequence encoder
+    bind<IEscapeSequenceEncoder>(ServiceIdentifiers.IEscapeSequenceEncoder)
+        .to(EscapeSequenceEncoder)
+        .inSingletonScope();
+
+    // levelled topological sorter
+    bind<ILevelledTopologicalSorter>(ServiceIdentifiers.ILevelledTopologicalSorter)
+        .to(LevelledTopologicalSorter);
+});