inversify 6.1.2 → 6.1.4-beta.0

package/es6/planning/planner.js

@@ -70,7 +70,7 @@ function _getActiveBindings(metadataReader, avoidConstraints, context, parentReq
     else {
         activeBindings = bindings;
     }
-    _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
+    _validateActiveBindingCount(target.serviceIdentifier, activeBindings, parentRequest, target, context.container);
     return activeBindings;
 }
 function _getTargetMetadata(isMultiInject, serviceIdentifier, key, value) {
@@ -85,7 +85,7 @@ function _getTargetMetadata(isMultiInject, serviceIdentifier, key, value) {
     }
     return metadataList;
 }
-function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
+function _validateActiveBindingCount(serviceIdentifier, bindings, parentRequest, target, container) {
     switch (bindings.length) {
         case binding_count_1.BindingCount.NoBindingsAvailable:
             if (target.isOptional()) {
@@ -96,6 +96,9 @@ function _validateActiveBindingCount(serviceIdentifier, bindings, target, contai
                 let msg = ERROR_MSGS.NOT_REGISTERED;
                 msg += (0, serialization_1.listMetadataForTarget)(serviceIdentifierString, target);
                 msg += (0, serialization_1.listRegisteredBindingsForServiceIdentifier)(container, serviceIdentifierString, getBindings);
+                if (parentRequest !== null) {
+                    msg += `\n${ERROR_MSGS.TRYING_TO_RESOLVE_BINDINGS((0, serialization_1.getServiceIdentifierAsString)(parentRequest.serviceIdentifier))}`;
+                }
                 throw new Error(msg);
             }
         case binding_count_1.BindingCount.OnlyOneBindingAvailable:

package/es6/planning/queryable_string.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from '../interfaces/interfaces';
+export declare class QueryableString implements interfaces.QueryableString {
+    private readonly str;
+    constructor(str: string);
+    startsWith(searchString: string): boolean;
+    endsWith(searchString: string): boolean;
+    contains(searchString: string): boolean;
+    equals(compareString: string): boolean;
+    value(): string;
+}

package/es6/planning/reflection_utils.d.ts

@@ -0,0 +1,5 @@
+import { interfaces } from '../interfaces/interfaces';
+import { getFunctionName } from '../utils/serialization';
+declare function getDependencies(metadataReader: interfaces.MetadataReader, func: NewableFunction): interfaces.Target[];
+declare function getBaseClassDependencyCount(metadataReader: interfaces.MetadataReader, func: NewableFunction): number;
+export { getDependencies, getBaseClassDependencyCount, getFunctionName };

package/es6/planning/request.d.ts

@@ -0,0 +1,14 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class Request implements interfaces.Request {
+    id: number;
+    serviceIdentifier: interfaces.ServiceIdentifier;
+    parentContext: interfaces.Context;
+    parentRequest: interfaces.Request | null;
+    bindings: interfaces.Binding<unknown>[];
+    childRequests: interfaces.Request[];
+    target: interfaces.Target;
+    requestScope: interfaces.RequestScope | null;
+    constructor(serviceIdentifier: interfaces.ServiceIdentifier, parentContext: interfaces.Context, parentRequest: interfaces.Request | null, bindings: interfaces.Binding<any> | interfaces.Binding<any>[], target: interfaces.Target);
+    addChildRequest(serviceIdentifier: interfaces.ServiceIdentifier, bindings: interfaces.Binding<unknown> | interfaces.Binding<unknown>[], target: interfaces.Target): interfaces.Request;
+}
+export { Request };

package/es6/resolution/instantiation.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function resolveInstance<T>(binding: interfaces.Binding<T>, constr: interfaces.Newable<T>, childRequests: interfaces.Request[], resolveRequest: interfaces.ResolveRequestHandler): T | Promise<T>;
+export { resolveInstance };

package/es6/resolution/resolver.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function resolve<T>(context: interfaces.Context): T | Promise<T> | (T | Promise<T>)[];
+export { resolve };

package/es6/scope/scope.d.ts

@@ -0,0 +1,3 @@
+import type { interfaces } from '../interfaces/interfaces';
+export declare const tryGetFromScope: <T>(requestScope: interfaces.RequestScope, binding: interfaces.Binding<T>) => T | Promise<T> | null;
+export declare const saveToScope: <T>(requestScope: interfaces.RequestScope, binding: interfaces.Binding<T>, result: T | Promise<T>) => void;

package/es6/syntax/binding_in_syntax.d.ts

@@ -0,0 +1,9 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingInSyntax<T> implements interfaces.BindingInSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    inRequestScope(): interfaces.BindingWhenOnSyntax<T>;
+    inSingletonScope(): interfaces.BindingWhenOnSyntax<T>;
+    inTransientScope(): interfaces.BindingWhenOnSyntax<T>;
+}
+export { BindingInSyntax };

package/es6/syntax/binding_in_when_on_syntax.d.ts

@@ -0,0 +1,29 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingInWhenOnSyntax<T> implements interfaces.BindingInSyntax<T>, interfaces.BindingWhenSyntax<T>, interfaces.BindingOnSyntax<T> {
+    private readonly _bindingInSyntax;
+    private readonly _bindingWhenSyntax;
+    private readonly _bindingOnSyntax;
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    inRequestScope(): interfaces.BindingWhenOnSyntax<T>;
+    inSingletonScope(): interfaces.BindingWhenOnSyntax<T>;
+    inTransientScope(): interfaces.BindingWhenOnSyntax<T>;
+    when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
+    whenTargetTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenParentTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    onActivation(handler: (context: interfaces.Context, injectable: T) => T | Promise<T>): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: (injectable: T) => void | Promise<void>): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingInWhenOnSyntax };

package/es6/syntax/binding_on_syntax.d.ts

@@ -0,0 +1,8 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingOnSyntax<T> implements interfaces.BindingOnSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    onActivation(handler: interfaces.BindingActivation<T>): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: interfaces.BindingDeactivation<T>): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingOnSyntax };

package/es6/syntax/binding_to_syntax.d.ts

@@ -0,0 +1,18 @@
+import { interfaces } from '../interfaces/interfaces';
+import { BindingWhenOnSyntax } from './binding_when_on_syntax';
+declare class BindingToSyntax<T> implements interfaces.BindingToSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    to(constructor: interfaces.Newable<T>): interfaces.BindingInWhenOnSyntax<T>;
+    toSelf(): interfaces.BindingInWhenOnSyntax<T>;
+    toConstantValue(value: T): interfaces.BindingWhenOnSyntax<T>;
+    toDynamicValue(func: interfaces.DynamicValue<T>): interfaces.BindingInWhenOnSyntax<T>;
+    toConstructor<T2>(constructor: interfaces.Newable<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toFactory<T2>(factory: interfaces.FactoryCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toFunction(func: T): interfaces.BindingWhenOnSyntax<T>;
+    toAutoFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toAutoNamedFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
+    toProvider<T2>(provider: interfaces.ProviderCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
+    toService(service: interfaces.ServiceIdentifier<T>): void;
+}
+export { BindingToSyntax };

package/es6/syntax/binding_when_on_syntax.d.ts

@@ -0,0 +1,25 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingWhenOnSyntax<T> implements interfaces.BindingWhenSyntax<T>, interfaces.BindingOnSyntax<T> {
+    private readonly _bindingWhenSyntax;
+    private readonly _bindingOnSyntax;
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenTargetNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
+    whenTargetTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenParentNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenParentTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    onActivation(handler: (context: interfaces.Context, injectable: T) => T): interfaces.BindingWhenSyntax<T>;
+    onDeactivation(handler: (injectable: T) => Promise<void> | void): interfaces.BindingWhenSyntax<T>;
+}
+export { BindingWhenOnSyntax };

package/es6/syntax/binding_when_syntax.d.ts

@@ -0,0 +1,21 @@
+import { interfaces } from '../interfaces/interfaces';
+declare class BindingWhenSyntax<T> implements interfaces.BindingWhenSyntax<T> {
+    private readonly _binding;
+    constructor(binding: interfaces.Binding<T>);
+    when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenTargetNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
+    whenTargetTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenParentNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenParentTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorMatches(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
+}
+export { BindingWhenSyntax };

package/es6/syntax/constraint_helpers.d.ts

@@ -0,0 +1,6 @@
+import { interfaces } from '../interfaces/interfaces';
+declare const traverseAncerstors: (request: interfaces.Request, constraint: interfaces.ConstraintFunction) => boolean;
+declare const taggedConstraint: (key: string | number | symbol) => (value: unknown) => interfaces.ConstraintFunction;
+declare const namedConstraint: (value: unknown) => interfaces.ConstraintFunction;
+declare const typeConstraint: (type: NewableFunction | string) => (request: interfaces.Request | null) => boolean;
+export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint, };

package/es6/utils/async.d.ts

@@ -0,0 +1,3 @@
+declare function isPromise<T>(object: unknown): object is Promise<T>;
+declare function isPromiseOrContainsPromise<T>(object: unknown): object is Promise<T> | (T | Promise<T>)[];
+export { isPromise, isPromiseOrContainsPromise };

package/es6/utils/binding_utils.d.ts

@@ -0,0 +1,4 @@
+import type { interfaces } from '../interfaces/interfaces';
+export declare const multiBindToService: (container: interfaces.Container) => (service: interfaces.ServiceIdentifier) => (...types: interfaces.ServiceIdentifier[]) => void;
+export declare const ensureFullyBound: <T = unknown>(binding: interfaces.Binding<T>) => void;
+export declare const getFactoryDetails: <T = unknown>(binding: interfaces.Binding<T>) => interfaces.FactoryDetails;

package/es6/utils/clonable.d.ts

@@ -0,0 +1,3 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function isClonable<T>(obj: unknown): obj is interfaces.Clonable<T>;
+export { isClonable };

package/es6/utils/exceptions.d.ts

@@ -0,0 +1,2 @@
+export declare function isStackOverflowException(error: unknown): error is RangeError;
+export declare const tryAndThrowErrorIfStackOverflow: <T>(fn: () => T, errorCallback: () => Error) => T;

package/es6/utils/factory_type.d.ts

@@ -0,0 +1,5 @@
+export declare enum FactoryType {
+    DynamicValue = "toDynamicValue",
+    Factory = "toFactory",
+    Provider = "toProvider"
+}

package/es6/utils/id.d.ts

@@ -0,0 +1,2 @@
+declare function id(): number;
+export { id };

package/es6/utils/js.d.ts

@@ -0,0 +1 @@
+export declare function getFirstArrayDuplicate<T>(array: T[]): T | undefined;

package/es6/utils/serialization.d.ts

@@ -0,0 +1,10 @@
+import { interfaces } from '../interfaces/interfaces';
+declare function getServiceIdentifierAsString(serviceIdentifier: interfaces.ServiceIdentifier): string;
+declare function listRegisteredBindingsForServiceIdentifier(container: interfaces.Container, serviceIdentifier: string, getBindings: <T>(container: interfaces.Container, serviceIdentifier: interfaces.ServiceIdentifier<T>) => interfaces.Binding<T>[]): string;
+declare function circularDependencyToException(request: interfaces.Request): void;
+declare function listMetadataForTarget(serviceIdentifierString: string, target: interfaces.Target): string;
+declare function getFunctionName(func: {
+    name: string | null | undefined;
+}): string;
+declare function getSymbolDescription(symbol: symbol): string;
+export { getFunctionName, getServiceIdentifierAsString, listRegisteredBindingsForServiceIdentifier, listMetadataForTarget, circularDependencyToException, getSymbolDescription, };

package/lib/constants/error_msgs.d.ts

@@ -5,7 +5,7 @@ export declare const KEY_NOT_FOUND: string;
 export declare const AMBIGUOUS_MATCH: string;
 export declare const CANNOT_UNBIND: string;
 export declare const NOT_REGISTERED: string;
-export declare const MISSING_INJECTABLE_ANNOTATION: string;
+export declare const TRYING_TO_RESOLVE_BINDINGS: (name: string) => string;
 export declare const UNDEFINED_INJECT_ANNOTATION: (name: string) => string;
 export declare const CIRCULAR_DEPENDENCY: string;
 export declare const INVALID_BINDING_TYPE: string;

package/lib/constants/error_msgs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STACK_OVERFLOW = exports.CIRCULAR_DEPENDENCY_IN_FACTORY = exports.ON_DEACTIVATION_ERROR = exports.PRE_DESTROY_ERROR = exports.POST_CONSTRUCT_ERROR = exports.ASYNC_UNBIND_REQUIRED = exports.MULTIPLE_POST_CONSTRUCT_METHODS = exports.MULTIPLE_PRE_DESTROY_METHODS = exports.CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = exports.CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = exports.CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = exports.CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = exports.ARGUMENTS_LENGTH_MISMATCH = exports.INVALID_DECORATOR_OPERATION = exports.INVALID_TO_SELF_VALUE = exports.LAZY_IN_SYNC = exports.INVALID_FUNCTION_BINDING = exports.INVALID_MIDDLEWARE_RETURN = exports.NO_MORE_SNAPSHOTS_AVAILABLE = exports.INVALID_BINDING_TYPE = exports.CIRCULAR_DEPENDENCY = exports.UNDEFINED_INJECT_ANNOTATION = exports.MISSING_INJECTABLE_ANNOTATION = exports.NOT_REGISTERED = exports.CANNOT_UNBIND = exports.AMBIGUOUS_MATCH = exports.KEY_NOT_FOUND = exports.NULL_ARGUMENT = exports.DUPLICATED_METADATA = exports.DUPLICATED_INJECTABLE_DECORATOR = void 0;
+exports.STACK_OVERFLOW = exports.CIRCULAR_DEPENDENCY_IN_FACTORY = exports.ON_DEACTIVATION_ERROR = exports.PRE_DESTROY_ERROR = exports.POST_CONSTRUCT_ERROR = exports.ASYNC_UNBIND_REQUIRED = exports.MULTIPLE_POST_CONSTRUCT_METHODS = exports.MULTIPLE_PRE_DESTROY_METHODS = exports.CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = exports.CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = exports.CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = exports.CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = exports.ARGUMENTS_LENGTH_MISMATCH = exports.INVALID_DECORATOR_OPERATION = exports.INVALID_TO_SELF_VALUE = exports.LAZY_IN_SYNC = exports.INVALID_FUNCTION_BINDING = exports.INVALID_MIDDLEWARE_RETURN = exports.NO_MORE_SNAPSHOTS_AVAILABLE = exports.INVALID_BINDING_TYPE = exports.CIRCULAR_DEPENDENCY = exports.UNDEFINED_INJECT_ANNOTATION = exports.TRYING_TO_RESOLVE_BINDINGS = exports.NOT_REGISTERED = exports.CANNOT_UNBIND = exports.AMBIGUOUS_MATCH = exports.KEY_NOT_FOUND = exports.NULL_ARGUMENT = exports.DUPLICATED_METADATA = exports.DUPLICATED_INJECTABLE_DECORATOR = void 0;
 exports.DUPLICATED_INJECTABLE_DECORATOR = 'Cannot apply @injectable decorator multiple times.';
 exports.DUPLICATED_METADATA = 'Metadata key was used more than once in a parameter:';
 exports.NULL_ARGUMENT = 'NULL argument';
@@ -8,7 +8,8 @@ exports.KEY_NOT_FOUND = 'Key Not Found';
 exports.AMBIGUOUS_MATCH = 'Ambiguous match found for serviceIdentifier:';
 exports.CANNOT_UNBIND = 'Could not unbind serviceIdentifier:';
 exports.NOT_REGISTERED = 'No matching bindings found for serviceIdentifier:';
-exports.MISSING_INJECTABLE_ANNOTATION = 'Missing required @injectable annotation in:';
+var TRYING_TO_RESOLVE_BINDINGS = function (name) { return "Trying to resolve bindings for \"".concat(name, "\""); };
+exports.TRYING_TO_RESOLVE_BINDINGS = TRYING_TO_RESOLVE_BINDINGS;
 var UNDEFINED_INJECT_ANNOTATION = function (name) {
     return "@inject called with undefined this could mean that the class ".concat(name, " has ") +
         'a circular dependency problem. You can use a LazyServiceIdentifer to ' +

package/lib/planning/planner.js

@@ -70,7 +70,7 @@ function _getActiveBindings(metadataReader, avoidConstraints, context, parentReq
     else {
         activeBindings = bindings;
     }
-    _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
+    _validateActiveBindingCount(target.serviceIdentifier, activeBindings, parentRequest, target, context.container);
     return activeBindings;
 }
 function _getTargetMetadata(isMultiInject, serviceIdentifier, key, value) {
@@ -85,7 +85,7 @@ function _getTargetMetadata(isMultiInject, serviceIdentifier, key, value) {
     }
     return metadataList;
 }
-function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
+function _validateActiveBindingCount(serviceIdentifier, bindings, parentRequest, target, container) {
     switch (bindings.length) {
         case binding_count_1.BindingCount.NoBindingsAvailable:
             if (target.isOptional()) {
@@ -96,6 +96,9 @@ function _validateActiveBindingCount(serviceIdentifier, bindings, target, contai
                 var msg = ERROR_MSGS.NOT_REGISTERED;
                 msg += (0, serialization_1.listMetadataForTarget)(serviceIdentifierString, target);
                 msg += (0, serialization_1.listRegisteredBindingsForServiceIdentifier)(container, serviceIdentifierString, getBindings);
+                if (parentRequest !== null) {
+                    msg += "\n".concat(ERROR_MSGS.TRYING_TO_RESOLVE_BINDINGS((0, serialization_1.getServiceIdentifierAsString)(parentRequest.serviceIdentifier)));
+                }
                 throw new Error(msg);
             }
         case binding_count_1.BindingCount.OnlyOneBindingAvailable:

package/package.json

@@ -62,7 +62,7 @@
   "scripts": {
     "build": "npm run build:lib && npm run build:amd && npm run build:es && npm run build:es6",
     "build:amd": "tsc -p src/tsconfig-amd.json",
-    "build:es": "tsc -p src/tsconfig-es.json",
+    "build:es": "tsc -p src/tsconfig-es.json && node ./scripts/writeEsmPackageJson.mjs ./es",
     "build:es6": "tsc -p src/tsconfig-es6.json",
     "build:lib": "tsc -p src/tsconfig.json",
     "clean": "rimraf amd es es6 lib",
@@ -76,5 +76,5 @@
   },
   "sideEffects": false,
   "types": "lib/inversify.d.ts",
-  "version": "6.1.2"
+  "version": "6.1.4-beta.0"
 }