lakutata 2.0.96 → 2.0.98

package/src/components/entrypoint/Entrypoint.cjs

@@ -1,396 +1,2035 @@
-/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+/* Build Date: Wed Nov 26 2025 13:02:50 GMT+0800 (China Standard Time) */
 "use strict";
 
 Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-const e = require("../../../vendor/Package.internal.135.cjs");
+const t = require("../../../vendor/Package.internal.3.cjs");
 
-const t = require("../../lib/core/Component.cjs");
+const e = require("../../lib/core/Component.cjs");
 
 const r = require("../../decorators/di/Configurable.cjs");
 
 const n = require("../../lib/base/internal/ControllerEntrypoint.cjs");
 
-const i = require("../../lib/base/internal/PatternManager.cjs");
+const o = require("../../lib/base/internal/PatternManager.cjs");
 
-const o = require("./lib/Controller.cjs");
+const a = require("./lib/Controller.cjs");
 
-const s = require("../../lib/helpers/As.cjs");
+const i = require("../../lib/helpers/As.cjs");
 
 const c = require("./exceptions/ControllerActionNotFoundException.cjs");
 
-const a = require("../../exceptions/DestroyRuntimeContainerException.cjs");
+const s = require("../../exceptions/DestroyRuntimeContainerException.cjs");
 
-const l = require("../../lib/helpers/GetObjectPropertyPaths.cjs");
+const u = require("../../lib/helpers/GetObjectPropertyPaths.cjs");
 
-const u = require("../../../vendor/Package.internal.193.cjs");
+const l = require("../../../vendor/Package.internal.2.cjs");
 
 const p = require("../../lib/helpers/UniqueArray.cjs");
 
-const d = require("../../lib/core/DTO.cjs");
+const f = require("../../../vendor/Package.internal.7.cjs");
 
-const h = require("../../decorators/di/Lifetime.cjs");
+const v = require("../../decorators/di/Lifetime.cjs");
 
-const j = require("../../../vendor/Package.internal.133.cjs");
+const d = require("./exceptions/DuplicateActionNameException.cjs");
 
-const g = require("./exceptions/DuplicateActionNameException.cjs");
+const h = require("./lib/AccessControl.cjs");
 
-const b = require("./lib/AccessControl.cjs");
+const y = require("../../lib/base/Context.cjs");
 
-const q = require("../../lib/base/Context.cjs");
+const b = require("./lib/AccessControlRule.cjs");
 
-const y = require("./lib/AccessControlRule.cjs");
+const j = require("./exceptions/InvalidActionGroupException.cjs");
 
-const A = require("./exceptions/InvalidActionGroupException.cjs");
+const g = require("../../lib/context/CLIContext.cjs");
 
-const C = require("../../lib/context/CLIContext.cjs");
+const A = require("../../lib/context/HTTPContext.cjs");
 
-const v = require("../../lib/context/HTTPContext.cjs");
+const m = require("../../lib/context/ServiceContext.cjs");
 
-const P = require("../../lib/context/ServiceContext.cjs");
+require("../../../vendor/Package.internal.4.cjs");
+
+require("../../lib/base/async-constructor/AsyncConstructor.cjs");
+
+require("../../lib/base/async-constructor/Append.cjs");
+
+require("../../lib/helpers/IsPromiseLike.cjs");
+
+require("../../lib/helpers/IsPromise.cjs");
+
+require("util/types");
+
+require("../../exceptions/MethodNotFoundException.cjs");
+
+require("../../lib/base/abstracts/Exception.cjs");
+
+require("../../lib/base/internal/BasicInfo.cjs");
+
+require("../../../vendor/Package.internal.5.cjs");
+
+require("../../../vendor/Package.internal.6.cjs");
+
+require("../../lib/base/internal/ThrowWarning.cjs");
+
+require("../../lib/helpers/Templating.cjs");
+
+require("../../lib/base/internal/CamelCase.cjs");
+
+require("../../lib/helpers/NoCase.cjs");
+
+require("../../lib/ioc/DependencyInjectionContainer.cjs");
+
+require("util");
+
+require("../../lib/ioc/Errors.cjs");
+
+require("../../exceptions/di/DependencyInjectionException.cjs");
+
+require("../../lib/base/internal/ConstructorSymbol.cjs");
+
+require("../../constants/DIMetadataKey.cjs");
+
+require("../../../vendor/Package.internal.1.cjs");
+
+require("node:crypto");
+
+require("../../lib/base/internal/DataValidator.cjs");
+
+require("node:util/types");
+
+require("../../lib/validation/VLD.cjs");
+
+require("url");
+
+require("../../exceptions/dto/InvalidValueException.cjs");
 
 require("../../../vendor/Package.internal.8.cjs");
 
-require("../../lib/base/BaseObject.cjs");
+require("../../lib/helpers/IsHtml.cjs");
+
+require("../../lib/helpers/IsXML.cjs");
+
+require("../../constants/DTOMetadataKey.cjs");
+
+require("../../lib/helpers/ObjectConstructor.cjs");
+
+require("../../lib/helpers/ObjectParentConstructors.cjs");
+
+require("../../lib/helpers/ObjectParentConstructor.cjs");
+
+require("../../lib/helpers/ObjectPrototype.cjs");
+
+require("../../lib/ioc/InjectionMode.cjs");
+
+require("../../lib/ioc/Lifetime.cjs");
+
+require("../../lib/ioc/ListModules.cjs");
+
+require("os");
+
+require("path");
+
+require("stream");
+
+require("events");
+
+require("fs");
+
+require("../../lib/ioc/Utils.cjs");
+
+require("../../lib/ioc/FunctionTokenizer.cjs");
+
+require("../../lib/ioc/LoadModules.cjs");
+
+require("../../lib/ioc/Resolvers.cjs");
+
+require("../../lib/ioc/ParamParser.cjs");
+
+require("../../lib/base/internal/ObjectLifetime.cjs");
+
+require("../../exceptions/di/LifetimeLockedException.cjs");
+
+require("../../lib/base/internal/ObjectWeakRefs.cjs");
+
+require("../../lib/base/internal/ConfigurableRecordsInjection.cjs");
+
+require("../../lib/base/internal/ObjectConfiguration.cjs");
+
+require("../../lib/base/internal/ObjectInjection.cjs");
+
+require("../../lib/base/internal/ObjectContainer.cjs");
+
+require("../../lib/helpers/DevNull.cjs");
+
+require("../../decorators/dto/Expect.cjs");
+
+require("../../decorators/dto/IndexSignature.cjs");
+
+require("../../decorators/dto/Accept.cjs");
+
+require("../../lib/base/internal/MethodValidation.cjs");
+
+require("../../exceptions/dto/InvalidMethodAcceptException.cjs");
+
+require("../../exceptions/dto/InvalidMethodReturnException.cjs");
+
+require("../../lib/helpers/IsEmptyObject.cjs");
+
+require("../../lib/base/EventEmitter.cjs");
+
+require("../../lib/core/Provider.cjs");
+
+require("../../lib/helpers/ObjectHash.cjs");
+
+require("crypto");
+
+require("../../lib/helpers/GetObjectNestingDepth.cjs");
+
+require("../../exceptions/InvalidActionPatternDepthException.cjs");
+
+require("../../lib/base/internal/StringifyPattern.cjs");
+
+require("../../../vendor/Package.internal.54.cjs");
+
+require("../../../vendor/Package.internal.542.cjs");
+
+require("node:http");
+
+require("./exceptions/AccessDenyException.cjs");
+
+function _(t) {
+    return t != null && typeof t === "object" && Array.isArray(t) === false;
+}
+
+const w = Object.freeze(Object.defineProperty({
+    __proto__: null,
+    default: _
+}, Symbol.toStringTag, {
+    value: "Module"
+}));
+
+const C = l.getAugmentedNamespace(w);
+
+var x = function t(e) {
+    return e != null && typeof e === "object" && Array.isArray(e) === false;
+};
+
+const O = x;
+
+var I = function(t, e, r) {
+    if (!O(r)) {
+        r = {
+            default: r
+        };
+    }
+    if (!S(t)) {
+        return typeof r.default !== "undefined" ? r.default : t;
+    }
+    if (typeof e === "number") {
+        e = String(e);
+    }
+    const n = Array.isArray(e);
+    const o = typeof e === "string";
+    const a = r.separator || ".";
+    const i = r.joinChar || (typeof a === "string" ? a : ".");
+    if (!o && !n) {
+        return t;
+    }
+    if (o && e in t) {
+        return P(e, t, r) ? t[e] : r.default;
+    }
+    let c = n ? e : E(e, a, r);
+    let s = c.length;
+    let u = 0;
+    do {
+        let e = c[u];
+        if (typeof e === "number") {
+            e = String(e);
+        }
+        while (e && e.slice(-1) === "\\") {
+            e = q([ e.slice(0, -1), c[++u] || "" ], i, r);
+        }
+        if (e in t) {
+            if (!P(e, t, r)) {
+                return r.default;
+            }
+            t = t[e];
+        } else {
+            let n = false;
+            let o = u + 1;
+            while (o < s) {
+                e = q([ e, c[o++] ], i, r);
+                if (n = e in t) {
+                    if (!P(e, t, r)) {
+                        return r.default;
+                    }
+                    t = t[e];
+                    u = o - 1;
+                    break;
+                }
+            }
+            if (!n) {
+                return r.default;
+            }
+        }
+    } while (++u < s && S(t));
+    if (u === s) {
+        return t;
+    }
+    return r.default;
+};
+
+function q(t, e, r) {
+    if (typeof r.join === "function") {
+        return r.join(t);
+    }
+    return t[0] + e + t[1];
+}
+
+function E(t, e, r) {
+    if (typeof r.split === "function") {
+        return r.split(t);
+    }
+    return t.split(e);
+}
+
+function P(t, e, r) {
+    if (typeof r.isValid === "function") {
+        return r.isValid(t, e);
+    }
+    return true;
+}
+
+function S(t) {
+    return O(t) || Array.isArray(t) || typeof t === "function";
+}
+
+var M = Object.prototype.toString;
+
+var T = function t(e) {
+    if (e === void 0) return "undefined";
+    if (e === null) return "null";
+    var r = typeof e;
+    if (r === "boolean") return "boolean";
+    if (r === "string") return "string";
+    if (r === "number") return "number";
+    if (r === "symbol") return "symbol";
+    if (r === "function") {
+        return F(e) ? "generatorfunction" : "function";
+    }
+    if (k(e)) return "array";
+    if (U(e)) return "buffer";
+    if (H(e)) return "arguments";
+    if (L(e)) return "date";
+    if (G(e)) return "error";
+    if (N(e)) return "regexp";
+    switch (D(e)) {
+      case "Symbol":
+        return "symbol";
+
+      case "Promise":
+        return "promise";
+
+      case "WeakMap":
+        return "weakmap";
+
+      case "WeakSet":
+        return "weakset";
+
+      case "Map":
+        return "map";
+
+      case "Set":
+        return "set";
+
+      case "Int8Array":
+        return "int8array";
+
+      case "Uint8Array":
+        return "uint8array";
+
+      case "Uint8ClampedArray":
+        return "uint8clampedarray";
+
+      case "Int16Array":
+        return "int16array";
+
+      case "Uint16Array":
+        return "uint16array";
+
+      case "Int32Array":
+        return "int32array";
+
+      case "Uint32Array":
+        return "uint32array";
+
+      case "Float32Array":
+        return "float32array";
+
+      case "Float64Array":
+        return "float64array";
+    }
+    if (z(e)) {
+        return "generator";
+    }
+    r = M.call(e);
+    switch (r) {
+      case "[object Object]":
+        return "object";
+
+      case "[object Map Iterator]":
+        return "mapiterator";
+
+      case "[object Set Iterator]":
+        return "setiterator";
+
+      case "[object String Iterator]":
+        return "stringiterator";
+
+      case "[object Array Iterator]":
+        return "arrayiterator";
+    }
+    return r.slice(8, -1).toLowerCase().replace(/\s/g, "");
+};
+
+function D(t) {
+    return typeof t.constructor === "function" ? t.constructor.name : null;
+}
+
+function k(t) {
+    if (Array.isArray) return Array.isArray(t);
+    return t instanceof Array;
+}
+
+function G(t) {
+    return t instanceof Error || typeof t.message === "string" && t.constructor && typeof t.constructor.stackTraceLimit === "number";
+}
+
+function L(t) {
+    if (t instanceof Date) return true;
+    return typeof t.toDateString === "function" && typeof t.getDate === "function" && typeof t.setDate === "function";
+}
+
+function N(t) {
+    if (t instanceof RegExp) return true;
+    return typeof t.flags === "string" && typeof t.ignoreCase === "boolean" && typeof t.multiline === "boolean" && typeof t.global === "boolean";
+}
+
+function F(t, e) {
+    return D(t) === "GeneratorFunction";
+}
+
+function z(t) {
+    return typeof t.throw === "function" && typeof t.return === "function" && typeof t.next === "function";
+}
+
+function H(t) {
+    try {
+        if (typeof t.length === "number" && typeof t.callee === "function") {
+            return true;
+        }
+    } catch (t) {
+        if (t.message.indexOf("callee") !== -1) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function U(t) {
+    if (t.constructor && typeof t.constructor.isBuffer === "function") {
+        return t.constructor.isBuffer(t);
+    }
+    return false;
+}
+
+const B = T;
+
+var R = function t(e) {
+    switch (B(e)) {
+      case "boolean":
+      case "date":
+      case "function":
+      case "null":
+      case "number":
+        return true;
+
+      case "undefined":
+        return false;
+
+      case "regexp":
+        return e.source !== "(?:)" && e.source !== "";
+
+      case "buffer":
+        return e.toString() !== "";
+
+      case "error":
+        return e.message !== "";
+
+      case "string":
+      case "arguments":
+        return e.length !== 0;
+
+      case "file":
+      case "map":
+      case "set":
+        return e.size !== 0;
+
+      case "array":
+      case "object":
+        for (const r of Object.keys(e)) {
+            if (t(e[r])) {
+                return true;
+            }
+        }
+        return false;
+
+      default:
+        {
+            return true;
+        }
+    }
+};
+
+const V = I;
+
+const W = R;
+
+var $ = function(t, e, r) {
+    if (K(t) && (typeof e === "string" || Array.isArray(e))) {
+        return W(V(t, e, r));
+    }
+    return false;
+};
+
+function K(t) {
+    return t != null && (typeof t === "object" || typeof t === "function" || Array.isArray(t));
+}
+
+var X = C;
+
+var J = $;
+
+const Q = t => t === "__proto__" || t === "constructor" || t === "prototype";
+
+const Y = t => {
+    if (Q(t)) {
+        throw new Error(`Cannot set unsafe key: "${t}"`);
+    }
+};
+
+var Z = function t(e, r) {
+    if (!X(e)) {
+        throw new TypeError("expected an object.");
+    }
+    var n = Array.isArray(r);
+    if (!n && e.hasOwnProperty(r)) {
+        delete e[r];
+        return true;
+    }
+    if (J(e, r)) {
+        var o = n ? r.slice() : r.split(".");
+        var a = o.pop();
+        while (o.length && o[o.length - 1].slice(-1) === "\\") {
+            a = o.pop().slice(0, -1) + "." + a;
+        }
+        while (o.length) {
+            r = o.shift();
+            Y(r);
+            e = e[r];
+        }
+        return delete e[a];
+    }
+    return true;
+};
+
+const tt = l.getDefaultExportFromCjs(Z);
+
+function et() {
+    this.__data__ = [];
+    this.size = 0;
+}
+
+var rt = et;
+
+function nt(t, e) {
+    return t === e || t !== t && e !== e;
+}
+
+var ot = nt;
+
+var at = ot;
+
+function it(t, e) {
+    var r = t.length;
+    while (r--) {
+        if (at(t[r][0], e)) {
+            return r;
+        }
+    }
+    return -1;
+}
+
+var ct = it;
+
+var st = ct;
+
+var ut = Array.prototype;
+
+var lt = ut.splice;
+
+function pt(t) {
+    var e = this.__data__, r = st(e, t);
+    if (r < 0) {
+        return false;
+    }
+    var n = e.length - 1;
+    if (r == n) {
+        e.pop();
+    } else {
+        lt.call(e, r, 1);
+    }
+    --this.size;
+    return true;
+}
+
+var ft = pt;
+
+var vt = ct;
+
+function dt(t) {
+    var e = this.__data__, r = vt(e, t);
+    return r < 0 ? undefined : e[r][1];
+}
+
+var ht = dt;
+
+var yt = ct;
+
+function bt(t) {
+    return yt(this.__data__, t) > -1;
+}
+
+var jt = bt;
+
+var gt = ct;
+
+function At(t, e) {
+    var r = this.__data__, n = gt(r, t);
+    if (n < 0) {
+        ++this.size;
+        r.push([ t, e ]);
+    } else {
+        r[n][1] = e;
+    }
+    return this;
+}
+
+var mt = At;
+
+var _t = rt, wt = ft, Ct = ht, xt = jt, Ot = mt;
+
+function It(t) {
+    var e = -1, r = t == null ? 0 : t.length;
+    this.clear();
+    while (++e < r) {
+        var n = t[e];
+        this.set(n[0], n[1]);
+    }
+}
+
+It.prototype.clear = _t;
+
+It.prototype["delete"] = wt;
+
+It.prototype.get = Ct;
+
+It.prototype.has = xt;
+
+It.prototype.set = Ot;
+
+var qt = It;
+
+var Et = qt;
+
+function Pt() {
+    this.__data__ = new Et;
+    this.size = 0;
+}
+
+var St = Pt;
+
+function Mt(t) {
+    var e = this.__data__, r = e["delete"](t);
+    this.size = e.size;
+    return r;
+}
+
+var Tt = Mt;
+
+function Dt(t) {
+    return this.__data__.get(t);
+}
+
+var kt = Dt;
+
+function Gt(t) {
+    return this.__data__.has(t);
+}
+
+var Lt = Gt;
+
+var Nt = typeof l.commonjsGlobal == "object" && l.commonjsGlobal && l.commonjsGlobal.Object === Object && l.commonjsGlobal;
+
+var Ft = Nt;
+
+var zt = Ft;
+
+var Ht = typeof self == "object" && self && self.Object === Object && self;
+
+var Ut = zt || Ht || Function("return this")();
+
+var Bt = Ut;
+
+var Rt = Bt;
+
+var Vt = Rt.Symbol;
+
+var Wt = Vt;
+
+var $t = Wt;
+
+var Kt = Object.prototype;
+
+var Xt = Kt.hasOwnProperty;
+
+var Jt = Kt.toString;
+
+var Qt = $t ? $t.toStringTag : undefined;
+
+function Yt(t) {
+    var e = Xt.call(t, Qt), r = t[Qt];
+    try {
+        t[Qt] = undefined;
+        var n = true;
+    } catch (t) {}
+    var o = Jt.call(t);
+    if (n) {
+        if (e) {
+            t[Qt] = r;
+        } else {
+            delete t[Qt];
+        }
+    }
+    return o;
+}
+
+var Zt = Yt;
+
+var te = Object.prototype;
+
+var ee = te.toString;
+
+function re(t) {
+    return ee.call(t);
+}
+
+var ne = re;
+
+var oe = Wt, ae = Zt, ie = ne;
+
+var ce = "[object Null]", se = "[object Undefined]";
+
+var ue = oe ? oe.toStringTag : undefined;
+
+function le(t) {
+    if (t == null) {
+        return t === undefined ? se : ce;
+    }
+    return ue && ue in Object(t) ? ae(t) : ie(t);
+}
+
+var pe = le;
+
+function fe(t) {
+    var e = typeof t;
+    return t != null && (e == "object" || e == "function");
+}
+
+var ve = fe;
+
+var de = pe, he = ve;
+
+var ye = "[object AsyncFunction]", be = "[object Function]", je = "[object GeneratorFunction]", ge = "[object Proxy]";
+
+function Ae(t) {
+    if (!he(t)) {
+        return false;
+    }
+    var e = de(t);
+    return e == be || e == je || e == ye || e == ge;
+}
+
+var me = Ae;
+
+var _e = Bt;
+
+var we = _e["__core-js_shared__"];
+
+var Ce = we;
+
+var xe = Ce;
+
+var Oe = function() {
+    var t = /[^.]+$/.exec(xe && xe.keys && xe.keys.IE_PROTO || "");
+    return t ? "Symbol(src)_1." + t : "";
+}();
+
+function Ie(t) {
+    return !!Oe && Oe in t;
+}
+
+var qe = Ie;
+
+var Ee = Function.prototype;
+
+var Pe = Ee.toString;
+
+function Se(t) {
+    if (t != null) {
+        try {
+            return Pe.call(t);
+        } catch (t) {}
+        try {
+            return t + "";
+        } catch (t) {}
+    }
+    return "";
+}
+
+var Me = Se;
+
+var Te = me, De = qe, ke = ve, Ge = Me;
+
+var Le = /[\\^$.*+?()[\]{}|]/g;
+
+var Ne = /^\[object .+?Constructor\]$/;
+
+var Fe = Function.prototype, ze = Object.prototype;
+
+var He = Fe.toString;
+
+var Ue = ze.hasOwnProperty;
+
+var Be = RegExp("^" + He.call(Ue).replace(Le, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+
+function Re(t) {
+    if (!ke(t) || De(t)) {
+        return false;
+    }
+    var e = Te(t) ? Be : Ne;
+    return e.test(Ge(t));
+}
+
+var Ve = Re;
+
+function We(t, e) {
+    return t == null ? undefined : t[e];
+}
+
+var $e = We;
+
+var Ke = Ve, Xe = $e;
+
+function Je(t, e) {
+    var r = Xe(t, e);
+    return Ke(r) ? r : undefined;
+}
+
+var Qe = Je;
+
+var Ye = Qe, Ze = Bt;
+
+var tr = Ye(Ze, "Map");
+
+var er = tr;
+
+var rr = Qe;
+
+var nr = rr(Object, "create");
+
+var or = nr;
+
+var ar = or;
+
+function ir() {
+    this.__data__ = ar ? ar(null) : {};
+    this.size = 0;
+}
+
+var cr = ir;
+
+function sr(t) {
+    var e = this.has(t) && delete this.__data__[t];
+    this.size -= e ? 1 : 0;
+    return e;
+}
+
+var ur = sr;
+
+var lr = or;
+
+var pr = "__lodash_hash_undefined__";
+
+var fr = Object.prototype;
+
+var vr = fr.hasOwnProperty;
+
+function dr(t) {
+    var e = this.__data__;
+    if (lr) {
+        var r = e[t];
+        return r === pr ? undefined : r;
+    }
+    return vr.call(e, t) ? e[t] : undefined;
+}
+
+var hr = dr;
+
+var yr = or;
+
+var br = Object.prototype;
+
+var jr = br.hasOwnProperty;
+
+function gr(t) {
+    var e = this.__data__;
+    return yr ? e[t] !== undefined : jr.call(e, t);
+}
+
+var Ar = gr;
+
+var mr = or;
+
+var _r = "__lodash_hash_undefined__";
+
+function wr(t, e) {
+    var r = this.__data__;
+    this.size += this.has(t) ? 0 : 1;
+    r[t] = mr && e === undefined ? _r : e;
+    return this;
+}
+
+var Cr = wr;
+
+var xr = cr, Or = ur, Ir = hr, qr = Ar, Er = Cr;
+
+function Pr(t) {
+    var e = -1, r = t == null ? 0 : t.length;
+    this.clear();
+    while (++e < r) {
+        var n = t[e];
+        this.set(n[0], n[1]);
+    }
+}
+
+Pr.prototype.clear = xr;
+
+Pr.prototype["delete"] = Or;
+
+Pr.prototype.get = Ir;
+
+Pr.prototype.has = qr;
+
+Pr.prototype.set = Er;
+
+var Sr = Pr;
+
+var Mr = Sr, Tr = qt, Dr = er;
+
+function kr() {
+    this.size = 0;
+    this.__data__ = {
+        hash: new Mr,
+        map: new (Dr || Tr),
+        string: new Mr
+    };
+}
+
+var Gr = kr;
+
+function Lr(t) {
+    var e = typeof t;
+    return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? t !== "__proto__" : t === null;
+}
+
+var Nr = Lr;
+
+var Fr = Nr;
+
+function zr(t, e) {
+    var r = t.__data__;
+    return Fr(e) ? r[typeof e == "string" ? "string" : "hash"] : r.map;
+}
+
+var Hr = zr;
+
+var Ur = Hr;
+
+function Br(t) {
+    var e = Ur(this, t)["delete"](t);
+    this.size -= e ? 1 : 0;
+    return e;
+}
+
+var Rr = Br;
+
+var Vr = Hr;
+
+function Wr(t) {
+    return Vr(this, t).get(t);
+}
+
+var $r = Wr;
+
+var Kr = Hr;
+
+function Xr(t) {
+    return Kr(this, t).has(t);
+}
+
+var Jr = Xr;
+
+var Qr = Hr;
+
+function Yr(t, e) {
+    var r = Qr(this, t), n = r.size;
+    r.set(t, e);
+    this.size += r.size == n ? 0 : 1;
+    return this;
+}
+
+var Zr = Yr;
+
+var tn = Gr, en = Rr, rn = $r, nn = Jr, on = Zr;
+
+function an(t) {
+    var e = -1, r = t == null ? 0 : t.length;
+    this.clear();
+    while (++e < r) {
+        var n = t[e];
+        this.set(n[0], n[1]);
+    }
+}
+
+an.prototype.clear = tn;
+
+an.prototype["delete"] = en;
+
+an.prototype.get = rn;
+
+an.prototype.has = nn;
+
+an.prototype.set = on;
+
+var cn = an;
+
+var sn = qt, un = er, ln = cn;
+
+var pn = 200;
+
+function fn(t, e) {
+    var r = this.__data__;
+    if (r instanceof sn) {
+        var n = r.__data__;
+        if (!un || n.length < pn - 1) {
+            n.push([ t, e ]);
+            this.size = ++r.size;
+            return this;
+        }
+        r = this.__data__ = new ln(n);
+    }
+    r.set(t, e);
+    this.size = r.size;
+    return this;
+}
+
+var vn = fn;
+
+var dn = qt, hn = St, yn = Tt, bn = kt, jn = Lt, gn = vn;
+
+function An(t) {
+    var e = this.__data__ = new dn(t);
+    this.size = e.size;
+}
+
+An.prototype.clear = hn;
+
+An.prototype["delete"] = yn;
+
+An.prototype.get = bn;
+
+An.prototype.has = jn;
+
+An.prototype.set = gn;
 
-require("../../lib/base/async-constructor/AsyncConstructor.cjs");
+var mn = An;
 
-require("../../lib/base/async-constructor/Append.cjs");
+function _n(t, e) {
+    var r = -1, n = t == null ? 0 : t.length;
+    while (++r < n) {
+        if (e(t[r], r, t) === false) {
+            break;
+        }
+    }
+    return t;
+}
 
-require("../../lib/helpers/IsPromiseLike.cjs");
+var wn = _n;
 
-require("../../lib/helpers/IsPromise.cjs");
+var Cn = Qe;
 
-require("util/types");
+var xn = function() {
+    try {
+        var t = Cn(Object, "defineProperty");
+        t({}, "", {});
+        return t;
+    } catch (t) {}
+}();
 
-require("../../exceptions/MethodNotFoundException.cjs");
+var On = xn;
 
-require("../../lib/base/abstracts/Exception.cjs");
+var In = On;
 
-require("../../lib/base/internal/BasicInfo.cjs");
+function qn(t, e, r) {
+    if (e == "__proto__" && In) {
+        In(t, e, {
+            configurable: true,
+            enumerable: true,
+            value: r,
+            writable: true
+        });
+    } else {
+        t[e] = r;
+    }
+}
 
-require("../../../vendor/Package.internal.139.cjs");
+var En = qn;
 
-require("../../../vendor/Package.internal.138.cjs");
+var Pn = En, Sn = ot;
 
-require("../../../vendor/Package.internal.28.cjs");
+var Mn = Object.prototype;
 
-require("../../lib/base/internal/ThrowWarning.cjs");
+var Tn = Mn.hasOwnProperty;
 
-require("../../lib/helpers/Templating.cjs");
+function Dn(t, e, r) {
+    var n = t[e];
+    if (!(Tn.call(t, e) && Sn(n, r)) || r === undefined && !(e in t)) {
+        Pn(t, e, r);
+    }
+}
 
-require("../../lib/base/internal/CamelCase.cjs");
+var kn = Dn;
 
-require("../../lib/helpers/NoCase.cjs");
+var Gn = kn, Ln = En;
 
-require("../../lib/core/Container.cjs");
+function Nn(t, e, r, n) {
+    var o = !r;
+    r || (r = {});
+    var a = -1, i = e.length;
+    while (++a < i) {
+        var c = e[a];
+        var s = n ? n(r[c], t[c], c, r, t) : undefined;
+        if (s === undefined) {
+            s = t[c];
+        }
+        if (o) {
+            Ln(r, c, s);
+        } else {
+            Gn(r, c, s);
+        }
+    }
+    return r;
+}
 
-require("../../lib/ioc/DependencyInjectionContainer.cjs");
+var Fn = Nn;
 
-require("util");
+function zn(t, e) {
+    var r = -1, n = Array(t);
+    while (++r < t) {
+        n[r] = e(r);
+    }
+    return n;
+}
 
-require("../../lib/ioc/Errors.cjs");
+var Hn = zn;
 
-require("../../exceptions/di/DependencyInjectionException.cjs");
+function Un(t) {
+    return t != null && typeof t == "object";
+}
 
-require("../../lib/base/internal/ConstructorSymbol.cjs");
+var Bn = Un;
 
-require("../../constants/DIMetadataKey.cjs");
+var Rn = pe, Vn = Bn;
 
-require("../../../vendor/Package.internal.175.cjs");
+var Wn = "[object Arguments]";
 
-require("node:crypto");
+function $n(t) {
+    return Vn(t) && Rn(t) == Wn;
+}
 
-require("../../lib/helpers/IsSymbol.cjs");
+var Kn = $n;
 
-require("../../lib/ioc/InjectionMode.cjs");
+var Xn = Kn, Jn = Bn;
 
-require("../../lib/ioc/Lifetime.cjs");
+var Qn = Object.prototype;
 
-require("../../lib/ioc/ListModules.cjs");
+var Yn = Qn.hasOwnProperty;
 
-require("../../../vendor/Package.internal.92.cjs");
+var Zn = Qn.propertyIsEnumerable;
 
-require("os");
+var to = Xn(function() {
+    return arguments;
+}()) ? Xn : function(t) {
+    return Jn(t) && Yn.call(t, "callee") && !Zn.call(t, "callee");
+};
 
-require("path");
+var eo = to;
 
-require("../../../vendor/Package.internal.93.cjs");
+var ro = Array.isArray;
 
-require("../../../vendor/Package.internal.125.cjs");
+var no = ro;
 
-require("../../../vendor/Package.internal.94.cjs");
+var oo = {
+    exports: {}
+};
 
-require("../../../vendor/Package.internal.45.cjs");
+function ao() {
+    return false;
+}
 
-require("../../../vendor/Package.internal.46.cjs");
+var io = ao;
 
-require("../../../vendor/Package.internal.126.cjs");
+oo.exports;
 
-require("../../../vendor/Package.internal.47.cjs");
+(function(t, e) {
+    var r = Bt, n = io;
+    var o = e && !e.nodeType && e;
+    var a = o && "object" == "object" && t && !t.nodeType && t;
+    var i = a && a.exports === o;
+    var c = i ? r.Buffer : undefined;
+    var s = c ? c.isBuffer : undefined;
+    var u = s || n;
+    t.exports = u;
+})(oo, oo.exports);
 
-require("../../../vendor/Package.internal.95.cjs");
+var co = oo.exports;
 
-require("stream");
+var so = 9007199254740991;
 
-require("../../../vendor/Package.internal.16.cjs");
+var uo = /^(?:0|[1-9]\d*)$/;
 
-require("events");
+function lo(t, e) {
+    var r = typeof t;
+    e = e == null ? so : e;
+    return !!e && (r == "number" || r != "symbol" && uo.test(t)) && (t > -1 && t % 1 == 0 && t < e);
+}
 
-require("fs");
+var po = lo;
 
-require("../../../vendor/Package.internal.17.cjs");
+var fo = 9007199254740991;
 
-require("../../../vendor/Package.internal.170.cjs");
+function vo(t) {
+    return typeof t == "number" && t > -1 && t % 1 == 0 && t <= fo;
+}
 
-require("../../../vendor/Package.internal.18.cjs");
+var ho = vo;
 
-require("../../../vendor/Package.internal.99.cjs");
+var yo = pe, bo = ho, jo = Bn;
 
-require("../../lib/ioc/Utils.cjs");
+var go = "[object Arguments]", Ao = "[object Array]", mo = "[object Boolean]", _o = "[object Date]", wo = "[object Error]", Co = "[object Function]", xo = "[object Map]", Oo = "[object Number]", Io = "[object Object]", qo = "[object RegExp]", Eo = "[object Set]", Po = "[object String]", So = "[object WeakMap]";
 
-require("../../lib/ioc/FunctionTokenizer.cjs");
+var Mo = "[object ArrayBuffer]", To = "[object DataView]", Do = "[object Float32Array]", ko = "[object Float64Array]", Go = "[object Int8Array]", Lo = "[object Int16Array]", No = "[object Int32Array]", Fo = "[object Uint8Array]", zo = "[object Uint8ClampedArray]", Ho = "[object Uint16Array]", Uo = "[object Uint32Array]";
 
-require("../../../vendor/Package.internal.185.cjs");
+var Bo = {};
 
-require("../../lib/ioc/LoadModules.cjs");
+Bo[Do] = Bo[ko] = Bo[Go] = Bo[Lo] = Bo[No] = Bo[Fo] = Bo[zo] = Bo[Ho] = Bo[Uo] = true;
 
-require("url");
+Bo[go] = Bo[Ao] = Bo[Mo] = Bo[mo] = Bo[To] = Bo[_o] = Bo[wo] = Bo[Co] = Bo[xo] = Bo[Oo] = Bo[Io] = Bo[qo] = Bo[Eo] = Bo[Po] = Bo[So] = false;
 
-require("../../lib/ioc/Resolvers.cjs");
+function Ro(t) {
+    return jo(t) && bo(t.length) && !!Bo[yo(t)];
+}
 
-require("../../lib/ioc/ParamParser.cjs");
+var Vo = Ro;
 
-require("../../lib/base/internal/ObjectLifetime.cjs");
+function Wo(t) {
+    return function(e) {
+        return t(e);
+    };
+}
 
-require("../../exceptions/di/LifetimeLockedException.cjs");
+var $o = Wo;
 
-require("../../lib/base/internal/ObjectWeakRefs.cjs");
+var Ko = {
+    exports: {}
+};
 
-require("../../options/LoadObjectOptions.cjs");
+Ko.exports;
 
-require("../../decorators/dto/Expect.cjs");
+(function(t, e) {
+    var r = Ft;
+    var n = e && !e.nodeType && e;
+    var o = n && "object" == "object" && t && !t.nodeType && t;
+    var a = o && o.exports === n;
+    var i = a && r.process;
+    var c = function() {
+        try {
+            var t = o && o.require && o.require("util").types;
+            if (t) {
+                return t;
+            }
+            return i && i.binding && i.binding("util");
+        } catch (t) {}
+    }();
+    t.exports = c;
+})(Ko, Ko.exports);
 
-require("../../lib/base/internal/ObjectSchemaValidation.cjs");
+var Xo = Ko.exports;
 
-require("../../constants/DTOMetadataKey.cjs");
+var Jo = Vo, Qo = $o, Yo = Xo;
 
-require("../../lib/base/internal/DataValidator.cjs");
+var Zo = Yo && Yo.isTypedArray;
 
-require("node:util/types");
+var ta = Zo ? Qo(Zo) : Jo;
 
-require("../../../vendor/Package.internal.62.cjs");
+var ea = ta;
 
-require("../../lib/validation/VLD.cjs");
+var ra = Hn, na = eo, oa = no, aa = co, ia = po, ca = ea;
 
-require("../../../vendor/Package.internal.131.cjs");
+var sa = Object.prototype;
 
-require("../../../vendor/Package.internal.9.cjs");
+var ua = sa.hasOwnProperty;
 
-require("../../../vendor/Package.internal.23.cjs");
+function la(t, e) {
+    var r = oa(t), n = !r && na(t), o = !r && !n && aa(t), a = !r && !n && !o && ca(t), i = r || n || o || a, c = i ? ra(t.length, String) : [], s = c.length;
+    for (var u in t) {
+        if ((e || ua.call(t, u)) && !(i && (u == "length" || o && (u == "offset" || u == "parent") || a && (u == "buffer" || u == "byteLength" || u == "byteOffset") || ia(u, s)))) {
+            c.push(u);
+        }
+    }
+    return c;
+}
 
-require("../../exceptions/dto/InvalidValueException.cjs");
+var pa = la;
 
-require("../../lib/helpers/IsGlobString.cjs");
+var fa = Object.prototype;
 
-require("../../lib/helpers/IsHtml.cjs");
+function va(t) {
+    var e = t && t.constructor, r = typeof e == "function" && e.prototype || fa;
+    return t === r;
+}
 
-require("../../../vendor/Package.internal.120.cjs");
+var da = va;
 
-require("../../lib/helpers/IsXML.cjs");
+function ha(t, e) {
+    return function(r) {
+        return t(e(r));
+    };
+}
 
-require("../../../vendor/Package.internal.97.cjs");
+var ya = ha;
 
-require("../../../vendor/Package.internal.98.cjs");
+var ba = ya;
 
-require("../../lib/helpers/ObjectConstructor.cjs");
+var ja = ba(Object.keys, Object);
 
-require("../../lib/helpers/ObjectParentConstructors.cjs");
+var ga = ja;
 
-require("../../lib/helpers/ObjectParentConstructor.cjs");
+var Aa = da, ma = ga;
 
-require("../../lib/helpers/ObjectPrototype.cjs");
+var _a = Object.prototype;
 
-require("../../decorators/dto/IndexSignature.cjs");
+var wa = _a.hasOwnProperty;
 
-require("../../lib/base/internal/ConfigurableRecordsInjection.cjs");
+function Ca(t) {
+    if (!Aa(t)) {
+        return ma(t);
+    }
+    var e = [];
+    for (var r in Object(t)) {
+        if (wa.call(t, r) && r != "constructor") {
+            e.push(r);
+        }
+    }
+    return e;
+}
 
-require("../../lib/base/internal/ObjectInjection.cjs");
+var xa = Ca;
 
-require("../../decorators/dto/Accept.cjs");
+var Oa = me, Ia = ho;
 
-require("../../lib/base/internal/MethodValidation.cjs");
+function qa(t) {
+    return t != null && Ia(t.length) && !Oa(t);
+}
 
-require("../../exceptions/dto/InvalidMethodAcceptException.cjs");
+var Ea = qa;
 
-require("../../exceptions/dto/InvalidMethodReturnException.cjs");
+var Pa = pa, Sa = xa, Ma = Ea;
 
-require("../../lib/helpers/DevNull.cjs");
+function Ta(t) {
+    return Ma(t) ? Pa(t) : Sa(t);
+}
 
-require("../../lib/helpers/IsEmptyObject.cjs");
+var Da = Ta;
 
-require("../../lib/base/internal/ObjectConfiguration.cjs");
+var ka = Fn, Ga = Da;
 
-require("../../lib/base/internal/ObjectContainer.cjs");
+function La(t, e) {
+    return t && ka(e, Ga(e), t);
+}
 
-require("../../lib/base/internal/ObjectType.cjs");
+var Na = La;
 
-require("../../lib/base/EventEmitter.cjs");
+function Fa(t) {
+    var e = [];
+    if (t != null) {
+        for (var r in Object(t)) {
+            e.push(r);
+        }
+    }
+    return e;
+}
 
-require("../../../vendor/Package.internal.87.cjs");
+var za = Fa;
 
-require("../../lib/core/Provider.cjs");
+var Ha = ve, Ua = da, Ba = za;
 
-require("../../lib/helpers/ObjectHash.cjs");
+var Ra = Object.prototype;
 
-require("../../../vendor/Package.internal.151.cjs");
+var Va = Ra.hasOwnProperty;
 
-require("crypto");
+function Wa(t) {
+    if (!Ha(t)) {
+        return Ba(t);
+    }
+    var e = Ua(t), r = [];
+    for (var n in t) {
+        if (!(n == "constructor" && (e || !Va.call(t, n)))) {
+            r.push(n);
+        }
+    }
+    return r;
+}
 
-require("../../lib/helpers/GetObjectNestingDepth.cjs");
+var $a = Wa;
 
-require("../../exceptions/InvalidActionPatternDepthException.cjs");
+var Ka = pa, Xa = $a, Ja = Ea;
 
-require("../../lib/base/internal/StringifyPattern.cjs");
+function Qa(t) {
+    return Ja(t) ? Ka(t, true) : Xa(t);
+}
+
+var Ya = Qa;
+
+var Za = Fn, ti = Ya;
+
+function ei(t, e) {
+    return t && Za(e, ti(e), t);
+}
+
+var ri = ei;
+
+var ni = {
+    exports: {}
+};
+
+ni.exports;
+
+(function(t, e) {
+    var r = Bt;
+    var n = e && !e.nodeType && e;
+    var o = n && "object" == "object" && t && !t.nodeType && t;
+    var a = o && o.exports === n;
+    var i = a ? r.Buffer : undefined, c = i ? i.allocUnsafe : undefined;
+    function s(t, e) {
+        if (e) {
+            return t.slice();
+        }
+        var r = t.length, n = c ? c(r) : new t.constructor(r);
+        t.copy(n);
+        return n;
+    }
+    t.exports = s;
+})(ni, ni.exports);
+
+var oi = ni.exports;
+
+function ai(t, e) {
+    var r = -1, n = t.length;
+    e || (e = Array(n));
+    while (++r < n) {
+        e[r] = t[r];
+    }
+    return e;
+}
+
+var ii = ai;
 
-require("../../../vendor/Package.internal.181.cjs");
+function ci(t, e) {
+    var r = -1, n = t == null ? 0 : t.length, o = 0, a = [];
+    while (++r < n) {
+        var i = t[r];
+        if (e(i, r, t)) {
+            a[o++] = i;
+        }
+    }
+    return a;
+}
 
-require("../../../vendor/Package.internal.29.cjs");
+var si = ci;
 
-require("../../../vendor/Package.internal.182.cjs");
+function ui() {
+    return [];
+}
 
-require("../../../vendor/Package.internal.194.cjs");
+var li = ui;
 
-require("../../../vendor/Package.internal.156.cjs");
+var pi = si, fi = li;
 
-require("../../../vendor/Package.internal.110.cjs");
+var vi = Object.prototype;
 
-require("../../../vendor/Package.internal.130.cjs");
+var di = vi.propertyIsEnumerable;
 
-require("../../../vendor/Package.internal.116.cjs");
+var hi = Object.getOwnPropertySymbols;
+
+var yi = !hi ? fi : function(t) {
+    if (t == null) {
+        return [];
+    }
+    t = Object(t);
+    return pi(hi(t), function(e) {
+        return di.call(t, e);
+    });
+};
 
-require("../../../vendor/Package.internal.109.cjs");
+var bi = yi;
 
-require("../../../vendor/Package.internal.117.cjs");
+var ji = Fn, gi = bi;
 
-require("../../../vendor/Package.internal.118.cjs");
+function Ai(t, e) {
+    return ji(t, gi(t), e);
+}
 
-require("../../../vendor/Package.internal.132.cjs");
+var mi = Ai;
 
-require("../../../vendor/Package.internal.60.cjs");
+function _i(t, e) {
+    var r = -1, n = e.length, o = t.length;
+    while (++r < n) {
+        t[o + r] = e[r];
+    }
+    return t;
+}
 
-require("./exceptions/AccessDenyException.cjs");
+var wi = _i;
 
-require("node:http");
+var Ci = ya;
+
+var xi = Ci(Object.getPrototypeOf, Object);
+
+var Oi = xi;
+
+var Ii = wi, qi = Oi, Ei = bi, Pi = li;
+
+var Si = Object.getOwnPropertySymbols;
+
+var Mi = !Si ? Pi : function(t) {
+    var e = [];
+    while (t) {
+        Ii(e, Ei(t));
+        t = qi(t);
+    }
+    return e;
+};
+
+var Ti = Mi;
+
+var Di = Fn, ki = Ti;
+
+function Gi(t, e) {
+    return Di(t, ki(t), e);
+}
+
+var Li = Gi;
+
+var Ni = wi, Fi = no;
+
+function zi(t, e, r) {
+    var n = e(t);
+    return Fi(t) ? n : Ni(n, r(t));
+}
+
+var Hi = zi;
+
+var Ui = Hi, Bi = bi, Ri = Da;
+
+function Vi(t) {
+    return Ui(t, Ri, Bi);
+}
 
-const f = e => e;
+var Wi = Vi;
 
-const m = e => e;
+var $i = Hi, Ki = Ti, Xi = Ya;
 
-const I = e => e;
+function Ji(t) {
+    return $i(t, Xi, Ki);
+}
 
-const x = e => e;
+var Qi = Ji;
 
-exports.Entrypoint = class Entrypoint extends t.Component {
+var Yi = Qe, Zi = Bt;
+
+var tc = Yi(Zi, "DataView");
+
+var ec = tc;
+
+var rc = Qe, nc = Bt;
+
+var oc = rc(nc, "Promise");
+
+var ac = oc;
+
+var ic = Qe, cc = Bt;
+
+var sc = ic(cc, "Set");
+
+var uc = sc;
+
+var lc = Qe, pc = Bt;
+
+var fc = lc(pc, "WeakMap");
+
+var vc = fc;
+
+var dc = ec, hc = er, yc = ac, bc = uc, jc = vc, gc = pe, Ac = Me;
+
+var mc = "[object Map]", _c = "[object Object]", wc = "[object Promise]", Cc = "[object Set]", xc = "[object WeakMap]";
+
+var Oc = "[object DataView]";
+
+var Ic = Ac(dc), qc = Ac(hc), Ec = Ac(yc), Pc = Ac(bc), Sc = Ac(jc);
+
+var Mc = gc;
+
+if (dc && Mc(new dc(new ArrayBuffer(1))) != Oc || hc && Mc(new hc) != mc || yc && Mc(yc.resolve()) != wc || bc && Mc(new bc) != Cc || jc && Mc(new jc) != xc) {
+    Mc = function(t) {
+        var e = gc(t), r = e == _c ? t.constructor : undefined, n = r ? Ac(r) : "";
+        if (n) {
+            switch (n) {
+              case Ic:
+                return Oc;
+
+              case qc:
+                return mc;
+
+              case Ec:
+                return wc;
+
+              case Pc:
+                return Cc;
+
+              case Sc:
+                return xc;
+            }
+        }
+        return e;
+    };
+}
+
+var Tc = Mc;
+
+var Dc = Object.prototype;
+
+var kc = Dc.hasOwnProperty;
+
+function Gc(t) {
+    var e = t.length, r = new t.constructor(e);
+    if (e && typeof t[0] == "string" && kc.call(t, "index")) {
+        r.index = t.index;
+        r.input = t.input;
+    }
+    return r;
+}
+
+var Lc = Gc;
+
+var Nc = Bt;
+
+var Fc = Nc.Uint8Array;
+
+var zc = Fc;
+
+var Hc = zc;
+
+function Uc(t) {
+    var e = new t.constructor(t.byteLength);
+    new Hc(e).set(new Hc(t));
+    return e;
+}
+
+var Bc = Uc;
+
+var Rc = Bc;
+
+function Vc(t, e) {
+    var r = e ? Rc(t.buffer) : t.buffer;
+    return new t.constructor(r, t.byteOffset, t.byteLength);
+}
+
+var Wc = Vc;
+
+var $c = /\w*$/;
+
+function Kc(t) {
+    var e = new t.constructor(t.source, $c.exec(t));
+    e.lastIndex = t.lastIndex;
+    return e;
+}
+
+var Xc = Kc;
+
+var Jc = Wt;
+
+var Qc = Jc ? Jc.prototype : undefined, Yc = Qc ? Qc.valueOf : undefined;
+
+function Zc(t) {
+    return Yc ? Object(Yc.call(t)) : {};
+}
+
+var ts = Zc;
+
+var es = Bc;
+
+function rs(t, e) {
+    var r = e ? es(t.buffer) : t.buffer;
+    return new t.constructor(r, t.byteOffset, t.length);
+}
+
+var ns = rs;
+
+var os = Bc, as = Wc, is = Xc, cs = ts, ss = ns;
+
+var us = "[object Boolean]", ls = "[object Date]", ps = "[object Map]", fs = "[object Number]", vs = "[object RegExp]", ds = "[object Set]", hs = "[object String]", ys = "[object Symbol]";
+
+var bs = "[object ArrayBuffer]", js = "[object DataView]", gs = "[object Float32Array]", As = "[object Float64Array]", ms = "[object Int8Array]", _s = "[object Int16Array]", ws = "[object Int32Array]", Cs = "[object Uint8Array]", xs = "[object Uint8ClampedArray]", Os = "[object Uint16Array]", Is = "[object Uint32Array]";
+
+function qs(t, e, r) {
+    var n = t.constructor;
+    switch (e) {
+      case bs:
+        return os(t);
+
+      case us:
+      case ls:
+        return new n(+t);
+
+      case js:
+        return as(t, r);
+
+      case gs:
+      case As:
+      case ms:
+      case _s:
+      case ws:
+      case Cs:
+      case xs:
+      case Os:
+      case Is:
+        return ss(t, r);
+
+      case ps:
+        return new n;
+
+      case fs:
+      case hs:
+        return new n(t);
+
+      case vs:
+        return is(t);
+
+      case ds:
+        return new n;
+
+      case ys:
+        return cs(t);
+    }
+}
+
+var Es = qs;
+
+var Ps = ve;
+
+var Ss = Object.create;
+
+var Ms = function() {
+    function t() {}
+    return function(e) {
+        if (!Ps(e)) {
+            return {};
+        }
+        if (Ss) {
+            return Ss(e);
+        }
+        t.prototype = e;
+        var r = new t;
+        t.prototype = undefined;
+        return r;
+    };
+}();
+
+var Ts = Ms;
+
+var Ds = Ts, ks = Oi, Gs = da;
+
+function Ls(t) {
+    return typeof t.constructor == "function" && !Gs(t) ? Ds(ks(t)) : {};
+}
+
+var Ns = Ls;
+
+var Fs = Tc, zs = Bn;
+
+var Hs = "[object Map]";
+
+function Us(t) {
+    return zs(t) && Fs(t) == Hs;
+}
+
+var Bs = Us;
+
+var Rs = Bs, Vs = $o, Ws = Xo;
+
+var $s = Ws && Ws.isMap;
+
+var Ks = $s ? Vs($s) : Rs;
+
+var Xs = Ks;
+
+var Js = Tc, Qs = Bn;
+
+var Ys = "[object Set]";
+
+function Zs(t) {
+    return Qs(t) && Js(t) == Ys;
+}
+
+var tu = Zs;
+
+var eu = tu, ru = $o, nu = Xo;
+
+var ou = nu && nu.isSet;
+
+var au = ou ? ru(ou) : eu;
+
+var iu = au;
+
+var cu = mn, su = wn, uu = kn, lu = Na, pu = ri, fu = oi, vu = ii, du = mi, hu = Li, yu = Wi, bu = Qi, ju = Tc, gu = Lc, Au = Es, mu = Ns, _u = no, wu = co, Cu = Xs, xu = ve, Ou = iu, Iu = Da, qu = Ya;
+
+var Eu = 1, Pu = 2, Su = 4;
+
+var Mu = "[object Arguments]", Tu = "[object Array]", Du = "[object Boolean]", ku = "[object Date]", Gu = "[object Error]", Lu = "[object Function]", Nu = "[object GeneratorFunction]", Fu = "[object Map]", zu = "[object Number]", Hu = "[object Object]", Uu = "[object RegExp]", Bu = "[object Set]", Ru = "[object String]", Vu = "[object Symbol]", Wu = "[object WeakMap]";
+
+var $u = "[object ArrayBuffer]", Ku = "[object DataView]", Xu = "[object Float32Array]", Ju = "[object Float64Array]", Qu = "[object Int8Array]", Yu = "[object Int16Array]", Zu = "[object Int32Array]", tl = "[object Uint8Array]", el = "[object Uint8ClampedArray]", rl = "[object Uint16Array]", nl = "[object Uint32Array]";
+
+var ol = {};
+
+ol[Mu] = ol[Tu] = ol[$u] = ol[Ku] = ol[Du] = ol[ku] = ol[Xu] = ol[Ju] = ol[Qu] = ol[Yu] = ol[Zu] = ol[Fu] = ol[zu] = ol[Hu] = ol[Uu] = ol[Bu] = ol[Ru] = ol[Vu] = ol[tl] = ol[el] = ol[rl] = ol[nl] = true;
+
+ol[Gu] = ol[Lu] = ol[Wu] = false;
+
+function al(t, e, r, n, o, a) {
+    var i, c = e & Eu, s = e & Pu, u = e & Su;
+    if (r) {
+        i = o ? r(t, n, o, a) : r(t);
+    }
+    if (i !== undefined) {
+        return i;
+    }
+    if (!xu(t)) {
+        return t;
+    }
+    var l = _u(t);
+    if (l) {
+        i = gu(t);
+        if (!c) {
+            return vu(t, i);
+        }
+    } else {
+        var p = ju(t), f = p == Lu || p == Nu;
+        if (wu(t)) {
+            return fu(t, c);
+        }
+        if (p == Hu || p == Mu || f && !o) {
+            i = s || f ? {} : mu(t);
+            if (!c) {
+                return s ? hu(t, pu(i, t)) : du(t, lu(i, t));
+            }
+        } else {
+            if (!ol[p]) {
+                return o ? t : {};
+            }
+            i = Au(t, p, c);
+        }
+    }
+    a || (a = new cu);
+    var v = a.get(t);
+    if (v) {
+        return v;
+    }
+    a.set(t, i);
+    if (Ou(t)) {
+        t.forEach(function(n) {
+            i.add(al(n, e, r, n, t, a));
+        });
+    } else if (Cu(t)) {
+        t.forEach(function(n, o) {
+            i.set(o, al(n, e, r, o, t, a));
+        });
+    }
+    var d = u ? s ? bu : yu : s ? qu : Iu;
+    var h = l ? undefined : d(t);
+    su(h || t, function(n, o) {
+        if (h) {
+            o = n;
+            n = t[o];
+        }
+        uu(i, o, al(n, e, r, o, t, a));
+    });
+    return i;
+}
+
+var il = al;
+
+var cl = il;
+
+var sl = 1, ul = 4;
+
+function ll(t) {
+    return cl(t, sl | ul);
+}
+
+var pl = ll;
+
+const fl = l.getDefaultExportFromCjs(pl);
+
+const vl = t => t;
+
+const dl = t => t;
+
+const hl = t => t;
+
+const yl = t => t;
+
+exports.Entrypoint = class Entrypoint extends e.Component {
     constructor() {
         super(...arguments);
         this.CLIActionPatternMap = new Map;
         this.HTTPActionPatternMap = new Map;
         this.ServiceActionPatternMap = new Map;
-        this.CLIActionPatternManager = new i.PatternManager;
-        this.HTTPActionPatternManager = new i.PatternManager;
-        this.ServiceActionPatternManager = new i.PatternManager;
+        this.CLIActionPatternManager = new o.PatternManager;
+        this.HTTPActionPatternManager = new o.PatternManager;
+        this.ServiceActionPatternManager = new o.PatternManager;
         this.entrypointDestroyers = [];
         this.httpActionInfoMap = new Map;
         this.serviceActionInfoMap = new Map;
         this.cliActionInfoMap = new Map;
-        this.accessControl = b.AccessControl;
+        this.accessControl = h.AccessControl;
     }
     async init() {
-        await Promise.all(this.controllers.map(e => {
-            n.BindControllerToComponent(this, e);
-            return new Promise((t, r) => this.container.register(e).then(t).catch(r));
+        await Promise.all(this.controllers.map(t => {
+            n.BindControllerToComponent(this, t);
+            return new Promise((e, r) => this.container.register(t).then(e).catch(r));
         }));
-        const {CLI: e, HTTP: t, Service: r} = n.GetComponentControllerActionMap(this);
-        e.forEach((e, t) => {
-            this.cliActionInfoMap.set(e.id, {
-                id: e.id,
-                command: e.pattern.command,
-                acl: e.acl,
-                name: e.name,
-                description: e.description,
-                groups: e.groups,
-                controller: e.constructor.className,
-                method: e.method.toString(),
-                jsonSchema: e.jsonSchema
+        const {CLI: t, HTTP: e, Service: r} = n.GetComponentControllerActionMap(this);
+        t.forEach((t, e) => {
+            this.cliActionInfoMap.set(t.id, {
+                id: t.id,
+                command: t.pattern.command,
+                acl: t.acl,
+                name: t.name,
+                description: t.description,
+                groups: t.groups,
+                controller: t.constructor.className,
+                method: t.method.toString(),
+                jsonSchema: t.jsonSchema
             });
-            this.CLIActionPatternMap.set(t, e);
-            this.CLIActionPatternManager.add(t, e);
+            this.CLIActionPatternMap.set(e, t);
+            this.CLIActionPatternManager.add(e, t);
         });
-        t.forEach((e, t) => {
-            this.httpActionInfoMap.set(e.id, {
-                id: e.id,
-                route: e.pattern.route,
-                acl: e.acl,
-                name: e.name,
-                description: e.description,
-                groups: e.groups,
-                controller: e.constructor.className,
-                method: e.method.toString(),
-                jsonSchema: e.jsonSchema
+        e.forEach((t, e) => {
+            this.httpActionInfoMap.set(t.id, {
+                id: t.id,
+                route: t.pattern.route,
+                acl: t.acl,
+                name: t.name,
+                description: t.description,
+                groups: t.groups,
+                controller: t.constructor.className,
+                method: t.method.toString(),
+                jsonSchema: t.jsonSchema
             });
-            this.HTTPActionPatternMap.set(t, e);
-            this.HTTPActionPatternManager.add(t, e);
+            this.HTTPActionPatternMap.set(e, t);
+            this.HTTPActionPatternManager.add(e, t);
         });
-        r.forEach((e, t) => {
-            this.serviceActionInfoMap.set(e.id, {
-                id: e.id,
-                pattern: e.pattern,
-                acl: e.acl,
-                name: e.name,
-                description: e.description,
-                groups: e.groups,
-                controller: e.constructor.className,
-                method: e.method.toString(),
-                jsonSchema: e.jsonSchema
+        r.forEach((t, e) => {
+            this.serviceActionInfoMap.set(t.id, {
+                id: t.id,
+                pattern: t.pattern,
+                acl: t.acl,
+                name: t.name,
+                description: t.description,
+                groups: t.groups,
+                controller: t.constructor.className,
+                method: t.method.toString(),
+                jsonSchema: t.jsonSchema
             });
-            this.ServiceActionPatternMap.set(t, e);
-            this.ServiceActionPatternManager.add(t, e);
+            this.ServiceActionPatternMap.set(e, t);
+            this.ServiceActionPatternManager.add(e, t);
         });
-        this.register(this.service, e => this.registerServiceEntrypoint(e));
-        this.register(this.cli, e => this.registerCLIEntrypoint(e));
-        this.register(this.http, e => this.registerHTTPEntrypoint(e));
-        const i = this.findInvalidActionGroupIds(this.cliActionInfoMap, "cli");
-        if (i.length) throw new A.InvalidActionGroupException("Found {type} action groups are not defined in cliActionGroups: {groupIds}", {
+        this.register(this.service, t => this.registerServiceEntrypoint(t));
+        this.register(this.cli, t => this.registerCLIEntrypoint(t));
+        this.register(this.http, t => this.registerHTTPEntrypoint(t));
+        const o = this.findInvalidActionGroupIds(this.cliActionInfoMap, "cli");
+        if (o.length) throw new j.InvalidActionGroupException("Found {type} action groups are not defined in cliActionGroups: {groupIds}", {
             type: "CLI",
-            groupIds: i
+            groupIds: o
         });
-        const o = this.findInvalidActionGroupIds(this.httpActionInfoMap, "http");
-        if (o.length) throw new A.InvalidActionGroupException("Found {type} action groups are not defined in httpActionGroups: {groupIds}", {
+        const a = this.findInvalidActionGroupIds(this.httpActionInfoMap, "http");
+        if (a.length) throw new j.InvalidActionGroupException("Found {type} action groups are not defined in httpActionGroups: {groupIds}", {
             type: "HTTP",
-            groupIds: o
+            groupIds: a
         });
-        const s = this.findInvalidActionGroupIds(this.serviceActionInfoMap, "service");
-        if (s.length) throw new A.InvalidActionGroupException("Found {type} action groups are not defined in serviceActionGroups: {groupIds}", {
+        const i = this.findInvalidActionGroupIds(this.serviceActionInfoMap, "service");
+        if (i.length) throw new j.InvalidActionGroupException("Found {type} action groups are not defined in serviceActionGroups: {groupIds}", {
             type: "Service",
-            groupIds: s
+            groupIds: i
         });
         const c = this.findDuplicateActionNames(this.cliActionInfoMap);
-        if (c.length) throw new g.DuplicateActionNameException("Duplicate {type} action names found: {names}", {
+        if (c.length) throw new d.DuplicateActionNameException("Duplicate {type} action names found: {names}", {
             type: "CLI",
             names: c
         });
-        const a = this.findDuplicateActionNames(this.httpActionInfoMap);
-        if (a.length) throw new g.DuplicateActionNameException("Duplicate {type} action names found: {names}", {
+        const s = this.findDuplicateActionNames(this.httpActionInfoMap);
+        if (s.length) throw new d.DuplicateActionNameException("Duplicate {type} action names found: {names}", {
             type: "HTTP",
-            names: a
+            names: s
         });
-        const l = this.findDuplicateActionNames(this.serviceActionInfoMap);
-        if (l.length) throw new g.DuplicateActionNameException("Duplicate {type} action names found: {names}", {
+        const u = this.findDuplicateActionNames(this.serviceActionInfoMap);
+        if (u.length) throw new d.DuplicateActionNameException("Duplicate {type} action names found: {names}", {
             type: "Service",
-            names: l
+            names: u
         });
     }
     get HTTP_ACTIONS() {
@@ -403,30 +2042,30 @@ exports.Entrypoint = class Entrypoint extends t.Component {
         return [ ...this.cliActionInfoMap.values() ];
     }
     async destroy() {
-        await Promise.all(this.entrypointDestroyers.map(e => new Promise((t, r) => Promise.resolve(e()).then(t).catch(r))));
+        await Promise.all(this.entrypointDestroyers.map(t => new Promise((e, r) => Promise.resolve(t()).then(e).catch(r))));
     }
-    getEntrypointActions(e) {
-        const t = new Map;
+    getEntrypointActions(t) {
+        const e = new Map;
         let r;
         let n;
-        switch (e) {
+        switch (t) {
           case "http":
             {
-                n = s.As(this.HTTP_ACTIONS);
+                n = i.As(this.HTTP_ACTIONS);
                 r = this.httpActionGroups;
             }
             break;
 
           case "cli":
             {
-                n = s.As(this.CLI_ACTIONS);
+                n = i.As(this.CLI_ACTIONS);
                 r = this.cliActionGroups;
             }
             break;
 
           case "service":
             {
-                n = s.As(this.SERVICE_ACTIONS);
+                n = i.As(this.SERVICE_ACTIONS);
                 r = this.serviceActionGroups;
             }
             break;
@@ -437,161 +2076,161 @@ exports.Entrypoint = class Entrypoint extends t.Component {
                 r = {};
             }
         }
-        n.forEach(e => {
-            e.groups.forEach(n => {
-                if (!t.has(n)) t.set(n, {
+        n.forEach(t => {
+            t.groups.forEach(n => {
+                if (!e.has(n)) e.set(n, {
                     id: n,
                     name: r[n],
                     actions: []
                 });
-                t.get(n)?.actions.push(e);
+                e.get(n)?.actions.push(t);
             });
         });
         return {
-            groups: [ ...t.values() ],
+            groups: [ ...e.values() ],
             actions: n
         };
     }
-    findInvalidActionGroupIds(e, t) {
-        const r = [ ...e.values() ];
+    findInvalidActionGroupIds(t, e) {
+        const r = [ ...t.values() ];
         const n = new Set;
-        r.forEach(e => {
-            e.groups.forEach(e => {
-                switch (t) {
+        r.forEach(t => {
+            t.groups.forEach(t => {
+                switch (e) {
                   case "cli":
-                    if (this.cliActionGroups[e] !== undefined) return;
+                    if (this.cliActionGroups[t] !== undefined) return;
                     break;
 
                   case "http":
-                    if (this.httpActionGroups[e] !== undefined) return;
+                    if (this.httpActionGroups[t] !== undefined) return;
                     break;
 
                   case "service":
-                    if (this.serviceActionGroups[e] !== undefined) return;
+                    if (this.serviceActionGroups[t] !== undefined) return;
                     break;
                 }
-                n.add(e);
+                n.add(t);
             });
         });
         return [ ...n ];
     }
-    findDuplicateActionNames(e) {
-        const t = [ ...e.values() ].map(e => e.name);
+    findDuplicateActionNames(t) {
+        const e = [ ...t.values() ].map(t => t.name);
         const r = new Set;
         const n = new Set;
-        t.forEach(e => r.has(e) ? n.add(e) : r.add(e));
+        e.forEach(t => r.has(t) ? n.add(t) : r.add(t));
         return Array.from(n);
     }
-    async runAccessControl(e, t, r, n, i) {
-        const [o, s] = await this.accessControl.run(e, t, r, n, i, e => {
-            switch (e) {
-              case q.ContextType.HTTP:
+    async runAccessControl(t, e, r, n, o) {
+        const [a, i] = await this.accessControl.run(t, e, r, n, o, t => {
+            switch (t) {
+              case y.ContextType.HTTP:
                 return this.HTTP_ACTIONS;
 
-              case q.ContextType.SERVICE:
+              case y.ContextType.SERVICE:
                 return this.SERVICE_ACTIONS;
 
-              case q.ContextType.CLI:
+              case y.ContextType.CLI:
                 return this.CLI_ACTIONS;
 
               default:
                 return [];
             }
         });
-        if (!o) throw s;
+        if (!a) throw i;
     }
-    async runControllerMethodWithoutAbortController(e, t, r) {
+    async runControllerMethodWithoutAbortController(t, e, r) {
         const n = this.createScope();
-        const i = await n.get(e.constructor, {
-            context: t
+        const o = await n.get(t.constructor, {
+            context: e
         });
         try {
-            const o = j.CloneDeep(await r.validateAsync(t.data));
-            await this.runAccessControl(this.rules, n, t, o, e);
-            return await i.getMethod(s.As(e.method))(o);
-        } catch (e) {
-            throw e;
+            const a = fl(await r.validateAsync(e.data));
+            await this.runAccessControl(this.rules, n, e, a, t);
+            return await o.getMethod(i.As(t.method))(a);
+        } catch (t) {
+            throw t;
         } finally {
-            n.destroy().catch(e => {
-                throw new a.DestroyRuntimeContainerException(e.message);
+            n.destroy().catch(t => {
+                throw new s.DestroyRuntimeContainerException(t.message);
             });
         }
     }
-    async runControllerMethodWithAbortController(e, t, r, n) {
-        let i = false;
-        const o = () => {
-            i = true;
-            c.destroy().catch(e => {
-                throw new a.DestroyRuntimeContainerException(e.message);
+    async runControllerMethodWithAbortController(t, e, r, n) {
+        let o = false;
+        const a = () => {
+            o = true;
+            c.destroy().catch(t => {
+                throw new s.DestroyRuntimeContainerException(t.message);
             });
         };
-        n.signal.addEventListener("abort", o, {
+        n.signal.addEventListener("abort", a, {
             once: true
         });
         const c = this.createScope();
-        const l = await c.get(e.constructor, {
-            context: t
+        const u = await c.get(t.constructor, {
+            context: e
         });
         try {
-            const n = j.CloneDeep(await r.validateAsync(t.data));
-            await this.runAccessControl(this.rules, c, t, n, e);
-            const o = await l.getMethod(s.As(e.method))(n);
-            if (!i) return o;
-        } catch (e) {
-            if (!i) n.signal.removeEventListener("abort", o);
-            throw e;
-        }
-    }
-    async runControllerMethod(e, t, r, n) {
-        if (n) return await this.runControllerMethodWithAbortController(e, t, r, n);
-        return await this.runControllerMethodWithoutAbortController(e, t, r);
-    }
-    register(e, t) {
-        (e ? Array.isArray(e) ? e : [ e ] : []).forEach(e => t(e));
-    }
-    registerCLIEntrypoint(e) {
-        const t = new Map;
-        this.CLIActionPatternMap.forEach((e, r) => t.set(r.command, e.jsonSchema));
-        return e(this.getModule(), t, async (e, t) => {
+            const n = fl(await r.validateAsync(e.data));
+            await this.runAccessControl(this.rules, c, e, n, t);
+            const a = await u.getMethod(i.As(t.method))(n);
+            if (!o) return a;
+        } catch (t) {
+            if (!o) n.signal.removeEventListener("abort", a);
+            throw t;
+        }
+    }
+    async runControllerMethod(t, e, r, n) {
+        if (n) return await this.runControllerMethodWithAbortController(t, e, r, n);
+        return await this.runControllerMethodWithoutAbortController(t, e, r);
+    }
+    register(t, e) {
+        (t ? Array.isArray(t) ? t : [ t ] : []).forEach(t => e(t));
+    }
+    registerCLIEntrypoint(t) {
+        const e = new Map;
+        this.CLIActionPatternMap.forEach((t, r) => e.set(r.command, t.jsonSchema));
+        return t(this.getModule(), e, async (t, e) => {
             const r = {
-                command: e.command
+                command: t.command
             };
             const n = this.CLIActionPatternManager.find(r);
             if (!n) throw new c.ControllerActionNotFoundException("Command not found");
-            return await this.runControllerMethod(n, e, n.dtoConstructor, t);
-        }, e => this.entrypointDestroyers.push(e));
+            return await this.runControllerMethod(n, t, n.dtoConstructor, e);
+        }, t => this.entrypointDestroyers.push(t));
     }
-    registerHTTPEntrypoint(e) {
-        const t = new Map;
-        for (const e of this.HTTPActionPatternMap.keys()) {
-            const r = t.get(e.route) || new Set;
-            r.add(e.method);
-            t.set(e.route, r);
+    registerHTTPEntrypoint(t) {
+        const e = new Map;
+        for (const t of this.HTTPActionPatternMap.keys()) {
+            const r = e.get(t.route) || new Set;
+            r.add(t.method);
+            e.set(t.route, r);
         }
-        return e(this.getModule(), t, async (e, t) => {
+        return t(this.getModule(), e, async (t, e) => {
             const r = {
-                route: e.route,
-                method: e.method
+                route: t.route,
+                method: t.method
             };
             const n = this.HTTPActionPatternManager.find(r);
-            if (!n) throw new c.ControllerActionNotFoundException("Route '{route}' not found", e);
-            return await this.runControllerMethod(n, e, n.dtoConstructor, t);
-        }, e => this.entrypointDestroyers.push(e));
+            if (!n) throw new c.ControllerActionNotFoundException("Route '{route}' not found", t);
+            return await this.runControllerMethod(n, t, n.dtoConstructor, e);
+        }, t => this.entrypointDestroyers.push(t));
     }
-    registerServiceEntrypoint(e) {
-        return e(this.getModule(), async (e, t) => {
-            const r = this.ServiceActionPatternManager.find(e.input);
+    registerServiceEntrypoint(t) {
+        return t(this.getModule(), async (t, e) => {
+            const r = this.ServiceActionPatternManager.find(t.input);
             if (!r) throw new c.ControllerActionNotFoundException("Controller action not found");
-            const n = l.GetObjectPropertyPaths(r.pattern);
-            n.forEach(t => u.unset(e.data, t));
-            const i = p.UniqueArray(n.map(e => e.substring(0, e.lastIndexOf("."))).filter(e => !!e));
-            i.forEach(t => {
-                let r = e.data;
-                t.split(".").forEach(e => r = r[e] ? r[e] : undefined);
-                if (r && !Object.keys(r).length) u.unset(e.data, t);
+            const n = u.GetObjectPropertyPaths(r.pattern);
+            n.forEach(e => tt(t.data, e));
+            const o = p.UniqueArray(n.map(t => t.substring(0, t.lastIndexOf("."))).filter(t => !!t));
+            o.forEach(e => {
+                let r = t.data;
+                e.split(".").forEach(t => r = r[t] ? r[t] : undefined);
+                if (r && !Object.keys(r).length) tt(t.data, e);
             });
-            return await this.runControllerMethod(r, e, r.dtoConstructor, t);
-        }, e => this.entrypointDestroyers.push(e));
+            return await this.runControllerMethod(r, t, r.dtoConstructor, e);
+        }, t => this.entrypointDestroyers.push(t));
     }
     getHttpActionGroups() {
         return this.httpActionGroups;
@@ -613,44 +2252,44 @@ exports.Entrypoint = class Entrypoint extends t.Component {
     }
 };
 
-e.__decorate([ r.Configurable(d.DTO.Array(d.DTO.Class(o.Controller)).optional().default([])), e.__metadata("design:type", Array) ], exports.Entrypoint.prototype, "controllers", void 0);
+t.__decorate([ r.Configurable(f.DTO.Array(f.DTO.Class(a.Controller)).optional().default([])), t.__metadata("design:type", Array) ], exports.Entrypoint.prototype, "controllers", void 0);
 
-e.__decorate([ r.Configurable(d.DTO.Array(d.DTO.Class(y.AccessControlRule)).optional().default([])), e.__metadata("design:type", Array) ], exports.Entrypoint.prototype, "rules", void 0);
+t.__decorate([ r.Configurable(f.DTO.Array(f.DTO.Class(b.AccessControlRule)).optional().default([])), t.__metadata("design:type", Array) ], exports.Entrypoint.prototype, "rules", void 0);
 
-e.__decorate([ r.Configurable(d.DTO.Object().pattern(d.DTO.String(), d.DTO.String()).optional().default({})), e.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "cliActionGroups", void 0);
+t.__decorate([ r.Configurable(f.DTO.Object().pattern(f.DTO.String(), f.DTO.String()).optional().default({})), t.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "cliActionGroups", void 0);
 
-e.__decorate([ r.Configurable(d.DTO.Object().pattern(d.DTO.String(), d.DTO.String()).optional().default({})), e.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "httpActionGroups", void 0);
+t.__decorate([ r.Configurable(f.DTO.Object().pattern(f.DTO.String(), f.DTO.String()).optional().default({})), t.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "httpActionGroups", void 0);
 
-e.__decorate([ r.Configurable(d.DTO.Object().pattern(d.DTO.String(), d.DTO.String()).optional().default({})), e.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "serviceActionGroups", void 0);
+t.__decorate([ r.Configurable(f.DTO.Object().pattern(f.DTO.String(), f.DTO.String()).optional().default({})), t.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "serviceActionGroups", void 0);
 
-e.__decorate([ r.Configurable(), e.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "cli", void 0);
+t.__decorate([ r.Configurable(), t.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "cli", void 0);
 
-e.__decorate([ r.Configurable(), e.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "http", void 0);
+t.__decorate([ r.Configurable(), t.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "http", void 0);
 
-e.__decorate([ r.Configurable(), e.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "service", void 0);
+t.__decorate([ r.Configurable(), t.__metadata("design:type", Object) ], exports.Entrypoint.prototype, "service", void 0);
 
-exports.Entrypoint = e.__decorate([ h.Singleton() ], exports.Entrypoint);
+exports.Entrypoint = t.__decorate([ v.Singleton() ], exports.Entrypoint);
 
 Object.defineProperty(exports, "BaseContext", {
     enumerable: true,
-    get: () => q.BaseContext
+    get: () => y.BaseContext
 });
 
 Object.defineProperty(exports, "ContextType", {
     enumerable: true,
-    get: () => q.ContextType
+    get: () => y.ContextType
 });
 
-exports.CLIContext = C.CLIContext;
+exports.CLIContext = g.CLIContext;
 
-exports.HTTPContext = v.HTTPContext;
+exports.HTTPContext = A.HTTPContext;
 
-exports.ServiceContext = P.ServiceContext;
+exports.ServiceContext = m.ServiceContext;
 
-exports.BuildCLIEntrypoint = f;
+exports.BuildCLIEntrypoint = vl;
 
-exports.BuildEntrypoints = x;
+exports.BuildEntrypoints = yl;
 
-exports.BuildHTTPEntrypoint = m;
+exports.BuildHTTPEntrypoint = dl;
 
-exports.BuildServiceEntrypoint = I;
+exports.BuildServiceEntrypoint = hl;