lakutata 2.0.82 → 2.0.83

package/src/lib/helpers/UniqueArray.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-function UniqueArray(r) {
-    return Array.from(new Set(r));
+function e(e) {
+    return Array.from(new Set(e));
 }
 
-exports.UniqueArray = UniqueArray;
+exports.UniqueArray = e;

package/src/lib/helpers/UniqueArray.mjs

@@ -1,5 +1,5 @@
-function UniqueArray(r) {
+function r(r) {
     return Array.from(new Set(r));
 }
 
-export { UniqueArray };
+export { r as UniqueArray };

package/src/lib/helpers/UnsignedToHex.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-function UnsignedToHex(e, t = 32) {
-    return BigInt(e).toString(16).toUpperCase().padStart(t / 4, "0");
+function t(t, e = 32) {
+    return BigInt(t).toString(16).toUpperCase().padStart(e / 4, "0");
 }
 
-exports.UnsignedToHex = UnsignedToHex;
+exports.UnsignedToHex = t;

package/src/lib/helpers/UnsignedToHex.mjs

@@ -1,5 +1,5 @@
-function UnsignedToHex(n, t = 32) {
-    return BigInt(n).toString(16).toUpperCase().padStart(t / 4, "0");
+function t(t, r = 32) {
+    return BigInt(t).toString(16).toUpperCase().padStart(r / 4, "0");
 }
 
-export { UnsignedToHex };
+export { t as UnsignedToHex };

package/src/lib/ioc/DependencyInjectionContainer.cjs

@@ -14,9 +14,9 @@ const n = require("./Lifetime.cjs");
 
 const i = require("./ListModules.cjs");
 
-const o = require("./LoadModules.cjs");
+const s = require("./LoadModules.cjs");
 
-const s = require("./Resolvers.cjs");
+const o = require("./Resolvers.cjs");
 
 const c = require("./Utils.cjs");
 
@@ -104,7 +104,7 @@ require("./FunctionTokenizer.cjs");
 
 require("../../exceptions/di/LifetimeLockedException.cjs");
 
-function _interopNamespace(e) {
+function f(e) {
     if (e && e.__esModule) return e;
     const r = Object.create(null, {
         [Symbol.toStringTag]: {
@@ -126,42 +126,42 @@ function _interopNamespace(e) {
     return Object.freeze(r);
 }
 
-const d = _interopNamespace(e);
+const d = f(e);
 
-function importModule(e) {
+function j(e) {
     return import(e);
 }
 
 const p = Symbol("familyTree");
 
-const f = Symbol("rollUpRegistrations");
+const q = Symbol("rollUpRegistrations");
 
 const g = "DependencyInjectionContainerCradle";
 
-function createContainer(e = {}) {
-    return createContainerInternal(e);
+function m(e = {}) {
+    return b(e);
 }
 
-function createContainerInternal(e, j, m) {
+function b(e, f, y) {
     e = {
         injectionMode: t.InjectionMode.PROXY,
         strict: false,
         ...e
     };
-    const q = m ?? [];
-    const b = {};
-    const y = new Proxy({
-        [d.inspect.custom]: toStringRepresentationFn
+    const h = y ?? [];
+    const v = {};
+    const O = new Proxy({
+        [d.inspect.custom]: D
     }, {
-        get: (e, r) => resolve(r),
+        get: (e, r) => C(r),
         set: (e, r) => {
             throw new Error(`Attempted setting property "${r}" on container cradle - this is not allowed.`);
         },
         ownKeys() {
-            return Array.from(y);
+            return Array.from(O);
         },
         getOwnPropertyDescriptor(e, r) {
-            const t = rollUpRegistrations();
+            const t = S();
             if (Object.getOwnPropertyDescriptor(t, r)) {
                 return {
                     enumerable: true,
@@ -171,93 +171,93 @@ function createContainerInternal(e, j, m) {
             return undefined;
         }
     });
-    const h = {
+    const P = {
         options: e,
-        cradle: y,
-        inspect,
+        cradle: O,
+        inspect: L,
         cache: new Map,
-        loadModules,
-        createScope,
-        register,
-        build,
-        resolve,
-        hasRegistration,
-        dispose,
-        getRegistration,
-        [d.inspect.custom]: inspect,
-        [f]: rollUpRegistrations,
+        loadModules: x,
+        createScope: E,
+        register: T,
+        build: R,
+        resolve: C,
+        hasRegistration: N,
+        dispose: A,
+        getRegistration: M,
+        [d.inspect.custom]: L,
+        [q]: S,
         get registrations() {
-            return rollUpRegistrations();
+            return S();
         }
     };
-    const v = j ? [ h ].concat(u.As(j)[p]) : [ h ];
-    h[p] = v;
-    const O = c.last(v);
-    return h;
-    function inspect() {
-        return `[DependencyInjectionContainer (${j ? "scoped, " : ""}registrations: ${Object.keys(h.registrations).length})]`;
+    const w = f ? [ P ].concat(u.As(f)[p]) : [ P ];
+    P[p] = w;
+    const I = c.last(w);
+    return P;
+    function L() {
+        return `[DependencyInjectionContainer (${f ? "scoped, " : ""}registrations: ${Object.keys(P.registrations).length})]`;
     }
-    function rollUpRegistrations() {
+    function S() {
         return {
-            ...j && j[f](),
-            ...b
+            ...f && f[q](),
+            ...v
         };
     }
-    function* cradleIterator() {
-        const e = rollUpRegistrations();
+    function* k() {
+        const e = S();
         for (const r in e) {
             yield r;
         }
     }
-    function createScope() {
-        return createContainerInternal(e, h, q);
+    function E() {
+        return b(e, P, h);
     }
-    function register(t, i) {
-        const o = c.nameValueToObject(t, i);
-        const s = [ ...Object.keys(o), ...Object.getOwnPropertySymbols(o) ];
-        for (const t of s) {
-            const i = o[t];
+    function T(t, i) {
+        const s = c.nameValueToObject(t, i);
+        const o = [ ...Object.keys(s), ...Object.getOwnPropertySymbols(s) ];
+        for (const t of o) {
+            const i = s[t];
             if (e.strict && i.lifetime === n.Lifetime.SINGLETON) {
-                if (j) {
+                if (f) {
                     throw new r.DependencyInjectionRegistrationError(t, "Cannot register a singleton on a scoped container.");
                 }
             }
-            b[t] = i;
+            v[t] = i;
         }
-        return h;
+        return P;
     }
-    function toStringRepresentationFn() {
-        return Object.prototype.toString.call(y);
+    function D() {
+        return Object.prototype.toString.call(O);
     }
-    function getRegistration(e) {
-        const r = b[e];
+    function M(e) {
+        const r = v[e];
         if (r) {
             return r;
         }
-        if (j) {
-            return j.getRegistration(e);
+        if (f) {
+            return f.getRegistration(e);
         }
         return null;
     }
-    function resolve(t, i) {
+    function C(t, i) {
         i = i || {};
         try {
-            const o = getRegistration(t);
-            if (q.some((({name: e}) => e === t))) {
-                throw new r.DependencyInjectionResolutionError(t, q, "Cyclic dependencies detected.");
+            const s = M(t);
+            if (h.some((({name: e}) => e === t))) {
+                throw new r.DependencyInjectionResolutionError(t, h, "Cyclic dependencies detected.");
             }
             if (t === "toJSON") {
-                return toStringRepresentationFn;
+                return D;
             }
             if (t === "constructor") {
-                return createContainer;
+                return m;
             }
-            if (!o) {
+            if (!s) {
                 switch (t) {
                   case d.inspect.custom:
                   case "inspect":
                   case "toString":
-                    return toStringRepresentationFn;
+                    return D;
 
                   case Symbol.toStringTag:
                     return g;
@@ -266,37 +266,37 @@ function createContainerInternal(e, j, m) {
                     return undefined;
 
                   case Symbol.iterator:
-                    return cradleIterator;
+                    return k;
                 }
                 if (i.allowUnregistered) {
                     return undefined;
                 }
-                throw new r.DependencyInjectionResolutionError(t, q);
+                throw new r.DependencyInjectionResolutionError(t, h);
             }
-            const s = o.lifetime || n.Lifetime.TRANSIENT;
-            if (e.strict && !o.isLeakSafe) {
-                const e = q.findIndex((({lifetime: e}) => n.isLifetimeLonger(e, s)));
+            const o = s.lifetime || n.Lifetime.TRANSIENT;
+            if (e.strict && !s.isLeakSafe) {
+                const e = h.findIndex((({lifetime: e}) => n.isLifetimeLonger(e, o)));
                 if (e > -1) {
-                    throw new r.DependencyInjectionResolutionError(t, q, `Dependency '${t.toString()}' has a shorter lifetime than its ancestor: '${q[e].name.toString()}'`);
+                    throw new r.DependencyInjectionResolutionError(t, h, `Dependency '${t.toString()}' has a shorter lifetime than its ancestor: '${h[e].name.toString()}'`);
                 }
             }
-            q.push({
+            h.push({
                 name: t,
-                lifetime: s
+                lifetime: o
             });
             let c;
             let u;
-            switch (s) {
+            switch (o) {
               case n.Lifetime.TRANSIENT:
-                u = o.resolve(h);
+                u = s.resolve(P);
                 break;
 
               case n.Lifetime.APPLICATION_SINGLETON:
-                c = O.cache.get(t);
+                c = I.cache.get(t);
                 if (!c) {
-                    u = o.resolve(e.strict ? O : h);
-                    O.cache.set(t, {
-                        resolver: o,
+                    u = s.resolve(e.strict ? I : P);
+                    I.cache.set(t, {
+                        resolver: s,
                         value: u
                     });
                 } else {
@@ -306,75 +306,75 @@ function createContainerInternal(e, j, m) {
 
               case n.Lifetime.MODULE_SINGLETON:
               case n.Lifetime.SINGLETON:
-                c = h.cache.get(t);
+                c = P.cache.get(t);
                 if (c !== undefined) {
                     u = c.value;
                     break;
                 }
-                u = o.resolve(h);
-                h.cache.set(t, {
-                    resolver: o,
+                u = s.resolve(P);
+                P.cache.set(t, {
+                    resolver: s,
                     value: u
                 });
                 break;
 
               case n.Lifetime.SCOPED:
-                c = h.cache.get(t);
+                c = P.cache.get(t);
                 if (c !== undefined) {
                     u = c.value;
                     break;
                 }
-                u = o.resolve(h);
-                h.cache.set(t, {
-                    resolver: o,
+                u = s.resolve(P);
+                P.cache.set(t, {
+                    resolver: s,
                     value: u
                 });
                 break;
 
               default:
-                throw new r.DependencyInjectionResolutionError(t, q, `Unknown lifetime "${o.lifetime}"`);
+                throw new r.DependencyInjectionResolutionError(t, h, `Unknown lifetime "${s.lifetime}"`);
             }
-            q.pop();
+            h.pop();
             if (a.GetObjectLifetime(u.constructor) === n.Lifetime.TRANSIENT) l.AppendObjectWeakRefs(this, u);
             return u;
         } catch (e) {
-            q.length = 0;
+            h.length = 0;
             throw e;
         }
     }
-    function hasRegistration(e) {
-        return !!getRegistration(e);
+    function N(e) {
+        return !!M(e);
     }
-    function build(e, t) {
+    function R(e, t) {
         if (e && e.resolve) {
-            return e.resolve(h);
+            return e.resolve(P);
         }
         const n = "build";
         const i = "targetOrResolver";
         r.DependencyInjectionTypeError.assert(e, n, i, "a registration, function or class", e);
         r.DependencyInjectionTypeError.assert(typeof e === "function", n, i, "a function or class", e);
-        const o = c.isClass(e) ? s.asClass(e, t) : s.asFunction(e, t);
-        return o.resolve(h);
+        const s = c.isClass(e) ? o.asClass(e, t) : o.asFunction(e, t);
+        return s.resolve(P);
     }
-    function loadModules(r, t) {
+    function x(r, t) {
         const n = {
             require: e.require || function(e) {
                 return require(e);
             },
             listModules: i.listModules,
-            container: h
+            container: P
         };
         if (t?.esModules) {
-            n.require = importModule;
-            return o.loadModules(n, r, t).then((() => h));
+            n.require = j;
+            return s.loadModules(n, r, t).then((() => P));
         } else {
-            o.loadModules(n, r, t);
-            return h;
+            s.loadModules(n, r, t);
+            return P;
         }
     }
-    async function dispose() {
-        const e = Array.from(h.cache.entries());
-        h.cache.clear();
+    async function A() {
+        const e = Array.from(P.cache.entries());
+        P.cache.clear();
         return Promise.all(e.map((async ([, e]) => {
             const {resolver: r, value: t} = e;
             const n = r;
@@ -387,4 +387,4 @@ function createContainerInternal(e, j, m) {
     }
 }
 
-exports.createContainer = createContainer;
+exports.createContainer = m;