@lppedd/di-wise-neo 0.3.0

package/dist/es/index.mjs

@@ -0,0 +1,1037 @@
+// @internal
+function assert(condition, message) {
+    if (!condition) {
+        const resolvedMessage = typeof message === "string" ? message : message();
+        throw new Error(tag(resolvedMessage));
+    }
+}
+// @internal
+function expectNever(value) {
+    throw new TypeError(tag(`unexpected value ${String(value)}`));
+}
+// @internal
+function throwUnregisteredError(token) {
+    throw new Error(tag(`unregistered token ${token.name}`));
+}
+// @internal
+function throwExistingUnregisteredError(sourceToken, targetTokenOrError) {
+    let message = tag(`token resolution error encountered while resolving ${sourceToken.name}`);
+    if (isError(targetTokenOrError)) {
+        message += `\n  [cause] ${untag(targetTokenOrError.message)}`;
+    } else {
+        message += `\n  [cause] the aliased token ${targetTokenOrError.name} is not registered`;
+    }
+    throw new Error(message);
+}
+function isError(value) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return value && value.stack && value.message && typeof value.message === "string";
+}
+function tag(message) {
+    return `[di-wise-neo] ${message}`;
+}
+function untag(message) {
+    return message.startsWith("[di-wise-neo]") //
+     ? message.substring(13).trimStart() : message;
+}
+
+// @internal
+function createInjectionContext() {
+    let current = null;
+    function provide(next) {
+        const prev = current;
+        current = next;
+        return ()=>current = prev;
+    }
+    function use() {
+        return current;
+    }
+    return [
+        provide,
+        use
+    ];
+}
+
+// @internal
+function invariant(condition) {
+    if (!condition) {
+        throw new Error("invariant violation");
+    }
+}
+
+// @internal
+class KeyedStack {
+    has(key) {
+        return this.myKeys.has(key);
+    }
+    peek() {
+        const entry = this.myEntries.at(-1);
+        return entry?.value;
+    }
+    push(key, value) {
+        invariant(!this.has(key));
+        this.myKeys.add(key);
+        this.myEntries.push({
+            key,
+            value
+        });
+        return ()=>{
+            this.myEntries.pop();
+            this.myKeys.delete(key);
+        };
+    }
+    constructor(){
+        this.myEntries = new Array();
+        this.myKeys = new WeakSet();
+    }
+}
+
+// @internal
+class WeakRefMap {
+    get(key) {
+        const ref = this.myMap.get(key);
+        if (ref) {
+            const value = ref.deref();
+            if (value) {
+                return value;
+            }
+            this.myMap.delete(key);
+        }
+    }
+    set(key, value) {
+        invariant(!this.get(key));
+        this.myMap.set(key, new WeakRef(value));
+        return ()=>{
+            this.myMap.delete(key);
+        };
+    }
+    constructor(){
+        this.myMap = new WeakMap();
+    }
+}
+
+// @internal
+function createResolution() {
+    return {
+        stack: new KeyedStack(),
+        values: new WeakRefMap(),
+        dependents: new WeakRefMap()
+    };
+}
+// @internal
+const [provideInjectionContext, useInjectionContext] = createInjectionContext();
+// @internal
+function ensureInjectionContext(fn) {
+    const context = useInjectionContext();
+    assert(context, `${fn.name}() can only be invoked within an injection context`);
+    return context;
+}
+
+function inject(token) {
+    const context = ensureInjectionContext(inject);
+    return context.container.resolve(token);
+}
+function injectBy(thisArg, token) {
+    const context = ensureInjectionContext(injectBy);
+    const resolution = context.resolution;
+    const currentFrame = resolution.stack.peek();
+    if (!currentFrame) {
+        return inject(token);
+    }
+    const currentRef = {
+        current: thisArg
+    };
+    const cleanup = resolution.dependents.set(currentFrame.provider, currentRef);
+    try {
+        return inject(token);
+    } finally{
+        cleanup();
+    }
+}
+
+function injectAll(token) {
+    const context = ensureInjectionContext(injectAll);
+    return context.container.resolveAll(token);
+}
+
+// @internal
+function getMetadata(Class) {
+    let metadata = metadataMap.get(Class);
+    if (!metadata) {
+        metadataMap.set(Class, metadata = {
+            tokensRef: {
+                getRefTokens: ()=>new Set()
+            },
+            provider: {
+                useClass: Class
+            },
+            dependencies: {
+                constructor: [],
+                methods: new Map()
+            }
+        });
+    }
+    return metadata;
+}
+const metadataMap = new WeakMap();
+
+function optional(token) {
+    const context = ensureInjectionContext(optional);
+    return context.container.resolve(token, true);
+}
+function optionalBy(thisArg, token) {
+    const context = ensureInjectionContext(optionalBy);
+    const resolution = context.resolution;
+    const currentFrame = resolution.stack.peek();
+    if (!currentFrame) {
+        return optional(token);
+    }
+    const currentRef = {
+        current: thisArg
+    };
+    const cleanup = resolution.dependents.set(currentFrame.provider, currentRef);
+    try {
+        return optional(token);
+    } finally{
+        cleanup();
+    }
+}
+
+function optionalAll(token) {
+    const context = ensureInjectionContext(optionalAll);
+    return context.container.resolveAll(token, true);
+}
+
+// @internal
+function isClassProvider(provider) {
+    return "useClass" in provider;
+}
+// @internal
+function isExistingProvider(provider) {
+    return "useExisting" in provider;
+}
+// @internal
+function isFactoryProvider(provider) {
+    return "useFactory" in provider;
+}
+// @internal
+function isValueProvider(provider) {
+    return "useValue" in provider;
+}
+
+const Scope = {
+    Inherited: "Inherited",
+    Transient: "Transient",
+    Resolution: "Resolution",
+    Container: "Container"
+};
+
+/**
+ * Type API.
+ */ /**
+ * Create a type token.
+ *
+ * @example
+ * ```ts
+ * const Spell = Type<Spell>("Spell");
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function Type(typeName) {
+    const type = {
+        name: `Type<${typeName}>`,
+        inter: Type,
+        union: Type,
+        toString () {
+            return type.name;
+        }
+    };
+    return type;
+}
+// @internal
+function isConstructor(token) {
+    return typeof token == "function";
+}
+
+// @internal
+function getTypeName(value) {
+    if (typeof value == "string") {
+        return `"${value}"`;
+    }
+    if (typeof value == "function") {
+        return value.name && `typeof ${value.name}` || "Function";
+    }
+    if (typeof value == "object") {
+        if (value === null) {
+            return "null";
+        }
+        const proto = Object.getPrototypeOf(value);
+        if (proto && proto !== Object.prototype) {
+            const constructor = proto.constructor;
+            if (typeof constructor == "function" && constructor.name) {
+                return constructor.name;
+            }
+        }
+    }
+    return typeof value;
+}
+
+// @internal
+class TokenRegistry {
+    constructor(parent){
+        this.parent = parent;
+        this.myMap = new Map();
+    }
+    get(token) {
+        // To clarify, at(-1) means we take the last added registration for this token
+        return this.getAll(token)?.at(-1);
+    }
+    getAll(token) {
+        const internal = internals.get(token);
+        return internal && [
+            internal
+        ] || this.getAllFromParent(token);
+    }
+    set(token, registration) {
+        assert(!internals.has(token), `cannot register reserved token ${token.name}`);
+        let registrations = this.myMap.get(token);
+        if (!registrations) {
+            this.myMap.set(token, registrations = []);
+        }
+        registrations.push(registration);
+    }
+    delete(token) {
+        const registrations = this.myMap.get(token);
+        this.myMap.delete(token);
+        return registrations;
+    }
+    deleteAll() {
+        const tokens = Array.from(this.myMap.keys());
+        const registrations = Array.from(this.myMap.values()).flat();
+        this.myMap.clear();
+        return [
+            tokens,
+            registrations
+        ];
+    }
+    clearRegistrations() {
+        const values = new Set();
+        for (const registrations of this.myMap.values()){
+            for(let i = 0; i < registrations.length; i++){
+                const registration = registrations[i];
+                const value = registration.value;
+                if (value) {
+                    values.add(value.current);
+                }
+                registrations[i] = {
+                    ...registration,
+                    value: undefined
+                };
+            }
+        }
+        return Array.from(values);
+    }
+    getAllFromParent(token) {
+        const registrations = this.myMap.get(token);
+        return registrations || this.parent?.getAllFromParent(token);
+    }
+}
+// @internal
+function isBuilder(provider) {
+    return builders.has(provider);
+}
+/**
+ * Create a one-off type token from a factory function.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   wand = inject(
+ *     Build(() => {
+ *       const wand = inject(Wand);
+ *       wand.owner = this;
+ *       // ...
+ *       return wand;
+ *     }),
+ *   );
+ * }
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function Build(factory) {
+    const token = Type(`Build<${getTypeName(factory)}>`);
+    const provider = {
+        useFactory: factory
+    };
+    internals.set(token, {
+        provider: provider,
+        options: {
+            scope: Scope.Transient
+        }
+    });
+    builders.add(provider);
+    return token;
+}
+const internals = new WeakMap();
+const builders = new WeakSet();
+
+// @internal
+// @internal
+function isDisposable(value) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return value && typeof value === "object" && typeof value.dispose === "function";
+}
+
+/**
+ * The default implementation of a di-wise-neo {@link Container}.
+ */ class DefaultContainer {
+    constructor(myParent, options){
+        this.myParent = myParent;
+        // eslint-disable-next-line no-use-before-define
+        this.myChildren = new Set();
+        this.myDisposed = false;
+        this.myOptions = {
+            autoRegister: false,
+            defaultScope: Scope.Inherited,
+            ...options
+        };
+        this.myTokenRegistry = new TokenRegistry(this.myParent?.myTokenRegistry);
+    }
+    get registry() {
+        return this.myTokenRegistry;
+    }
+    get options() {
+        return {
+            ...this.myOptions
+        };
+    }
+    get parent() {
+        return this.myParent;
+    }
+    get isDisposed() {
+        return this.myDisposed;
+    }
+    createChild(options) {
+        this.checkDisposed();
+        const container = new DefaultContainer(this, {
+            ...this.myOptions,
+            ...options
+        });
+        this.myChildren.add(container);
+        return container;
+    }
+    clearCache() {
+        this.checkDisposed();
+        return this.myTokenRegistry.clearRegistrations();
+    }
+    getCached(token) {
+        this.checkDisposed();
+        const registration = this.myTokenRegistry.get(token);
+        return registration?.value?.current;
+    }
+    getAllCached(token) {
+        this.checkDisposed();
+        const registrations = this.myTokenRegistry.getAll(token);
+        if (!registrations) {
+            return [];
+        }
+        const values = new Set();
+        for (const registration of registrations){
+            const value = registration.value;
+            if (value) {
+                values.add(value.current);
+            }
+        }
+        return Array.from(values);
+    }
+    resetRegistry() {
+        this.checkDisposed();
+        const [, registrations] = this.myTokenRegistry.deleteAll();
+        const values = new Set();
+        for (const registration of registrations){
+            const value = registration.value;
+            if (value) {
+                values.add(value.current);
+            }
+        }
+        return Array.from(values);
+    }
+    isRegistered(token) {
+        this.checkDisposed();
+        return this.myTokenRegistry.get(token) !== undefined;
+    }
+    register(...args) {
+        this.checkDisposed();
+        if (args.length == 1) {
+            const Class = args[0];
+            const metadata = getMetadata(Class);
+            // Register the class itself
+            this.myTokenRegistry.set(Class, {
+                // The provider is of type ClassProvider, initialized by getMetadata
+                provider: metadata.provider,
+                options: {
+                    scope: metadata.scope
+                },
+                dependencies: metadata.dependencies
+            });
+            // Register the additional tokens specified via class decorators.
+            // These tokens will point to the original Class token and will have the same scope.
+            for (const token of metadata.tokensRef.getRefTokens()){
+                this.myTokenRegistry.set(token, {
+                    provider: {
+                        useExisting: Class
+                    }
+                });
+            }
+        } else {
+            const [token, provider, options] = args;
+            if (isClassProvider(provider)) {
+                const Class = provider.useClass;
+                const metadata = getMetadata(Class);
+                this.myTokenRegistry.set(token, {
+                    provider: metadata.provider,
+                    options: {
+                        // The explicit registration options override what is specified
+                        // via class decorators (e.g., @Scoped)
+                        scope: metadata.scope,
+                        ...options
+                    },
+                    dependencies: metadata.dependencies
+                });
+            } else {
+                if (isExistingProvider(provider)) {
+                    assert(token !== provider.useExisting, `the useExisting token ${token.name} cannot be the same as the token being registered`);
+                }
+                this.myTokenRegistry.set(token, {
+                    provider: provider,
+                    options: options
+                });
+            }
+        }
+        return this;
+    }
+    unregister(token) {
+        this.checkDisposed();
+        const registrations = this.myTokenRegistry.delete(token);
+        if (!registrations) {
+            return [];
+        }
+        const values = new Set();
+        for (const registration of registrations){
+            const value = registration.value;
+            if (value) {
+                values.add(value.current);
+            }
+        }
+        return Array.from(values);
+    }
+    resolve(token, optional) {
+        this.checkDisposed();
+        const registration = this.myTokenRegistry.get(token);
+        if (registration) {
+            return this.resolveRegistration(token, registration);
+        }
+        if (isConstructor(token)) {
+            return this.instantiateClass(token, optional);
+        }
+        return optional ? undefined : throwUnregisteredError(token);
+    }
+    resolveAll(token, optional) {
+        this.checkDisposed();
+        const registrations = this.myTokenRegistry.getAll(token);
+        if (registrations) {
+            return registrations.map((registration)=>this.resolveRegistration(token, registration)).filter((value)=>value != null);
+        }
+        if (isConstructor(token)) {
+            const instance = this.instantiateClass(token, optional);
+            return instance === undefined // = could not resolve, but since it is optional
+             ? [] : [
+                instance
+            ];
+        }
+        return optional ? [] : throwUnregisteredError(token);
+    }
+    dispose() {
+        if (this.myDisposed) {
+            return;
+        }
+        // Dispose children containers first
+        for (const child of this.myChildren){
+            child.dispose();
+        }
+        this.myChildren.clear();
+        // Remove ourselves from our parent container
+        this.myParent?.myChildren?.delete(this);
+        this.myDisposed = true;
+        const [, registrations] = this.myTokenRegistry.deleteAll();
+        const disposedRefs = new Set();
+        // Dispose all resolved (aka instantiated) tokens that implement the Disposable interface
+        for (const registration of registrations){
+            const value = registration.value?.current;
+            if (isDisposable(value) && !disposedRefs.has(value)) {
+                disposedRefs.add(value);
+                value.dispose();
+            }
+        }
+        // Allow values to be GCed
+        disposedRefs.clear();
+    }
+    resolveRegistration(token, registration) {
+        let currRegistration = registration;
+        let currProvider = currRegistration.provider;
+        while(isExistingProvider(currProvider)){
+            const targetToken = currProvider.useExisting;
+            currRegistration = this.myTokenRegistry.get(targetToken);
+            if (!currRegistration) {
+                throwExistingUnregisteredError(token, targetToken);
+            }
+            currProvider = currRegistration.provider;
+        }
+        try {
+            return this.resolveProviderValue(currRegistration, currProvider);
+        } catch (e) {
+            // If we were trying to resolve a token registered via ExistingProvider,
+            // we must add the cause of the error to the message
+            if (isExistingProvider(registration.provider)) {
+                throwExistingUnregisteredError(token, e);
+            }
+            throw e;
+        }
+    }
+    instantiateClass(Class, optional) {
+        const metadata = getMetadata(Class);
+        if (metadata.autoRegister ?? this.myOptions.autoRegister) {
+            this.register(Class);
+            return this.resolve(Class);
+        }
+        const scope = this.resolveScope(metadata.scope);
+        if (optional && scope === Scope.Container) {
+            // It would not be possible to resolve the class in container scope,
+            // as that would require prior registration.
+            // However, since resolution is marked optional, we simply return undefined.
+            return undefined;
+        }
+        assert(scope !== Scope.Container, `unregistered class ${Class.name} cannot be resolved in container scope`);
+        const registration = {
+            provider: metadata.provider,
+            options: {
+                scope: scope
+            },
+            dependencies: metadata.dependencies
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        return this.resolveScopedValue(registration, (args)=>new Class(...args));
+    }
+    resolveProviderValue(registration, provider) {
+        assert(registration.provider === provider, "internal error: mismatching provider");
+        if (isClassProvider(provider)) {
+            const Class = provider.useClass;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return this.resolveScopedValue(registration, (args)=>new Class(...args));
+        }
+        if (isFactoryProvider(provider)) {
+            const factory = provider.useFactory;
+            return this.resolveScopedValue(registration, factory);
+        }
+        if (isValueProvider(provider)) {
+            return provider.useValue;
+        }
+        if (isExistingProvider(provider)) {
+            assert(false, "internal error: unexpected ExistingProvider");
+        }
+        expectNever(provider);
+    }
+    resolveScopedValue(registration, factory) {
+        let context = useInjectionContext();
+        if (!context || context.container !== this) {
+            context = {
+                container: this,
+                resolution: createResolution()
+            };
+        }
+        const resolution = context.resolution;
+        const provider = registration.provider;
+        const options = registration.options;
+        if (resolution.stack.has(provider)) {
+            const dependentRef = resolution.dependents.get(provider);
+            assert(dependentRef, "circular dependency detected");
+            return dependentRef.current;
+        }
+        const scope = this.resolveScope(options?.scope, context);
+        const cleanups = [
+            provideInjectionContext(context),
+            !isBuilder(provider) && resolution.stack.push(provider, {
+                provider,
+                scope
+            })
+        ];
+        try {
+            switch(scope){
+                case Scope.Container:
+                    {
+                        const valueRef = registration.value;
+                        if (valueRef) {
+                            return valueRef.current;
+                        }
+                        const args = this.resolveConstructorDependencies(registration);
+                        const value = this.injectDependencies(registration, factory(args));
+                        registration.value = {
+                            current: value
+                        };
+                        return value;
+                    }
+                case Scope.Resolution:
+                    {
+                        const valueRef = resolution.values.get(provider);
+                        if (valueRef) {
+                            return valueRef.current;
+                        }
+                        const args = this.resolveConstructorDependencies(registration);
+                        const value = this.injectDependencies(registration, factory(args));
+                        resolution.values.set(provider, {
+                            current: value
+                        });
+                        return value;
+                    }
+                case Scope.Transient:
+                    {
+                        const args = this.resolveConstructorDependencies(registration);
+                        return this.injectDependencies(registration, factory(args));
+                    }
+            }
+        } finally{
+            cleanups.forEach((cleanup)=>cleanup && cleanup());
+        }
+    }
+    resolveScope(scope = this.myOptions.defaultScope, context = useInjectionContext()) {
+        if (scope == Scope.Inherited) {
+            const dependentFrame = context?.resolution.stack.peek();
+            return dependentFrame?.scope || Scope.Transient;
+        }
+        return scope;
+    }
+    resolveConstructorDependencies(registration) {
+        const dependencies = registration.dependencies;
+        if (dependencies) {
+            assert(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            const ctorDeps = dependencies.constructor;
+            if (ctorDeps.length > 0) {
+                // Let's check if all necessary constructor parameters are decorated.
+                // If not, we cannot safely create an instance.
+                const ctor = registration.provider.useClass;
+                assert(ctor.length === ctorDeps.length, ()=>{
+                    const msg = `expected ${ctor.length} decorated constructor parameters in ${ctor.name}`;
+                    return msg + `, but found ${ctorDeps.length}`;
+                });
+                return ctorDeps.sort((a, b)=>a.index - b.index).map((dep)=>{
+                    const token = dep.tokenRef.getRefToken();
+                    switch(dep.decorator){
+                        case "Inject":
+                            return this.resolve(token);
+                        case "InjectAll":
+                            return this.resolveAll(token);
+                        case "Optional":
+                            return this.resolve(token, true);
+                        case "OptionalAll":
+                            return this.resolveAll(token, true);
+                    }
+                });
+            }
+        }
+        return [];
+    }
+    injectDependencies(registration, instance) {
+        const dependencies = registration.dependencies;
+        if (dependencies) {
+            assert(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            const ctor = registration.provider.useClass;
+            // Perform method injection
+            for (const [key, methodDeps] of dependencies.methods){
+                // Let's check if all necessary method parameters are decorated.
+                // If not, we cannot safely invoke the method.
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                const method = instance[key];
+                assert(methodDeps.length === method.length, ()=>{
+                    const msg = `expected ${method.length} decorated method parameters`;
+                    return msg + ` in ${ctor.name}.${String(key)}, but found ${methodDeps.length}`;
+                });
+                const args = methodDeps.sort((a, b)=>a.index - b.index).map((dep)=>{
+                    const token = dep.tokenRef.getRefToken();
+                    switch(dep.decorator){
+                        case "Inject":
+                            return injectBy(instance, token);
+                        case "InjectAll":
+                            return injectAll(token);
+                        case "Optional":
+                            return optionalBy(instance, token);
+                        case "OptionalAll":
+                            return optionalAll(token);
+                    }
+                });
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                method.bind(instance)(...args);
+            }
+        }
+        return instance;
+    }
+    checkDisposed() {
+        assert(!this.myDisposed, "the container is disposed");
+    }
+}
+
+/**
+ * Creates a new container.
+ */ function createContainer(options = {
+    autoRegister: false,
+    defaultScope: Scope.Inherited
+}) {
+    return new DefaultContainer(undefined, options);
+}
+
+/**
+ * Class decorator for enabling auto-registration of an unregistered class
+ * when first resolving it from the container.
+ *
+ * @example
+ * ```ts
+ * @AutoRegister()
+ * class Wizard {}
+ *
+ * const wizard = container.resolve(Wizard);
+ * container.isRegistered(Wizard); // => true
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function AutoRegister(enable = true) {
+    return function(Class) {
+        const metadata = getMetadata(Class);
+        metadata.autoRegister = enable;
+    };
+}
+
+function forwardRef(token) {
+    return {
+        getRefTokens: ()=>{
+            // Normalize the single token here, so that we don't have
+            // to do it at every getRefTokens call site
+            const tokenOrTokens = token();
+            const tokensArray = Array.isArray(tokenOrTokens) ? tokenOrTokens : [
+                tokenOrTokens
+            ];
+            return new Set(tokensArray);
+        },
+        getRefToken: ()=>{
+            const tokenOrTokens = token();
+            assert(!Array.isArray(tokenOrTokens), "internal error: ref tokens should be a single token");
+            return tokenOrTokens;
+        }
+    };
+}
+// @internal
+function isTokensRef(value) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return value && typeof value === "object" && typeof value.getRefTokens === "function";
+}
+// @internal
+function isTokenRef(value) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return value && typeof value === "object" && typeof value.getRefToken === "function";
+}
+
+function processDecoratedParameter(decorator, token, target, propertyKey, parameterIndex) {
+    // Error out immediately if the decorator has been applied
+    // to a static property or a static method
+    if (propertyKey !== undefined && typeof target === "function") {
+        assert(false, `@${decorator} cannot be used on static member ${target.name}.${String(propertyKey)}`);
+    }
+    const tokenRef = isTokenRef(token) ? token : forwardRef(()=>token);
+    if (propertyKey === undefined) {
+        // Constructor
+        const metadata = getMetadata(target);
+        metadata.dependencies.constructor.push({
+            decorator: decorator,
+            tokenRef: tokenRef,
+            index: parameterIndex
+        });
+    } else {
+        // Normal instance method
+        const metadata = getMetadata(target.constructor);
+        const methods = metadata.dependencies.methods;
+        let dep = methods.get(propertyKey);
+        if (dep === undefined) {
+            dep = [];
+            methods.set(propertyKey, dep);
+        }
+        dep.push({
+            decorator: decorator,
+            tokenRef: tokenRef,
+            index: parameterIndex
+        });
+    }
+}
+
+function Inject(token) {
+    return function(target, propertyKey, parameterIndex) {
+        processDecoratedParameter("Inject", token, target, propertyKey, parameterIndex);
+    };
+}
+
+/**
+ * @__NO_SIDE_EFFECTS__
+ */ function Injectable(...args) {
+    return function(Class) {
+        const metadata = getMetadata(Class);
+        const arg0 = args[0];
+        const tokensRef = isTokensRef(arg0) ? arg0 : forwardRef(()=>args);
+        const existingTokensRef = metadata.tokensRef;
+        metadata.tokensRef = {
+            getRefTokens: ()=>{
+                const existingTokens = existingTokensRef.getRefTokens();
+                for (const token of tokensRef.getRefTokens()){
+                    existingTokens.add(token);
+                }
+                return existingTokens;
+            }
+        };
+    };
+}
+
+function InjectAll(token) {
+    return function(target, propertyKey, parameterIndex) {
+        processDecoratedParameter("InjectAll", token, target, propertyKey, parameterIndex);
+    };
+}
+
+function Optional(token) {
+    return function(target, propertyKey, parameterIndex) {
+        processDecoratedParameter("Optional", token, target, propertyKey, parameterIndex);
+    };
+}
+
+function OptionalAll(token) {
+    return function(target, propertyKey, parameterIndex) {
+        processDecoratedParameter("OptionalAll", token, target, propertyKey, parameterIndex);
+    };
+}
+
+/**
+ * Class decorator for setting the scope of the decorated type when registering it.
+ *
+ * The scope set by this decorator can be overridden by explicit registration options, if provided.
+ *
+ * @example
+ * ```ts
+ * @Scoped(Scope.Container)
+ * class Wizard {}
+ *
+ * container.register(Wizard);
+ *
+ * // Under the hood
+ * container.register(
+ *   Wizard,
+ *   { useClass: Wizard },
+ *   { scope: Scope.Container },
+ * );
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function Scoped(scope) {
+    return function(Class) {
+        const metadata = getMetadata(Class);
+        metadata.scope = scope;
+    };
+}
+
+/**
+ * Injector token for dynamic injections.
+ *
+ * @example
+ * ```ts
+ * class Wizard {
+ *   private injector = inject(Injector);
+ *   private wand?: Wand;
+ *
+ *   getWand(): Wand {
+ *     return (this.wand ??= this.injector.inject(Wand));
+ *   }
+ * }
+ *
+ * const wizard = container.resolve(Wizard);
+ * wizard.getWand(); // => Wand
+ * ```
+ */ const Injector = /*@__PURE__*/ Build(function Injector() {
+    const context = ensureInjectionContext(Injector);
+    const resolution = context.resolution;
+    const dependentFrame = resolution.stack.peek();
+    const dependentRef = dependentFrame && resolution.dependents.get(dependentFrame.provider);
+    function withCurrentContext(fn) {
+        if (useInjectionContext()) {
+            return fn();
+        }
+        const cleanups = [
+            provideInjectionContext(context),
+            dependentFrame && resolution.stack.push(dependentFrame.provider, dependentFrame),
+            dependentRef && resolution.dependents.set(dependentFrame.provider, dependentRef)
+        ];
+        try {
+            return fn();
+        } finally{
+            for (const cleanup of cleanups){
+                cleanup?.();
+            }
+        }
+    }
+    return {
+        inject: (token)=>withCurrentContext(()=>inject(token)),
+        injectAll: (token)=>withCurrentContext(()=>injectAll(token)),
+        optional: (token)=>withCurrentContext(()=>optional(token)),
+        optionalAll: (token)=>withCurrentContext(()=>optionalAll(token))
+    };
+});
+
+/**
+ * Apply middleware functions to a container.
+ *
+ * Middlewares are applied in array order, but execute in reverse order.
+ *
+ * @example
+ * ```ts
+ * const container = applyMiddleware(
+ *   createContainer(),
+ *   [A, B],
+ * );
+ * ```
+ *
+ * The execution order will be:
+ *
+ * 1. B before
+ * 2. A before
+ * 3. original function
+ * 4. A after
+ * 5. B after
+ *
+ * This allows outer middlewares to wrap and control the behavior of inner middlewares.
+ */ function applyMiddleware(container, middlewares) {
+    const composer = {
+        use (key, wrap) {
+            // We need to bind the 'this' context of the function to the container
+            // before passing it to the middleware wrapper.
+            //
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+            const fn = container[key].bind(container);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            container[key] = wrap(fn);
+            return composer;
+        }
+    };
+    const api = container.api ||= {
+        ...container
+    };
+    for (const middleware of middlewares){
+        middleware(composer, api);
+    }
+    return container;
+}
+
+export { AutoRegister, Build, Inject, InjectAll, Injectable, Injector, Optional, OptionalAll, Scope, Scoped, Type, applyMiddleware, createContainer, forwardRef, inject, injectAll, injectBy };
+//# sourceMappingURL=index.mjs.map