@adimm/x-injection 1.2.0 → 2.0.3

package/dist/index.cjs

@@ -1,671 +1,814 @@
 "use strict";
 
-var e, i = Object.defineProperty, t = Object.getOwnPropertyDescriptor, n = Object.getOwnPropertyNames, o = Object.prototype.hasOwnProperty, r = (e, t) => i(e, "name", {
-    value: t,
+var e, t = Object.defineProperty, i = Object.getOwnPropertyDescriptor, o = Object.getOwnPropertyNames, r = Object.prototype.hasOwnProperty, n = (e, i) => t(e, "name", {
+    value: i,
     configurable: !0
 }), s = {};
 
-((e, t) => {
-    for (var n in t) i(e, n, {
-        get: t[n],
+((e, i) => {
+    for (var o in i) t(e, o, {
+        get: i[o],
         enumerable: !0
     });
 })(s, {
-    AppModule: () => $,
-    GLOBAL_APP_MODULE_ID: () => d,
-    GlobalAppModule: () => H,
-    GlobalContainer: () => L,
-    Inject: () => T,
-    InjectFromBase: () => _,
-    Injectable: () => E,
-    InjectionError: () => x,
-    InjectionProviderModuleDisposedError: () => q,
-    InjectionProviderModuleError: () => F,
-    InjectionProviderModuleGlobalMarkError: () => N,
-    InjectionProviderModuleMissingIdentifierError: () => U,
-    InjectionScope: () => c,
-    MultiInject: () => w,
-    Named: () => P,
-    Optional: () => C,
-    ProviderModule: () => W,
-    ProviderModuleDefinition: () => m,
-    ProviderModuleHelpers: () => I,
-    ProviderTokenHelpers: () => f,
-    Tagged: () => R,
-    Unmanaged: () => A,
-    bindingScopeToInjectionScope: () => l,
-    injectionScopeToBindingScope: () => u,
-    isClass: () => p,
-    isClassOrFunction: () => v,
-    isFunction: () => S,
-    isPlainObject: () => b
-}), module.exports = (e = s, ((e, r, s, d) => {
-    if (r && "object" == typeof r || "function" == typeof r) for (let a of n(r)) o.call(e, a) || a === s || i(e, a, {
-        get: () => r[a],
-        enumerable: !(d = t(r, a)) || d.enumerable
+    AppModule: () => Z,
+    DefinitionEventType: () => p,
+    Inject: () => V,
+    InjectFromBase: () => N,
+    Injectable: () => q,
+    InjectionError: () => I,
+    InjectionProviderModuleDisposedError: () => P,
+    InjectionProviderModuleError: () => b,
+    InjectionProviderModuleMissingIdentifierError: () => x,
+    InjectionProviderModuleMissingProviderError: () => E,
+    InjectionProviderModuleUnknownProviderError: () => w,
+    InjectionScope: () => u,
+    MiddlewareType: () => a,
+    MultiInject: () => U,
+    Named: () => H,
+    Optional: () => J,
+    ProviderModule: () => G,
+    ProviderModuleBlueprint: () => A,
+    ProviderModuleHelpers: () => g,
+    ProviderTokenHelpers: () => h,
+    Tagged: () => Q,
+    Unmanaged: () => Y,
+    bindingScopeToInjectionScope: () => c,
+    deepClone: () => k,
+    injectionScopeToBindingScope: () => l,
+    isClass: () => v,
+    isClassOrFunction: () => m,
+    isFunction: () => F,
+    isPlainObject: () => y
+}), module.exports = (e = s, ((e, n, s, d) => {
+    if (n && "object" == typeof n || "function" == typeof n) for (let u of o(n)) r.call(e, u) || u === s || t(e, u, {
+        get: () => n[u],
+        enumerable: !(d = i(n, u)) || d.enumerable
     });
     return e;
-})(i({}, "__esModule", {
+})(t({}, "__esModule", {
     value: !0
 }), e));
 
-var d = "GlobalAppModule", a = require("inversify"), c = function(e) {
+var d = require("inversify"), u = function(e) {
     return e[e.Singleton = 0] = "Singleton", e[e.Transient = 1] = "Transient", e[e.Request = 2] = "Request", 
     e;
+}({}), a = function(e) {
+    return e[e.BeforeAddImport = 0] = "BeforeAddImport", e[e.BeforeAddProvider = 1] = "BeforeAddProvider", 
+    e[e.BeforeGet = 2] = "BeforeGet", e[e.BeforeRemoveImport = 3] = "BeforeRemoveImport", 
+    e[e.BeforeRemoveProvider = 4] = "BeforeRemoveProvider", e[e.BeforeRemoveExport = 5] = "BeforeRemoveExport", 
+    e[e.OnExportAccess = 6] = "OnExportAccess", e;
+}({}), p = function(e) {
+    return e[e.Noop = 0] = "Noop", e[e.Import = 1] = "Import", e[e.Provider = 2] = "Provider", 
+    e[e.GetProvider = 3] = "GetProvider", e[e.Export = 4] = "Export", e[e.ExportModule = 5] = "ExportModule", 
+    e[e.ExportProvider = 6] = "ExportProvider", e[e.ImportRemoved = 7] = "ImportRemoved", 
+    e[e.ProviderRemoved = 8] = "ProviderRemoved", e[e.ExportRemoved = 9] = "ExportRemoved", 
+    e[e.ExportModuleRemoved = 10] = "ExportModuleRemoved", e[e.ExportProviderRemoved = 11] = "ExportProviderRemoved", 
+    e;
 }({});
 
-function u(e) {
+function l(e) {
     switch (e) {
-      case c.Singleton:
+      case u.Singleton:
         return "Singleton";
 
-      case c.Transient:
+      case u.Transient:
         return "Transient";
 
-      case c.Request:
+      case u.Request:
         return "Request";
     }
 }
 
-function l(e) {
+function c(e) {
     switch (e) {
       case "Singleton":
-        return c.Singleton;
+        return u.Singleton;
 
       case "Transient":
-        return c.Transient;
+        return u.Transient;
 
       case "Request":
-        return c.Request;
+        return u.Request;
     }
 }
 
-r(u, "injectionScopeToBindingScope"), r(l, "bindingScopeToInjectionScope");
+n(l, "injectionScopeToBindingScope"), n(c, "bindingScopeToInjectionScope");
 
-var f, h = require("@inversifyjs/core");
+var h, f = require("@inversifyjs/core");
 
-function p(e) {
+function v(e) {
     return "function" == typeof e && Function.prototype.toString.call(e).startsWith("class ");
 }
 
-function v(e) {
+function m(e) {
     return "function" == typeof e;
 }
 
-function S(e) {
-    return "function" == typeof e && !Function.prototype.toString.call(e).startsWith("class ");
-}
-
-function g(e) {
+function M(e) {
     return "[object Object]" === Object.prototype.toString.call(e);
 }
 
-function b(e) {
-    if (!1 === g(e)) return !1;
-    const i = e.constructor;
-    if (void 0 === i) return !0;
-    const t = i.prototype;
-    return !1 !== g(t) && !1 !== t.hasOwnProperty("isPrototypeOf");
+function y(e) {
+    if (!1 === M(e)) return !1;
+    const t = e.constructor;
+    if (void 0 === t) return !0;
+    const i = t.prototype;
+    return !1 !== M(i) && !1 !== i.hasOwnProperty("isPrototypeOf");
 }
 
-r(p, "isClass"), r(v, "isClassOrFunction"), r(S, "isFunction"), r(g, "isObject"), 
-r(b, "isPlainObject"), function(e) {
-    function i(e) {
+n(v, "isClass"), n(m, "isClassOrFunction"), n(M, "isObject"), n(y, "isPlainObject"), 
+function(e) {
+    function t(e) {
         return I(e) && "useClass" in e;
     }
-    function t(e) {
+    function i(e) {
         return I(e) && "useValue" in e;
     }
-    function n(e) {
+    function o(e) {
         return I(e) && "useFactory" in e;
     }
-    function o(e) {
-        return "string" == typeof e || "symbol" == typeof e || v(e);
+    function r(e) {
+        return "string" == typeof e || "symbol" == typeof e || m(e);
     }
     function s(e) {
-        return o(e) ? e : e.provide;
+        return r(e) ? e : e.provide;
     }
     function d(e) {
         return e.map((e => s(e)));
     }
-    function a(e, i) {
-        return p(e) ? {
-            ...i,
-            provide: i?.provide ?? e,
-            useClass: i?.useClass ?? e
-        } : S(e) ? {
-            ...i,
-            provide: i?.provide ?? e,
-            useFactory: i?.useFactory ?? e
-        } : {
-            ...e,
-            ...i
-        };
+    function u(e) {
+        return "symbol" == typeof e || "string" == typeof e ? e.toString() : e.name;
     }
-    function c(e, i) {
-        return f(e) ?? g(e) ?? i;
+    function a(e) {
+        return u(s(e));
     }
-    function u(e) {
+    function p(e, r) {
+        if (e === r) return !0;
+        return s(e) === s(r) && (t(e) && t(r) ? e.useClass === r.useClass : i(e) && i(r) ? e.useValue === r.useValue : !o(e) || !o(r) || e.useFactory === r.useFactory);
+    }
+    function l(e, t) {
+        return M(e) ?? g(e) ?? t;
+    }
+    function h(e) {
         if (I(e)) return e;
     }
-    function f(e) {
-        const i = u(e);
-        if (i) return i.scope;
+    function M(e) {
+        const t = h(e);
+        if (t) return t.scope;
     }
     function g(e) {
-        const i = s(e);
-        if (!p(i)) return;
-        const t = (0, h.getClassMetadata)(i)?.scope;
-        return t ? l(t) : void 0;
+        const t = s(e);
+        if (!v(t)) return;
+        const i = (0, f.getClassMetadata)(t)?.scope;
+        return i ? c(i) : void 0;
     }
     function I(e) {
-        return b(e) && "object" == typeof e && "provide" in e;
-    }
-    r(i, "isClassToken"), e.isClassToken = i, r(t, "isValueToken"), e.isValueToken = t, 
-    r(n, "isFactoryToken"), e.isFactoryToken = n, r(o, "isProviderIdentifier"), e.isProviderIdentifier = o, 
-    r(s, "toServiceIdentifier"), e.toServiceIdentifier = s, r(d, "toServiceIdentifiers"), 
-    e.toServiceIdentifiers = d, r(a, "toDependencyProviderWithOptions"), e.toDependencyProviderWithOptions = a, 
-    r(c, "getInjectionScopeByPriority"), e.getInjectionScopeByPriority = c, r(u, "tryGetProviderOptions"), 
-    e.tryGetProviderOptions = u, r(f, "tryGetScopeFromProvider"), e.tryGetScopeFromProvider = f, 
-    r(g, "tryGetDecoratorScopeFromClass"), e.tryGetDecoratorScopeFromClass = g, r(I, "hasProvideProperty");
-}(f || (f = {}));
-
-var I, y = new Set, m = class e {
+        return y(e) && "object" == typeof e && "provide" in e;
+    }
+    n(t, "isClassToken"), e.isClassToken = t, n(i, "isValueToken"), e.isValueToken = i, 
+    n(o, "isFactoryToken"), e.isFactoryToken = o, n(r, "isProviderIdentifier"), e.isProviderIdentifier = r, 
+    n(s, "toProviderIdentifier"), e.toProviderIdentifier = s, n(d, "toProviderIdentifiers"), 
+    e.toProviderIdentifiers = d, n(u, "providerIdentifierToString"), e.providerIdentifierToString = u, 
+    n(a, "providerTokenToString"), e.providerTokenToString = a, n(p, "providerTokensAreEqual"), 
+    e.providerTokensAreEqual = p, n(l, "getInjectionScopeByPriority"), e.getInjectionScopeByPriority = l, 
+    n(h, "tryGetProviderOptions"), e.tryGetProviderOptions = h, n(M, "tryGetScopeFromProvider"), 
+    e.tryGetScopeFromProvider = M, n(g, "tryGetDecoratorScopeFromClass"), e.tryGetDecoratorScopeFromClass = g, 
+    n(I, "hasProvideProperty");
+}(h || (h = {}));
+
+var g, I = class e extends Error {
     static {
-        r(this, "ProviderModuleDefinition");
-    }
-    identifier;
-    imports;
-    providers;
-    exports;
-    defaultScope;
-    isGlobal;
-    onReady;
-    onDispose;
-    constructor(e) {
-        const {identifier: i, imports: t, providers: n, exports: o, defaultScope: r, isGlobal: s, onReady: d, onDispose: a} = e;
-        this.identifier = i, this.imports = t, this.providers = n, this.exports = o, this.defaultScope = r ?? c.Singleton, 
-        this.isGlobal = s ?? !1, this.onReady = d, this.onDispose = a, this.checkIfShouldBeAddedToTheGlobalRegister();
-    }
-    getDefinition() {
-        return {
-            identifier: this.identifier,
-            imports: this.imports,
-            providers: this.providers,
-            exports: this.exports,
-            defaultScope: this.defaultScope,
-            isGlobal: this.isGlobal,
-            onReady: this.onReady,
-            onDispose: this.onDispose
-        };
-    }
-    clone(i) {
-        const t = this.getDefinition();
-        return new e(i ? {
-            ...t,
-            ...i
-        } : t);
-    }
-    toString() {
-        return ("symbol" == typeof this.identifier ? this.identifier.description : this.identifier) ?? "Unknown";
-    }
-    checkIfShouldBeAddedToTheGlobalRegister() {
-        this.isGlobal && y.add(this);
-    }
-};
-
-function E(e) {
-    return void 0 === e ? (0, a.injectable)() : (0, a.injectable)(u(e));
-}
-
-!function(e) {
-    function i(e) {
-        return e;
-    }
-    function t(e) {
-        const {identifier: i, imports: t, providers: o, exports: r, defaultScope: s, isGlobal: d, onReady: a, onDispose: c, ...u} = e, l = u;
-        if (n(e)) {
-            const e = u;
-            delete e.getDefinition, delete e.clone, delete e.toString;
-        }
-        return {
-            options: {
-                identifier: i,
-                imports: t,
-                providers: o,
-                exports: r,
-                defaultScope: s,
-                isGlobal: d,
-                onReady: a,
-                onDispose: c
-            },
-            internalOptions: l
-        };
-    }
-    function n(e) {
-        return e instanceof m;
-    }
-    function o(e) {
-        return S(e);
+        n(this, "InjectionError");
     }
-    function s(e, i) {
-        return o(i) ? i(e) : i;
-    }
-    r(i, "buildInternalConstructorParams"), e.buildInternalConstructorParams = i, r(t, "getOptionsOrModuleDefinitionOptions"), 
-    e.getOptionsOrModuleDefinitionOptions = t, r(n, "isModuleDefinition"), e.isModuleDefinition = n, 
-    r(o, "isLazyExport"), e.isLazyExport = o, r(s, "tryStaticOrLazyExportToStaticExport"), 
-    e.tryStaticOrLazyExportToStaticExport = s;
-}(I || (I = {})), r(E, "Injectable");
-
-var M = require("inversify");
-
-function T(e) {
-    return (0, M.inject)(f.toServiceIdentifier(e));
-}
-
-r(T, "Inject");
-
-var k = require("inversify");
-
-function w(e) {
-    return (0, k.multiInject)(f.toServiceIdentifier(e));
-}
-
-r(w, "MultiInject");
-
-var D = require("inversify");
-
-function _(e) {
-    return (0, D.injectFromBase)(e);
-}
-
-r(_, "InjectFromBase");
-
-var j = require("inversify");
-
-function P(e) {
-    return (0, j.named)(e);
-}
-
-r(P, "Named");
-
-var O = require("inversify");
-
-function C() {
-    return (0, O.optional)();
-}
-
-r(C, "Optional");
-
-var G = require("inversify");
-
-function R(e, i) {
-    return (0, G.tagged)(e, i);
-}
-
-r(R, "Tagged");
-
-var B = require("inversify");
-
-function A() {
-    return (0, B.unmanaged)();
-}
-
-r(A, "Unmanaged");
-
-var x = class e extends Error {
+    name=e.name;
+}, b = class e extends Error {
     static {
-        r(this, "InjectionError");
+        n(this, "InjectionProviderModuleError");
     }
     name=e.name;
-}, F = class e extends Error {
+    constructor(e, t) {
+        let i = "Unknown";
+        try {
+            i = e.toString();
+        } catch {}
+        super(`{ProviderModule.${i}} => ${t}`);
+    }
+}, w = class e extends b {
     static {
-        r(this, "InjectionProviderModuleError");
+        n(this, "InjectionProviderModuleUnknownProviderError");
     }
     name=e.name;
-    constructor(e, i) {
-        super(`{ProviderModule.${e.toString()}} => ${i}`);
+    constructor(e, t) {
+        super(e, `The [${h.providerTokenToString(t)}] provider is of an unknown type!`);
     }
-}, q = class e extends F {
+}, P = class e extends b {
     static {
-        r(this, "InjectionProviderModuleDisposedError");
+        n(this, "InjectionProviderModuleDisposedError");
     }
     name=e.name;
     constructor(e) {
-        super(e, "Has been disposed! You can re-initialize it by using the `_internalInit` method.");
+        super(e, "Has been disposed!");
     }
-}, U = class e extends F {
+}, x = class e extends b {
     static {
-        r(this, "InjectionProviderModuleMissingIdentifierError");
+        n(this, "InjectionProviderModuleMissingIdentifierError");
     }
     name=e.name;
     constructor(e) {
         super(e, "An `identifier` must be supplied!");
     }
-}, N = class e extends F {
+}, E = class e extends b {
     static {
-        r(this, "InjectionProviderModuleGlobalMarkError");
+        n(this, "InjectionProviderModuleMissingProviderError");
     }
     name=e.name;
-    constructor(e, i) {
-        super(e, i);
+    constructor(e, t) {
+        super(e, `The [${h.providerTokenToString(t)}] provider is not bound to this (or any imported) module container, and was not found either in the 'AppModule'!`);
     }
-}, L = new (require("inversify").Container)({
+}, S = require("inversify"), D = new (require("inversify").Container)({
     defaultScope: "Singleton"
-}), z = require("inversify"), V = class {
+}), C = class {
     static {
-        r(this, "ProviderModuleUtils");
-    }
-    get container() {
-        return this.moduleNaked.container;
-    }
-    appModule=$;
-    module;
-    moduleNaked;
-    constructor(e, i) {
-        this.module = e, this.moduleNaked = e.toNaked(), this.appModule = i.appModule?.() ?? this.appModule, 
-        this.checkIfShouldBeAddedToTheGlobalRegister();
-    }
-    bindToContainer(e, i) {
-        return f.isProviderIdentifier(e) ? this.bindSelfTokenToContainer(e, i) : f.isClassToken(e) ? this.bindClassTokenToContainer(e, i) : f.isValueToken(e) ? this.bindValueTokenToContainer(e) : !!f.isFactoryToken(e) && this.bindFactoryTokenToContainer(e, i);
+        n(this, "ModuleContainer");
     }
-    checkIfShouldBeAddedToTheGlobalRegister() {
-        this.moduleNaked.isAppModule || !this.module.isGlobal || this.moduleNaked.instantiatedFromDefinition || y.add(this.module);
+    container;
+    providerModule;
+    constructor(e, t) {
+        this.providerModule = e;
+        const {defaultScope: i = u.Singleton} = e.options;
+        this.container = "AppModule" === e.id ? D : new S.Container({
+            parent: t ?? this.providerModule.appModuleRef.moduleContainer.container,
+            defaultScope: l(i)
+        }), this.providerModule.options.providers?.forEach((e => this.bindToContainer(e)));
+    }
+    get(e, t, i) {
+        const o = this.providerModule.middlewaresManager.applyMiddlewares(a.BeforeGet, this.getProvider(e, i), e, this.getProvider.bind(this));
+        if (o || null === o) return o;
+        if (!t) throw new E(this.providerModule, e);
     }
-    bindSelfTokenToContainer(e, i) {
-        return this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).toSelf(), i), 
-        this.moduleNaked.__isCurrentBound(e);
+    getMany(...e) {
+        return e.map((e => {
+            const t = y(e) && "provider" in e;
+            return this.get(t ? e.provider : e, !!t && e.isOptional, !!t && e.asList);
+        }));
     }
-    bindClassTokenToContainer(e, i) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).to(e.useClass), i))), 
-        this.moduleNaked.__isCurrentBound(e);
+    bindToContainer(e) {
+        const t = h.toProviderIdentifier(e), i = [ {
+            providerTypeMatches: h.isProviderIdentifier,
+            bind: n((() => this.container.bind(t).toSelf()), "bind")
+        }, {
+            providerTypeMatches: h.isClassToken,
+            bind: n((() => this.container.bind(t).to(e.useClass)), "bind")
+        }, {
+            providerTypeMatches: h.isValueToken,
+            bind: n((() => this.container.bind(t).toConstantValue(e.useValue)), "bind")
+        }, {
+            providerTypeMatches: h.isFactoryToken,
+            bind: n((() => this.container.bind(t).toResolvedValue((() => {
+                const t = e, i = this.providerModule.getMany(...t.inject ?? []);
+                return t.useFactory(...i);
+            }))), "bind")
+        } ], {bind: o} = i.find((({providerTypeMatches: t}) => t(e))) ?? {};
+        if (!o) throw new w(this.providerModule, e);
+        const r = h.isProviderIdentifier(e);
+        let s = o();
+        if (h.isValueToken(e) || r || (s = this.setBindingScope(e, s)), r) return;
+        const d = e;
+        d.when && s.when(d.when);
+    }
+    setBindingScope(e, t) {
+        switch (h.getInjectionScopeByPriority(e, this.providerModule.options.defaultScope ?? u.Singleton)) {
+          case u.Singleton:
+            return t.inSingletonScope();
+
+          case u.Transient:
+            return t.inTransientScope();
+
+          case u.Request:
+            return t.inRequestScope();
+        }
     }
-    bindValueTokenToContainer(e) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.container.bind(f.toServiceIdentifier(e)).toConstantValue(e.useValue))), 
-        this.moduleNaked.__isCurrentBound(e);
+    dispose() {
+        this.providerModule = null, this.container = null;
     }
-    bindFactoryTokenToContainer(e, i) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).toResolvedValue(e.useFactory, f.toServiceIdentifiers(e.inject ?? [])), i))), 
-        this.moduleNaked.__isCurrentBound(e);
+    getProvider(e, t) {
+        const i = h.toProviderIdentifier(e);
+        return t ? this.container.getAll(i, {
+            optional: !0
+        }) : this.container.get(i, {
+            optional: !0
+        });
     }
-    setBindingScope(e, i, t) {
-        if (f.isValueToken(e)) return i;
-        switch (f.getInjectionScopeByPriority(e, t)) {
-          case c.Singleton:
-            return i.inSingletonScope();
-
-          case c.Transient:
-            return i.inTransientScope();
-
-          case c.Request:
-            return i.inRequestScope();
+}, R = require("inversify"), T = class {
+    static {
+        n(this, "ImportedModuleContainer");
+    }
+    get moduleDef() {
+        return this.providerModule.dynamicModuleDef.moduleDef;
+    }
+    importedIntoModule;
+    providerModule;
+    proxyContainer;
+    proxyContainerOptions;
+    constructor(e, t) {
+        this.importedIntoModule = e, this.providerModule = t, this.proxyContainer = this.buildProxyContainer();
+    }
+    dispose() {
+        this.importedIntoModule.moduleContainer.container.unloadSync(this.proxyContainer), 
+        this.importedIntoModule = null, this.providerModule = null, this.proxyContainer = null, 
+        this.proxyContainerOptions = null;
+    }
+    buildProxyContainer() {
+        const e = new R.ContainerModule((e => {
+            this.proxyContainerOptions = e, this.traverseExportGraph(((e, t) => {
+                this.proxyProviderIdentifier(e, t);
+            }), this.moduleDef.exports), this.providerModule.dynamicModuleDef.event$.subscribe((({type: e, change: t}) => {
+                if (e !== p.Export && e !== p.ExportRemoved) return;
+                if (!g.isModule(t)) return void (e === p.Export ? this.proxyProviderIdentifier(t, this.providerModule) : e === p.ExportRemoved && this.unproxyProviderIdentifier(t));
+                const i = t;
+                e === p.Export ? this.traverseExportGraph(((e, t) => {
+                    this.proxyProviderIdentifier(e, t);
+                }), i.dynamicModuleDef.moduleDef.exports) : this.traverseExportGraph((e => {
+                    this.unproxyProviderIdentifier(e);
+                }), i.dynamicModuleDef.moduleDef.exports);
+            }));
+        }));
+        return this.importedIntoModule.moduleContainer.container.loadSync(e), e;
+    }
+    proxyProviderIdentifier(e, t) {
+        const i = h.toProviderIdentifier(e);
+        if (this.proxyContainerOptions.isBound(i)) return;
+        const o = this.proxyContainerOptions.bind(i).toDynamicValue((() => {
+            if (!1 !== this.providerModule.middlewaresManager.applyMiddlewares(a.OnExportAccess, this.importedIntoModule, i)) return t.moduleContainer.container.get(i);
+            this.proxyContainerOptions.unbind(i);
+        }));
+        this.providerModule.moduleContainer.setBindingScope(e, o);
+    }
+    unproxyProviderIdentifier(e) {
+        const t = h.toProviderIdentifier(e);
+        this.proxyContainerOptions.isBound(t) && this.proxyContainerOptions.unbind(t);
+    }
+    traverseExportGraph(e, t) {
+        const i = [];
+        for (const o of t) {
+            if (o instanceof G) i.push(o); else {
+                if (!1 === this.providerModule.middlewaresManager.applyMiddlewares(a.OnExportAccess, this.importedIntoModule, o)) continue;
+                e(o, this.providerModule);
+            }
         }
+        for (const t of i) this.traverseExportGraph(e, t.dynamicModuleDef.moduleDef.exports);
     }
-    setWhenBinding(e, i) {
-        if (f.isProviderIdentifier(e)) return i;
-        const t = e.when;
-        return t ? i.when(t) : i;
-    }
-    setBindingOnEvent(e, i) {
-        if (f.isProviderIdentifier(e)) return;
-        const t = e;
-        t.onEvent?.activation && i.onActivation(t.onEvent.activation), t.onEvent?.deactivation && i.onDeactivation(t.onEvent.deactivation);
-    }
-}, W = class e {
+}, B = class {
     static {
-        r(this, "ProviderModule");
+        n(this, "Signal");
     }
-    isDisposed=!1;
-    identifier;
-    isGlobal=!1;
-    isAppModule;
-    instantiatedFromDefinition;
-    container;
-    defaultScope;
-    onReady;
-    onDispose;
-    moduleUtils;
-    imports;
-    providers;
-    exports;
-    registeredSideEffects;
+    value;
+    subscribers=new Set;
     constructor(e) {
-        const {options: i, internalOptions: t} = I.getOptionsOrModuleDefinitionOptions(e);
-        this.identifier = this.setIdentifier(i.identifier), this.isDisposed = t.isDisposed ?? !1, 
-        this.isAppModule = t.isAppModule ?? !1, this.instantiatedFromDefinition = t.instantiatedFromDefinition ?? !1, 
-        this.isAppModule || this._internalInit({
-            ...i,
-            ...t
-        });
+        this.value = e;
     }
-    get(e, i) {
-        return this.__get(e, {
-            optional: i ?? !1
-        });
+    emit(e) {
+        this.value = e, this.subscribers.forEach((e => e(this.value)));
     }
-    getMany(...e) {
-        return e.map((e => {
-            const i = b(e) && "provider" in e;
-            return this.get(i ? e.provider : e, !!i && e.isOptional);
-        }));
+    get() {
+        return this.value;
     }
-    lazyImport(...e) {
-        this.injectImportedModules(e);
+    subscribe(e, t) {
+        return this.subscribers.add(e), t && e(this.value), () => this.subscribers.delete(e);
     }
-    toNaked() {
-        return this;
+    dispose() {
+        this.subscribers = null, this.value = null;
     }
-    async dispose() {
-        const {before: e, after: i} = this.onDispose?.() ?? {};
-        await (e?.(this)), await this.__unbindAll(), this.container = null, this.imports = null, 
-        this.providers = null, this.exports = null, this.registeredSideEffects = null, this.isDisposed = !0, 
-        await (i?.(this));
+}, j = class {
+    static {
+        n(this, "DynamicModuleDefinition");
     }
-    toString() {
-        return ("symbol" == typeof this.identifier ? this.identifier.description : this.identifier) ?? "Unknown";
+    get moduleContainer() {
+        return this.providerModule.moduleContainer;
     }
-    setIdentifier(e) {
-        if (!e) throw new U(this);
-        return e;
+    get subscribe() {
+        if (null === this.event$) throw new P(this.providerModule);
+        return this.event$.subscribe.bind(this.event$);
     }
-    prepareContainer(e) {
-        return this.isAppModule ? e.container?.() ?? L : e.container ? (console.warn(`[xInjection]: The '${this.toString()}' module is overwriting its container!`), 
-        e.container()) : new z.Container({
-            parent: L,
-            defaultScope: this.defaultScope.inversify
-        });
+    moduleDef;
+    event$=new B({
+        type: p.Noop,
+        change: null
+    });
+    providerModule;
+    emittingModules=new Set;
+    importedModuleSubscriptions=new Map;
+    constructor(e) {
+        this.providerModule = e, this.moduleDef = {
+            imports: new Set,
+            providers: new Set,
+            exports: new Set
+        }, this.buildInitialDefinition(e.options);
+    }
+    addImport(e, t = !1) {
+        let i = g.tryBlueprintToModule(e);
+        const o = this.providerModule.middlewaresManager.applyMiddlewares(a.BeforeAddImport, i);
+        !1 !== o && (i = o, this.moduleDef.imports.add(i), this.createImportedModuleContainer(i), 
+        this.subscribeToImportedModuleEvents(i), this.emitEventSafely({
+            type: p.Export,
+            change: i
+        }), this.emitEventSafely({
+            type: p.Import,
+            change: i
+        }), t && (this.moduleDef.exports.add(i), this.emitEventSafely({
+            type: p.ExportModule,
+            change: i
+        })));
     }
-    injectImportedModules(i) {
-        i && 0 !== i.length && i.forEach((i => {
-            if ("GlobalAppModule" === i.toString()) throw new F(this, "The 'GlobalAppModule' can't be imported!");
-            if (!this.isAppModule && i.isGlobal) return void this.moduleUtils.appModule._importWithoutSecondaryImportCheck(i);
-            const t = I.isModuleDefinition(i) ? new e(I.buildInternalConstructorParams({
-                ...i.getDefinition(),
-                instantiatedFromDefinition: !0
-            })) : i;
-            t.exports.forEach((i => {
-                const n = I.tryStaticOrLazyExportToStaticExport(this, i);
-                if (!n) return;
-                if (n instanceof e) return void this.injectImportedModules([ n ]);
-                const o = n, s = f.toServiceIdentifier(o), d = {
-                    scope: f.getInjectionScopeByPriority(o, t.defaultScope.native),
-                    provide: s,
-                    useFactory: r((() => t.get(o)), "useFactory")
-                };
-                this.moduleUtils.bindToContainer(d, t.defaultScope.native), t.registerSideEffect(o, "unbind", (() => this.__unbind(d)), {
-                    registerModuleId: this.identifier
-                }), this._onUnbind(s, (() => {
-                    const e = t.registeredSideEffects.get(s);
-                    e && (e.onUnbindEffects = e.onUnbindEffects.filter((e => e.registerModuleId !== this.identifier)));
-                }));
-            }));
-        }));
+    async addImportLazy(e, t) {
+        const i = await e();
+        this.addImport(i, t);
+    }
+    addProvider(e, t = !1) {
+        const i = this.providerModule.middlewaresManager.applyMiddlewares(a.BeforeAddProvider, e);
+        !1 !== i && (e = i, this.moduleDef.providers.add(e), this.moduleContainer.bindToContainer(e), 
+        this.emitEventSafely({
+            type: p.Provider,
+            change: e
+        }), t && (this.moduleDef.exports.add(e), this.emitEventSafely({
+            type: p.Export,
+            change: e
+        }), this.emitEventSafely({
+            type: p.ExportProvider,
+            change: e
+        })));
     }
-    injectProviders() {
-        this.providers.forEach((e => this.moduleUtils.bindToContainer(e, this.defaultScope.native)));
+    async addProviderLazy(e, t) {
+        const i = await e();
+        this.addProvider(i, t);
+    }
+    removeImport(e) {
+        if (!this.moduleDef.imports.has(e)) return !1;
+        if (!1 === this.providerModule.middlewaresManager.applyMiddlewares(a.BeforeRemoveImport, e)) return !1;
+        this.unsubscribeFromImportedModuleEvents(e);
+        return this.providerModule.importedModuleContainers.get(e).dispose(), this.providerModule.importedModuleContainers.delete(e), 
+        this.moduleDef.imports.delete(e), this.emitEventSafely({
+            type: p.ImportRemoved,
+            change: e
+        }), this.removeFromExports(e), !0;
+    }
+    removeProvider(e) {
+        if (!this.moduleDef.providers.has(e)) return !1;
+        return !1 !== this.providerModule.middlewaresManager.applyMiddlewares(a.BeforeRemoveProvider, e) && (this.moduleDef.providers.delete(e), 
+        this.moduleContainer.container.unbindSync(h.toProviderIdentifier(e)), this.emitEventSafely({
+            type: p.ProviderRemoved,
+            change: e
+        }), this.removeFromExports(e), !0);
+    }
+    removeFromExports(e) {
+        if (!this.moduleDef.exports.has(e)) return !1;
+        return !1 !== this.providerModule.middlewaresManager.applyMiddlewares(a.BeforeRemoveExport, e) && (this.moduleDef.exports.delete(e), 
+        this.emitEventSafely({
+            type: p.ExportRemoved,
+            change: e
+        }), g.isModule(e) ? this.emitEventSafely({
+            type: p.ExportModuleRemoved,
+            change: e
+        }) : this.emitEventSafely({
+            type: p.ExportProviderRemoved,
+            change: e
+        }), !0);
+    }
+    emitEventSafely(e) {
+        if (!this.emittingModules.has(this.providerModule)) try {
+            this.emittingModules.add(this.providerModule), this.event$.emit(e);
+        } finally {
+            this.emittingModules.delete(this.providerModule);
+        }
     }
-    registerSideEffect(e, i, t, n) {
-        const o = f.toServiceIdentifier(e);
-        this.registeredSideEffects.has(o) || this.registeredSideEffects.set(o, {
-            onBindEffects: [],
-            onGetEffects: [],
-            onRebindEffects: [],
-            onUnbindEffects: []
-        });
-        const r = this.registeredSideEffects.get(o);
-        "bind" === i ? r.onBindEffects.push(t) : "get" === i ? r.onGetEffects.push({
-            once: n.once,
-            invoked: !1,
-            cb: t
-        }) : "rebind" === i ? r.onRebindEffects.push(t) : "unbind" === i && r.onUnbindEffects.push({
-            registerModuleId: n?.registerModuleId,
-            cb: t
-        });
+    dispose() {
+        this.importedModuleSubscriptions = null, this.emittingModules = null, this.event$.dispose(), 
+        this.event$ = null, this.moduleDef = null;
+    }
+    buildInitialDefinition({imports: e = [], providers: t = [], exports: i = []}) {
+        this.moduleDef.providers = new Set(t), i.forEach((e => {
+            g.isModuleOrBlueprint(e) || this.moduleDef.exports.add(e);
+        })), e.forEach((e => {
+            if (g.isModule(e) ? e.options.isGlobal : e.isGlobal) return;
+            const t = g.tryBlueprintToModule(e), o = i.some((e => g.isModuleOrBlueprint(e) && e.id === t.id));
+            this.addImport(t, o);
+        }));
     }
-    invokeRegisteredSideEffects(e, i) {
-        const t = f.toServiceIdentifier(e), n = this.registeredSideEffects.get(t);
-        n && n[`${i}Effects`].forEach((e => {
-            if ("function" == typeof e) return e();
-            if ("onGet" === i) {
-                const i = e;
-                if (i.invoked && i.once) return;
-                i.invoked = !0;
+    createImportedModuleContainer(e) {
+        if (e.isAppModule) throw new b(this.providerModule, "The 'AppModule' can't be imported!");
+        this.providerModule.importedModuleContainers.set(e, new T(this.providerModule, e));
+    }
+    subscribeToImportedModuleEvents(e) {
+        if (this.importedModuleSubscriptions.has(e)) return;
+        const t = e.dynamicModuleDef.event$.subscribe((({type: e, change: t}) => {
+            switch (e) {
+              case p.Export:
+              case p.ExportRemoved:
+              case p.ExportModule:
+              case p.ExportModuleRemoved:
+              case p.ExportProvider:
+              case p.ExportProviderRemoved:
+                this.emitEventSafely({
+                    type: e,
+                    change: t
+                });
             }
-            e.cb();
         }));
+        this.importedModuleSubscriptions.set(e, t);
     }
-    async removeRegisteredSideEffects(e) {
-        if (!this.registeredSideEffects) return;
-        if ("all" === e) return this.registeredSideEffects.forEach((({onUnbindEffects: e}) => e.forEach((e => e.cb())))), 
-        void this.registeredSideEffects.clear();
-        const i = f.toServiceIdentifier(e);
-        if (!this.registeredSideEffects.has(i)) return;
-        const t = this.registeredSideEffects.get(i)?.onUnbindEffects ?? [];
-        for (const e of t) await e.cb();
-        this.registeredSideEffects.delete(i);
-    }
-    shouldThrowIfDisposed() {
-        if (null === this.container) throw new q(this);
-    }
-    _internalInit(e) {
-        const {options: {isGlobal: i, imports: t = [], providers: n = [], exports: o = [], defaultScope: r = c.Singleton, onReady: s, onDispose: d}, internalOptions: a} = I.getOptionsOrModuleDefinitionOptions(e);
-        return this.isGlobal = i ?? !1, this.isDisposed = !1, this.imports = t, this.providers = n, 
-        this.exports = o, this.defaultScope = {
-            native: r,
-            inversify: u(r)
-        }, this.onReady = s, this.onDispose = d, this.container = this.prepareContainer({
-            ...a
-        }), this.moduleUtils = new V(this, a), this.registeredSideEffects = new Map, this.injectImportedModules(this.imports), 
-        this.injectProviders(), this.onReady?.(this), this;
-    }
-    _onBind(e, i) {
-        this.shouldThrowIfDisposed(), this.registerSideEffect(e, "bind", i);
-    }
-    _onGet(e, i, t) {
-        if (this.shouldThrowIfDisposed(), "boolean" != typeof i) throw new F(this, `The 'once' parameter is required when using the '${this._onGet.name}' method!`);
-        this.registerSideEffect(e, "get", t, {
-            once: i
-        });
-    }
-    _onRebind(e, i) {
-        this.shouldThrowIfDisposed(), this.registerSideEffect(e, "rebind", i);
+    unsubscribeFromImportedModuleEvents(e) {
+        const t = this.importedModuleSubscriptions.get(e);
+        t && (t(), this.importedModuleSubscriptions.delete(e));
     }
-    _onUnbind(e, i) {
-        this.shouldThrowIfDisposed(), this.registerSideEffect(e, "unbind", i);
-    }
-    _overwriteContainer(e) {
-        this.container = e();
-    }
-    __bind(e) {
-        this.shouldThrowIfDisposed();
-        const i = this.container.bind(f.toServiceIdentifier(e));
-        return this.invokeRegisteredSideEffects(e, "onBind"), i;
+}, O = class {
+    static {
+        n(this, "MiddlewaresManager");
     }
-    __get(e, i) {
-        return this.shouldThrowIfDisposed(), this.invokeRegisteredSideEffects(e, "onGet"), 
-        this.container.get(f.toServiceIdentifier(e), i);
+    middlewaresMap=new Map;
+    providerModule;
+    constructor(e) {
+        this.providerModule = e;
+    }
+    add(e, t) {
+        const i = this.middlewaresMap.get(e);
+        i ? i.push(t) : this.middlewaresMap.set(e, [ t ]);
+    }
+    applyMiddlewares(e, ...t) {
+        if (null === this.middlewaresMap) throw new P(this.providerModule);
+        const i = this.middlewaresMap.get(e);
+        switch (e) {
+          case a.BeforeAddImport:
+          case a.BeforeAddProvider:
+            if (!i) return t[0];
+            let e = t[0];
+            for (const t of i) {
+                const i = t(e);
+                if (!1 === i) return !1;
+                !0 !== i && (e = i);
+            }
+            return e;
+
+          case a.BeforeGet:
+            return i ? i.reduce(((e, i) => i(e, t[1], t[2])), t[0]) : t[0];
+
+          case a.BeforeRemoveImport:
+          case a.BeforeRemoveProvider:
+          case a.BeforeRemoveExport:
+          case a.OnExportAccess:
+            return !i || !i.some((e => !e(t[0], t[1])));
+        }
     }
-    async __getAsync(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAsync(f.toServiceIdentifier(e), i);
+    clear() {
+        this.middlewaresMap.clear();
     }
-    __getAll(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAll(f.toServiceIdentifier(e), i);
+    dispose() {
+        this.middlewaresMap = null;
     }
-    async __getAllAsync(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAllAsync(f.toServiceIdentifier(e), i);
+}, A = class e {
+    static {
+        n(this, "ProviderModuleBlueprint");
     }
-    __isBound(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.isBound(f.toServiceIdentifier(e), i);
+    id;
+    imports;
+    providers;
+    exports;
+    defaultScope;
+    isGlobal;
+    onReady;
+    onReset;
+    onDispose;
+    blueprintOptions;
+    constructor(e, t) {
+        this.updateDefinition(e), this.blueprintOptions = {
+            autoImportIntoAppModuleWhenGlobal: t?.autoImportIntoAppModuleWhenGlobal ?? !0
+        }, this.convertToModuleAndInjectIntoAppModuleIfGlobal();
     }
-    __isCurrentBound(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.isCurrentBound(f.toServiceIdentifier(e), i);
+    updateDefinition(e) {
+        return this.id = e.id, this.imports = e.imports, this.providers = e.providers, this.exports = e.exports, 
+        this.defaultScope = e.defaultScope, this.isGlobal = e.isGlobal, this.onReady = e.onReady, 
+        this.onReset = e.onReset, this.onDispose = e.onDispose, this;
     }
-    __takeSnapshot() {
-        this.shouldThrowIfDisposed(), this.container.snapshot();
+    getDefinition() {
+        return {
+            id: this.id,
+            imports: this.imports,
+            providers: this.providers,
+            exports: this.exports,
+            defaultScope: this.defaultScope,
+            isGlobal: this.isGlobal,
+            onReady: this.onReady,
+            onReset: this.onReset,
+            onDispose: this.onDispose
+        };
     }
-    __restoreSnapshot() {
-        this.shouldThrowIfDisposed(), this.container.restore();
+    clone() {
+        return new e(k(this.getDefinition()), {
+            ...this.blueprintOptions
+        });
     }
-    async __rebind(e) {
-        this.shouldThrowIfDisposed();
-        const i = await this.container.rebind(f.toServiceIdentifier(e));
-        return this.invokeRegisteredSideEffects(e, "onRebind"), i;
+    convertToModuleAndInjectIntoAppModuleIfGlobal() {
+        this.isGlobal && this.blueprintOptions?.autoImportIntoAppModuleWhenGlobal && G.APP_MODULE_REF.update.addImport(this);
     }
-    __rebindSync(e) {
-        this.shouldThrowIfDisposed();
-        const i = this.container.rebindSync(f.toServiceIdentifier(e));
-        return this.invokeRegisteredSideEffects(e, "onRebind"), i;
+}, G = class e {
+    static {
+        n(this, "ProviderModule");
+    }
+    get id() {
+        return this.options.id;
+    }
+    get definition() {
+        return this.throwIfDisposed(), this.dynamicModuleDef.moduleDef;
+    }
+    get update() {
+        return this.throwIfDisposed(), this.dynamicModuleDef;
+    }
+    get middlewares() {
+        return this.throwIfDisposed(), this.middlewaresManager;
+    }
+    get isDisposed() {
+        return this.disposed;
+    }
+    get isAppModule() {
+        return "AppModule" === this.id;
+    }
+    static APP_MODULE_REF;
+    appModuleRef;
+    options;
+    middlewaresManager;
+    dynamicModuleDef;
+    moduleContainer;
+    importedModuleContainers=new Map;
+    disposed=!1;
+    constructor({appModuleRef: t = e.APP_MODULE_REF, inversify: i, ...o}) {
+        this.appModuleRef = t, this.options = o, this.throwIfIdIsMissing(), this.middlewaresManager = new O(this), 
+        this.moduleContainer = new C(this, i?.parentContainer), this.dynamicModuleDef = new j(this), 
+        !this.isAppModule && this.options.isGlobal && this.appModuleRef.update.addImport(this, !0), 
+        this.options.onReady?.(this);
+    }
+    static create(t) {
+        const i = g.isBlueprint(t) ? t.getDefinition() : t;
+        if ("AppModule" === i.id) throw new I("The 'AppModule' id can't be used as it is already being used by the built-in 'AppModule'");
+        return new e(i);
+    }
+    static blueprint(e, t) {
+        return new A(e, t);
+    }
+    isImportingModule(e) {
+        return this.throwIfDisposed(), g.isModule(e) ? this.importedModuleContainers.has(e) : this.importedModuleContainers.keys().some((t => t.id === e));
+    }
+    hasProvider(e) {
+        this.throwIfDisposed();
+        const t = h.toProviderIdentifier(e);
+        return this.moduleContainer.container.isBound(t);
+    }
+    get(e, t, i) {
+        this.throwIfDisposed();
+        const o = this.moduleContainer.get(e, t, i);
+        return this.dynamicModuleDef.emitEventSafely({
+            type: p.GetProvider,
+            change: o
+        }), o;
     }
-    async __unbind(e) {
-        this.shouldThrowIfDisposed(), await this.container.unbind(f.toServiceIdentifier(e)), 
-        await this.removeRegisteredSideEffects(e);
+    getMany(...e) {
+        return this.throwIfDisposed(), this.moduleContainer.getMany(...e);
+    }
+    isExportingModule(e) {
+        return this.throwIfDisposed(), !!this.isImportingModule(e) && (g.isModule(e) ? this.definition.exports.has(e) : this.definition.exports.keys().some((t => g.isModule(t) && t.id === e)));
+    }
+    isExportingProvider(e) {
+        this.throwIfDisposed();
+        let t = this.definition.exports.has(e);
+        return !t && h.isProviderIdentifier(e) && (t = this.definition.exports.keys().some((t => !g.isModuleOrBlueprint(t) && h.toProviderIdentifier(t) === e))), 
+        t;
+    }
+    async reset(e = !0) {
+        let t, i;
+        if (this.throwIfDisposed(), e) {
+            const e = this.options.onReset?.() ?? {};
+            t = e.before, i = e.after, await (t?.(this));
+        }
+        this.middlewaresManager.clear(), this.moduleContainer.container.unbindAll(), this.definition.imports.clear(), 
+        this.definition.providers.clear(), this.definition.exports.clear(), this.importedModuleContainers.clear(), 
+        e && await (i?.());
     }
-    __unbindSync(e) {
-        this.shouldThrowIfDisposed(), this.container.unbindSync(f.toServiceIdentifier(e)), 
-        this.removeRegisteredSideEffects(e);
+    async dispose() {
+        this.throwIfDisposed();
+        const {before: e, after: t} = this.options.onDispose?.() ?? {};
+        await (e?.(this)), await this.reset(!1), this.middlewaresManager.dispose(), this.dynamicModuleDef.dispose(), 
+        this.importedModuleContainers.forEach((e => e.dispose())), this.moduleContainer.dispose(), 
+        this.options = {
+            id: this.options.id
+        }, this.dynamicModuleDef = null, this.importedModuleContainers = null, this.moduleContainer = null, 
+        this.disposed = !0, await (t?.());
     }
-    async __unbindAll() {
-        this.shouldThrowIfDisposed(), await this.container.unbindAll(), await this.removeRegisteredSideEffects("all");
+    toString() {
+        return this.id.toString();
     }
-}, H = class extends W {
-    static {
-        r(this, "GlobalAppModule");
-    }
-    _strict;
-    nakedModule=this;
-    isLoaded=!1;
-    constructor() {
-        super(I.buildInternalConstructorParams({
-            identifier: d,
-            isAppModule: !0
-        }));
+    throwIfIdIsMissing() {
+        if (!this.options.id || 0 === this.options.id.toString().trim().length) throw new x(this);
     }
-    register(e) {
-        if (this.isLoaded) throw new x(`The '${this.toString()}' has already been registered!`);
-        return this._strict = e._strict ?? !0, this.nakedModule._internalInit(e), this.checkIfRegisteredModulesHaveGlobalMark(this.nakedModule, this.imports), 
-        this.isLoaded = !0, this;
+    throwIfDisposed() {
+        if (this.isDisposed) throw new P(this);
     }
-    lazyImport(...e) {
-        this.checkIfRegisteredModulesHaveGlobalMark(this.nakedModule, e), super.lazyImport(...e);
+};
+
+function F(e) {
+    return "function" == typeof e && !Function.prototype.toString.call(e).startsWith("class ");
+}
+
+function k(e) {
+    if (null === e || "object" != typeof e) return e;
+    if ("function" == typeof e) return (...t) => e(...t);
+    if (Array.isArray(e)) return e.map((e => k(e)));
+    const t = {};
+    for (const i in e) Object.prototype.hasOwnProperty.call(e, i) && (t[i] = k(e[i]));
+    return t;
+}
+
+function q(e) {
+    return void 0 === e ? (0, d.injectable)() : (0, d.injectable)(l(e));
+}
+
+!function(e) {
+    function t(e) {
+        return e instanceof G;
     }
-    toNaked() {
-        return super.toNaked();
+    function i(e) {
+        return e instanceof A;
     }
-    async dispose() {
-        this.isLoaded = !1, await super.dispose();
+    function o(e) {
+        return t(e) || i(e);
     }
-    _importWithoutSecondaryImportCheck(...e) {
-        this.checkIfRegisteredModulesHaveGlobalMark(this.nakedModule, e, !0), super.lazyImport(...e);
+    function r(e) {
+        return e instanceof A ? s(e) : e;
     }
-    checkIfRegisteredModulesHaveGlobalMark(e, i, t = !1) {
-        this._strict && (i.forEach((i => {
-            const n = I.tryStaticOrLazyExportToStaticExport(this, i), o = I.isModuleDefinition(n);
-            if (n instanceof W || o) {
-                if (n.isGlobal) return y.delete(n), void (n.exports && this.checkIfRegisteredModulesHaveGlobalMark(n, n.exports, !0));
-                throw new N(n, t ? `Is not marked as \`global\` but has been imported into the \`AppModule\` via the \`${e.toString()}\` module!` : "Is not marked as `global` but has been imported into the `AppModule`!");
-            }
-        })), t || y.forEach((e => {
-            throw new N(e, "Is marked as 'global' and has not been imported into the 'AppModule'!");
-        })));
+    function s(e) {
+        return G.create(e.getDefinition());
     }
-}, $ = new H;//# sourceMappingURL=index.cjs.map
+    n(t, "isModule"), e.isModule = t, n(i, "isBlueprint"), e.isBlueprint = i, n(o, "isModuleOrBlueprint"), 
+    e.isModuleOrBlueprint = o, n(r, "tryBlueprintToModule"), e.tryBlueprintToModule = r, 
+    n(s, "blueprintToModule"), e.blueprintToModule = s;
+}(g || (g = {})), n(F, "isFunction"), n(k, "deepClone"), n(q, "Injectable");
+
+var $ = require("inversify");
+
+function V(e) {
+    return (0, $.inject)(h.toProviderIdentifier(e));
+}
+
+n(V, "Inject");
+
+var _ = require("inversify");
+
+function U(e) {
+    return (0, _.multiInject)(h.toProviderIdentifier(e));
+}
+
+n(U, "MultiInject");
+
+var L = require("inversify");
+
+function N(e) {
+    return (0, L.injectFromBase)(e);
+}
+
+n(N, "InjectFromBase");
+
+var W = require("inversify");
+
+function H(e) {
+    return (0, W.named)(e);
+}
+
+n(H, "Named");
+
+var z = require("inversify");
+
+function J() {
+    return (0, z.optional)();
+}
+
+n(J, "Optional");
+
+var K = require("inversify");
+
+function Q(e, t) {
+    return (0, K.tagged)(e, t);
+}
+
+n(Q, "Tagged");
+
+var X = require("inversify");
+
+function Y() {
+    return (0, X.unmanaged)();
+}
+
+n(Y, "Unmanaged");
+
+var Z = new G({
+    id: "AppModule"
+});
+
+G.APP_MODULE_REF = Z;//# sourceMappingURL=index.cjs.map