lakutata/src/components/entrypoint/Entrypoint.mjs

An IoC-based universal application framework.

import { _ as t, a as r } from "../../../vendor/Package.1.mjs";

import { Component as e } from "../../lib/core/Component.mjs";

import { Configurable as n } from "../../decorators/di/Configurable.mjs";

import { BindControllerToComponent as o, GetComponentControllerActionMap as a } from "../../lib/base/internal/ControllerEntrypoint.mjs";

import { PatternManager as i } from "../../lib/base/internal/PatternManager.mjs";

import { Controller as c } from "./lib/Controller.mjs";

import { As as s } from "../../lib/helpers/As.mjs";

import { ControllerActionNotFoundException as u } from "./exceptions/ControllerActionNotFoundException.mjs";

import { DestroyRuntimeContainerException as f } from "../../exceptions/DestroyRuntimeContainerException.mjs";

import { GetObjectPropertyPaths as l } from "../../lib/helpers/GetObjectPropertyPaths.mjs";

import { a as p, g as v, c as b } from "../../../vendor/Package.5.mjs";

import { UniqueArray as y } from "../../lib/helpers/UniqueArray.mjs";

import { D as m } from "../../../vendor/Package.2.mjs";

import { Singleton as h } from "../../decorators/di/Lifetime.mjs";

export { BaseContext, ContextType } from "../../lib/base/Context.mjs";

export { CLIContext } from "../../lib/context/CLIContext.mjs";

export { HTTPContext } from "../../lib/context/HTTPContext.mjs";

export { ServiceContext } from "../../lib/context/ServiceContext.mjs";

import "../../../vendor/Package.3.mjs";

import "../../lib/base/async-constructor/AsyncConstructor.mjs";

import "../../lib/base/async-constructor/Append.mjs";

import "../../lib/helpers/IsPromiseLike.mjs";

import "../../lib/helpers/IsPromise.mjs";

import "util/types";

import "../../exceptions/MethodNotFoundException.mjs";

import "../../lib/base/abstracts/Exception.mjs";

import "../../lib/base/internal/BasicInfo.mjs";

import "../../../vendor/Package.6.mjs";

import "../../../vendor/Package.7.mjs";

import "../../lib/base/internal/ThrowWarning.mjs";

import "../../lib/helpers/Templating.mjs";

import "../../lib/base/internal/CamelCase.mjs";

import "../../lib/helpers/NoCase.mjs";

import "../../lib/ioc/DependencyInjectionContainer.mjs";

import "util";

import "../../lib/ioc/Errors.mjs";

import "../../exceptions/di/DependencyInjectionException.mjs";

import "../../lib/base/internal/ConstructorSymbol.mjs";

import "../../constants/DIMetadataKey.mjs";

import "../../../vendor/Package.4.mjs";

import "node:crypto";

import "../../lib/base/internal/DataValidator.mjs";

import "node:util/types";

import "../../lib/validation/VLD.mjs";

import "../../../vendor/Package.11.mjs";

import "url";

import "../../../vendor/Package.10.mjs";

import "../../exceptions/dto/InvalidValueException.mjs";

import "../../../vendor/Package.9.mjs";

import "../../lib/helpers/IsHtml.mjs";

import "../../lib/helpers/IsXML.mjs";

import "../../constants/DTOMetadataKey.mjs";

import "../../lib/helpers/ObjectConstructor.mjs";

import "../../lib/helpers/ObjectParentConstructors.mjs";

import "../../lib/helpers/ObjectParentConstructor.mjs";

import "../../lib/helpers/ObjectPrototype.mjs";

import "../../lib/ioc/InjectionMode.mjs";

import "../../lib/ioc/Lifetime.mjs";

import "../../lib/ioc/ListModules.mjs";

import "../../../vendor/Package.8.mjs";

import "os";

import "path";

import "stream";

import "events";

import "fs";

import "../../lib/ioc/Utils.mjs";

import "../../lib/ioc/FunctionTokenizer.mjs";

import "../../lib/ioc/LoadModules.mjs";

import "../../lib/ioc/Resolvers.mjs";

import "../../lib/ioc/ParamParser.mjs";

import "../../lib/base/internal/ObjectLifetime.mjs";

import "../../exceptions/di/LifetimeLockedException.mjs";

import "../../lib/base/internal/ObjectWeakRefs.mjs";

import "../../lib/base/internal/ConfigurableRecordsInjection.mjs";

import "../../lib/base/internal/ObjectConfiguration.mjs";

import "../../lib/base/internal/ObjectInjection.mjs";

import "../../lib/base/internal/ObjectContainer.mjs";

import "../../lib/helpers/DevNull.mjs";

import "../../decorators/dto/Expect.mjs";

import "../../decorators/dto/IndexSignature.mjs";

import "../../decorators/dto/Accept.mjs";

import "../../lib/base/internal/MethodValidation.mjs";

import "../../exceptions/dto/InvalidMethodAcceptException.mjs";

import "../../exceptions/dto/InvalidMethodReturnException.mjs";

import "../../lib/helpers/IsEmptyObject.mjs";

import "../../lib/base/EventEmitter.mjs";

import "../../lib/core/Provider.mjs";

import "../../lib/helpers/ObjectHash.mjs";

import "../../../vendor/Package.15.mjs";

import "crypto";

import "../../lib/helpers/GetObjectNestingDepth.mjs";

import "../../exceptions/InvalidActionPatternDepthException.mjs";

import "node:http";


// -- Shims --
import cjsUrl from 'node:url';
import cjsPath from 'node:path';
import cjsModule from 'node:module';
const __filename = cjsUrl.fileURLToPath(import.meta.url);
const __dirname = cjsPath.dirname(__filename);
const require = cjsModule.createRequire(import.meta.url);
function j(t) {
    return t != null && typeof t === "object" && Array.isArray(t) === false;
}

const d = Object.freeze(Object.defineProperty({
    __proto__: null,
    default: j
}, Symbol.toStringTag, {
    value: "Module"
}));

const g = p(d);

"use strict";

var _ = function t(r) {
    return r != null && typeof r === "object" && Array.isArray(r) === false;
};

const w = v(_);

const A = _;

var O = function(t, r, e) {
    if (!A(e)) {
        e = {
            default: e
        };
    }
    if (!M(t)) {
        return typeof e.default !== "undefined" ? e.default : t;
    }
    if (typeof r === "number") {
        r = String(r);
    }
    const n = Array.isArray(r);
    const o = typeof r === "string";
    const a = e.separator || ".";
    const i = e.joinChar || (typeof a === "string" ? a : ".");
    if (!o && !n) {
        return t;
    }
    if (o && r in t) {
        return C(r, t, e) ? t[r] : e.default;
    }
    let c = n ? r : x(r, a, e);
    let s = c.length;
    let u = 0;
    do {
        let r = c[u];
        if (typeof r === "number") {
            r = String(r);
        }
        while (r && r.slice(-1) === "\\") {
            r = P([ r.slice(0, -1), c[++u] || "" ], i, e);
        }
        if (r in t) {
            if (!C(r, t, e)) {
                return e.default;
            }
            t = t[r];
        } else {
            let n = false;
            let o = u + 1;
            while (o < s) {
                r = P([ r, c[o++] ], i, e);
                if (n = r in t) {
                    if (!C(r, t, e)) {
                        return e.default;
                    }
                    t = t[r];
                    u = o - 1;
                    break;
                }
            }
            if (!n) {
                return e.default;
            }
        }
    } while (++u < s && M(t));
    if (u === s) {
        return t;
    }
    return e.default;
};

function P(t, r, e) {
    if (typeof e.join === "function") {
        return e.join(t);
    }
    return t[0] + r + t[1];
}

function x(t, r, e) {
    if (typeof e.split === "function") {
        return e.split(t);
    }
    return t.split(r);
}

function C(t, r, e) {
    if (typeof e.isValid === "function") {
        return e.isValid(t, r);
    }
    return true;
}

function M(t) {
    return A(t) || Array.isArray(t) || typeof t === "function";
}

const S = v(O);

var I = Object.prototype.toString;

var E = function t(r) {
    if (r === void 0) return "undefined";
    if (r === null) return "null";
    var e = typeof r;
    if (e === "boolean") return "boolean";
    if (e === "string") return "string";
    if (e === "number") return "number";
    if (e === "symbol") return "symbol";
    if (e === "function") {
        return F(r) ? "generatorfunction" : "function";
    }
    if (k(r)) return "array";
    if (H(r)) return "buffer";
    if (B(r)) return "arguments";
    if (L(r)) return "date";
    if (D(r)) return "error";
    if (z(r)) return "regexp";
    switch (T(r)) {
      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 (U(r)) {
        return "generator";
    }
    e = I.call(r);
    switch (e) {
      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 e.slice(8, -1).toLowerCase().replace(/\s/g, "");
};

function T(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 D(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 z(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, r) {
    return T(t) === "GeneratorFunction";
}

function U(t) {
    return typeof t.throw === "function" && typeof t.return === "function" && typeof t.next === "function";
}

function B(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 H(t) {
    if (t.constructor && typeof t.constructor.isBuffer === "function") {
        return t.constructor.isBuffer(t);
    }
    return false;
}

const R = v(E);

"use strict";

const W = E;

var V = function t(r) {
    switch (W(r)) {
      case "boolean":
      case "date":
      case "function":
      case "null":
      case "number":
        return true;

      case "undefined":
        return false;

      case "regexp":
        return r.source !== "(?:)" && r.source !== "";

      case "buffer":
        return r.toString() !== "";

      case "error":
        return r.message !== "";

      case "string":
      case "arguments":
        return r.length !== 0;

      case "file":
      case "map":
      case "set":
        return r.size !== 0;

      case "array":
      case "object":
        for (const e of Object.keys(r)) {
            if (t(r[e])) {
                return true;
            }
        }
        return false;

      default:
        {
            return true;
        }
    }
};

const N = v(V);

"use strict";

const $ = O;

const G = V;

var q = function(t, r, e) {
    if (K(t) && (typeof r === "string" || Array.isArray(r))) {
        return G($(t, r, e));
    }
    return false;
};

function K(t) {
    return t != null && (typeof t === "object" || typeof t === "function" || Array.isArray(t));
}

const X = v(q);

"use strict";

var J = g;

var Q = q;

const Y = t => t === "__proto__" || t === "constructor" || t === "prototype";

const Z = t => {
    if (Y(t)) {
        throw new Error(`Cannot set unsafe key: "${t}"`);
    }
};

var tt = function t(r, e) {
    if (!J(r)) {
        throw new TypeError("expected an object.");
    }
    var n = Array.isArray(e);
    if (!n && r.hasOwnProperty(e)) {
        delete r[e];
        return true;
    }
    if (Q(r, e)) {
        var o = n ? e.slice() : e.split(".");
        var a = o.pop();
        while (o.length && o[o.length - 1].slice(-1) === "\\") {
            a = o.pop().slice(0, -1) + "." + a;
        }
        while (o.length) {
            e = o.shift();
            Z(e);
            r = r[e];
        }
        return delete r[a];
    }
    return true;
};

const rt = v(tt);

function et() {
    this.__data__ = [];
    this.size = 0;
}

var nt = et;

const ot = v(nt);

function at(t, r) {
    return t === r || t !== t && r !== r;
}

var it = at;

const ct = v(it);

var st = it;

function ut(t, r) {
    var e = t.length;
    while (e--) {
        if (st(t[e][0], r)) {
            return e;
        }
    }
    return -1;
}

var ft = ut;

const lt = v(ft);

var pt = ft;

var vt = Array.prototype;

var bt = vt.splice;

function yt(t) {
    var r = this.__data__, e = pt(r, t);
    if (e < 0) {
        return false;
    }
    var n = r.length - 1;
    if (e == n) {
        r.pop();
    } else {
        bt.call(r, e, 1);
    }
    --this.size;
    return true;
}

var mt = yt;

const ht = v(mt);

var jt = ft;

function dt(t) {
    var r = this.__data__, e = jt(r, t);
    return e < 0 ? undefined : r[e][1];
}

var gt = dt;

const _t = v(gt);

var wt = ft;

function At(t) {
    return wt(this.__data__, t) > -1;
}

var Ot = At;

const Pt = v(Ot);

var xt = ft;

function Ct(t, r) {
    var e = this.__data__, n = xt(e, t);
    if (n < 0) {
        ++this.size;
        e.push([ t, r ]);
    } else {
        e[n][1] = r;
    }
    return this;
}

var Mt = Ct;

const St = v(Mt);

var It = nt, Et = mt, Tt = gt, kt = Ot, Dt = Mt;

function Lt(t) {
    var r = -1, e = t == null ? 0 : t.length;
    this.clear();
    while (++r < e) {
        var n = t[r];
        this.set(n[0], n[1]);
    }
}

Lt.prototype.clear = It;

Lt.prototype["delete"] = Et;

Lt.prototype.get = Tt;

Lt.prototype.has = kt;

Lt.prototype.set = Dt;

var zt = Lt;

const Ft = v(zt);

var Ut = zt;

function Bt() {
    this.__data__ = new Ut;
    this.size = 0;
}

var Ht = Bt;

const Rt = v(Ht);

function Wt(t) {
    var r = this.__data__, e = r["delete"](t);
    this.size = r.size;
    return e;
}

var Vt = Wt;

const Nt = v(Vt);

function $t(t) {
    return this.__data__.get(t);
}

var Gt = $t;

const qt = v(Gt);

function Kt(t) {
    return this.__data__.has(t);
}

var Xt = Kt;

const Jt = v(Xt);

var Qt = typeof b == "object" && b && b.Object === Object && b;

var Yt = Qt;

const Zt = v(Yt);

var tr = Yt;

var rr = typeof self == "object" && self && self.Object === Object && self;

var er = tr || rr || Function("return this")();

var nr = er;

const or = v(nr);

var ar = nr;

var ir = ar.Symbol;

var cr = ir;

const sr = v(cr);

var ur = cr;

var fr = Object.prototype;

var lr = fr.hasOwnProperty;

var pr = fr.toString;

var vr = ur ? ur.toStringTag : undefined;

function br(t) {
    var r = lr.call(t, vr), e = t[vr];
    try {
        t[vr] = undefined;
        var n = true;
    } catch (t) {}
    var o = pr.call(t);
    if (n) {
        if (r) {
            t[vr] = e;
        } else {
            delete t[vr];
        }
    }
    return o;
}

var yr = br;

const mr = v(yr);

var hr = Object.prototype;

var jr = hr.toString;

function dr(t) {
    return jr.call(t);
}

var gr = dr;

const _r = v(gr);

var wr = cr, Ar = yr, Or = gr;

var Pr = "[object Null]", xr = "[object Undefined]";

var Cr = wr ? wr.toStringTag : undefined;

function Mr(t) {
    if (t == null) {
        return t === undefined ? xr : Pr;
    }
    return Cr && Cr in Object(t) ? Ar(t) : Or(t);
}

var Sr = Mr;

const Ir = v(Sr);

function Er(t) {
    var r = typeof t;
    return t != null && (r == "object" || r == "function");
}

var Tr = Er;

const kr = v(Tr);

var Dr = Sr, Lr = Tr;

var zr = "[object AsyncFunction]", Fr = "[object Function]", Ur = "[object GeneratorFunction]", Br = "[object Proxy]";

function Hr(t) {
    if (!Lr(t)) {
        return false;
    }
    var r = Dr(t);
    return r == Fr || r == Ur || r == zr || r == Br;
}

var Rr = Hr;

const Wr = v(Rr);

var Vr = nr;

var Nr = Vr["__core-js_shared__"];

var $r = Nr;

const Gr = v($r);

var qr = $r;

var Kr = function() {
    var t = /[^.]+$/.exec(qr && qr.keys && qr.keys.IE_PROTO || "");
    return t ? "Symbol(src)_1." + t : "";
}();

function Xr(t) {
    return !!Kr && Kr in t;
}

var Jr = Xr;

const Qr = v(Jr);

var Yr = Function.prototype;

var Zr = Yr.toString;

function te(t) {
    if (t != null) {
        try {
            return Zr.call(t);
        } catch (t) {}
        try {
            return t + "";
        } catch (t) {}
    }
    return "";
}

var re = te;

const ee = v(re);

var ne = Rr, oe = Jr, ae = Tr, ie = re;

var ce = /[\\^$.*+?()[\]{}|]/g;

var se = /^\[object .+?Constructor\]$/;

var ue = Function.prototype, fe = Object.prototype;

var le = ue.toString;

var pe = fe.hasOwnProperty;

var ve = RegExp("^" + le.call(pe).replace(ce, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");

function be(t) {
    if (!ae(t) || oe(t)) {
        return false;
    }
    var r = ne(t) ? ve : se;
    return r.test(ie(t));
}

var ye = be;

const me = v(ye);

function he(t, r) {
    return t == null ? undefined : t[r];
}

var je = he;

const de = v(je);

var ge = ye, _e = je;

function we(t, r) {
    var e = _e(t, r);
    return ge(e) ? e : undefined;
}

var Ae = we;

const Oe = v(Ae);

var Pe = Ae, xe = nr;

var Ce = Pe(xe, "Map");

var Me = Ce;

const Se = v(Me);

var Ie = Ae;

var Ee = Ie(Object, "create");

var Te = Ee;

const ke = v(Te);

var De = Te;

function Le() {
    this.__data__ = De ? De(null) : {};
    this.size = 0;
}

var ze = Le;

const Fe = v(ze);

function Ue(t) {
    var r = this.has(t) && delete this.__data__[t];
    this.size -= r ? 1 : 0;
    return r;
}

var Be = Ue;

const He = v(Be);

var Re = Te;

var We = "__lodash_hash_undefined__";

var Ve = Object.prototype;

var Ne = Ve.hasOwnProperty;

function $e(t) {
    var r = this.__data__;
    if (Re) {
        var e = r[t];
        return e === We ? undefined : e;
    }
    return Ne.call(r, t) ? r[t] : undefined;
}

var Ge = $e;

const qe = v(Ge);

var Ke = Te;

var Xe = Object.prototype;

var Je = Xe.hasOwnProperty;

function Qe(t) {
    var r = this.__data__;
    return Ke ? r[t] !== undefined : Je.call(r, t);
}

var Ye = Qe;

const Ze = v(Ye);

var tn = Te;

var rn = "__lodash_hash_undefined__";

function en(t, r) {
    var e = this.__data__;
    this.size += this.has(t) ? 0 : 1;
    e[t] = tn && r === undefined ? rn : r;
    return this;
}

var nn = en;

const on = v(nn);

var an = ze, cn = Be, sn = Ge, un = Ye, fn = nn;

function ln(t) {
    var r = -1, e = t == null ? 0 : t.length;
    this.clear();
    while (++r < e) {
        var n = t[r];
        this.set(n[0], n[1]);
    }
}

ln.prototype.clear = an;

ln.prototype["delete"] = cn;

ln.prototype.get = sn;

ln.prototype.has = un;

ln.prototype.set = fn;

var pn = ln;

const vn = v(pn);

var bn = pn, yn = zt, mn = Me;

function hn() {
    this.size = 0;
    this.__data__ = {
        hash: new bn,
        map: new (mn || yn),
        string: new bn
    };
}

var jn = hn;

const dn = v(jn);

function gn(t) {
    var r = typeof t;
    return r == "string" || r == "number" || r == "symbol" || r == "boolean" ? t !== "__proto__" : t === null;
}

var _n = gn;

const wn = v(_n);

var An = _n;

function On(t, r) {
    var e = t.__data__;
    return An(r) ? e[typeof r == "string" ? "string" : "hash"] : e.map;
}

var Pn = On;

const xn = v(Pn);

var Cn = Pn;

function Mn(t) {
    var r = Cn(this, t)["delete"](t);
    this.size -= r ? 1 : 0;
    return r;
}

var Sn = Mn;

const In = v(Sn);

var En = Pn;

function Tn(t) {
    return En(this, t).get(t);
}

var kn = Tn;

const Dn = v(kn);

var Ln = Pn;

function zn(t) {
    return Ln(this, t).has(t);
}

var Fn = zn;

const Un = v(Fn);

var Bn = Pn;

function Hn(t, r) {
    var e = Bn(this, t), n = e.size;
    e.set(t, r);
    this.size += e.size == n ? 0 : 1;
    return this;
}

var Rn = Hn;

const Wn = v(Rn);

var Vn = jn, Nn = Sn, $n = kn, Gn = Fn, qn = Rn;

function Kn(t) {
    var r = -1, e = t == null ? 0 : t.length;
    this.clear();
    while (++r < e) {
        var n = t[r];
        this.set(n[0], n[1]);
    }
}

Kn.prototype.clear = Vn;

Kn.prototype["delete"] = Nn;

Kn.prototype.get = $n;

Kn.prototype.has = Gn;

Kn.prototype.set = qn;

var Xn = Kn;

const Jn = v(Xn);

var Qn = zt, Yn = Me, Zn = Xn;

var to = 200;

function ro(t, r) {
    var e = this.__data__;
    if (e instanceof Qn) {
        var n = e.__data__;
        if (!Yn || n.length < to - 1) {
            n.push([ t, r ]);
            this.size = ++e.size;
            return this;
        }
        e = this.__data__ = new Zn(n);
    }
    e.set(t, r);
    this.size = e.size;
    return this;
}

var eo = ro;

const no = v(eo);

var oo = zt, ao = Ht, io = Vt, co = Gt, so = Xt, uo = eo;

function fo(t) {
    var r = this.__data__ = new oo(t);
    this.size = r.size;
}

fo.prototype.clear = ao;

fo.prototype["delete"] = io;

fo.prototype.get = co;

fo.prototype.has = so;

fo.prototype.set = uo;

var lo = fo;

const po = v(lo);

function vo(t, r) {
    var e = -1, n = t == null ? 0 : t.length;
    while (++e < n) {
        if (r(t[e], e, t) === false) {
            break;
        }
    }
    return t;
}

var bo = vo;

const yo = v(bo);

var mo = Ae;

var ho = function() {
    try {
        var t = mo(Object, "defineProperty");
        t({}, "", {});
        return t;
    } catch (t) {}
}();

var jo = ho;

const go = v(jo);

var _o = jo;

function wo(t, r, e) {
    if (r == "__proto__" && _o) {
        _o(t, r, {
            configurable: true,
            enumerable: true,
            value: e,
            writable: true
        });
    } else {
        t[r] = e;
    }
}

var Ao = wo;

const Oo = v(Ao);

var Po = Ao, xo = it;

var Co = Object.prototype;

var Mo = Co.hasOwnProperty;

function So(t, r, e) {
    var n = t[r];
    if (!(Mo.call(t, r) && xo(n, e)) || e === undefined && !(r in t)) {
        Po(t, r, e);
    }
}

var Io = So;

const Eo = v(Io);

var To = Io, ko = Ao;

function Do(t, r, e, n) {
    var o = !e;
    e || (e = {});
    var a = -1, i = r.length;
    while (++a < i) {
        var c = r[a];
        var s = n ? n(e[c], t[c], c, e, t) : undefined;
        if (s === undefined) {
            s = t[c];
        }
        if (o) {
            ko(e, c, s);
        } else {
            To(e, c, s);
        }
    }
    return e;
}

var Lo = Do;

const zo = v(Lo);

function Fo(t, r) {
    var e = -1, n = Array(t);
    while (++e < t) {
        n[e] = r(e);
    }
    return n;
}

var Uo = Fo;

const Bo = v(Uo);

function Ho(t) {
    return t != null && typeof t == "object";
}

var Ro = Ho;

const Wo = v(Ro);

var Vo = Sr, No = Ro;

var $o = "[object Arguments]";

function Go(t) {
    return No(t) && Vo(t) == $o;
}

var qo = Go;

const Ko = v(qo);

var Xo = qo, Jo = Ro;

var Qo = Object.prototype;

var Yo = Qo.hasOwnProperty;

var Zo = Qo.propertyIsEnumerable;

var ta = Xo(function() {
    return arguments;
}()) ? Xo : function(t) {
    return Jo(t) && Yo.call(t, "callee") && !Zo.call(t, "callee");
};

var ra = ta;

const ea = v(ra);

var na = Array.isArray;

var oa = na;

const aa = v(oa);

var ia = {
    exports: {}
};

function ca() {
    return false;
}

var sa = ca;

const ua = v(sa);

var fa = ia.exports;

(function(t, r) {
    var e = nr, n = sa;
    var o = "object" == "object" && r && !r.nodeType && r;
    var a = o && "object" == "object" && t && !t.nodeType && t;
    var i = a && a.exports === o;
    var c = i ? e.Buffer : undefined;
    var s = c ? c.isBuffer : undefined;
    var u = s || n;
    t.exports = u;
})(ia, ia.exports);

var la = ia.exports;

const pa = v(la);

var va = 9007199254740991;

var ba = /^(?:0|[1-9]\d*)$/;

function ya(t, r) {
    var e = typeof t;
    r = r == null ? va : r;
    return !!r && (e == "number" || e != "symbol" && ba.test(t)) && (t > -1 && t % 1 == 0 && t < r);
}

var ma = ya;

const ha = v(ma);

var ja = 9007199254740991;

function da(t) {
    return typeof t == "number" && t > -1 && t % 1 == 0 && t <= ja;
}

var ga = da;

const _a = v(ga);

var wa = Sr, Aa = ga, Oa = Ro;

var Pa = "[object Arguments]", xa = "[object Array]", Ca = "[object Boolean]", Ma = "[object Date]", Sa = "[object Error]", Ia = "[object Function]", Ea = "[object Map]", Ta = "[object Number]", ka = "[object Object]", Da = "[object RegExp]", La = "[object Set]", za = "[object String]", Fa = "[object WeakMap]";

var Ua = "[object ArrayBuffer]", Ba = "[object DataView]", Ha = "[object Float32Array]", Ra = "[object Float64Array]", Wa = "[object Int8Array]", Va = "[object Int16Array]", Na = "[object Int32Array]", $a = "[object Uint8Array]", Ga = "[object Uint8ClampedArray]", qa = "[object Uint16Array]", Ka = "[object Uint32Array]";

var Xa = {};

Xa[Ha] = Xa[Ra] = Xa[Wa] = Xa[Va] = Xa[Na] = Xa[$a] = Xa[Ga] = Xa[qa] = Xa[Ka] = true;

Xa[Pa] = Xa[xa] = Xa[Ua] = Xa[Ca] = Xa[Ba] = Xa[Ma] = Xa[Sa] = Xa[Ia] = Xa[Ea] = Xa[Ta] = Xa[ka] = Xa[Da] = Xa[La] = Xa[za] = Xa[Fa] = false;

function Ja(t) {
    return Oa(t) && Aa(t.length) && !!Xa[wa(t)];
}

var Qa = Ja;

const Ya = v(Qa);

function Za(t) {
    return function(r) {
        return t(r);
    };
}

var ti = Za;

const ri = v(ti);

var ei = {
    exports: {}
};

var ni = ei.exports;

(function(t, r) {
    var e = Yt;
    var n = "object" == "object" && r && !r.nodeType && r;
    var o = n && "object" == "object" && t && !t.nodeType && t;
    var a = o && o.exports === n;
    var i = a && e.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;
})(ei, ei.exports);

var oi = ei.exports;

const ai = v(oi);

var ii = Qa, ci = ti, si = oi;

var ui = si && si.isTypedArray;

var fi = ui ? ci(ui) : ii;

var li = fi;

const pi = v(li);

var vi = Uo, bi = ra, yi = oa, mi = la, hi = ma, ji = li;

var di = Object.prototype;

var gi = di.hasOwnProperty;

function _i(t, r) {
    var e = yi(t), n = !e && bi(t), o = !e && !n && mi(t), a = !e && !n && !o && ji(t), i = e || n || o || a, c = i ? vi(t.length, String) : [], s = c.length;
    for (var u in t) {
        if ((r || gi.call(t, u)) && !(i && (u == "length" || o && (u == "offset" || u == "parent") || a && (u == "buffer" || u == "byteLength" || u == "byteOffset") || hi(u, s)))) {
            c.push(u);
        }
    }
    return c;
}

var wi = _i;

const Ai = v(wi);

var Oi = Object.prototype;

function Pi(t) {
    var r = t && t.constructor, e = typeof r == "function" && r.prototype || Oi;
    return t === e;
}

var xi = Pi;

const Ci = v(xi);

function Mi(t, r) {
    return function(e) {
        return t(r(e));
    };
}

var Si = Mi;

const Ii = v(Si);

var Ei = Si;

var Ti = Ei(Object.keys, Object);

var ki = Ti;

const Di = v(ki);

var Li = xi, zi = ki;

var Fi = Object.prototype;

var Ui = Fi.hasOwnProperty;

function Bi(t) {
    if (!Li(t)) {
        return zi(t);
    }
    var r = [];
    for (var e in Object(t)) {
        if (Ui.call(t, e) && e != "constructor") {
            r.push(e);
        }
    }
    return r;
}

var Hi = Bi;

const Ri = v(Hi);

var Wi = Rr, Vi = ga;

function Ni(t) {
    return t != null && Vi(t.length) && !Wi(t);
}

var $i = Ni;

const Gi = v($i);

var qi = wi, Ki = Hi, Xi = $i;

function Ji(t) {
    return Xi(t) ? qi(t) : Ki(t);
}

var Qi = Ji;

const Yi = v(Qi);

var Zi = Lo, tc = Qi;

function rc(t, r) {
    return t && Zi(r, tc(r), t);
}

var ec = rc;

const nc = v(ec);

function oc(t) {
    var r = [];
    if (t != null) {
        for (var e in Object(t)) {
            r.push(e);
        }
    }
    return r;
}

var ac = oc;

const ic = v(ac);

var cc = Tr, sc = xi, uc = ac;

var fc = Object.prototype;

var lc = fc.hasOwnProperty;

function pc(t) {
    if (!cc(t)) {
        return uc(t);
    }
    var r = sc(t), e = [];
    for (var n in t) {
        if (!(n == "constructor" && (r || !lc.call(t, n)))) {
            e.push(n);
        }
    }
    return e;
}

var vc = pc;

const bc = v(vc);

var yc = wi, mc = vc, hc = $i;

function jc(t) {
    return hc(t) ? yc(t, true) : mc(t);
}

var dc = jc;

const gc = v(dc);

var _c = Lo, wc = dc;

function Ac(t, r) {
    return t && _c(r, wc(r), t);
}

var Oc = Ac;

const Pc = v(Oc);

var xc = {
    exports: {}
};

var Cc = xc.exports;

(function(t, r) {
    var e = nr;
    var n = "object" == "object" && r && !r.nodeType && r;
    var o = n && "object" == "object" && t && !t.nodeType && t;
    var a = o && o.exports === n;
    var i = a ? e.Buffer : undefined, c = i ? i.allocUnsafe : undefined;
    function s(t, r) {
        if (r) {
            return t.slice();
        }
        var e = t.length, n = c ? c(e) : new t.constructor(e);
        t.copy(n);
        return n;
    }
    t.exports = s;
})(xc, xc.exports);

var Mc = xc.exports;

const Sc = v(Mc);

function Ic(t, r) {
    var e = -1, n = t.length;
    r || (r = Array(n));
    while (++e < n) {
        r[e] = t[e];
    }
    return r;
}

var Ec = Ic;

const Tc = v(Ec);

function kc(t, r) {
    var e = -1, n = t == null ? 0 : t.length, o = 0, a = [];
    while (++e < n) {
        var i = t[e];
        if (r(i, e, t)) {
            a[o++] = i;
        }
    }
    return a;
}

var Dc = kc;

const Lc = v(Dc);

function zc() {
    return [];
}

var Fc = zc;

const Uc = v(Fc);

var Bc = Dc, Hc = Fc;

var Rc = Object.prototype;

var Wc = Rc.propertyIsEnumerable;

var Vc = Object.getOwnPropertySymbols;

var Nc = !Vc ? Hc : function(t) {
    if (t == null) {
        return [];
    }
    t = Object(t);
    return Bc(Vc(t), (function(r) {
        return Wc.call(t, r);
    }));
};

var $c = Nc;

const Gc = v($c);

var qc = Lo, Kc = $c;

function Xc(t, r) {
    return qc(t, Kc(t), r);
}

var Jc = Xc;

const Qc = v(Jc);

function Yc(t, r) {
    var e = -1, n = r.length, o = t.length;
    while (++e < n) {
        t[o + e] = r[e];
    }
    return t;
}

var Zc = Yc;

const ts = v(Zc);

var rs = Si;

var es = rs(Object.getPrototypeOf, Object);

var ns = es;

const os = v(ns);

var as = Zc, is = ns, cs = $c, ss = Fc;

var us = Object.getOwnPropertySymbols;

var fs = !us ? ss : function(t) {
    var r = [];
    while (t) {
        as(r, cs(t));
        t = is(t);
    }
    return r;
};

var ls = fs;

const ps = v(ls);

var vs = Lo, bs = ls;

function ys(t, r) {
    return vs(t, bs(t), r);
}

var ms = ys;

const hs = v(ms);

var js = Zc, ds = oa;

function gs(t, r, e) {
    var n = r(t);
    return ds(t) ? n : js(n, e(t));
}

var _s = gs;

const ws = v(_s);

var As = _s, Os = $c, Ps = Qi;

function xs(t) {
    return As(t, Ps, Os);
}

var Cs = xs;

const Ms = v(Cs);

var Ss = _s, Is = ls, Es = dc;

function Ts(t) {
    return Ss(t, Es, Is);
}

var ks = Ts;

const Ds = v(ks);

var Ls = Ae, zs = nr;

var Fs = Ls(zs, "DataView");

var Us = Fs;

const Bs = v(Us);

var Hs = Ae, Rs = nr;

var Ws = Hs(Rs, "Promise");

var Vs = Ws;

const Ns = v(Vs);

var $s = Ae, Gs = nr;

var qs = $s(Gs, "Set");

var Ks = qs;

const Xs = v(Ks);

var Js = Ae, Qs = nr;

var Ys = Js(Qs, "WeakMap");

var Zs = Ys;

const tu = v(Zs);

var ru = Us, eu = Me, nu = Vs, ou = Ks, au = Zs, iu = Sr, cu = re;

var su = "[object Map]", uu = "[object Object]", fu = "[object Promise]", lu = "[object Set]", pu = "[object WeakMap]";

var vu = "[object DataView]";

var bu = cu(ru), yu = cu(eu), mu = cu(nu), hu = cu(ou), ju = cu(au);

var du = iu;

if (ru && du(new ru(new ArrayBuffer(1))) != vu || eu && du(new eu) != su || nu && du(nu.resolve()) != fu || ou && du(new ou) != lu || au && du(new au) != pu) {
    du = function(t) {
        var r = iu(t), e = r == uu ? t.constructor : undefined, n = e ? cu(e) : "";
        if (n) {
            switch (n) {
              case bu:
                return vu;

              case yu:
                return su;

              case mu:
                return fu;

              case hu:
                return lu;

              case ju:
                return pu;
            }
        }
        return r;
    };
}

var gu = du;

const _u = v(gu);

var wu = Object.prototype;

var Au = wu.hasOwnProperty;

function Ou(t) {
    var r = t.length, e = new t.constructor(r);
    if (r && typeof t[0] == "string" && Au.call(t, "index")) {
        e.index = t.index;
        e.input = t.input;
    }
    return e;
}

var Pu = Ou;

const xu = v(Pu);

var Cu = nr;

var Mu = Cu.Uint8Array;

var Su = Mu;

const Iu = v(Su);

var Eu = Su;

function Tu(t) {
    var r = new t.constructor(t.byteLength);
    new Eu(r).set(new Eu(t));
    return r;
}

var ku = Tu;

const Du = v(ku);

var Lu = ku;

function zu(t, r) {
    var e = r ? Lu(t.buffer) : t.buffer;
    return new t.constructor(e, t.byteOffset, t.byteLength);
}

var Fu = zu;

const Uu = v(Fu);

var Bu = /\w*$/;

function Hu(t) {
    var r = new t.constructor(t.source, Bu.exec(t));
    r.lastIndex = t.lastIndex;
    return r;
}

var Ru = Hu;

const Wu = v(Ru);

var Vu = cr;

var Nu = Vu ? Vu.prototype : undefined, $u = Nu ? Nu.valueOf : undefined;

function Gu(t) {
    return $u ? Object($u.call(t)) : {};
}

var qu = Gu;

const Ku = v(qu);

var Xu = ku;

function Ju(t, r) {
    var e = r ? Xu(t.buffer) : t.buffer;
    return new t.constructor(e, t.byteOffset, t.length);
}

var Qu = Ju;

const Yu = v(Qu);

var Zu = ku, tf = Fu, rf = Ru, ef = qu, nf = Qu;

var of = "[object Boolean]", af = "[object Date]", cf = "[object Map]", sf = "[object Number]", uf = "[object RegExp]", ff = "[object Set]", lf = "[object String]", pf = "[object Symbol]";

var vf = "[object ArrayBuffer]", bf = "[object DataView]", yf = "[object Float32Array]", mf = "[object Float64Array]", hf = "[object Int8Array]", jf = "[object Int16Array]", df = "[object Int32Array]", gf = "[object Uint8Array]", _f = "[object Uint8ClampedArray]", wf = "[object Uint16Array]", Af = "[object Uint32Array]";

function Of(t, r, e) {
    var n = t.constructor;
    switch (r) {
      case vf:
        return Zu(t);

      case of:
      case af:
        return new n(+t);

      case bf:
        return tf(t, e);

      case yf:
      case mf:
      case hf:
      case jf:
      case df:
      case gf:
      case _f:
      case wf:
      case Af:
        return nf(t, e);

      case cf:
        return new n;

      case sf:
      case lf:
        return new n(t);

      case uf:
        return rf(t);

      case ff:
        return new n;

      case pf:
        return ef(t);
    }
}

var Pf = Of;

const xf = v(Pf);

var Cf = Tr;

var Mf = Object.create;

var Sf = function() {
    function t() {}
    return function(r) {
        if (!Cf(r)) {
            return {};
        }
        if (Mf) {
            return Mf(r);
        }
        t.prototype = r;
        var e = new t;
        t.prototype = undefined;
        return e;
    };
}();

var If = Sf;

const Ef = v(If);

var Tf = If, kf = ns, Df = xi;

function Lf(t) {
    return typeof t.constructor == "function" && !Df(t) ? Tf(kf(t)) : {};
}

var zf = Lf;

const Ff = v(zf);

var Uf = gu, Bf = Ro;

var Hf = "[object Map]";

function Rf(t) {
    return Bf(t) && Uf(t) == Hf;
}

var Wf = Rf;

const Vf = v(Wf);

var Nf = Wf, $f = ti, Gf = oi;

var qf = Gf && Gf.isMap;

var Kf = qf ? $f(qf) : Nf;

var Xf = Kf;

const Jf = v(Xf);

var Qf = gu, Yf = Ro;

var Zf = "[object Set]";

function tl(t) {
    return Yf(t) && Qf(t) == Zf;
}

var rl = tl;

const el = v(rl);

var nl = rl, ol = ti, al = oi;

var il = al && al.isSet;

var cl = il ? ol(il) : nl;

var sl = cl;

const ul = v(sl);

var fl = lo, ll = bo, pl = Io, vl = ec, bl = Oc, yl = Mc, ml = Ec, hl = Jc, jl = ms, dl = Cs, gl = ks, _l = gu, wl = Pu, Al = Pf, Ol = zf, Pl = oa, xl = la, Cl = Xf, Ml = Tr, Sl = sl, Il = Qi, El = dc;

var Tl = 1, kl = 2, Dl = 4;

var Ll = "[object Arguments]", zl = "[object Array]", Fl = "[object Boolean]", Ul = "[object Date]", Bl = "[object Error]", Hl = "[object Function]", Rl = "[object GeneratorFunction]", Wl = "[object Map]", Vl = "[object Number]", Nl = "[object Object]", $l = "[object RegExp]", Gl = "[object Set]", ql = "[object String]", Kl = "[object Symbol]", Xl = "[object WeakMap]";

var Jl = "[object ArrayBuffer]", Ql = "[object DataView]", Yl = "[object Float32Array]", Zl = "[object Float64Array]", tp = "[object Int8Array]", rp = "[object Int16Array]", ep = "[object Int32Array]", np = "[object Uint8Array]", op = "[object Uint8ClampedArray]", ap = "[object Uint16Array]", ip = "[object Uint32Array]";

var cp = {};

cp[Ll] = cp[zl] = cp[Jl] = cp[Ql] = cp[Fl] = cp[Ul] = cp[Yl] = cp[Zl] = cp[tp] = cp[rp] = cp[ep] = cp[Wl] = cp[Vl] = cp[Nl] = cp[$l] = cp[Gl] = cp[ql] = cp[Kl] = cp[np] = cp[op] = cp[ap] = cp[ip] = true;

cp[Bl] = cp[Hl] = cp[Xl] = false;

function sp(t, r, e, n, o, a) {
    var i, c = r & Tl, s = r & kl, u = r & Dl;
    if (e) {
        i = o ? e(t, n, o, a) : e(t);
    }
    if (i !== undefined) {
        return i;
    }
    if (!Ml(t)) {
        return t;
    }
    var f = Pl(t);
    if (f) {
        i = wl(t);
        if (!c) {
            return ml(t, i);
        }
    } else {
        var l = _l(t), p = l == Hl || l == Rl;
        if (xl(t)) {
            return yl(t, c);
        }
        if (l == Nl || l == Ll || p && !o) {
            i = s || p ? {} : Ol(t);
            if (!c) {
                return s ? jl(t, bl(i, t)) : hl(t, vl(i, t));
            }
        } else {
            if (!cp[l]) {
                return o ? t : {};
            }
            i = Al(t, l, c);
        }
    }
    a || (a = new fl);
    var v = a.get(t);
    if (v) {
        return v;
    }
    a.set(t, i);
    if (Sl(t)) {
        t.forEach((function(n) {
            i.add(sp(n, r, e, n, t, a));
        }));
    } else if (Cl(t)) {
        t.forEach((function(n, o) {
            i.set(o, sp(n, r, e, o, t, a));
        }));
    }
    var b = u ? s ? gl : dl : s ? El : Il;
    var y = f ? undefined : b(t);
    ll(y || t, (function(n, o) {
        if (y) {
            o = n;
            n = t[o];
        }
        pl(i, o, sp(n, r, e, o, t, a));
    }));
    return i;
}

var up = sp;

const fp = v(up);

var lp = up;

var pp = 1, vp = 4;

function bp(t) {
    return lp(t, pp | vp);
}

var yp = bp;

const mp = v(yp);

const hp = t => t;

const jp = t => t;

const dp = t => t;

const gp = t => t;

let _p = class Entrypoint extends e {
    constructor() {
        super(...arguments);
        this.CLIActionPatternMap = new Map;
        this.HTTPActionPatternMap = new Map;
        this.ServiceActionPatternMap = new Map;
        this.CLIActionPatternManager = new i;
        this.HTTPActionPatternManager = new i;
        this.ServiceActionPatternManager = new i;
        this.entrypointDestroyers = [];
    }
    async init() {
        await Promise.all(this.controllers.map((t => {
            o(this, t);
            return new Promise(((r, e) => this.container.register(t).then(r).catch(e)));
        })));
        const {CLI: t, HTTP: r, Service: e} = a(this);
        t.forEach(((t, r) => {
            this.CLIActionPatternMap.set(r, t);
            this.CLIActionPatternManager.add(r, t);
        }));
        r.forEach(((t, r) => {
            this.HTTPActionPatternMap.set(r, t);
            this.HTTPActionPatternManager.add(r, t);
        }));
        e.forEach(((t, r) => {
            this.ServiceActionPatternMap.set(r, t);
            this.ServiceActionPatternManager.add(r, t);
        }));
        this.register(this.service, (t => this.registerServiceEntrypoint(t)));
        this.register(this.cli, (t => this.registerCLIEntrypoint(t)));
        this.register(this.http, (t => this.registerHTTPEntrypoint(t)));
    }
    async destroy() {
        await Promise.all(this.entrypointDestroyers.map((t => new Promise(((r, e) => Promise.resolve(t()).then(r).catch(e))))));
    }
    async runControllerMethodWithoutAbortController(t, r, e) {
        const n = this.createScope();
        const o = await n.get(t.constructor, {
            context: r
        });
        try {
            return await o.getMethod(s(t.method))(mp(await e.validateAsync(r.data)));
        } catch (t) {
            throw t;
        } finally {
            n.destroy().catch((t => {
                throw new f(t.message);
            }));
        }
    }
    async runControllerMethodWithAbortController(t, r, e, n) {
        let o = false;
        const a = () => {
            o = true;
            i.destroy().catch((t => {
                throw new f(t.message);
            }));
        };
        n.signal.addEventListener("abort", a, {
            once: true
        });
        const i = this.createScope();
        const c = await i.get(t.constructor, {
            context: r
        });
        try {
            const n = await c.getMethod(s(t.method))(mp(await e.validateAsync(r.data)));
            if (!o) return n;
        } catch (t) {
            if (!o) n.signal.removeEventListener("abort", a);
            throw t;
        }
    }
    async runControllerMethod(t, r, e, n) {
        if (n) return await this.runControllerMethodWithAbortController(t, r, e, n);
        return await this.runControllerMethodWithoutAbortController(t, r, e);
    }
    register(t, r) {
        (t ? Array.isArray(t) ? t : [ t ] : []).forEach((t => r(t)));
    }
    registerCLIEntrypoint(t) {
        const r = new Map;
        this.CLIActionPatternMap.forEach(((t, e) => r.set(e.command, t.jsonSchema)));
        return t(this.getModule(), r, (async (t, r) => {
            const e = {
                command: t.command
            };
            const n = this.CLIActionPatternManager.find(e);
            if (!n) throw new u("Command not found");
            return await this.runControllerMethod(n, t, n.dtoConstructor, r);
        }), (t => this.entrypointDestroyers.push(t)));
    }
    registerHTTPEntrypoint(t) {
        const r = new Map;
        for (const t of this.HTTPActionPatternMap.keys()) {
            const e = r.get(t.route) || new Set;
            e.add(t.method);
            r.set(t.route, e);
        }
        return t(this.getModule(), r, (async (t, r) => {
            const e = {
                route: t.route,
                method: t.method
            };
            const n = this.HTTPActionPatternManager.find(e);
            if (!n) throw new u("Route '{route}' not found", t);
            return await this.runControllerMethod(n, t, n.dtoConstructor, r);
        }), (t => this.entrypointDestroyers.push(t)));
    }
    registerServiceEntrypoint(t) {
        return t(this.getModule(), (async (t, r) => {
            const e = this.ServiceActionPatternManager.find(t.input);
            if (!e) throw new u("Controller action not found");
            const n = l(e.pattern);
            n.forEach((r => rt(t.data, r)));
            const o = y(n.map((t => t.substring(0, t.lastIndexOf(".")))).filter((t => !!t)));
            o.forEach((r => {
                let e = t.data;
                r.split(".").forEach((t => e = e[t] ? e[t] : undefined));
                if (e && !Object.keys(e).length) rt(t.data, r);
            }));
            return await this.runControllerMethod(e, t, e.dtoConstructor, r);
        }), (t => this.entrypointDestroyers.push(t)));
    }
};

t([ n(m.Array(m.Class(c)).optional().default([])), r("design:type", Array) ], _p.prototype, "controllers", void 0);

t([ n(), r("design:type", Object) ], _p.prototype, "cli", void 0);

t([ n(), r("design:type", Object) ], _p.prototype, "http", void 0);

t([ n(), r("design:type", Object) ], _p.prototype, "service", void 0);

_p = t([ h() ], _p);

export { hp as BuildCLIEntrypoint, gp as BuildEntrypoints, jp as BuildHTTPEntrypoint, dp as BuildServiceEntrypoint, _p as Entrypoint };