inversify 6.0.2 → 6.1.0

package/es/syntax/binding_in_syntax.js

@@ -1,21 +1,21 @@
-import { BindingScopeEnum } from '../constants/literal_types';
-import { BindingWhenOnSyntax } from './binding_when_on_syntax';
-var BindingInSyntax = (function () {
-    function BindingInSyntax(binding) {
-        this._binding = binding;
-    }
-    BindingInSyntax.prototype.inRequestScope = function () {
-        this._binding.scope = BindingScopeEnum.Request;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingInSyntax.prototype.inSingletonScope = function () {
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingInSyntax.prototype.inTransientScope = function () {
-        this._binding.scope = BindingScopeEnum.Transient;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    return BindingInSyntax;
-}());
-export { BindingInSyntax };
+import { BindingScopeEnum } from '../constants/literal_types';
+import { BindingWhenOnSyntax } from './binding_when_on_syntax';
+var BindingInSyntax = (function () {
+    function BindingInSyntax(binding) {
+        this._binding = binding;
+    }
+    BindingInSyntax.prototype.inRequestScope = function () {
+        this._binding.scope = BindingScopeEnum.Request;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingInSyntax.prototype.inSingletonScope = function () {
+        this._binding.scope = BindingScopeEnum.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingInSyntax.prototype.inTransientScope = function () {
+        this._binding.scope = BindingScopeEnum.Transient;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    return BindingInSyntax;
+}());
+export { BindingInSyntax };

package/es/syntax/binding_in_when_on_syntax.js

@@ -1,73 +1,73 @@
-import { BindingInSyntax } from './binding_in_syntax';
-import { BindingOnSyntax } from './binding_on_syntax';
-import { BindingWhenSyntax } from './binding_when_syntax';
-var BindingInWhenOnSyntax = (function () {
-    function BindingInWhenOnSyntax(binding) {
-        this._binding = binding;
-        this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
-        this._bindingOnSyntax = new BindingOnSyntax(this._binding);
-        this._bindingInSyntax = new BindingInSyntax(binding);
-    }
-    BindingInWhenOnSyntax.prototype.inRequestScope = function () {
-        return this._bindingInSyntax.inRequestScope();
-    };
-    BindingInWhenOnSyntax.prototype.inSingletonScope = function () {
-        return this._bindingInSyntax.inSingletonScope();
-    };
-    BindingInWhenOnSyntax.prototype.inTransientScope = function () {
-        return this._bindingInSyntax.inTransientScope();
-    };
-    BindingInWhenOnSyntax.prototype.when = function (constraint) {
-        return this._bindingWhenSyntax.when(constraint);
-    };
-    BindingInWhenOnSyntax.prototype.whenTargetNamed = function (name) {
-        return this._bindingWhenSyntax.whenTargetNamed(name);
-    };
-    BindingInWhenOnSyntax.prototype.whenTargetIsDefault = function () {
-        return this._bindingWhenSyntax.whenTargetIsDefault();
-    };
-    BindingInWhenOnSyntax.prototype.whenTargetTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenTargetTagged(tag, value);
-    };
-    BindingInWhenOnSyntax.prototype.whenInjectedInto = function (parent) {
-        return this._bindingWhenSyntax.whenInjectedInto(parent);
-    };
-    BindingInWhenOnSyntax.prototype.whenParentNamed = function (name) {
-        return this._bindingWhenSyntax.whenParentNamed(name);
-    };
-    BindingInWhenOnSyntax.prototype.whenParentTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenParentTagged(tag, value);
-    };
-    BindingInWhenOnSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
-        return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
-    };
-    BindingInWhenOnSyntax.prototype.whenNoAncestorIs = function (ancestor) {
-        return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
-    };
-    BindingInWhenOnSyntax.prototype.whenAnyAncestorNamed = function (name) {
-        return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
-    };
-    BindingInWhenOnSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
-    };
-    BindingInWhenOnSyntax.prototype.whenNoAncestorNamed = function (name) {
-        return this._bindingWhenSyntax.whenNoAncestorNamed(name);
-    };
-    BindingInWhenOnSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
-    };
-    BindingInWhenOnSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
-        return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
-    };
-    BindingInWhenOnSyntax.prototype.whenNoAncestorMatches = function (constraint) {
-        return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
-    };
-    BindingInWhenOnSyntax.prototype.onActivation = function (handler) {
-        return this._bindingOnSyntax.onActivation(handler);
-    };
-    BindingInWhenOnSyntax.prototype.onDeactivation = function (handler) {
-        return this._bindingOnSyntax.onDeactivation(handler);
-    };
-    return BindingInWhenOnSyntax;
-}());
-export { BindingInWhenOnSyntax };
+import { BindingInSyntax } from './binding_in_syntax';
+import { BindingOnSyntax } from './binding_on_syntax';
+import { BindingWhenSyntax } from './binding_when_syntax';
+var BindingInWhenOnSyntax = (function () {
+    function BindingInWhenOnSyntax(binding) {
+        this._binding = binding;
+        this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
+        this._bindingOnSyntax = new BindingOnSyntax(this._binding);
+        this._bindingInSyntax = new BindingInSyntax(binding);
+    }
+    BindingInWhenOnSyntax.prototype.inRequestScope = function () {
+        return this._bindingInSyntax.inRequestScope();
+    };
+    BindingInWhenOnSyntax.prototype.inSingletonScope = function () {
+        return this._bindingInSyntax.inSingletonScope();
+    };
+    BindingInWhenOnSyntax.prototype.inTransientScope = function () {
+        return this._bindingInSyntax.inTransientScope();
+    };
+    BindingInWhenOnSyntax.prototype.when = function (constraint) {
+        return this._bindingWhenSyntax.when(constraint);
+    };
+    BindingInWhenOnSyntax.prototype.whenTargetNamed = function (name) {
+        return this._bindingWhenSyntax.whenTargetNamed(name);
+    };
+    BindingInWhenOnSyntax.prototype.whenTargetIsDefault = function () {
+        return this._bindingWhenSyntax.whenTargetIsDefault();
+    };
+    BindingInWhenOnSyntax.prototype.whenTargetTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenTargetTagged(tag, value);
+    };
+    BindingInWhenOnSyntax.prototype.whenInjectedInto = function (parent) {
+        return this._bindingWhenSyntax.whenInjectedInto(parent);
+    };
+    BindingInWhenOnSyntax.prototype.whenParentNamed = function (name) {
+        return this._bindingWhenSyntax.whenParentNamed(name);
+    };
+    BindingInWhenOnSyntax.prototype.whenParentTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenParentTagged(tag, value);
+    };
+    BindingInWhenOnSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
+        return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
+    };
+    BindingInWhenOnSyntax.prototype.whenNoAncestorIs = function (ancestor) {
+        return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
+    };
+    BindingInWhenOnSyntax.prototype.whenAnyAncestorNamed = function (name) {
+        return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
+    };
+    BindingInWhenOnSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
+    };
+    BindingInWhenOnSyntax.prototype.whenNoAncestorNamed = function (name) {
+        return this._bindingWhenSyntax.whenNoAncestorNamed(name);
+    };
+    BindingInWhenOnSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
+    };
+    BindingInWhenOnSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
+        return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
+    };
+    BindingInWhenOnSyntax.prototype.whenNoAncestorMatches = function (constraint) {
+        return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
+    };
+    BindingInWhenOnSyntax.prototype.onActivation = function (handler) {
+        return this._bindingOnSyntax.onActivation(handler);
+    };
+    BindingInWhenOnSyntax.prototype.onDeactivation = function (handler) {
+        return this._bindingOnSyntax.onDeactivation(handler);
+    };
+    return BindingInWhenOnSyntax;
+}());
+export { BindingInWhenOnSyntax };

package/es/syntax/binding_on_syntax.js

@@ -1,16 +1,16 @@
-import { BindingWhenSyntax } from './binding_when_syntax';
-var BindingOnSyntax = (function () {
-    function BindingOnSyntax(binding) {
-        this._binding = binding;
-    }
-    BindingOnSyntax.prototype.onActivation = function (handler) {
-        this._binding.onActivation = handler;
-        return new BindingWhenSyntax(this._binding);
-    };
-    BindingOnSyntax.prototype.onDeactivation = function (handler) {
-        this._binding.onDeactivation = handler;
-        return new BindingWhenSyntax(this._binding);
-    };
-    return BindingOnSyntax;
-}());
-export { BindingOnSyntax };
+import { BindingWhenSyntax } from './binding_when_syntax';
+var BindingOnSyntax = (function () {
+    function BindingOnSyntax(binding) {
+        this._binding = binding;
+    }
+    BindingOnSyntax.prototype.onActivation = function (handler) {
+        this._binding.onActivation = handler;
+        return new BindingWhenSyntax(this._binding);
+    };
+    BindingOnSyntax.prototype.onDeactivation = function (handler) {
+        this._binding.onDeactivation = handler;
+        return new BindingWhenSyntax(this._binding);
+    };
+    return BindingOnSyntax;
+}());
+export { BindingOnSyntax };

package/es/syntax/binding_to_syntax.js

@@ -1,84 +1,91 @@
-import * as ERROR_MSGS from "../constants/error_msgs";
-import { BindingScopeEnum, BindingTypeEnum } from "../constants/literal_types";
-import { BindingInWhenOnSyntax } from "./binding_in_when_on_syntax";
-import { BindingWhenOnSyntax } from "./binding_when_on_syntax";
-var BindingToSyntax = (function () {
-    function BindingToSyntax(binding) {
-        this._binding = binding;
-    }
-    BindingToSyntax.prototype.to = function (constructor) {
-        this._binding.type = BindingTypeEnum.Instance;
-        this._binding.implementationType = constructor;
-        return new BindingInWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toSelf = function () {
-        if (typeof this._binding.serviceIdentifier !== "function") {
-            throw new Error("" + ERROR_MSGS.INVALID_TO_SELF_VALUE);
-        }
-        var self = this._binding.serviceIdentifier;
-        return this.to(self);
-    };
-    BindingToSyntax.prototype.toConstantValue = function (value) {
-        this._binding.type = BindingTypeEnum.ConstantValue;
-        this._binding.cache = value;
-        this._binding.dynamicValue = null;
-        this._binding.implementationType = null;
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toDynamicValue = function (func) {
-        this._binding.type = BindingTypeEnum.DynamicValue;
-        this._binding.cache = null;
-        this._binding.dynamicValue = func;
-        this._binding.implementationType = null;
-        return new BindingInWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toConstructor = function (constructor) {
-        this._binding.type = BindingTypeEnum.Constructor;
-        this._binding.implementationType = constructor;
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toFactory = function (factory) {
-        this._binding.type = BindingTypeEnum.Factory;
-        this._binding.factory = factory;
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toFunction = function (func) {
-        if (typeof func !== "function") {
-            throw new Error(ERROR_MSGS.INVALID_FUNCTION_BINDING);
-        }
-        var bindingWhenOnSyntax = this.toConstantValue(func);
-        this._binding.type = BindingTypeEnum.Function;
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return bindingWhenOnSyntax;
-    };
-    BindingToSyntax.prototype.toAutoFactory = function (serviceIdentifier) {
-        this._binding.type = BindingTypeEnum.Factory;
-        this._binding.factory = function (context) {
-            var autofactory = function () { return context.container.get(serviceIdentifier); };
-            return autofactory;
-        };
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toAutoNamedFactory = function (serviceIdentifier) {
-        this._binding.type = BindingTypeEnum.Factory;
-        this._binding.factory = function (context) {
-            return function (named) { return context.container.getNamed(serviceIdentifier, named); };
-        };
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toProvider = function (provider) {
-        this._binding.type = BindingTypeEnum.Provider;
-        this._binding.provider = provider;
-        this._binding.scope = BindingScopeEnum.Singleton;
-        return new BindingWhenOnSyntax(this._binding);
-    };
-    BindingToSyntax.prototype.toService = function (service) {
-        this.toDynamicValue(function (context) { return context.container.get(service); });
-    };
-    return BindingToSyntax;
-}());
-export { BindingToSyntax };
+import * as ERROR_MSGS from '../constants/error_msgs';
+import { BindingScopeEnum, BindingTypeEnum } from '../constants/literal_types';
+import { BindingInWhenOnSyntax } from './binding_in_when_on_syntax';
+import { BindingWhenOnSyntax } from './binding_when_on_syntax';
+var BindingToSyntax = (function () {
+    function BindingToSyntax(binding) {
+        this._binding = binding;
+    }
+    BindingToSyntax.prototype.to = function (constructor) {
+        this._binding.type = BindingTypeEnum.Instance;
+        this._binding.implementationType = constructor;
+        return new BindingInWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toSelf = function () {
+        if (typeof this._binding.serviceIdentifier !== 'function') {
+            throw new Error(ERROR_MSGS.INVALID_TO_SELF_VALUE);
+        }
+        var self = this._binding
+            .serviceIdentifier;
+        return this.to(self);
+    };
+    BindingToSyntax.prototype.toConstantValue = function (value) {
+        this._binding.type = BindingTypeEnum.ConstantValue;
+        this._binding.cache = value;
+        this._binding.dynamicValue = null;
+        this._binding.implementationType = null;
+        this._binding.scope = BindingScopeEnum.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toDynamicValue = function (func) {
+        this._binding.type = BindingTypeEnum.DynamicValue;
+        this._binding.cache = null;
+        this._binding.dynamicValue = func;
+        this._binding.implementationType = null;
+        return new BindingInWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toConstructor = function (constructor) {
+        this._binding.type = BindingTypeEnum.Constructor;
+        this._binding.implementationType = constructor;
+        this._binding.scope = BindingScopeEnum.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toFactory = function (factory) {
+        this._binding.type = BindingTypeEnum.Factory;
+        this._binding.factory = factory;
+        this._binding.scope = BindingScopeEnum.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toFunction = function (func) {
+        if (typeof func !== 'function') {
+            throw new Error(ERROR_MSGS.INVALID_FUNCTION_BINDING);
+        }
+        var bindingWhenOnSyntax = this.toConstantValue(func);
+        this._binding.type = BindingTypeEnum.Function;
+        this._binding.scope = BindingScopeEnum.Singleton;
+        return bindingWhenOnSyntax;
+    };
+    BindingToSyntax.prototype.toAutoFactory = function (serviceIdentifier) {
+        this._binding.type = BindingTypeEnum.Factory;
+        this._binding.factory = function (context) {
+            var autofactory = function () {
+                return context.container.get(serviceIdentifier);
+            };
+            return autofactory;
+        };
+        this._binding.scope = BindingScopeEnum.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toAutoNamedFactory = function (serviceIdentifier) {
+        this._binding.type = BindingTypeEnum.Factory;
+        this._binding.factory = function (context) {
+            return function (named) {
+                return context.container.getNamed(serviceIdentifier, named);
+            };
+        };
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toProvider = function (provider) {
+        this._binding.type = BindingTypeEnum.Provider;
+        this._binding.provider = provider;
+        this._binding.scope = BindingScopeEnum.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    };
+    BindingToSyntax.prototype.toService = function (service) {
+        this.toDynamicValue(function (context) {
+            return context.container.get(service);
+        });
+    };
+    return BindingToSyntax;
+}());
+export { BindingToSyntax };

package/es/syntax/binding_when_on_syntax.js

@@ -1,62 +1,62 @@
-import { BindingOnSyntax } from './binding_on_syntax';
-import { BindingWhenSyntax } from './binding_when_syntax';
-var BindingWhenOnSyntax = (function () {
-    function BindingWhenOnSyntax(binding) {
-        this._binding = binding;
-        this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
-        this._bindingOnSyntax = new BindingOnSyntax(this._binding);
-    }
-    BindingWhenOnSyntax.prototype.when = function (constraint) {
-        return this._bindingWhenSyntax.when(constraint);
-    };
-    BindingWhenOnSyntax.prototype.whenTargetNamed = function (name) {
-        return this._bindingWhenSyntax.whenTargetNamed(name);
-    };
-    BindingWhenOnSyntax.prototype.whenTargetIsDefault = function () {
-        return this._bindingWhenSyntax.whenTargetIsDefault();
-    };
-    BindingWhenOnSyntax.prototype.whenTargetTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenTargetTagged(tag, value);
-    };
-    BindingWhenOnSyntax.prototype.whenInjectedInto = function (parent) {
-        return this._bindingWhenSyntax.whenInjectedInto(parent);
-    };
-    BindingWhenOnSyntax.prototype.whenParentNamed = function (name) {
-        return this._bindingWhenSyntax.whenParentNamed(name);
-    };
-    BindingWhenOnSyntax.prototype.whenParentTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenParentTagged(tag, value);
-    };
-    BindingWhenOnSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
-        return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
-    };
-    BindingWhenOnSyntax.prototype.whenNoAncestorIs = function (ancestor) {
-        return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
-    };
-    BindingWhenOnSyntax.prototype.whenAnyAncestorNamed = function (name) {
-        return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
-    };
-    BindingWhenOnSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
-    };
-    BindingWhenOnSyntax.prototype.whenNoAncestorNamed = function (name) {
-        return this._bindingWhenSyntax.whenNoAncestorNamed(name);
-    };
-    BindingWhenOnSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
-        return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
-    };
-    BindingWhenOnSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
-        return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
-    };
-    BindingWhenOnSyntax.prototype.whenNoAncestorMatches = function (constraint) {
-        return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
-    };
-    BindingWhenOnSyntax.prototype.onActivation = function (handler) {
-        return this._bindingOnSyntax.onActivation(handler);
-    };
-    BindingWhenOnSyntax.prototype.onDeactivation = function (handler) {
-        return this._bindingOnSyntax.onDeactivation(handler);
-    };
-    return BindingWhenOnSyntax;
-}());
-export { BindingWhenOnSyntax };
+import { BindingOnSyntax } from './binding_on_syntax';
+import { BindingWhenSyntax } from './binding_when_syntax';
+var BindingWhenOnSyntax = (function () {
+    function BindingWhenOnSyntax(binding) {
+        this._binding = binding;
+        this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
+        this._bindingOnSyntax = new BindingOnSyntax(this._binding);
+    }
+    BindingWhenOnSyntax.prototype.when = function (constraint) {
+        return this._bindingWhenSyntax.when(constraint);
+    };
+    BindingWhenOnSyntax.prototype.whenTargetNamed = function (name) {
+        return this._bindingWhenSyntax.whenTargetNamed(name);
+    };
+    BindingWhenOnSyntax.prototype.whenTargetIsDefault = function () {
+        return this._bindingWhenSyntax.whenTargetIsDefault();
+    };
+    BindingWhenOnSyntax.prototype.whenTargetTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenTargetTagged(tag, value);
+    };
+    BindingWhenOnSyntax.prototype.whenInjectedInto = function (parent) {
+        return this._bindingWhenSyntax.whenInjectedInto(parent);
+    };
+    BindingWhenOnSyntax.prototype.whenParentNamed = function (name) {
+        return this._bindingWhenSyntax.whenParentNamed(name);
+    };
+    BindingWhenOnSyntax.prototype.whenParentTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenParentTagged(tag, value);
+    };
+    BindingWhenOnSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
+        return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
+    };
+    BindingWhenOnSyntax.prototype.whenNoAncestorIs = function (ancestor) {
+        return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
+    };
+    BindingWhenOnSyntax.prototype.whenAnyAncestorNamed = function (name) {
+        return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
+    };
+    BindingWhenOnSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
+    };
+    BindingWhenOnSyntax.prototype.whenNoAncestorNamed = function (name) {
+        return this._bindingWhenSyntax.whenNoAncestorNamed(name);
+    };
+    BindingWhenOnSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
+        return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
+    };
+    BindingWhenOnSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
+        return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
+    };
+    BindingWhenOnSyntax.prototype.whenNoAncestorMatches = function (constraint) {
+        return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
+    };
+    BindingWhenOnSyntax.prototype.onActivation = function (handler) {
+        return this._bindingOnSyntax.onActivation(handler);
+    };
+    BindingWhenOnSyntax.prototype.onDeactivation = function (handler) {
+        return this._bindingOnSyntax.onDeactivation(handler);
+    };
+    return BindingWhenOnSyntax;
+}());
+export { BindingWhenOnSyntax };