lakutata 2.0.24 → 2.0.26

package/vendor/Package.3.mjs

@@ -1,460 +1,948 @@
-import { _ as t, a as e } from "./Package.1.mjs";
+import { c as e } from "./Package.4.mjs";
 
-import { AsyncConstructor as s } from "../src/lib/base/async-constructor/AsyncConstructor.mjs";
+var t = {};
 
-import { Transient as i } from "../src/decorators/di/Lifetime.mjs";
+var r;
 
-import { MethodNotFoundException as r } from "../src/exceptions/MethodNotFoundException.mjs";
-
-import { createContainer as o } from "../src/lib/ioc/DependencyInjectionContainer.mjs";
-
-import { randomUUID as n } from "node:crypto";
-
-import { GetConfigurableRecords as a, SetIdToInstance as c, SetConfigurableRecordsToInstance as l, SetConfigurableRecords as h, GetConfigurableRecordsFromInstance as d, GetIdFromInstance as m } from "../src/lib/base/internal/ConfigurableRecordsInjection.mjs";
-
-import { GetObjectConfigurableProperties as p } from "../src/lib/base/internal/ObjectConfiguration.mjs";
-
-import { GetObjectIsAutoload as u, GetObjectInjectItemsByPrototype as f } from "../src/lib/base/internal/ObjectInjection.mjs";
-
-import { SetObjectContainerGetter as b } from "../src/lib/base/internal/ObjectContainer.mjs";
-
-import { D as y, I as j } from "./Package.2.mjs";
-
-import { ObjectConstructor as g } from "../src/lib/helpers/ObjectConstructor.mjs";
-
-import { As as w } from "../src/lib/helpers/As.mjs";
-
-import { DevNull as O } from "../src/lib/helpers/DevNull.mjs";
-
-import { ObjectParentConstructors as P } from "../src/lib/helpers/ObjectParentConstructors.mjs";
-
-import { DependencyInjectionException as C } from "../src/exceptions/di/DependencyInjectionException.mjs";
-
-import { ConstructorSymbol as R } from "../src/lib/base/internal/ConstructorSymbol.mjs";
-
-import { Expect as S } from "../src/decorators/dto/Expect.mjs";
-
-import { IndexSignature as N } from "../src/decorators/dto/IndexSignature.mjs";
-
-import { asValue as v, asClass as I } from "../src/lib/ioc/Resolvers.mjs";
-
-import { GetObjectLifetime as E } from "../src/lib/base/internal/ObjectLifetime.mjs";
-
-import { Accept as M } from "../src/decorators/dto/Accept.mjs";
-
-import { listModules as A } from "../src/lib/ioc/ListModules.mjs";
+(function(t) {
+    (function(r) {
+        var n = typeof globalThis === "object" ? globalThis : typeof e === "object" ? e : typeof self === "object" ? self : typeof this === "object" ? this : o();
+        var i = a(t);
+        if (typeof n.Reflect !== "undefined") {
+            i = a(n.Reflect, i);
+        }
+        r(i, n);
+        if (typeof n.Reflect === "undefined") {
+            n.Reflect = t;
+        }
+        function a(e, t) {
+            return function(r, n) {
+                Object.defineProperty(e, r, {
+                    configurable: true,
+                    writable: true,
+                    value: n
+                });
+                if (t) t(r, n);
+            };
+        }
+        function u() {
+            try {
+                return Function("return this;")();
+            } catch (e) {}
+        }
+        function f() {
+            try {
+                return (void 0, eval)("(function() { return this; })()");
+            } catch (e) {}
+        }
+        function o() {
+            return u() || f();
+        }
+    })((function(e, t) {
+        var r = Object.prototype.hasOwnProperty;
+        var n = typeof Symbol === "function";
+        var i = n && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+        var a = n && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+        var u = typeof Object.create === "function";
+        var f = {
+            __proto__: []
+        } instanceof Array;
+        var o = !u && !f;
+        var s = {
+            create: u ? function() {
+                return le(Object.create(null));
+            } : f ? function() {
+                return le({
+                    __proto__: null
+                });
+            } : function() {
+                return le({});
+            },
+            has: o ? function(e, t) {
+                return r.call(e, t);
+            } : function(e, t) {
+                return t in e;
+            },
+            get: o ? function(e, t) {
+                return r.call(e, t) ? e[t] : undefined;
+            } : function(e, t) {
+                return e[t];
+            }
+        };
+        var c = Object.getPrototypeOf(Function);
+        var l = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : oe();
+        var d = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : se();
+        var h = typeof WeakMap === "function" ? WeakMap : ce();
+        var y = n ? Symbol.for("@reflect-metadata:registry") : undefined;
+        var v = ie();
+        var p = ae(v);
+        function w(e, t, r, n) {
+            if (!D(r)) {
+                if (!B(e)) throw new TypeError;
+                if (!G(t)) throw new TypeError;
+                if (!G(n) && !D(n) && !C(n)) throw new TypeError;
+                if (C(n)) n = undefined;
+                r = q(r);
+                return j(e, t, r, n);
+            } else {
+                if (!B(e)) throw new TypeError;
+                if (!N(t)) throw new TypeError;
+                return T(e, t);
+            }
+        }
+        e("decorate", w);
+        function _(e, t) {
+            function r(r, n) {
+                if (!G(r)) throw new TypeError;
+                if (!D(n) && !Q(n)) throw new TypeError;
+                A(e, t, r, n);
+            }
+            return r;
+        }
+        e("metadata", _);
+        function g(e, t, r, n) {
+            if (!G(r)) throw new TypeError;
+            if (!D(n)) n = q(n);
+            return A(e, t, r, n);
+        }
+        e("defineMetadata", g);
+        function b(e, t, r) {
+            if (!G(t)) throw new TypeError;
+            if (!D(r)) r = q(r);
+            return x(e, t, r);
+        }
+        e("hasMetadata", b);
+        function O(e, t, r) {
+            if (!G(t)) throw new TypeError;
+            if (!D(r)) r = q(r);
+            return R(e, t, r);
+        }
+        e("hasOwnMetadata", O);
+        function k(e, t, r) {
+            if (!G(t)) throw new TypeError;
+            if (!D(r)) r = q(r);
+            return S(e, t, r);
+        }
+        e("getMetadata", k);
+        function M(e, t, r) {
+            if (!G(t)) throw new TypeError;
+            if (!D(r)) r = q(r);
+            return K(e, t, r);
+        }
+        e("getOwnMetadata", M);
+        function m(e, t) {
+            if (!G(e)) throw new TypeError;
+            if (!D(t)) t = q(t);
+            return I(e, t);
+        }
+        e("getMetadataKeys", m);
+        function E(e, t) {
+            if (!G(e)) throw new TypeError;
+            if (!D(t)) t = q(t);
+            return F(e, t);
+        }
+        e("getOwnMetadataKeys", E);
+        function P(e, t, r) {
+            if (!G(t)) throw new TypeError;
+            if (!D(r)) r = q(r);
+            if (!G(t)) throw new TypeError;
+            if (!D(r)) r = q(r);
+            var n = fe(t, r, false);
+            if (D(n)) return false;
+            return n.OrdinaryDeleteMetadata(e, t, r);
+        }
+        e("deleteMetadata", P);
+        function T(e, t) {
+            for (var r = e.length - 1; r >= 0; --r) {
+                var n = e[r];
+                var i = n(t);
+                if (!D(i) && !C(i)) {
+                    if (!N(i)) throw new TypeError;
+                    t = i;
+                }
+            }
+            return t;
+        }
+        function j(e, t, r, n) {
+            for (var i = e.length - 1; i >= 0; --i) {
+                var a = e[i];
+                var u = a(t, r, n);
+                if (!D(u) && !C(u)) {
+                    if (!G(u)) throw new TypeError;
+                    n = u;
+                }
+            }
+            return n;
+        }
+        function x(e, t, r) {
+            var n = R(e, t, r);
+            if (n) return true;
+            var i = re(t);
+            if (!C(i)) return x(e, i, r);
+            return false;
+        }
+        function R(e, t, r) {
+            var n = fe(t, r, false);
+            if (D(n)) return false;
+            return V(n.OrdinaryHasOwnMetadata(e, t, r));
+        }
+        function S(e, t, r) {
+            var n = R(e, t, r);
+            if (n) return K(e, t, r);
+            var i = re(t);
+            if (!C(i)) return S(e, i, r);
+            return undefined;
+        }
+        function K(e, t, r) {
+            var n = fe(t, r, false);
+            if (D(n)) return;
+            return n.OrdinaryGetOwnMetadata(e, t, r);
+        }
+        function A(e, t, r, n) {
+            var i = fe(r, n, true);
+            i.OrdinaryDefineOwnMetadata(e, t, r, n);
+        }
+        function I(e, t) {
+            var r = F(e, t);
+            var n = re(e);
+            if (n === null) return r;
+            var i = I(n, t);
+            if (i.length <= 0) return r;
+            if (r.length <= 0) return i;
+            var a = new d;
+            var u = [];
+            for (var f = 0, o = r; f < o.length; f++) {
+                var s = o[f];
+                var c = a.has(s);
+                if (!c) {
+                    a.add(s);
+                    u.push(s);
+                }
+            }
+            for (var l = 0, h = i; l < h.length; l++) {
+                var s = h[l];
+                var c = a.has(s);
+                if (!c) {
+                    a.add(s);
+                    u.push(s);
+                }
+            }
+            return u;
+        }
+        function F(e, t) {
+            var r = fe(e, t, false);
+            if (!r) {
+                return [];
+            }
+            return r.OrdinaryOwnMetadataKeys(e, t);
+        }
+        function z(e) {
+            if (e === null) return 1;
+            switch (typeof e) {
+              case "undefined":
+                return 0;
 
-import { pathToFileURL as T } from "url";
+              case "boolean":
+                return 2;
 
-import { isClass as L } from "../src/lib/ioc/Utils.mjs";
+              case "string":
+                return 3;
 
-import { IsEmptyObject as k } from "../src/lib/helpers/IsEmptyObject.mjs";
+              case "symbol":
+                return 4;
 
-import { AppendObjectWeakRefs as D, GetObjectWeakRefs as U, ClearObjectWeakRefs as x } from "../src/lib/base/internal/ObjectWeakRefs.mjs";
+              case "number":
+                return 5;
 
-var B;
+              case "object":
+                return e === null ? 1 : 6;
 
-const _ = Symbol("OBJECT_ID");
+              default:
+                return 6;
+            }
+        }
+        function D(e) {
+            return e === undefined;
+        }
+        function C(e) {
+            return e === null;
+        }
+        function W(e) {
+            return typeof e === "symbol";
+        }
+        function G(e) {
+            return typeof e === "object" ? e !== null : typeof e === "function";
+        }
+        function H(e, t) {
+            switch (z(e)) {
+              case 0:
+                return e;
 
-let F = class LoadObjectOptions extends y {
-    static {
-        B = _;
-    }
-};
+              case 1:
+                return e;
 
-t([ S(y.Alternatives(y.String(), y.Symbol()).optional()), e("design:type", Object) ], F.prototype, B, void 0);
+              case 2:
+                return e;
 
-t([ S(y.Class((() => tt)).required()), e("design:type", Object) ], F.prototype, "class", void 0);
+              case 3:
+                return e;
 
-F = t([ N(y.Any()) ], F);
+              case 4:
+                return e;
 
-const G = Symbol("LAKUTATA.DI.CONTAINER.SYMBOL");
+              case 5:
+                return e;
+            }
+            var r = t === 3 ? "string" : t === 5 ? "number" : "default";
+            var n = Y(e, i);
+            if (n !== undefined) {
+                var a = n.call(e, r);
+                if (G(a)) throw new TypeError;
+                return a;
+            }
+            return U(e, r === "default" ? "number" : r);
+        }
+        function U(e, t) {
+            if (t === "string") {
+                var r = e.toString;
+                if (J(r)) {
+                    var n = r.call(e);
+                    if (!G(n)) return n;
+                }
+                var i = e.valueOf;
+                if (J(i)) {
+                    var n = i.call(e);
+                    if (!G(n)) return n;
+                }
+            } else {
+                var i = e.valueOf;
+                if (J(i)) {
+                    var n = i.call(e);
+                    if (!G(n)) return n;
+                }
+                var a = e.toString;
+                if (J(a)) {
+                    var n = a.call(e);
+                    if (!G(n)) return n;
+                }
+            }
+            throw new TypeError;
+        }
+        function V(e) {
+            return !!e;
+        }
+        function L(e) {
+            return "" + e;
+        }
+        function q(e) {
+            var t = H(e, 3);
+            if (W(t)) return t;
+            return L(t);
+        }
+        function B(e) {
+            return Array.isArray ? Array.isArray(e) : e instanceof Object ? e instanceof Array : Object.prototype.toString.call(e) === "[object Array]";
+        }
+        function J(e) {
+            return typeof e === "function";
+        }
+        function N(e) {
+            return typeof e === "function";
+        }
+        function Q(e) {
+            switch (z(e)) {
+              case 3:
+                return true;
 
-const Y = Symbol("LAKUTATA.DI.OWNER.SYMBOL");
+              case 4:
+                return true;
 
-class Container {
-    #t;
-    #e;
-    #s;
-    constructor(t, e) {
-        this.#e = new Set;
-        this.#s = false;
-        this.injectionNames = new Set;
-        this.parent = t;
-        this.#t = t ? t.#t.createScope() : o({
-            injectionMode: "PROXY",
-            strict: false
-        });
-        if (this.parent) this.parent.#e.add(this);
-        this.#t.register(G, v(this));
-        if (e) this.#t.register(Y, v(new WeakRef(e)));
-    }
-    async disposer(t) {
-        try {
-            await t.getMethod(H, false)();
-        } catch (t) {
-            O(t);
-        }
-    }
-    buildResolverOptions(t) {
-        const e = E(t);
-        return {
-            lifetime: e,
-            dispose: t => this.disposer(t)
-        };
-    }
-    async processResolved(t, e, s = {}) {
-        const i = a(w(t.constructor), e);
-        const r = y.isValid(t.constructor, y.Class(tt));
-        if (r) {
-            c(w(t), e);
-            l(w(t), {
-                ...i,
-                ...s
-            });
-        }
-        return Promise.resolve(t);
-    }
-    buildNameAndRegistrationPairFromOptions(t) {
-        const e = {};
-        const s = t[_] ? t[_] : R(t.class);
-        const i = {
-            ...t,
-            class: void 0
-        };
-        delete i.id;
-        delete i.class;
-        h(t.class, s, i);
-        e[s] = I(t.class, this.buildResolverOptions(t.class));
-        return e;
-    }
-    async buildNameAndRegistrationPairFromGlob(t) {
-        const e = [];
-        A(t).forEach((t => {
-            e.push(new Promise((e => {
-                import(T(t.path).toString()).then((t => {
-                    Object.keys(t).forEach((s => {
-                        const i = t[s];
-                        if (L(i) && y.isValid(i, y.Class(tt))) {
-                            const t = i;
-                            const s = {};
-                            s[R(t)] = I(t, this.buildResolverOptions(t));
-                            return e(s);
-                        } else {
-                            return e({});
+              default:
+                return false;
+            }
+        }
+        function X(e, t) {
+            return e === t || e !== e && t !== t;
+        }
+        function Y(e, t) {
+            var r = e[t];
+            if (r === undefined || r === null) return undefined;
+            if (!J(r)) throw new TypeError;
+            return r;
+        }
+        function Z(e) {
+            var t = Y(e, a);
+            if (!J(t)) throw new TypeError;
+            var r = t.call(e);
+            if (!G(r)) throw new TypeError;
+            return r;
+        }
+        function $(e) {
+            return e.value;
+        }
+        function ee(e) {
+            var t = e.next();
+            return t.done ? false : t;
+        }
+        function te(e) {
+            var t = e["return"];
+            if (t) t.call(e);
+        }
+        function re(e) {
+            var t = Object.getPrototypeOf(e);
+            if (typeof e !== "function" || e === c) return t;
+            if (t !== c) return t;
+            var r = e.prototype;
+            var n = r && Object.getPrototypeOf(r);
+            if (n == null || n === Object.prototype) return t;
+            var i = n.constructor;
+            if (typeof i !== "function") return t;
+            if (i === e) return t;
+            return i;
+        }
+        function ne() {
+            var e;
+            if (!D(y) && typeof t.Reflect !== "undefined" && !(y in t.Reflect) && typeof t.Reflect.defineMetadata === "function") {
+                e = ue(t.Reflect);
+            }
+            var r;
+            var n;
+            var i;
+            var a = new h;
+            var u = {
+                registerProvider: f,
+                getProvider: s,
+                setProvider: v
+            };
+            return u;
+            function f(t) {
+                if (!Object.isExtensible(u)) {
+                    throw new Error("Cannot add provider to a frozen registry.");
+                }
+                switch (true) {
+                  case e === t:
+                    break;
+
+                  case D(r):
+                    r = t;
+                    break;
+
+                  case r === t:
+                    break;
+
+                  case D(n):
+                    n = t;
+                    break;
+
+                  case n === t:
+                    break;
+
+                  default:
+                    if (i === undefined) i = new d;
+                    i.add(t);
+                    break;
+                }
+            }
+            function o(t, a) {
+                if (!D(r)) {
+                    if (r.isProviderFor(t, a)) return r;
+                    if (!D(n)) {
+                        if (n.isProviderFor(t, a)) return r;
+                        if (!D(i)) {
+                            var u = Z(i);
+                            while (true) {
+                                var f = ee(u);
+                                if (!f) {
+                                    return undefined;
+                                }
+                                var o = $(f);
+                                if (o.isProviderFor(t, a)) {
+                                    te(u);
+                                    return o;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (!D(e) && e.isProviderFor(t, a)) {
+                    return e;
+                }
+                return undefined;
+            }
+            function s(e, t) {
+                var r = a.get(e);
+                var n;
+                if (!D(r)) {
+                    n = r.get(t);
+                }
+                if (!D(n)) {
+                    return n;
+                }
+                n = o(e, t);
+                if (!D(n)) {
+                    if (D(r)) {
+                        r = new l;
+                        a.set(e, r);
+                    }
+                    r.set(t, n);
+                }
+                return n;
+            }
+            function c(e) {
+                if (D(e)) throw new TypeError;
+                return r === e || n === e || !D(i) && i.has(e);
+            }
+            function v(e, t, r) {
+                if (!c(r)) {
+                    throw new Error("Metadata provider not registered.");
+                }
+                var n = s(e, t);
+                if (n !== r) {
+                    if (!D(n)) {
+                        return false;
+                    }
+                    var i = a.get(e);
+                    if (D(i)) {
+                        i = new l;
+                        a.set(e, i);
+                    }
+                    i.set(t, r);
+                }
+                return true;
+            }
+        }
+        function ie() {
+            var e;
+            if (!D(y) && G(t.Reflect) && Object.isExtensible(t.Reflect)) {
+                e = t.Reflect[y];
+            }
+            if (D(e)) {
+                e = ne();
+            }
+            if (!D(y) && G(t.Reflect) && Object.isExtensible(t.Reflect)) {
+                Object.defineProperty(t.Reflect, y, {
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                    value: e
+                });
+            }
+            return e;
+        }
+        function ae(e) {
+            var t = new h;
+            var r = {
+                isProviderFor: function(e, r) {
+                    var n = t.get(e);
+                    if (D(n)) return false;
+                    return n.has(r);
+                },
+                OrdinaryDefineOwnMetadata: u,
+                OrdinaryHasOwnMetadata: i,
+                OrdinaryGetOwnMetadata: a,
+                OrdinaryOwnMetadataKeys: f,
+                OrdinaryDeleteMetadata: o
+            };
+            v.registerProvider(r);
+            return r;
+            function n(n, i, a) {
+                var u = t.get(n);
+                var f = false;
+                if (D(u)) {
+                    if (!a) return undefined;
+                    u = new l;
+                    t.set(n, u);
+                    f = true;
+                }
+                var o = u.get(i);
+                if (D(o)) {
+                    if (!a) return undefined;
+                    o = new l;
+                    u.set(i, o);
+                    if (!e.setProvider(n, i, r)) {
+                        u.delete(i);
+                        if (f) {
+                            t.delete(n);
+                        }
+                        throw new Error("Wrong provider for target.");
+                    }
+                }
+                return o;
+            }
+            function i(e, t, r) {
+                var i = n(t, r, false);
+                if (D(i)) return false;
+                return V(i.has(e));
+            }
+            function a(e, t, r) {
+                var i = n(t, r, false);
+                if (D(i)) return undefined;
+                return i.get(e);
+            }
+            function u(e, t, r, i) {
+                var a = n(r, i, true);
+                a.set(e, t);
+            }
+            function f(e, t) {
+                var r = [];
+                var i = n(e, t, false);
+                if (D(i)) return r;
+                var a = i.keys();
+                var u = Z(a);
+                var f = 0;
+                while (true) {
+                    var o = ee(u);
+                    if (!o) {
+                        r.length = f;
+                        return r;
+                    }
+                    var s = $(o);
+                    try {
+                        r[f] = s;
+                    } catch (e) {
+                        try {
+                            te(u);
+                        } finally {
+                            throw e;
+                        }
+                    }
+                    f++;
+                }
+            }
+            function o(e, r, i) {
+                var a = n(r, i, false);
+                if (D(a)) return false;
+                if (!a.delete(e)) return false;
+                if (a.size === 0) {
+                    var u = t.get(r);
+                    if (!D(u)) {
+                        u.delete(i);
+                        if (u.size === 0) {
+                            t.delete(u);
+                        }
+                    }
+                }
+                return true;
+            }
+        }
+        function ue(e) {
+            var t = e.defineMetadata, r = e.hasOwnMetadata, n = e.getOwnMetadata, i = e.getOwnMetadataKeys, a = e.deleteMetadata;
+            var u = new h;
+            var f = {
+                isProviderFor: function(e, t) {
+                    var r = u.get(e);
+                    if (!D(r) && r.has(t)) {
+                        return true;
+                    }
+                    if (i(e, t).length) {
+                        if (D(r)) {
+                            r = new d;
+                            u.set(e, r);
                         }
-                    }));
-                })).catch((() => e({})));
-            })));
-        }));
-        const s = await Promise.all(e);
-        let i = {};
-        s.forEach((t => {
-            i = {
-                ...i,
-                ...t
+                        r.add(t);
+                        return true;
+                    }
+                    return false;
+                },
+                OrdinaryDefineOwnMetadata: t,
+                OrdinaryHasOwnMetadata: r,
+                OrdinaryGetOwnMetadata: n,
+                OrdinaryOwnMetadataKeys: i,
+                OrdinaryDeleteMetadata: a
             };
-        }));
-        return i;
-    }
-    owner() {
-        const t = this.#t.resolve(Y, {
-            allowUnregistered: true
-        });
-        return t ? t.deref() : undefined;
-    }
-    async load(t) {
-        let e = {};
-        const s = [];
-        t.forEach((t => {
-            if (typeof t === "string") {
-                s.push(new Promise(((e, s) => this.buildNameAndRegistrationPairFromGlob(t).then(e).catch(s))));
-            } else if (L(w(t))) {
-                const s = {
-                    class: w(t)
+            return f;
+        }
+        function fe(e, t, r) {
+            var n = v.getProvider(e, t);
+            if (!D(n)) {
+                return n;
+            }
+            if (r) {
+                if (v.setProvider(e, t, p)) {
+                    return p;
+                }
+                throw new Error("Illegal state.");
+            }
+            return undefined;
+        }
+        function oe() {
+            var e = {};
+            var t = [];
+            var r = function() {
+                function e(e, t, r) {
+                    this._index = 0;
+                    this._keys = e;
+                    this._values = t;
+                    this._selector = r;
+                }
+                e.prototype["@@iterator"] = function() {
+                    return this;
                 };
-                e = {
-                    ...e,
-                    ...this.buildNameAndRegistrationPairFromOptions(s)
+                e.prototype[a] = function() {
+                    return this;
                 };
-            } else {
-                const s = w(t);
-                e = {
-                    ...e,
-                    ...this.buildNameAndRegistrationPairFromOptions(s)
+                e.prototype.next = function() {
+                    var e = this._index;
+                    if (e >= 0 && e < this._keys.length) {
+                        var r = this._selector(this._keys[e], this._values[e]);
+                        if (e + 1 >= this._keys.length) {
+                            this._index = -1;
+                            this._keys = t;
+                            this._values = t;
+                        } else {
+                            this._index++;
+                        }
+                        return {
+                            value: r,
+                            done: false
+                        };
+                    }
+                    return {
+                        value: undefined,
+                        done: true
+                    };
+                };
+                e.prototype.throw = function(e) {
+                    if (this._index >= 0) {
+                        this._index = -1;
+                        this._keys = t;
+                        this._values = t;
+                    }
+                    throw e;
+                };
+                e.prototype.return = function(e) {
+                    if (this._index >= 0) {
+                        this._index = -1;
+                        this._keys = t;
+                        this._values = t;
+                    }
+                    return {
+                        value: e,
+                        done: true
+                    };
+                };
+                return e;
+            }();
+            var n = function() {
+                function t() {
+                    this._keys = [];
+                    this._values = [];
+                    this._cacheKey = e;
+                    this._cacheIndex = -2;
+                }
+                Object.defineProperty(t.prototype, "size", {
+                    get: function() {
+                        return this._keys.length;
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+                t.prototype.has = function(e) {
+                    return this._find(e, false) >= 0;
+                };
+                t.prototype.get = function(e) {
+                    var t = this._find(e, false);
+                    return t >= 0 ? this._values[t] : undefined;
+                };
+                t.prototype.set = function(e, t) {
+                    var r = this._find(e, true);
+                    this._values[r] = t;
+                    return this;
+                };
+                t.prototype.delete = function(t) {
+                    var r = this._find(t, false);
+                    if (r >= 0) {
+                        var n = this._keys.length;
+                        for (var i = r + 1; i < n; i++) {
+                            this._keys[i - 1] = this._keys[i];
+                            this._values[i - 1] = this._values[i];
+                        }
+                        this._keys.length--;
+                        this._values.length--;
+                        if (X(t, this._cacheKey)) {
+                            this._cacheKey = e;
+                            this._cacheIndex = -2;
+                        }
+                        return true;
+                    }
+                    return false;
+                };
+                t.prototype.clear = function() {
+                    this._keys.length = 0;
+                    this._values.length = 0;
+                    this._cacheKey = e;
+                    this._cacheIndex = -2;
+                };
+                t.prototype.keys = function() {
+                    return new r(this._keys, this._values, i);
+                };
+                t.prototype.values = function() {
+                    return new r(this._keys, this._values, u);
+                };
+                t.prototype.entries = function() {
+                    return new r(this._keys, this._values, f);
+                };
+                t.prototype["@@iterator"] = function() {
+                    return this.entries();
+                };
+                t.prototype[a] = function() {
+                    return this.entries();
                 };
+                t.prototype._find = function(e, t) {
+                    if (!X(this._cacheKey, e)) {
+                        this._cacheIndex = -1;
+                        for (var r = 0; r < this._keys.length; r++) {
+                            if (X(this._keys[r], e)) {
+                                this._cacheIndex = r;
+                                break;
+                            }
+                        }
+                    }
+                    if (this._cacheIndex < 0 && t) {
+                        this._cacheIndex = this._keys.length;
+                        this._keys.push(e);
+                        this._values.push(undefined);
+                    }
+                    return this._cacheIndex;
+                };
+                return t;
+            }();
+            return n;
+            function i(e, t) {
+                return e;
+            }
+            function u(e, t) {
+                return t;
             }
-        }));
-        if (s.length) {
-            const t = await Promise.all(s);
-            t.forEach((t => {
-                e = {
-                    ...t,
-                    ...e
+            function f(e, t) {
+                return [ e, t ];
+            }
+        }
+        function se() {
+            var e = function() {
+                function e() {
+                    this._map = new l;
+                }
+                Object.defineProperty(e.prototype, "size", {
+                    get: function() {
+                        return this._map.size;
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+                e.prototype.has = function(e) {
+                    return this._map.has(e);
                 };
-            }));
-        }
-        if (!k(e)) {
-            Object.getOwnPropertyNames(e).forEach((t => this.injectionNames.add(t)));
-            Object.getOwnPropertySymbols(e).forEach((t => this.injectionNames.add(t)));
-            this.#t.register(e);
-        }
-    }
-    async get(t, e = {}) {
-        const s = typeof t === "function" ? R(t) : t;
-        if (!this.#t.hasRegistration(s) && typeof t === "function" && u(w(t))) {
-            await this.load([ {
-                id: s,
-                class: w(t)
-            } ]);
-        }
-        return (this.#t.getRegistration(s)?.lifetime === "SINGLETON" || this.#t.getRegistration(s)?.lifetime === "MODULE_SINGLETON") && !this.injectionNames.has(s) && this.parent ? await this.parent.get(s, e) : await this.processResolved(this.#t.resolve(s), s, e);
-    }
-    has(t) {
-        if (typeof t === "function") return this.#t.hasRegistration(R(t));
-        return this.#t.hasRegistration(t);
-    }
-    async set(t, e = {}) {
-        await this.load([ {
-            ...e,
-            class: t
-        } ]);
-        return await this.get(t);
-    }
-    async register(t, e = {}) {
-        await this.load([ {
-            ...e,
-            class: t
-        } ]);
-    }
-    async build(t, e = {}) {
-        const s = await this.processResolved(this.#t.build(t, this.buildResolverOptions(t)), R(t), e);
-        D(this.#t, s);
-        return s;
-    }
-    createScope() {
-        return new Container(this, this.owner());
-    }
-    registerContainerToItsParent() {
-        if (this.parent) this.parent.#e.add(this);
-    }
-    async clear() {
-        const t = [];
-        this.#e.forEach((e => t.push(new Promise(((t, s) => e.destroy().then(t).catch(s))))));
-        await Promise.all(t);
-        await this.#t.dispose();
-        const e = [];
-        U(this.#t).forEach((t => {
-            let s = t.deref();
-            if (!s) return;
-            if (s[H]) {
-                e.push(new Promise((t => s ? Promise.resolve(s[H]()).then((() => {
-                    s = undefined;
-                    return t();
-                })).catch(O) : t())));
-            }
-        }));
-        await Promise.all(e);
-        x(this.#t);
-    }
-    async destroy() {
-        if (this.#s) return;
-        this.#s = true;
-        if (this.parent) this.parent.#e.delete(this);
-        await this.clear();
-    }
-}
-
-t([ M(y.Array(y.Alternatives(F.Schema(), y.Class((() => tt)), y.Glob()))), e("design:type", Function), e("design:paramtypes", [ Array ]), e("design:returntype", Promise) ], Container.prototype, "load", null);
-
-const $ = Symbol("OBJECT.TYPE");
-
-var q;
-
-(function(t) {
-    t["Unknown"] = "Unknown";
-    t["Object"] = "Object";
-    t["Provider"] = "Provider";
-    t["Controller"] = "Controller";
-    t["Component"] = "Component";
-    t["Module"] = "Module";
-})(q || (q = {}));
-
-function z(t) {
-    return e => J(e, t);
-}
-
-function J(t, e) {
-    Reflect.defineMetadata($, y.isValid(t, y.Class(tt)) ? e : q.Unknown, t);
-    return t;
-}
-
-function V(t) {
-    if (Reflect.hasOwnMetadata($, t)) return Reflect.getOwnMetadata($, t);
-    let e = q.Unknown;
-    for (const s of P(t)) {
-        if (Reflect.hasOwnMetadata($, s)) {
-            e = Reflect.getOwnMetadata($, s);
-            break;
-        }
-    }
-    J(t, e);
-    return V(t);
-}
-
-var W;
-
-var K;
-
-const X = Symbol("__init");
-
-const H = Symbol("__destroy");
-
-const Q = Symbol("anonymous");
-
-const Z = Symbol("OBJECT.SYMBOL.PROPERTY");
-
-let tt = K = class BaseObject extends s {
-    #i;
-    #r;
-    #o=n();
-    #n=false;
-    async #a() {
-        const t = d(this);
-        const e = [];
-        p(this).forEach(((s, i) => {
-            if (j(i)) return;
-            e.push(new Promise(((e, r) => {
-                y.validateAsync(t[w(i)], s.schema, {
-                    targetName: i
-                }).then((t => Promise.resolve(s.fn.bind(this)(t)).then((t => {
-                    this[i] = t;
-                    return e();
-                })).catch(r))).catch(r);
-            })));
-        }));
-        await Promise.all(e);
-    }
-    async #c() {
-        const t = f(this);
-        const e = [];
-        t.forEach(((t, s) => {
-            const i = t.name;
-            e.push(new Promise(((e, r) => {
-                this.#i.get(i).then((i => {
-                    Promise.resolve(t.transform(i)).then((t => {
-                        Reflect.set(this, s, t);
-                        return e();
-                    })).catch(r);
-                })).catch((t => r(new C("Unable to inject value for property {0} of {1} because: {2}", [ s, this.className, t.message ]))));
-            })));
-        }));
-        await Promise.all(e);
-    }
-    #l() {
-        const t = m(this);
-        this.#r = t ? t : Q;
-    }
-    constructor(t) {
-        super((async () => {
-            this.#l();
-            const t = Object.getOwnPropertyDescriptor(this, "then");
-            if (t) Object.defineProperty(this, "then", {
-                enumerable: false
-            });
-            await this[X]();
-        }));
-        this.#i = new Container(t[G], this);
-        b(this, this.#i);
-    }
-    static get className() {
-        return this.name;
-    }
-    get className() {
-        return g(this).name;
-    }
-    async [X](...t) {
-        this.#i.registerContainerToItsParent();
-        if (!this.#n) {
-            await this.#c();
-            await this.#a();
-            this.#n = true;
-        }
-        for (const e of t) await e();
-        await this.init();
-    }
-    async [H](...t) {
-        await this.#i.destroy();
-        for (const e of t) await e();
-        await this.destroy();
-    }
-    async init() {}
-    async destroy() {}
-    async getObject(t, e = {}) {
-        return await this.#i.get(t, e);
-    }
-    async buildObject(t, e = {}) {
-        return this.#i.build(t, e);
-    }
-    getParent() {
-        return this.#i.parent?.owner();
-    }
-    getModule() {
-        let t = this.getParent();
-        while (t && V(w(g(t))) !== q.Module) {
-            t = this.getParent();
-        }
-        return w(t);
-    }
-    get $uuid() {
-        return this.#o;
-    }
-    get $id() {
-        return this.#r;
-    }
-    get $symbol() {
-        if (Reflect.hasOwnMetadata(Z, this)) return Reflect.getOwnMetadata(Z, this);
-        Reflect.defineMetadata(Z, Symbol(this.$uuid), this);
-        return this.$symbol;
-    }
-    setProperty(t, e) {
-        this[t] = e;
-    }
-    getProperty(t, e) {
-        if (this.hasProperty(t)) return w(this[t]);
-        return w(e);
-    }
-    hasProperty(t) {
-        return typeof t === "string" ? this.propertyNames().includes(t) : this.propertySymbols().includes(t);
-    }
-    propertySymbols() {
-        return Object.getOwnPropertySymbols(this);
-    }
-    propertyNames() {
-        return Object.getOwnPropertyNames(this);
-    }
-    hasMethod(t) {
-        const e = this.hasProperty(t);
-        if (e) return false;
-        return typeof this[t] === "function";
-    }
-    getMethod(t, e = false) {
-        if (this.hasMethod(t)) {
-            return (...e) => this[t](...e);
-        } else if (e) {
-            throw new r('Method "{methodName}" not found in "{className}"', {
-                methodName: t,
-                className: this.constructor.name
-            });
-        } else {
-            return (...t) => O(...t);
-        }
-    }
-    async dispose() {
-        await this.destroy();
-    }
-};
-
-tt = K = t([ i(), z(q.Object), e("design:paramtypes", [ Object ]) ], tt);
-
-export { tt as B, Container as C, z as D, V as G, F as L, q as O, J as S, X as _, H as a, _ as b, G as c, Q as d, Y as o };
+                e.prototype.add = function(e) {
+                    return this._map.set(e, e), this;
+                };
+                e.prototype.delete = function(e) {
+                    return this._map.delete(e);
+                };
+                e.prototype.clear = function() {
+                    this._map.clear();
+                };
+                e.prototype.keys = function() {
+                    return this._map.keys();
+                };
+                e.prototype.values = function() {
+                    return this._map.keys();
+                };
+                e.prototype.entries = function() {
+                    return this._map.entries();
+                };
+                e.prototype["@@iterator"] = function() {
+                    return this.keys();
+                };
+                e.prototype[a] = function() {
+                    return this.keys();
+                };
+                return e;
+            }();
+            return e;
+        }
+        function ce() {
+            var e = 16;
+            var t = s.create();
+            var n = i();
+            return function() {
+                function e() {
+                    this._key = i();
+                }
+                e.prototype.has = function(e) {
+                    var t = a(e, false);
+                    return t !== undefined ? s.has(t, this._key) : false;
+                };
+                e.prototype.get = function(e) {
+                    var t = a(e, false);
+                    return t !== undefined ? s.get(t, this._key) : undefined;
+                };
+                e.prototype.set = function(e, t) {
+                    var r = a(e, true);
+                    r[this._key] = t;
+                    return this;
+                };
+                e.prototype.delete = function(e) {
+                    var t = a(e, false);
+                    return t !== undefined ? delete t[this._key] : false;
+                };
+                e.prototype.clear = function() {
+                    this._key = i();
+                };
+                return e;
+            }();
+            function i() {
+                var e;
+                do {
+                    e = "@@WeakMap@@" + o();
+                } while (s.has(t, e));
+                t[e] = true;
+                return e;
+            }
+            function a(e, t) {
+                if (!r.call(e, n)) {
+                    if (!t) return undefined;
+                    Object.defineProperty(e, n, {
+                        value: s.create()
+                    });
+                }
+                return e[n];
+            }
+            function u(e, t) {
+                for (var r = 0; r < t; ++r) e[r] = Math.random() * 255 | 0;
+                return e;
+            }
+            function f(e) {
+                if (typeof Uint8Array === "function") {
+                    var t = new Uint8Array(e);
+                    if (typeof crypto !== "undefined") {
+                        crypto.getRandomValues(t);
+                    } else if (typeof msCrypto !== "undefined") {
+                        msCrypto.getRandomValues(t);
+                    } else {
+                        u(t, e);
+                    }
+                    return t;
+                }
+                return u(new Array(e), e);
+            }
+            function o() {
+                var t = f(e);
+                t[6] = t[6] & 79 | 64;
+                t[8] = t[8] & 191 | 128;
+                var r = "";
+                for (var n = 0; n < e; ++n) {
+                    var i = t[n];
+                    if (n === 4 || n === 6 || n === 8) r += "-";
+                    if (i < 16) r += "0";
+                    r += i.toString(16).toLowerCase();
+                }
+                return r;
+            }
+        }
+        function le(e) {
+            e.__ = undefined;
+            delete e.__;
+            return e;
+        }
+    }));
+})(r || (r = {}));