@adimm/x-injection 0.8.0 → 1.1.6

package/dist/index.cjs

@@ -1,50 +1,51 @@
 "use strict";
 
-var e, i = Object.defineProperty, t = Object.getOwnPropertyDescriptor, n = Object.getOwnPropertyNames, r = Object.prototype.hasOwnProperty, o = (e, t) => i(e, "name", {
-    value: t,
+var e, t = Object.defineProperty, i = Object.getOwnPropertyDescriptor, n = Object.getOwnPropertyNames, o = Object.prototype.hasOwnProperty, r = (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 n in i) t(e, n, {
+        get: i[n],
         enumerable: !0
     });
 })(s, {
     AppModule: () => H,
     GLOBAL_APP_MODULE_ID: () => d,
     GlobalAppModule: () => $,
-    GlobalContainer: () => q,
-    Inject: () => E,
-    InjectFromBase: () => w,
-    Injectable: () => I,
-    InjectionError: () => G,
-    InjectionProviderModuleDisposedError: () => O,
+    GlobalContainer: () => N,
+    Inject: () => T,
+    InjectFromBase: () => _,
+    Injectable: () => m,
+    InjectionError: () => B,
+    InjectionProviderModuleDisposedError: () => F,
     InjectionProviderModuleError: () => x,
     InjectionProviderModuleGlobalMarkError: () => U,
-    InjectionProviderModuleMissingIdentifierError: () => F,
+    InjectionProviderModuleMissingIdentifierError: () => q,
     InjectionScope: () => c,
-    MultiInject: () => T,
-    Named: () => P,
-    Optional: () => B,
-    ProviderModule: () => W,
-    ProviderModuleHelpers: () => f,
-    ProviderTokenHelpers: () => h,
-    Tagged: () => D,
-    Unmanaged: () => R,
+    MultiInject: () => k,
+    Named: () => j,
+    Optional: () => P,
+    ProviderModule: () => z,
+    ProviderModuleDefinition: () => I,
+    ProviderModuleHelpers: () => y,
+    ProviderTokenHelpers: () => f,
+    Tagged: () => C,
+    Unmanaged: () => G,
     bindingScopeToInjectionScope: () => l,
     injectionScopeToBindingScope: () => u,
-    isClass: () => v,
-    isClassOrFunction: () => g,
+    isClass: () => p,
+    isClassOrFunction: () => v,
     isFunction: () => S,
-    isPlainObject: () => m
-}), module.exports = (e = s, ((e, o, s, d) => {
-    if (o && "object" == typeof o || "function" == typeof o) for (let a of n(o)) r.call(e, a) || a === s || i(e, a, {
-        get: () => o[a],
-        enumerable: !(d = t(o, a)) || d.enumerable
+    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 || t(e, a, {
+        get: () => r[a],
+        enumerable: !(d = i(r, a)) || d.enumerable
     });
     return e;
-})(i({}, "__esModule", {
+})(t({}, "__esModule", {
     value: !0
 }), e));
 
@@ -79,15 +80,15 @@ function l(e) {
     }
 }
 
-o(u, "injectionScopeToBindingScope"), o(l, "bindingScopeToInjectionScope");
+r(u, "injectionScopeToBindingScope"), r(l, "bindingScopeToInjectionScope");
 
-var h, f, p = require("@inversifyjs/core");
+var f, h = require("@inversifyjs/core");
 
-function v(e) {
+function p(e) {
     return "function" == typeof e && Function.prototype.toString.call(e).startsWith("class ");
 }
 
-function g(e) {
+function v(e) {
     return "function" == typeof e;
 }
 
@@ -95,173 +96,237 @@ function S(e) {
     return "function" == typeof e && !Function.prototype.toString.call(e).startsWith("class ");
 }
 
-function b(e) {
+function g(e) {
     return "[object Object]" === Object.prototype.toString.call(e);
 }
 
-function m(e) {
-    if (!1 === b(e)) return !1;
-    const i = e.constructor;
-    if (void 0 === i) return !0;
-    const t = i.prototype;
-    return !1 !== b(t) && !1 !== t.hasOwnProperty("isPrototypeOf");
-}
-
-function I(e) {
-    return void 0 === e ? (0, a.injectable)() : (0, a.injectable)(u(e));
+function b(e) {
+    if (!1 === g(e)) return !1;
+    const t = e.constructor;
+    if (void 0 === t) return !0;
+    const i = t.prototype;
+    return !1 !== g(i) && !1 !== i.hasOwnProperty("isPrototypeOf");
 }
 
-o(v, "isClass"), o(g, "isClassOrFunction"), o(S, "isFunction"), o(b, "isObject"), 
-o(m, "isPlainObject"), function(e) {
-    function i(e) {
-        return b(e) && "useClass" in e;
-    }
+r(p, "isClass"), r(v, "isClassOrFunction"), r(S, "isFunction"), r(g, "isObject"), 
+r(b, "isPlainObject"), function(e) {
     function t(e) {
-        return b(e) && "useValue" in e;
+        return y(e) && "useClass" in e;
+    }
+    function i(e) {
+        return y(e) && "useValue" in e;
     }
     function n(e) {
-        return b(e) && "useFactory" in e;
+        return y(e) && "useFactory" in e;
     }
-    function r(e) {
-        return "string" == typeof e || "symbol" == typeof e || g(e);
+    function o(e) {
+        return "string" == typeof e || "symbol" == typeof e || v(e);
     }
     function s(e) {
-        return r(e) ? e : e.provide;
+        return o(e) ? e : e.provide;
     }
     function d(e) {
         return e.map((e => s(e)));
     }
-    function a(e, i) {
-        return v(e) ? {
-            ...i,
-            provide: i?.provide ?? e,
-            useClass: i?.useClass ?? e
+    function a(e, t) {
+        return p(e) ? {
+            ...t,
+            provide: t?.provide ?? e,
+            useClass: t?.useClass ?? e
         } : S(e) ? {
-            ...i,
-            provide: i?.provide ?? e,
-            useFactory: i?.useFactory ?? e
+            ...t,
+            provide: t?.provide ?? e,
+            useFactory: t?.useFactory ?? e
         } : {
             ...e,
-            ...i
+            ...t
         };
     }
-    function c(e, i) {
-        return h(e) ?? f(e) ?? i;
+    function c(e, t) {
+        return f(e) ?? g(e) ?? t;
     }
     function u(e) {
-        if (b(e)) return e;
-    }
-    function h(e) {
-        const i = u(e);
-        if (i) return i.scope;
+        if (y(e)) return e;
     }
     function f(e) {
-        const i = s(e);
-        if (!v(i)) return;
-        const t = (0, p.getClassMetadata)(i)?.scope;
-        return t ? l(t) : void 0;
-    }
-    function b(e) {
-        return m(e) && "object" == typeof e && "provide" in e;
-    }
-    o(i, "isClassToken"), e.isClassToken = i, o(t, "isValueToken"), e.isValueToken = t, 
-    o(n, "isFactoryToken"), e.isFactoryToken = n, o(r, "isProviderIdentifier"), e.isProviderIdentifier = r, 
-    o(s, "toServiceIdentifier"), e.toServiceIdentifier = s, o(d, "toServiceIdentifiers"), 
-    e.toServiceIdentifiers = d, o(a, "toDependencyProviderWithOptions"), e.toDependencyProviderWithOptions = a, 
-    o(c, "getInjectionScopeByPriority"), e.getInjectionScopeByPriority = c, o(u, "tryGetProviderOptions"), 
-    e.tryGetProviderOptions = u, o(h, "tryGetScopeFromProvider"), e.tryGetScopeFromProvider = h, 
-    o(f, "tryGetDecoratorScopeFromClass"), e.tryGetDecoratorScopeFromClass = f, o(b, "hasProvideProperty");
-}(h || (h = {})), function(e) {
-    function i(e) {
-        return e;
+        const t = u(e);
+        if (t) return t.scope;
+    }
+    function g(e) {
+        const t = s(e);
+        if (!p(t)) return;
+        const i = (0, h.getClassMetadata)(t)?.scope;
+        return i ? l(i) : void 0;
+    }
+    function y(e) {
+        return b(e) && "object" == typeof e && "provide" in e;
+    }
+    r(t, "isClassToken"), e.isClassToken = t, r(i, "isValueToken"), e.isValueToken = i, 
+    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(y, "hasProvideProperty");
+}(f || (f = {}));
+
+var y, I = class {
+    static {
+        r(this, "ProviderModuleDefinition");
+    }
+    identifier;
+    imports;
+    providers;
+    exports;
+    defaultScope;
+    markAsGlobal;
+    onReady;
+    onDispose;
+    constructor(e) {
+        const {identifier: t, imports: i, providers: n, exports: o, defaultScope: r, markAsGlobal: s, onReady: d, onDispose: a} = e;
+        this.identifier = t, this.imports = i, this.providers = n, this.exports = o, this.defaultScope = r ?? c.Singleton, 
+        this.markAsGlobal = s ?? !1, this.onReady = d, this.onDispose = a;
     }
+    getDefinition() {
+        return {
+            identifier: this.identifier,
+            imports: this.imports,
+            providers: this.providers,
+            exports: this.exports,
+            defaultScope: this.defaultScope,
+            markAsGlobal: this.markAsGlobal,
+            onReady: this.onReady,
+            onDispose: this.onDispose
+        };
+    }
+    toString() {
+        return ("symbol" == typeof this.identifier ? this.identifier.description : this.identifier) ?? "Unknown";
+    }
+};
+
+function m(e) {
+    return void 0 === e ? (0, a.injectable)() : (0, a.injectable)(u(e));
+}
+
+!function(e) {
     function t(e) {
-        return !Array.isArray(e) && "function" == typeof e;
+        return e;
+    }
+    function i(e) {
+        const {identifier: t, imports: i, providers: o, exports: r, defaultScope: s, markAsGlobal: d, onReady: a, onDispose: c, ...u} = e, l = u;
+        if (n(e)) {
+            const e = u;
+            delete e.getDefinition, delete e.toString;
+        }
+        return {
+            options: {
+                identifier: t,
+                imports: i,
+                providers: o,
+                exports: r,
+                defaultScope: s,
+                markAsGlobal: d,
+                onReady: a,
+                onDispose: c
+            },
+            internalOptions: l
+        };
     }
-    o(i, "buildInternalConstructorParams"), e.buildInternalConstructorParams = i, o(t, "isDynamicExport"), 
-    e.isDynamicExport = t;
-}(f || (f = {})), o(I, "Injectable");
+    function n(e) {
+        return e instanceof I;
+    }
+    function o(e) {
+        return S(e);
+    }
+    function s(e, t) {
+        return o(t) ? t(e) : t;
+    }
+    r(t, "buildInternalConstructorParams"), e.buildInternalConstructorParams = t, r(i, "getOptionsOrModuleDefinitionOptions"), 
+    e.getOptionsOrModuleDefinitionOptions = i, r(n, "isModuleDefinition"), e.isModuleDefinition = n, 
+    r(o, "isLazyExport"), e.isLazyExport = o, r(s, "tryStaticOrLazyExportToStaticExport"), 
+    e.tryStaticOrLazyExportToStaticExport = s;
+}(y || (y = {})), r(m, "Injectable");
 
-var y = require("inversify");
+var E = require("inversify");
 
-function E(e) {
-    return (0, y.inject)(h.toServiceIdentifier(e));
+function T(e) {
+    return (0, E.inject)(f.toServiceIdentifier(e));
 }
 
-o(E, "Inject");
+r(T, "Inject");
 
 var M = require("inversify");
 
-function T(e) {
-    return (0, M.multiInject)(h.toServiceIdentifier(e));
+function k(e) {
+    return (0, M.multiInject)(f.toServiceIdentifier(e));
 }
 
-o(T, "MultiInject");
+r(k, "MultiInject");
 
-var k = require("inversify");
+var w = require("inversify");
 
-function w(e) {
-    return (0, k.injectFromBase)(e);
+function _(e) {
+    return (0, w.injectFromBase)(e);
 }
 
-o(w, "InjectFromBase");
+r(_, "InjectFromBase");
 
-var _ = require("inversify");
+var D = require("inversify");
 
-function P(e) {
-    return (0, _.named)(e);
+function j(e) {
+    return (0, D.named)(e);
 }
 
-o(P, "Named");
+r(j, "Named");
 
-var j = require("inversify");
+var O = require("inversify");
 
-function B() {
-    return (0, j.optional)();
+function P() {
+    return (0, O.optional)();
 }
 
-o(B, "Optional");
+r(P, "Optional");
 
 var A = require("inversify");
 
-function D(e, i) {
-    return (0, A.tagged)(e, i);
+function C(e, t) {
+    return (0, A.tagged)(e, t);
 }
 
-o(D, "Tagged");
+r(C, "Tagged");
 
-var C = require("inversify");
+var R = require("inversify");
 
-function R() {
-    return (0, C.unmanaged)();
+function G() {
+    return (0, R.unmanaged)();
 }
 
-o(R, "Unmanaged");
+r(G, "Unmanaged");
 
-var G = class e extends Error {
+var B = class e extends Error {
     static {
-        o(this, "InjectionError");
+        r(this, "InjectionError");
     }
     name=e.name;
 }, x = class e extends Error {
     static {
-        o(this, "InjectionProviderModuleError");
+        r(this, "InjectionProviderModuleError");
     }
     name=e.name;
-    constructor(e, i) {
-        super(`{ProviderModule.${e.toString()}} => ${i}`);
+    constructor(e, t) {
+        super(`{ProviderModule.${e.toString()}} => ${t}`);
     }
-}, O = class e extends x {
+}, F = class e extends x {
     static {
-        o(this, "InjectionProviderModuleDisposedError");
+        r(this, "InjectionProviderModuleDisposedError");
     }
     name=e.name;
     constructor(e) {
-        super(e, "Has been disposed! You can re-initialize it by using the `_lazyInit` method.");
+        super(e, "Has been disposed! You can re-initialize it by using the `_internalInit` method.");
     }
-}, F = class e extends x {
+}, q = class e extends x {
     static {
-        o(this, "InjectionProviderModuleMissingIdentifierError");
+        r(this, "InjectionProviderModuleMissingIdentifierError");
     }
     name=e.name;
     constructor(e) {
@@ -269,17 +334,17 @@ var G = class e extends Error {
     }
 }, U = class e extends x {
     static {
-        o(this, "InjectionProviderModuleGlobalMarkError");
+        r(this, "InjectionProviderModuleGlobalMarkError");
     }
     name=e.name;
-    constructor(e, i) {
-        super(e, i);
+    constructor(e, t) {
+        super(e, t);
     }
-}, q = new (require("inversify").Container)({
+}, N = new (require("inversify").Container)({
     defaultScope: "Singleton"
-}), N = require("inversify"), V = class {
+}), L = require("inversify"), V = class {
     static {
-        o(this, "ProviderModuleUtils");
+        r(this, "ProviderModuleUtils");
     }
     get container() {
         return this.moduleNaked.container;
@@ -287,158 +352,135 @@ var G = class e extends Error {
     module;
     moduleNaked;
     appModule=H;
-    constructor(e, i) {
-        this.module = e, this.moduleNaked = e.toNaked(), this.appModule = i.appModule?.() ?? this.appModule, 
+    constructor(e, t) {
+        this.module = e, this.moduleNaked = e.toNaked(), this.appModule = t.appModule?.() ?? this.appModule, 
         this.checkIfShouldBeAddedToTheGlobalRegister();
     }
-    bindToContainer(e, i) {
-        return h.isProviderIdentifier(e) ? this.bindSelfTokenToContainer(e, i) : h.isClassToken(e) ? this.bindClassTokenToContainer(e, i) : h.isValueToken(e) ? this.bindValueTokenToContainer(e) : !!h.isFactoryToken(e) && this.bindFactoryTokenToContainer(e, i);
+    bindToContainer(e, t) {
+        return f.isProviderIdentifier(e) ? this.bindSelfTokenToContainer(e, t) : f.isClassToken(e) ? this.bindClassTokenToContainer(e, t) : f.isValueToken(e) ? this.bindValueTokenToContainer(e) : !!f.isFactoryToken(e) && this.bindFactoryTokenToContainer(e, t);
     }
     checkIfShouldBeAddedToTheGlobalRegister() {
-        !this.moduleNaked.isAppModule && this.module.isMarkedAsGlobal && L.add(this.module);
+        !this.moduleNaked.isAppModule && this.module.isMarkedAsGlobal && W.add(this.module);
     }
-    bindSelfTokenToContainer(e, i) {
-        return this.setBindingScope(e, this.container.bind(h.toServiceIdentifier(e)).toSelf(), i), 
+    bindSelfTokenToContainer(e, t) {
+        return this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).toSelf(), t), 
         this.moduleNaked.__isCurrentBound(e);
     }
-    bindClassTokenToContainer(e, i) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(h.toServiceIdentifier(e)).to(e.useClass), i))), 
+    bindClassTokenToContainer(e, t) {
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).to(e.useClass), t))), 
         this.moduleNaked.__isCurrentBound(e);
     }
     bindValueTokenToContainer(e) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.container.bind(h.toServiceIdentifier(e)).toConstantValue(e.useValue))), 
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.container.bind(f.toServiceIdentifier(e)).toConstantValue(e.useValue))), 
         this.moduleNaked.__isCurrentBound(e);
     }
-    bindFactoryTokenToContainer(e, i) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(h.toServiceIdentifier(e)).toResolvedValue(e.useFactory, h.toServiceIdentifiers(e.inject ?? [])), i))), 
+    bindFactoryTokenToContainer(e, t) {
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).toResolvedValue(e.useFactory, f.toServiceIdentifiers(e.inject ?? [])), t))), 
         this.moduleNaked.__isCurrentBound(e);
     }
-    setBindingScope(e, i, t) {
-        if (h.isValueToken(e)) return i;
-        switch (h.getInjectionScopeByPriority(e, t)) {
+    setBindingScope(e, t, i) {
+        if (f.isValueToken(e)) return t;
+        switch (f.getInjectionScopeByPriority(e, i)) {
           case c.Singleton:
-            return i.inSingletonScope();
+            return t.inSingletonScope();
 
           case c.Transient:
-            return i.inTransientScope();
+            return t.inTransientScope();
 
           case c.Request:
-            return i.inRequestScope();
+            return t.inRequestScope();
         }
     }
-    setWhenBinding(e, i) {
-        if (h.isProviderIdentifier(e)) return i;
-        const t = e.when;
-        return t ? i.when(t) : i;
+    setWhenBinding(e, t) {
+        if (f.isProviderIdentifier(e)) return t;
+        const i = e.when;
+        return i ? t.when(i) : t;
     }
-    setBindingOnEvent(e, i) {
-        if (h.isProviderIdentifier(e)) return;
-        const t = e;
-        t.onEvent?.activation && i.onActivation(t.onEvent.activation), t.onEvent?.deactivation && i.onDeactivation(t.onEvent.deactivation);
+    setBindingOnEvent(e, t) {
+        if (f.isProviderIdentifier(e)) return;
+        const i = e;
+        i.onEvent?.activation && t.onActivation(i.onEvent.activation), i.onEvent?.deactivation && t.onDeactivation(i.onEvent.deactivation);
     }
-}, W = class e {
+}, z = class e {
     static {
-        o(this, "ProviderModule");
+        r(this, "ProviderModule");
     }
+    isDisposed=!1;
     identifier;
     isMarkedAsGlobal=!1;
-    isDisposed=!1;
     isAppModule;
     container;
     defaultScope;
-    dynamicExports;
     onReady;
     onDispose;
-    importedProvidersMap;
     moduleUtils;
     imports;
     providers;
-    importedProviders;
     exports;
     registeredSideEffects;
-    constructor({identifier: e, imports: i, providers: t, exports: n, defaultScope: r, markAsGlobal: o, dynamicExports: s, onReady: d, onDispose: a, ...c}) {
-        const u = c;
-        this.identifier = this.setIdentifier(e), this.isDisposed = u.isDisposed ?? !1, this.isAppModule = u.isAppModule ?? !1, 
-        this.isAppModule || this._lazyInit({
-            markAsGlobal: o,
-            imports: i,
-            providers: t,
-            exports: n,
-            defaultScope: r,
-            dynamicExports: s,
-            onReady: d,
-            onDispose: a,
-            ...c
+    constructor(e) {
+        const {options: t, internalOptions: i} = y.getOptionsOrModuleDefinitionOptions(e);
+        this.identifier = this.setIdentifier(t.identifier), this.isDisposed = i.isDisposed ?? !1, 
+        this.isAppModule = i.isAppModule ?? !1, this.isAppModule || this._internalInit({
+            ...t,
+            ...i
         });
     }
-    get(e, i) {
+    get(e, t) {
         return this.__get(e, {
-            optional: i ?? !1
+            optional: t ?? !1
         });
     }
     getMany(...e) {
         return e.map((e => {
-            const i = m(e) && "provider" in e;
-            return this.get(i ? e.provider : e, !!i && e.isOptional);
+            const t = b(e) && "provider" in e;
+            return this.get(t ? e.provider : e, !!t && e.isOptional);
         }));
     }
+    lazyImport(...e) {
+        this.injectImportedModules(e);
+    }
     toNaked() {
         return this;
     }
-    clone(i) {
-        const t = i, n = new e(f.buildInternalConstructorParams({
-            isAppModule: this.isAppModule,
-            markAsGlobal: this.isMarkedAsGlobal,
-            identifier: this.identifier,
-            defaultScope: this.defaultScope.native,
-            dynamicExports: this.dynamicExports,
-            onReady: this.onReady,
-            onDispose: this.onDispose,
-            importedProvidersMap: this.importedProvidersMap,
-            imports: [ ...this.imports ],
-            providers: [ ...this.providers ],
-            exports: [ ...this.exports ],
-            ...t
-        }));
-        return n.registeredSideEffects = new Map(this.registeredSideEffects), n;
-    }
     async dispose() {
-        await (this.onDispose?.(this)), await this.__unbindAll(), this.container = null, 
-        this.imports = null, this.providers = null, this.importedProviders = null, this.exports = null, 
-        this.dynamicExports = null, this.registeredSideEffects = null, this.isDisposed = !0;
+        const {before: e, after: t} = 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 (t?.(this));
     }
     toString() {
-        return this.identifier?.description ?? "Unknown";
+        return ("symbol" == typeof this.identifier ? this.identifier.description : this.identifier) ?? "Unknown";
     }
     setIdentifier(e) {
-        if (!e) throw new F(this);
+        if (!e) throw new q(this);
         return e;
     }
     prepareContainer(e) {
-        return this.isAppModule ? e.container?.() ?? q : e.container ? (console.warn(`[xInjection]: The '${this.toString()}' module is using a dynamic container!`), 
-        e.container()) : new N.Container({
-            parent: q,
+        return this.isAppModule ? e.container?.() ?? N : e.container ? (console.warn(`[xInjection]: The '${this.toString()}' module is overwriting its container!`), 
+        e.container()) : new L.Container({
+            parent: N,
             defaultScope: this.defaultScope.inversify
         });
     }
-    injectImportedModules(i) {
-        i && 0 !== i.length && i.forEach((i => {
-            if ("GlobalAppModule" === i.toString()) throw new x(this, "The 'GlobalAppModule' can't be imported!");
-            const t = (i = "function" == typeof i ? i() : i)._getExportableModulesAndProviders(), n = i.dynamicExports?.(this, t);
-            (n ?? t).forEach((t => {
-                if (t instanceof e) {
-                    const e = t.toNaked();
-                    return void this.injectImportedModules([ e ]);
-                }
-                const n = t, r = h.toServiceIdentifier(n), s = this.importedProvidersMap({
-                    scope: h.getInjectionScopeByPriority(n, i.defaultScope.native),
-                    provide: r,
-                    useFactory: o((() => i.get(n)), "useFactory")
-                }, n, i);
-                this.importedProviders.set(i, [ ...this.importedProviders.get(i) ?? [], s ]), this.moduleUtils.bindToContainer(s, i.defaultScope.native);
-                const d = i;
-                d.onUnbindInternal(n, this.identifier, (() => this.__unbind(s))), this._onUnbind(s, (() => {
-                    this.removeOnUnbindEffectsFromImportedModule(r, d);
+    injectImportedModules(t) {
+        t && 0 !== t.length && t.forEach((t => {
+            if ("GlobalAppModule" === t.toString()) throw new x(this, "The 'GlobalAppModule' can't be imported!");
+            const i = y.isModuleDefinition(t) ? new e(t.getDefinition()) : t;
+            i.exports.forEach((t => {
+                const n = y.tryStaticOrLazyExportToStaticExport(this, t);
+                if (!n) return;
+                if (n instanceof e) return void this.injectImportedModules([ n ]);
+                const o = n, s = f.toServiceIdentifier(o), d = {
+                    scope: f.getInjectionScopeByPriority(o, i.defaultScope.native),
+                    provide: s,
+                    useFactory: r((() => i.get(o)), "useFactory")
+                };
+                this.moduleUtils.bindToContainer(d, i.defaultScope.native), i.registerSideEffect(o, "unbind", (() => this.__unbind(d)), {
+                    registerModuleId: this.identifier
+                }), this._onUnbind(s, (() => {
+                    const e = i.registeredSideEffects.get(s);
+                    e && (e.onUnbindEffects = e.onUnbindEffects.filter((e => e.registerModuleId !== this.identifier)));
                 }));
             }));
         }));
@@ -446,118 +488,101 @@ var G = class e extends Error {
     injectProviders() {
         this.providers.forEach((e => this.moduleUtils.bindToContainer(e, this.defaultScope.native)));
     }
-    onUnbindInternal(e, i, t) {
-        this.shouldThrowIfDisposed(), this.registerBindingSideEffect(e, "unbind", t, {
-            registerModule: i
-        });
-    }
-    registerBindingSideEffect(e, i, t, n) {
-        const r = h.toServiceIdentifier(e);
-        this.registeredSideEffects.has(r) || this.registeredSideEffects.set(r, {
+    registerSideEffect(e, t, i, n) {
+        const o = f.toServiceIdentifier(e);
+        this.registeredSideEffects.has(o) || this.registeredSideEffects.set(o, {
             onBindEffects: [],
             onGetEffects: [],
             onRebindEffects: [],
             onUnbindEffects: []
         });
-        const o = this.registeredSideEffects.get(r);
-        "bind" === i ? o.onBindEffects.push(t) : "get" === i ? o.onGetEffects.push({
+        const r = this.registeredSideEffects.get(o);
+        "bind" === t ? r.onBindEffects.push(i) : "get" === t ? r.onGetEffects.push({
             once: n.once,
             invoked: !1,
-            cb: t
-        }) : "rebind" === i ? o.onRebindEffects.push(t) : "unbind" === i && o.onUnbindEffects.push({
-            registerModule: n?.registerModule,
-            cb: t
+            cb: i
+        }) : "rebind" === t ? r.onRebindEffects.push(i) : "unbind" === t && r.onUnbindEffects.push({
+            registerModuleId: n?.registerModuleId,
+            cb: i
         });
     }
-    invokeRegisteredBindingSideEffects(e, i) {
-        const t = h.toServiceIdentifier(e), n = this.registeredSideEffects.get(t);
-        n && n[`${i}Effects`].forEach((e => {
+    invokeRegisteredSideEffects(e, t) {
+        const i = f.toServiceIdentifier(e), n = this.registeredSideEffects.get(i);
+        n && n[`${t}Effects`].forEach((e => {
             if ("function" == typeof e) return e();
-            if ("onGet" === i) {
-                const i = e;
-                if (i.invoked && i.once) return;
-                i.invoked = !0;
+            if ("onGet" === t) {
+                const t = e;
+                if (t.invoked && t.once) return;
+                t.invoked = !0;
             }
             e.cb();
         }));
     }
-    removeRegisteredBindingSideEffects(e) {
+    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 = h.toServiceIdentifier(e);
-        this.registeredSideEffects.has(i) && (this.registeredSideEffects.get(i)?.onUnbindEffects.forEach((e => e.cb())), 
-        this.registeredSideEffects.delete(i));
-    }
-    removeOnUnbindEffectsFromImportedModule(e, i) {
-        const t = i.registeredSideEffects.get(e);
-        t && (t.onUnbindEffects = t.onUnbindEffects.filter((e => e.registerModule !== this.identifier)));
+        const t = f.toServiceIdentifier(e);
+        if (!this.registeredSideEffects.has(t)) return;
+        const i = this.registeredSideEffects.get(t)?.onUnbindEffects ?? [];
+        for (const e of i) await e.cb();
+        this.registeredSideEffects.delete(t);
     }
     shouldThrowIfDisposed() {
-        if (null === this.container) throw new O(this);
+        if (null === this.container) throw new F(this);
     }
-    _lazyInit({markAsGlobal: e, imports: i = [], providers: t = [], exports: n = [], defaultScope: r = c.Singleton, dynamicExports: o, onReady: s, onDispose: d, ...a}) {
-        return this.isMarkedAsGlobal = e ?? !1, this.isDisposed = !1, this.imports = i, 
-        this.providers = t, this.importedProviders = a.importedProviders ?? new Map, this.exports = n, 
-        this.defaultScope = {
+    _internalInit(e) {
+        const {options: {markAsGlobal: t, imports: i = [], providers: n = [], exports: o = [], defaultScope: r = c.Singleton, onReady: s, onDispose: d}, internalOptions: a} = y.getOptionsOrModuleDefinitionOptions(e);
+        return this.isMarkedAsGlobal = t ?? !1, this.isDisposed = !1, this.imports = i, 
+        this.providers = n, this.exports = o, this.defaultScope = {
             native: r,
             inversify: u(r)
-        }, this.dynamicExports = o, this.onReady = s, this.onDispose = d, this.importedProvidersMap = a.importedProvidersMap ?? (e => e), 
-        this.container = this.prepareContainer({
+        }, this.onReady = s, this.onDispose = d, this.container = this.prepareContainer({
             ...a
-        }), this.moduleUtils = new V(this, a), this.registeredSideEffects = new Map, this.injectImportedModules(this._getImportedModules()), 
+        }), this.moduleUtils = new V(this, a), this.registeredSideEffects = new Map, this.injectImportedModules(this.imports), 
         this.injectProviders(), this.onReady?.(this), this;
     }
-    _getImportedModules() {
-        return this.shouldThrowIfDisposed(), this.imports;
-    }
-    _getProviders() {
-        return this.shouldThrowIfDisposed(), this.providers;
+    _onBind(e, t) {
+        this.shouldThrowIfDisposed(), this.registerSideEffect(e, "bind", t);
     }
-    _getExportableModulesAndProviders() {
-        return this.shouldThrowIfDisposed(), this.exports;
-    }
-    _onBind(e, i) {
-        this.shouldThrowIfDisposed(), this.registerBindingSideEffect(e, "bind", i);
-    }
-    _onGet(e, i, t) {
-        if (this.shouldThrowIfDisposed(), "boolean" != typeof i) throw new x(this, `The 'once' parameter is required when using the '${this._onGet.name}' method!`);
-        this.registerBindingSideEffect(e, "get", t, {
-            once: i
+    _onGet(e, t, i) {
+        if (this.shouldThrowIfDisposed(), "boolean" != typeof t) throw new x(this, `The 'once' parameter is required when using the '${this._onGet.name}' method!`);
+        this.registerSideEffect(e, "get", i, {
+            once: t
         });
     }
-    _onRebind(e, i) {
-        this.shouldThrowIfDisposed(), this.registerBindingSideEffect(e, "rebind", i);
+    _onRebind(e, t) {
+        this.shouldThrowIfDisposed(), this.registerSideEffect(e, "rebind", t);
     }
-    _onUnbind(e, i) {
-        this.shouldThrowIfDisposed(), this.registerBindingSideEffect(e, "unbind", i);
+    _onUnbind(e, t) {
+        this.shouldThrowIfDisposed(), this.registerSideEffect(e, "unbind", t);
     }
     _overwriteContainer(e) {
         this.container = e();
     }
     __bind(e) {
         this.shouldThrowIfDisposed();
-        const i = this.container.bind(h.toServiceIdentifier(e));
-        return this.invokeRegisteredBindingSideEffects(e, "onBind"), i;
+        const t = this.container.bind(f.toServiceIdentifier(e));
+        return this.invokeRegisteredSideEffects(e, "onBind"), t;
     }
-    __get(e, i) {
-        return this.shouldThrowIfDisposed(), this.invokeRegisteredBindingSideEffects(e, "onGet"), 
-        this.container.get(h.toServiceIdentifier(e), i);
+    __get(e, t) {
+        return this.shouldThrowIfDisposed(), this.invokeRegisteredSideEffects(e, "onGet"), 
+        this.container.get(f.toServiceIdentifier(e), t);
     }
-    async __getAsync(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAsync(h.toServiceIdentifier(e), i);
+    async __getAsync(e, t) {
+        return this.shouldThrowIfDisposed(), this.container.getAsync(f.toServiceIdentifier(e), t);
     }
-    __getAll(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAll(h.toServiceIdentifier(e), i);
+    __getAll(e, t) {
+        return this.shouldThrowIfDisposed(), this.container.getAll(f.toServiceIdentifier(e), t);
     }
-    async __getAllAsync(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAllAsync(h.toServiceIdentifier(e), i);
+    async __getAllAsync(e, t) {
+        return this.shouldThrowIfDisposed(), this.container.getAllAsync(f.toServiceIdentifier(e), t);
     }
-    __isBound(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.isBound(h.toServiceIdentifier(e), i);
+    __isBound(e, t) {
+        return this.shouldThrowIfDisposed(), this.container.isBound(f.toServiceIdentifier(e), t);
     }
-    __isCurrentBound(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.isCurrentBound(h.toServiceIdentifier(e), i);
+    __isCurrentBound(e, t) {
+        return this.shouldThrowIfDisposed(), this.container.isCurrentBound(f.toServiceIdentifier(e), t);
     }
     __takeSnapshot() {
         this.shouldThrowIfDisposed(), this.container.snapshot();
@@ -567,56 +592,58 @@ var G = class e extends Error {
     }
     async __rebind(e) {
         this.shouldThrowIfDisposed();
-        const i = await this.container.rebind(h.toServiceIdentifier(e));
-        return this.invokeRegisteredBindingSideEffects(e, "onRebind"), i;
+        const t = await this.container.rebind(f.toServiceIdentifier(e));
+        return this.invokeRegisteredSideEffects(e, "onRebind"), t;
     }
     __rebindSync(e) {
         this.shouldThrowIfDisposed();
-        const i = this.container.rebindSync(h.toServiceIdentifier(e));
-        return this.invokeRegisteredBindingSideEffects(e, "onRebind"), i;
+        const t = this.container.rebindSync(f.toServiceIdentifier(e));
+        return this.invokeRegisteredSideEffects(e, "onRebind"), t;
     }
     async __unbind(e) {
-        this.shouldThrowIfDisposed(), await this.container.unbind(h.toServiceIdentifier(e)), 
-        this.removeRegisteredBindingSideEffects(e);
+        this.shouldThrowIfDisposed(), await this.container.unbind(f.toServiceIdentifier(e)), 
+        await this.removeRegisteredSideEffects(e);
     }
     __unbindSync(e) {
-        this.shouldThrowIfDisposed(), this.container.unbindSync(h.toServiceIdentifier(e)), 
-        this.removeRegisteredBindingSideEffects(e);
+        this.shouldThrowIfDisposed(), this.container.unbindSync(f.toServiceIdentifier(e)), 
+        this.removeRegisteredSideEffects(e);
     }
     async __unbindAll() {
-        this.shouldThrowIfDisposed(), await this.container.unbindAll(), this.removeRegisteredBindingSideEffects("all");
+        this.shouldThrowIfDisposed(), await this.container.unbindAll(), await this.removeRegisteredSideEffects("all");
     }
-}, L = new Set, $ = class extends W {
+}, W = new Set, $ = class extends z {
     static {
-        o(this, "GlobalAppModule");
+        r(this, "GlobalAppModule");
     }
+    _strict;
     nakedModule=this;
     isLoaded=!1;
     constructor() {
-        super(f.buildInternalConstructorParams({
-            identifier: Symbol(d),
+        super(y.buildInternalConstructorParams({
+            identifier: d,
             isAppModule: !0
         }));
     }
     register(e) {
-        if (this.isLoaded) throw new G(`The '${this.toString()}' has already been registered!`);
-        return this.nakedModule._lazyInit(e), this.checkIfRegisteredModulesHaveGlobalMark(this.toNaked(), this.imports), 
+        if (this.isLoaded) throw new B(`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;
     }
     toNaked() {
         return super.toNaked();
     }
     async dispose() {
-        this.isLoaded = !1, super.dispose();
-    }
-    checkIfRegisteredModulesHaveGlobalMark(e, i, t = !1) {
-        i.forEach((i => {
-            if (i instanceof W) {
-                if (i.isMarkedAsGlobal) return L.delete(i), void (i.exports && this.checkIfRegisteredModulesHaveGlobalMark(i, i.exports, !0));
-                throw new U(i, 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`!");
+        this.isLoaded = !1, await super.dispose();
+    }
+    checkIfRegisteredModulesHaveGlobalMark(e, t, i = !1) {
+        this._strict && (t.forEach((t => {
+            const n = y.tryStaticOrLazyExportToStaticExport(this, t);
+            if (n instanceof z) {
+                if (n.isMarkedAsGlobal) return W.delete(n), void (n.exports && this.checkIfRegisteredModulesHaveGlobalMark(n, n.exports, !0));
+                throw new U(n, i ? `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 || L.forEach((e => {
+        })), i || W.forEach((e => {
             throw new U(e, "Is marked as 'global' and has not been imported into the 'AppModule'!");
-        }));
+        })));
     }
 }, H = new $;//# sourceMappingURL=index.cjs.map