@adimm/x-injection 1.2.1 → 2.0.4

package/dist/index.js

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