Inversify beta.3: replaced getTagged by getNamed with enums

dist/index.js

@@ -88,7 +88,7 @@ module.exports =
 /******/ 	__webpack_require__.p = "";
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 119);
+/******/ 	return __webpack_require__(__webpack_require__.s = 120);
 /******/ })
 /************************************************************************/
 /******/ ([
@@ -2589,34 +2589,32 @@ var StringArrayCallsWrapper_1 = __webpack_require__(59);
 var StringArrayNode_1 = __webpack_require__(26);
 var StringArrayRotateFunctionNode_1 = __webpack_require__(60);
 exports.customNodesModule = new inversify_1.ContainerModule(function (bind) {
-    var customNodesTag = 'customNodes';
-    var customNodesConcreteFactoriesTag = 'customNodesConcreteFactories';
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(BinaryExpressionFunctionNode_1.BinaryExpressionFunctionNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.BinaryExpressionFunctionNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(ControlFlowStorageCallNode_1.ControlFlowStorageCallNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.ControlFlowStorageCallNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(ControlFlowStorageNode_1.ControlFlowStorageNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.ControlFlowStorageNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(ConsoleOutputDisableExpressionNode_1.ConsoleOutputDisableExpressionNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.ConsoleOutputDisableExpressionNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DebugProtectionFunctionCallNode_1.DebugProtectionFunctionCallNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.DebugProtectionFunctionCallNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DebugProtectionFunctionIntervalNode_1.DebugProtectionFunctionIntervalNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.DebugProtectionFunctionIntervalNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DebugProtectionFunctionNode_1.DebugProtectionFunctionNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.DebugProtectionFunctionNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DomainLockNode_1.DomainLockNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.DomainLockNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.NodeCallsControllerFunctionNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(SelfDefendingUnicodeNode_1.SelfDefendingUnicodeNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.SelfDefendingUnicodeNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(StringArrayCallsWrapper_1.StringArrayCallsWrapper).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.StringArrayCallsWrapper);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(StringArrayNode_1.StringArrayNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.StringArrayNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(StringArrayRotateFunctionNode_1.StringArrayRotateFunctionNode).whenTargetTagged(customNodesTag, CustomNodes_1.CustomNodes.StringArrayRotateFunctionNode);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(ConsoleOutputCustomNodesFactory_1.ConsoleOutputCustomNodesFactory).whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories_1.CustomNodesFactories.ConsoleOutputCustomNodesFactory);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(DebugProtectionCustomNodesFactory_1.DebugProtectionCustomNodesFactory).whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories_1.CustomNodesFactories.DebugProtectionCustomNodesFactory);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(DomainLockCustomNodesFactory_1.DomainLockCustomNodesFactory).whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories_1.CustomNodesFactories.DomainLockCustomNodesFactory);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(SelfDefendingCustomNodesFactory_1.SelfDefendingCustomNodesFactory).whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories_1.CustomNodesFactories.SelfDefendingCustomNodesFactory);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(StringArrayCustomNodesFactory_1.StringArrayCustomNodesFactory).whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories_1.CustomNodesFactories.StringArrayCustomNodesFactory);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(BinaryExpressionFunctionNode_1.BinaryExpressionFunctionNode).whenTargetNamed(CustomNodes_1.CustomNodes.BinaryExpressionFunctionNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(ControlFlowStorageCallNode_1.ControlFlowStorageCallNode).whenTargetNamed(CustomNodes_1.CustomNodes.ControlFlowStorageCallNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(ControlFlowStorageNode_1.ControlFlowStorageNode).whenTargetNamed(CustomNodes_1.CustomNodes.ControlFlowStorageNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(ConsoleOutputDisableExpressionNode_1.ConsoleOutputDisableExpressionNode).whenTargetNamed(CustomNodes_1.CustomNodes.ConsoleOutputDisableExpressionNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DebugProtectionFunctionCallNode_1.DebugProtectionFunctionCallNode).whenTargetNamed(CustomNodes_1.CustomNodes.DebugProtectionFunctionCallNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DebugProtectionFunctionIntervalNode_1.DebugProtectionFunctionIntervalNode).whenTargetNamed(CustomNodes_1.CustomNodes.DebugProtectionFunctionIntervalNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DebugProtectionFunctionNode_1.DebugProtectionFunctionNode).whenTargetNamed(CustomNodes_1.CustomNodes.DebugProtectionFunctionNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(DomainLockNode_1.DomainLockNode).whenTargetNamed(CustomNodes_1.CustomNodes.DomainLockNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(NodeCallsControllerFunctionNode_1.NodeCallsControllerFunctionNode).whenTargetNamed(CustomNodes_1.CustomNodes.NodeCallsControllerFunctionNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(SelfDefendingUnicodeNode_1.SelfDefendingUnicodeNode).whenTargetNamed(CustomNodes_1.CustomNodes.SelfDefendingUnicodeNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(StringArrayCallsWrapper_1.StringArrayCallsWrapper).whenTargetNamed(CustomNodes_1.CustomNodes.StringArrayCallsWrapper);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(StringArrayNode_1.StringArrayNode).whenTargetNamed(CustomNodes_1.CustomNodes.StringArrayNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode).to(StringArrayRotateFunctionNode_1.StringArrayRotateFunctionNode).whenTargetNamed(CustomNodes_1.CustomNodes.StringArrayRotateFunctionNode);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(ConsoleOutputCustomNodesFactory_1.ConsoleOutputCustomNodesFactory).whenTargetNamed(CustomNodesFactories_1.CustomNodesFactories.ConsoleOutputCustomNodesFactory);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(DebugProtectionCustomNodesFactory_1.DebugProtectionCustomNodesFactory).whenTargetNamed(CustomNodesFactories_1.CustomNodesFactories.DebugProtectionCustomNodesFactory);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(DomainLockCustomNodesFactory_1.DomainLockCustomNodesFactory).whenTargetNamed(CustomNodesFactories_1.CustomNodesFactories.DomainLockCustomNodesFactory);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(SelfDefendingCustomNodesFactory_1.SelfDefendingCustomNodesFactory).whenTargetNamed(CustomNodesFactories_1.CustomNodesFactories.SelfDefendingCustomNodesFactory);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory).to(StringArrayCustomNodesFactory_1.StringArrayCustomNodesFactory).whenTargetNamed(CustomNodesFactories_1.CustomNodesFactories.StringArrayCustomNodesFactory);
     bind(ServiceIdentifiers_1.ServiceIdentifiers['Factory<ICustomNode>']).toFactory(function (context) {
         return function (customNodeName) {
-            return context.container.getTagged(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode, customNodesTag, customNodeName);
+            return context.container.getNamed(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNode, customNodeName);
         };
     });
     bind(ServiceIdentifiers_1.ServiceIdentifiers['Factory<ICustomNodesFactory>']).toFactory(function (context) {
         return function (customNodesFactoryName) {
-            return context.container.getTagged(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory, customNodesConcreteFactoriesTag, customNodesFactoryName);
+            return context.container.getNamed(ServiceIdentifiers_1.ServiceIdentifiers.ICustomNodesFactory, customNodesFactoryName);
         };
     });
 });
@@ -2633,15 +2631,14 @@ var ServiceIdentifiers_1 = __webpack_require__(1);
 var NodeControlFlowTransformersReplacers_1 = __webpack_require__(63);
 var BinaryExpressionControlFlowReplacer_1 = __webpack_require__(31);
 exports.nodeControlFlowTransformersModule = new inversify_1.ContainerModule(function (bind) {
-    var nodeControlFlowTransformersReplacersTag = 'nodeControlFlowTransformersReplacers';
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.IControlFlowReplacer).to(BinaryExpressionControlFlowReplacer_1.BinaryExpressionControlFlowReplacer).whenTargetTagged(nodeControlFlowTransformersReplacersTag, NodeControlFlowTransformersReplacers_1.NodeControlFlowTransformersReplacers.BinaryExpressionControlFlowReplacer);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.IControlFlowReplacer).to(BinaryExpressionControlFlowReplacer_1.BinaryExpressionControlFlowReplacer).whenTargetNamed(NodeControlFlowTransformersReplacers_1.NodeControlFlowTransformersReplacers.BinaryExpressionControlFlowReplacer);
     bind(ServiceIdentifiers_1.ServiceIdentifiers['Factory<IControlFlowReplacer>']).toFactory(function (context) {
         var cache = new Map();
         return function (replacer) {
             if (cache.has(replacer)) {
                 return cache.get(replacer);
             }
-            var controlFlowReplacer = context.container.getTagged(ServiceIdentifiers_1.ServiceIdentifiers.IControlFlowReplacer, nodeControlFlowTransformersReplacersTag, replacer);
+            var controlFlowReplacer = context.container.getNamed(ServiceIdentifiers_1.ServiceIdentifiers.IControlFlowReplacer, replacer);
             cache.set(replacer, controlFlowReplacer);
             return controlFlowReplacer;
         };
@@ -2663,18 +2660,17 @@ var IdentifierReplacer_1 = __webpack_require__(77);
 var NumberLiteralReplacer_1 = __webpack_require__(78);
 var StringLiteralReplacer_1 = __webpack_require__(79);
 exports.nodeObfuscatorsModule = new inversify_1.ContainerModule(function (bind) {
-    var nodeObfuscatorsReplacersTag = 'nodeObfuscatorsReplacers';
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(BooleanLiteralReplacer_1.BooleanLiteralReplacer).whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.BooleanReplacer);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(IdentifierReplacer_1.IdentifierReplacer).whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.IdentifierReplacer);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(NumberLiteralReplacer_1.NumberLiteralReplacer).whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.NumberLiteralReplacer);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(StringLiteralReplacer_1.StringLiteralReplacer).whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.StringLiteralReplacer);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(BooleanLiteralReplacer_1.BooleanLiteralReplacer).whenTargetNamed(NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.BooleanReplacer);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(IdentifierReplacer_1.IdentifierReplacer).whenTargetNamed(NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.IdentifierReplacer);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(NumberLiteralReplacer_1.NumberLiteralReplacer).whenTargetNamed(NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.NumberLiteralReplacer);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer).to(StringLiteralReplacer_1.StringLiteralReplacer).whenTargetNamed(NodeObfuscatorsReplacers_1.NodeObfuscatorsReplacers.StringLiteralReplacer);
     bind(ServiceIdentifiers_1.ServiceIdentifiers['Factory<IReplacer>']).toFactory(function (context) {
         var cache = new Map();
         return function (replacer) {
             if (cache.has(replacer)) {
                 return cache.get(replacer);
             }
-            var obfuscationReplacer = context.container.getTagged(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer, nodeObfuscatorsReplacersTag, replacer);
+            var obfuscationReplacer = context.container.getNamed(ServiceIdentifiers_1.ServiceIdentifiers.IReplacer, replacer);
             cache.set(replacer, obfuscationReplacer);
             return obfuscationReplacer;
         };
@@ -2702,17 +2698,16 @@ var MethodDefinitionObfuscator_1 = __webpack_require__(73);
 var ObjectExpressionObfuscator_1 = __webpack_require__(74);
 var VariableDeclarationObfuscator_1 = __webpack_require__(75);
 exports.nodeTransformersModule = new inversify_1.ContainerModule(function (bind) {
-    var nodeTransformersTag = 'nodeTransformers';
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(FunctionControlFlowTransformer_1.FunctionControlFlowTransformer).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.FunctionControlFlowTransformer);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(CatchClauseObfuscator_1.CatchClauseObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.CatchClauseObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.FunctionDeclarationObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(FunctionObfuscator_1.FunctionObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.FunctionObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(LabeledStatementObfuscator_1.LabeledStatementObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.LabeledStatementObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(LiteralObfuscator_1.LiteralObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.LiteralObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(MemberExpressionObfuscator_1.MemberExpressionObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.MemberExpressionObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(MethodDefinitionObfuscator_1.MethodDefinitionObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.MethodDefinitionObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(ObjectExpressionObfuscator_1.ObjectExpressionObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.ObjectExpressionObfuscator);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(VariableDeclarationObfuscator_1.VariableDeclarationObfuscator).whenTargetTagged(nodeTransformersTag, NodeTransformers_1.NodeTransformers.VariableDeclarationObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(FunctionControlFlowTransformer_1.FunctionControlFlowTransformer).whenTargetNamed(NodeTransformers_1.NodeTransformers.FunctionControlFlowTransformer);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(CatchClauseObfuscator_1.CatchClauseObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.CatchClauseObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.FunctionDeclarationObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(FunctionObfuscator_1.FunctionObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.FunctionObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(LabeledStatementObfuscator_1.LabeledStatementObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.LabeledStatementObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(LiteralObfuscator_1.LiteralObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.LiteralObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(MemberExpressionObfuscator_1.MemberExpressionObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.MemberExpressionObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(MethodDefinitionObfuscator_1.MethodDefinitionObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.MethodDefinitionObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(ObjectExpressionObfuscator_1.ObjectExpressionObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.ObjectExpressionObfuscator);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer).to(VariableDeclarationObfuscator_1.VariableDeclarationObfuscator).whenTargetNamed(NodeTransformers_1.NodeTransformers.VariableDeclarationObfuscator);
     bind(ServiceIdentifiers_1.ServiceIdentifiers['Factory<INodeTransformer[]>']).toFactory(function (context) {
         var cache = new Map();
         return function (nodeTransformersMap) {
@@ -2724,7 +2719,7 @@ exports.nodeTransformersModule = new inversify_1.ContainerModule(function (bind)
                     if (cache.has(transformer)) {
                         nodeTransformer = cache.get(transformer);
                     } else {
-                        nodeTransformer = context.container.getTagged(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer, nodeTransformersTag, transformer);
+                        nodeTransformer = context.container.getNamed(ServiceIdentifiers_1.ServiceIdentifiers.INodeTransformer, transformer);
                         cache.set(transformer, nodeTransformer);
                     }
                     instancesArray.push(nodeTransformer);
@@ -2750,18 +2745,17 @@ var FunctionExpressionCalleeDataExtractor_1 = __webpack_require__(85);
 var ObjectExpressionCalleeDataExtractor_1 = __webpack_require__(86);
 var StackTraceAnalyzer_1 = __webpack_require__(83);
 exports.stackTraceAnalyzerModule = new inversify_1.ContainerModule(function (bind) {
-    var calleeDataExtractorsTag = 'calleeDataExtractors';
     bind(ServiceIdentifiers_1.ServiceIdentifiers.IStackTraceAnalyzer).to(StackTraceAnalyzer_1.StackTraceAnalyzer).inSingletonScope();
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor).to(FunctionDeclarationCalleeDataExtractor_1.FunctionDeclarationCalleeDataExtractor).whenTargetTagged(calleeDataExtractorsTag, CalleeDataExtractors_1.CalleeDataExtractors.FunctionDeclarationCalleeDataExtractor);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor).to(FunctionExpressionCalleeDataExtractor_1.FunctionExpressionCalleeDataExtractor).whenTargetTagged(calleeDataExtractorsTag, CalleeDataExtractors_1.CalleeDataExtractors.FunctionExpressionCalleeDataExtractor);
-    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor).to(ObjectExpressionCalleeDataExtractor_1.ObjectExpressionCalleeDataExtractor).whenTargetTagged(calleeDataExtractorsTag, CalleeDataExtractors_1.CalleeDataExtractors.ObjectExpressionCalleeDataExtractor);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor).to(FunctionDeclarationCalleeDataExtractor_1.FunctionDeclarationCalleeDataExtractor).whenTargetNamed(CalleeDataExtractors_1.CalleeDataExtractors.FunctionDeclarationCalleeDataExtractor);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor).to(FunctionExpressionCalleeDataExtractor_1.FunctionExpressionCalleeDataExtractor).whenTargetNamed(CalleeDataExtractors_1.CalleeDataExtractors.FunctionExpressionCalleeDataExtractor);
+    bind(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor).to(ObjectExpressionCalleeDataExtractor_1.ObjectExpressionCalleeDataExtractor).whenTargetNamed(CalleeDataExtractors_1.CalleeDataExtractors.ObjectExpressionCalleeDataExtractor);
     bind(ServiceIdentifiers_1.ServiceIdentifiers['Factory<ICalleeDataExtractor>']).toFactory(function (context) {
         var cache = new Map();
         return function (calleeDataExtractorName) {
             if (cache.has(calleeDataExtractorName)) {
                 return cache.get(calleeDataExtractorName);
             }
-            var calleeDataExtractor = context.container.getTagged(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor, calleeDataExtractorsTag, calleeDataExtractorName);
+            var calleeDataExtractor = context.container.getNamed(ServiceIdentifiers_1.ServiceIdentifiers.ICalleeDataExtractor, calleeDataExtractorName);
             cache.set(calleeDataExtractorName, calleeDataExtractor);
             return calleeDataExtractor;
         };
@@ -6682,7 +6676,8 @@ module.exports = require("mkdirp");
 module.exports = require("reflect-metadata");
 
 /***/ },
-/* 119 */
+/* 119 */,
+/* 120 */
 /***/ function(module, exports, __webpack_require__) {
 
 "use strict";

package.json

@@ -27,7 +27,7 @@
     "escodegen": "1.8.1",
     "esprima": "3.1.2",
     "estraverse": "4.2.0",
-    "inversify": "^3.0.0-beta.2",
+    "inversify": "^3.0.0-beta.3",
     "is-equal": "^1.5.3",
     "mkdirp": "0.5.1",
     "reflect-metadata": "^0.1.8",

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

@@ -28,90 +28,86 @@ import { StringArrayNode } from '../../../custom-nodes/string-array-nodes/String
 import { StringArrayRotateFunctionNode } from '../../../custom-nodes/string-array-nodes/StringArrayRotateFunctionNode';
 
 export const customNodesModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    const customNodesTag: string = 'customNodes';
-    const customNodesConcreteFactoriesTag: string = 'customNodesConcreteFactories';
-
     // custom nodes
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(BinaryExpressionFunctionNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.BinaryExpressionFunctionNode);
+        .whenTargetNamed(CustomNodes.BinaryExpressionFunctionNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(ControlFlowStorageCallNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.ControlFlowStorageCallNode);
+        .whenTargetNamed(CustomNodes.ControlFlowStorageCallNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(ControlFlowStorageNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.ControlFlowStorageNode);
+        .whenTargetNamed(CustomNodes.ControlFlowStorageNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(ConsoleOutputDisableExpressionNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.ConsoleOutputDisableExpressionNode);
+        .whenTargetNamed(CustomNodes.ConsoleOutputDisableExpressionNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(DebugProtectionFunctionCallNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.DebugProtectionFunctionCallNode);
+        .whenTargetNamed(CustomNodes.DebugProtectionFunctionCallNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(DebugProtectionFunctionIntervalNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.DebugProtectionFunctionIntervalNode);
+        .whenTargetNamed(CustomNodes.DebugProtectionFunctionIntervalNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(DebugProtectionFunctionNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.DebugProtectionFunctionNode);
+        .whenTargetNamed(CustomNodes.DebugProtectionFunctionNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(DomainLockNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.DomainLockNode);
+        .whenTargetNamed(CustomNodes.DomainLockNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(NodeCallsControllerFunctionNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.NodeCallsControllerFunctionNode);
+        .whenTargetNamed(CustomNodes.NodeCallsControllerFunctionNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(SelfDefendingUnicodeNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.SelfDefendingUnicodeNode);
+        .whenTargetNamed(CustomNodes.SelfDefendingUnicodeNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(StringArrayCallsWrapper)
-        .whenTargetTagged(customNodesTag, CustomNodes.StringArrayCallsWrapper);
+        .whenTargetNamed(CustomNodes.StringArrayCallsWrapper);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(StringArrayNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.StringArrayNode);
+        .whenTargetNamed(CustomNodes.StringArrayNode);
 
     bind<ICustomNode>(ServiceIdentifiers.ICustomNode)
         .to(StringArrayRotateFunctionNode)
-        .whenTargetTagged(customNodesTag, CustomNodes.StringArrayRotateFunctionNode);
+        .whenTargetNamed(CustomNodes.StringArrayRotateFunctionNode);
 
     // custom nodes concrete factories
     bind<ICustomNodesFactory>(ServiceIdentifiers.ICustomNodesFactory)
         .to(ConsoleOutputCustomNodesFactory)
-        .whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories.ConsoleOutputCustomNodesFactory);
+        .whenTargetNamed(CustomNodesFactories.ConsoleOutputCustomNodesFactory);
 
     bind<ICustomNodesFactory>(ServiceIdentifiers.ICustomNodesFactory)
         .to(DebugProtectionCustomNodesFactory)
-        .whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories.DebugProtectionCustomNodesFactory);
+        .whenTargetNamed(CustomNodesFactories.DebugProtectionCustomNodesFactory);
 
     bind<ICustomNodesFactory>(ServiceIdentifiers.ICustomNodesFactory)
         .to(DomainLockCustomNodesFactory)
-        .whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories.DomainLockCustomNodesFactory);
+        .whenTargetNamed(CustomNodesFactories.DomainLockCustomNodesFactory);
 
     bind<ICustomNodesFactory>(ServiceIdentifiers.ICustomNodesFactory)
         .to(SelfDefendingCustomNodesFactory)
-        .whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories.SelfDefendingCustomNodesFactory);
+        .whenTargetNamed(CustomNodesFactories.SelfDefendingCustomNodesFactory);
 
     bind<ICustomNodesFactory>(ServiceIdentifiers.ICustomNodesFactory)
         .to(StringArrayCustomNodesFactory)
-        .whenTargetTagged(customNodesConcreteFactoriesTag, CustomNodesFactories.StringArrayCustomNodesFactory);
+        .whenTargetNamed(CustomNodesFactories.StringArrayCustomNodesFactory);
 
     // customNode factory
     bind<ICustomNode>(ServiceIdentifiers['Factory<ICustomNode>'])
         .toFactory<ICustomNode>((context: interfaces.Context) => {
             return (customNodeName: CustomNodes) => {
-                return context.container.getTagged<ICustomNode>(
+                return context.container.getNamed<ICustomNode>(
                     ServiceIdentifiers.ICustomNode,
-                    customNodesTag,
                     customNodeName
                 );
             };
@@ -121,9 +117,8 @@ export const customNodesModule: interfaces.ContainerModule = new ContainerModule
     bind<ICustomNodesFactory>(ServiceIdentifiers['Factory<ICustomNodesFactory>'])
         .toFactory<ICustomNodesFactory>((context: interfaces.Context) => {
             return (customNodesFactoryName: CustomNodesFactories) => {
-                return context.container.getTagged<ICustomNodesFactory>(
+                return context.container.getNamed<ICustomNodesFactory>(
                     ServiceIdentifiers.ICustomNodesFactory,
-                    customNodesConcreteFactoriesTag,
                     customNodesFactoryName
                 );
             };

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

@@ -8,14 +8,9 @@ import { NodeControlFlowTransformersReplacers } from '../../../enums/container/N
 import { BinaryExpressionControlFlowReplacer } from '../../../node-transformers/node-control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer';
 
 export const nodeControlFlowTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    const nodeControlFlowTransformersReplacersTag: string = 'nodeControlFlowTransformersReplacers';
-
     bind<IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer)
         .to(BinaryExpressionControlFlowReplacer)
-        .whenTargetTagged(
-            nodeControlFlowTransformersReplacersTag,
-            NodeControlFlowTransformersReplacers.BinaryExpressionControlFlowReplacer
-        );
+        .whenTargetNamed(NodeControlFlowTransformersReplacers.BinaryExpressionControlFlowReplacer);
 
     bind<IControlFlowReplacer>(ServiceIdentifiers['Factory<IControlFlowReplacer>'])
         .toFactory<IControlFlowReplacer>((context: interfaces.Context) => {
@@ -26,9 +21,8 @@ export const nodeControlFlowTransformersModule: interfaces.ContainerModule = new
                     return <IControlFlowReplacer>cache.get(replacer);
                 }
 
-                const controlFlowReplacer: IControlFlowReplacer = context.container.getTagged<IControlFlowReplacer>(
+                const controlFlowReplacer: IControlFlowReplacer = context.container.getNamed<IControlFlowReplacer>(
                     ServiceIdentifiers.IControlFlowReplacer,
-                    nodeControlFlowTransformersReplacersTag,
                     replacer
                 );
 

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

@@ -11,23 +11,21 @@ import { NumberLiteralReplacer } from '../../../node-transformers/node-obfuscato
 import { StringLiteralReplacer } from '../../../node-transformers/node-obfuscators/replacers/StringLiteralReplacer';
 
 export const nodeObfuscatorsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    const nodeObfuscatorsReplacersTag: string = 'nodeObfuscatorsReplacers';
-
     bind<IReplacer>(ServiceIdentifiers.IReplacer)
         .to(BooleanLiteralReplacer)
-        .whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers.BooleanReplacer);
+        .whenTargetNamed(NodeObfuscatorsReplacers.BooleanReplacer);
 
     bind<IReplacer>(ServiceIdentifiers.IReplacer)
         .to(IdentifierReplacer)
-        .whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers.IdentifierReplacer);
+        .whenTargetNamed(NodeObfuscatorsReplacers.IdentifierReplacer);
 
     bind<IReplacer>(ServiceIdentifiers.IReplacer)
         .to(NumberLiteralReplacer)
-        .whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers.NumberLiteralReplacer);
+        .whenTargetNamed(NodeObfuscatorsReplacers.NumberLiteralReplacer);
 
     bind<IReplacer>(ServiceIdentifiers.IReplacer)
         .to(StringLiteralReplacer)
-        .whenTargetTagged(nodeObfuscatorsReplacersTag, NodeObfuscatorsReplacers.StringLiteralReplacer);
+        .whenTargetNamed(NodeObfuscatorsReplacers.StringLiteralReplacer);
 
     bind<IReplacer>(ServiceIdentifiers['Factory<IReplacer>'])
         .toFactory<IReplacer>((context: interfaces.Context) => {
@@ -38,9 +36,8 @@ export const nodeObfuscatorsModule: interfaces.ContainerModule = new ContainerMo
                     return <IReplacer>cache.get(replacer);
                 }
 
-                const obfuscationReplacer: IReplacer = context.container.getTagged<IReplacer>(
+                const obfuscationReplacer: IReplacer = context.container.getNamed<IReplacer>(
                     ServiceIdentifiers.IReplacer,
-                    nodeObfuscatorsReplacersTag,
                     replacer
                 );
 

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

@@ -18,49 +18,47 @@ import { ObjectExpressionObfuscator } from '../../../node-transformers/node-obfu
 import { VariableDeclarationObfuscator } from '../../../node-transformers/node-obfuscators/VariableDeclarationObfuscator';
 
 export const nodeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    const nodeTransformersTag: string = 'nodeTransformers';
-
     // node control flow transformers
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(FunctionControlFlowTransformer)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.FunctionControlFlowTransformer);
+        .whenTargetNamed(NodeTransformers.FunctionControlFlowTransformer);
 
     // node obfuscators
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(CatchClauseObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.CatchClauseObfuscator);
+        .whenTargetNamed(NodeTransformers.CatchClauseObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(FunctionDeclarationObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.FunctionDeclarationObfuscator);
+        .whenTargetNamed(NodeTransformers.FunctionDeclarationObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(FunctionObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.FunctionObfuscator);
+        .whenTargetNamed(NodeTransformers.FunctionObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(LabeledStatementObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.LabeledStatementObfuscator);
+        .whenTargetNamed(NodeTransformers.LabeledStatementObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(LiteralObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.LiteralObfuscator);
+        .whenTargetNamed(NodeTransformers.LiteralObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(MemberExpressionObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.MemberExpressionObfuscator);
+        .whenTargetNamed(NodeTransformers.MemberExpressionObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(MethodDefinitionObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.MethodDefinitionObfuscator);
+        .whenTargetNamed(NodeTransformers.MethodDefinitionObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(ObjectExpressionObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.ObjectExpressionObfuscator);
+        .whenTargetNamed(NodeTransformers.ObjectExpressionObfuscator);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(VariableDeclarationObfuscator)
-        .whenTargetTagged(nodeTransformersTag, NodeTransformers.VariableDeclarationObfuscator);
+        .whenTargetNamed(NodeTransformers.VariableDeclarationObfuscator);
 
     // node transformers factory
     bind<INodeTransformer[]>(ServiceIdentifiers['Factory<INodeTransformer[]>'])
@@ -77,9 +75,8 @@ export const nodeTransformersModule: interfaces.ContainerModule = new ContainerM
                     if (cache.has(transformer)) {
                         nodeTransformer = <INodeTransformer>cache.get(transformer);
                     } else {
-                        nodeTransformer = context.container.getTagged<INodeTransformer>(
+                        nodeTransformer = context.container.getNamed<INodeTransformer>(
                             ServiceIdentifiers.INodeTransformer,
-                            nodeTransformersTag,
                             transformer
                         );
                         cache.set(transformer, nodeTransformer);

src/container/modules/stack-trace-analyzer/StackTraceAnalyzerModule.ts

@@ -11,8 +11,6 @@ import { ObjectExpressionCalleeDataExtractor } from '../../../stack-trace-analyz
 import { StackTraceAnalyzer } from '../../../stack-trace-analyzer/StackTraceAnalyzer';
 
 export const stackTraceAnalyzerModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    const calleeDataExtractorsTag: string = 'calleeDataExtractors';
-
     // stack trace analyzer
     bind<IStackTraceAnalyzer>(ServiceIdentifiers.IStackTraceAnalyzer)
         .to(StackTraceAnalyzer)
@@ -21,15 +19,15 @@ export const stackTraceAnalyzerModule: interfaces.ContainerModule = new Containe
     // callee data extractors
     bind<ICalleeDataExtractor>(ServiceIdentifiers.ICalleeDataExtractor)
         .to(FunctionDeclarationCalleeDataExtractor)
-        .whenTargetTagged(calleeDataExtractorsTag, CalleeDataExtractors.FunctionDeclarationCalleeDataExtractor);
+        .whenTargetNamed(CalleeDataExtractors.FunctionDeclarationCalleeDataExtractor);
 
     bind<ICalleeDataExtractor>(ServiceIdentifiers.ICalleeDataExtractor)
         .to(FunctionExpressionCalleeDataExtractor)
-        .whenTargetTagged(calleeDataExtractorsTag, CalleeDataExtractors.FunctionExpressionCalleeDataExtractor);
+        .whenTargetNamed(CalleeDataExtractors.FunctionExpressionCalleeDataExtractor);
 
     bind<ICalleeDataExtractor>(ServiceIdentifiers.ICalleeDataExtractor)
         .to(ObjectExpressionCalleeDataExtractor)
-        .whenTargetTagged(calleeDataExtractorsTag, CalleeDataExtractors.ObjectExpressionCalleeDataExtractor);
+        .whenTargetNamed(CalleeDataExtractors.ObjectExpressionCalleeDataExtractor);
 
     // node transformers factory
     bind<ICalleeDataExtractor>(ServiceIdentifiers['Factory<ICalleeDataExtractor>'])
@@ -41,9 +39,8 @@ export const stackTraceAnalyzerModule: interfaces.ContainerModule = new Containe
                     return <ICalleeDataExtractor>cache.get(calleeDataExtractorName);
                 }
 
-                const calleeDataExtractor: ICalleeDataExtractor = context.container.getTagged<ICalleeDataExtractor>(
+                const calleeDataExtractor: ICalleeDataExtractor = context.container.getNamed<ICalleeDataExtractor>(
                     ServiceIdentifiers.ICalleeDataExtractor,
-                    calleeDataExtractorsTag,
                     calleeDataExtractorName
                 );
 

test/unit-tests/OptionsNormalizer.spec.ts

@@ -37,10 +37,12 @@ describe('OptionsNormalizer', () => {
 
         it('should normalize options preset: selfDefendingRule', () => {
             optionsPreset = Object.assign({}, DEFAULT_PRESET, {
+                selfDefending: true,
                 compact: false
             });
 
             expectedOptionsPreset = Object.assign({}, DEFAULT_PRESET, {
+                selfDefending: true,
                 compact: true
             });