lakutata 2.0.80 → 2.0.82

package/orm.cjs

@@ -8,19 +8,21 @@ require("./vendor/Package.4.cjs");
 
 const e = require("./vendor/Package.5.cjs");
 
-const t = require("./vendor/Package.102.cjs");
+const r = require("./vendor/Package.112.cjs");
 
-const r = require("./vendor/Package.10.cjs");
+const t = require("./vendor/Package.11.cjs");
 
 require("./vendor/Package.12.cjs");
 
 require("./vendor/Package.1.cjs");
 
+require("fs/promises");
+
 require("./vendor/Package.62.cjs");
 
-require("./vendor/Package.11.cjs");
+require("./vendor/Package.13.cjs");
 
-require("./vendor/Package.122.cjs");
+require("./vendor/Package.14.cjs");
 
 require("buffer");
 
@@ -30,30 +32,28 @@ require("url");
 
 require("tty");
 
+require("./vendor/Package.10.cjs");
+
+require("util");
+
+require("stream");
+
+require("./vendor/Package.7.cjs");
+
 require("./vendor/Package.8.cjs");
 
 require("os");
 
 require("path");
 
-require("util");
-
-require("stream");
-
 require("events");
 
 require("fs");
 
-require("./vendor/Package.7.cjs");
-
-require("./vendor/Package.13.cjs");
+require("./vendor/Package.15.cjs");
 
 require("crypto");
 
-require("fs/promises");
-
-require("./vendor/Package.63.cjs");
-
 require("node:url");
 
 require("node:path");
@@ -68,1237 +68,1774 @@ require("node:stream");
 
 require("node:string_decoder");
 
-var o = t.requireGlobals();
+var n = r.requireGlobals();
 
-const n = e.getDefaultExportFromCjs(o);
+const o = e.getDefaultExportFromCjs(n);
+
+var u = r.requireContainer();
+
+const i = e.getDefaultExportFromCjs(u);
 
 var s = {};
 
-"use strict";
+var a;
 
-Object.defineProperty(s, "__esModule", {
-    value: true
-});
+function requireEntityTarget() {
+    if (a) return s;
+    a = 1;
+    "use strict";
+    Object.defineProperty(s, "__esModule", {
+        value: true
+    });
+    return s;
+}
 
-var i = {};
+var c = requireEntityTarget();
 
-"use strict";
+const l = e.getDefaultExportFromCjs(c);
 
-Object.defineProperty(i, "__esModule", {
-    value: true
-});
+var p = {};
 
-var u = {};
+var f;
 
-"use strict";
+function requireObjectType() {
+    if (f) return p;
+    f = 1;
+    "use strict";
+    Object.defineProperty(p, "__esModule", {
+        value: true
+    });
+    return p;
+}
 
-Object.defineProperty(u, "__esModule", {
-    value: true
-});
+var d = requireObjectType();
 
-var a = {};
+const v = e.getDefaultExportFromCjs(d);
 
-"use strict";
+var y = {};
 
-Object.defineProperty(a, "__esModule", {
-    value: true
-});
+var g;
 
-var c = {};
+function requireObjectLiteral() {
+    if (g) return y;
+    g = 1;
+    "use strict";
+    Object.defineProperty(y, "__esModule", {
+        value: true
+    });
+    return y;
+}
 
-"use strict";
+var O = requireObjectLiteral();
 
-Object.defineProperty(c, "__esModule", {
-    value: true
-});
+const q = e.getDefaultExportFromCjs(O);
 
-var d = {};
+var m = {};
 
-"use strict";
+var E;
 
-Object.defineProperty(d, "__esModule", {
-    value: true
-});
+function requireMixedList() {
+    if (E) return m;
+    E = 1;
+    "use strict";
+    Object.defineProperty(m, "__esModule", {
+        value: true
+    });
+    return m;
+}
 
-var l = {};
+var j = requireMixedList();
 
-"use strict";
+const F = e.getDefaultExportFromCjs(j);
 
-Object.defineProperty(l, "__esModule", {
-    value: true
-});
+var C = {};
 
-var p = {};
+var x;
 
-"use strict";
+function requireDeepPartial() {
+    if (x) return C;
+    x = 1;
+    "use strict";
+    Object.defineProperty(C, "__esModule", {
+        value: true
+    });
+    return C;
+}
 
-Object.defineProperty(p, "__esModule", {
-    value: true
-});
+var b = requireDeepPartial();
 
-var y = {};
+const h = e.getDefaultExportFromCjs(b);
 
-"use strict";
+var _ = {};
 
-Object.defineProperty(y, "__esModule", {
-    value: true
-});
+var D;
 
-var O = {};
+function requireRelationType() {
+    if (D) return _;
+    D = 1;
+    "use strict";
+    Object.defineProperty(_, "__esModule", {
+        value: true
+    });
+    return _;
+}
 
-"use strict";
+var M = requireRelationType();
 
-Object.defineProperty(O, "__esModule", {
-    value: true
-});
+const R = e.getDefaultExportFromCjs(M);
 
-var f = {};
+var P = r.requireError();
 
-"use strict";
+const B = e.getDefaultExportFromCjs(P);
 
-Object.defineProperty(f, "__esModule", {
-    value: true
-});
+var T = {};
 
-var b = {};
+var S;
 
-"use strict";
+function requireColumnOptions() {
+    if (S) return T;
+    S = 1;
+    "use strict";
+    Object.defineProperty(T, "__esModule", {
+        value: true
+    });
+    return T;
+}
 
-Object.defineProperty(b, "__esModule", {
-    value: true
-});
+var I = requireColumnOptions();
 
-var g = {};
+const N = e.getDefaultExportFromCjs(I);
 
-"use strict";
+var L = {};
 
-Object.defineProperty(g, "__esModule", {
-    value: true
-});
+var k;
 
-var v = {};
+function requireIndexOptions() {
+    if (k) return L;
+    k = 1;
+    "use strict";
+    Object.defineProperty(L, "__esModule", {
+        value: true
+    });
+    return L;
+}
 
-"use strict";
+var w = requireIndexOptions();
 
-Object.defineProperty(v, "__esModule", {
-    value: true
-});
+const A = e.getDefaultExportFromCjs(w);
 
-var _ = v.And = j;
+var Q = {};
 
-const m = t.FindOperator;
+var U;
 
-function j(...e) {
-    return new m.FindOperator("and", e, true, true);
+function requireJoinColumnOptions() {
+    if (U) return Q;
+    U = 1;
+    "use strict";
+    Object.defineProperty(Q, "__esModule", {
+        value: true
+    });
+    return Q;
 }
 
-var P = {};
-
-"use strict";
+var J = requireJoinColumnOptions();
 
-Object.defineProperty(P, "__esModule", {
-    value: true
-});
+const K = e.getDefaultExportFromCjs(J);
 
-var h = P.Any = x;
+var X = {};
 
-const M = t.FindOperator;
+var z;
 
-function x(e) {
-    return new M.FindOperator("any", e);
+function requireJoinTableOptions() {
+    if (z) return X;
+    z = 1;
+    "use strict";
+    Object.defineProperty(X, "__esModule", {
+        value: true
+    });
+    return X;
 }
 
-var E = {};
+var Z = requireJoinTableOptions();
 
-"use strict";
-
-Object.defineProperty(E, "__esModule", {
-    value: true
-});
+const G = e.getDefaultExportFromCjs(Z);
 
-var R = E.ArrayContainedBy = S;
+var V = {};
 
-const B = t.FindOperator;
+var W;
 
-function S(e) {
-    return new B.FindOperator("arrayContainedBy", e);
+function requireRelationOptions() {
+    if (W) return V;
+    W = 1;
+    "use strict";
+    Object.defineProperty(V, "__esModule", {
+        value: true
+    });
+    return V;
 }
 
-var F = {};
-
-"use strict";
+var H = requireRelationOptions();
 
-Object.defineProperty(F, "__esModule", {
-    value: true
-});
+const Y = e.getDefaultExportFromCjs(H);
 
-var I = F.ArrayContains = T;
+var $ = {};
 
-const q = t.FindOperator;
+var ee;
 
-function T(e) {
-    return new q.FindOperator("arrayContains", e);
+function requireEntityOptions() {
+    if (ee) return $;
+    ee = 1;
+    "use strict";
+    Object.defineProperty($, "__esModule", {
+        value: true
+    });
+    return $;
 }
 
-var C = {};
-
-"use strict";
+var re = requireEntityOptions();
 
-Object.defineProperty(C, "__esModule", {
-    value: true
-});
+const te = e.getDefaultExportFromCjs(re);
 
-var N = C.ArrayOverlap = k;
+var ne = {};
 
-const D = t.FindOperator;
+var oe;
 
-function k(e) {
-    return new D.FindOperator("arrayOverlap", e);
+function requireValueTransformer() {
+    if (oe) return ne;
+    oe = 1;
+    "use strict";
+    Object.defineProperty(ne, "__esModule", {
+        value: true
+    });
+    return ne;
 }
 
-var w = {};
-
-"use strict";
+var ue = requireValueTransformer();
 
-Object.defineProperty(w, "__esModule", {
-    value: true
-});
+const ie = e.getDefaultExportFromCjs(ue);
 
-var L = w.Between = Q;
+var se = {};
 
-const A = t.FindOperator;
+var ae;
 
-function Q(e, t) {
-    return new A.FindOperator("between", [ e, t ], true, true);
+function requireAnd() {
+    if (ae) return se;
+    ae = 1;
+    "use strict";
+    Object.defineProperty(se, "__esModule", {
+        value: true
+    });
+    se.And = And;
+    const e = r.requireFindOperator();
+    function And(...r) {
+        return new e.FindOperator("and", r, true, true);
+    }
+    return se;
 }
 
-var U = {};
-
-var K = {};
-
-"use strict";
+var ce = requireAnd();
 
-Object.defineProperty(K, "__esModule", {
-    value: true
-});
+const le = e.getDefaultExportFromCjs(ce);
 
-exports.EqualOperator = K.EqualOperator = void 0;
+var pe = {};
 
-const X = t.FindOperator;
+var fe;
 
-class EqualOperator extends X.FindOperator {
-    constructor(e) {
-        super("equal", e);
-        this["@instanceof"] = Symbol.for("EqualOperator");
+function requireAny() {
+    if (fe) return pe;
+    fe = 1;
+    "use strict";
+    Object.defineProperty(pe, "__esModule", {
+        value: true
+    });
+    pe.Any = Any;
+    const e = r.requireFindOperator();
+    function Any(r) {
+        return new e.FindOperator("any", r);
     }
+    return pe;
 }
 
-exports.EqualOperator = K.EqualOperator = EqualOperator;
-
-"use strict";
+var de = requireAny();
 
-Object.defineProperty(U, "__esModule", {
-    value: true
-});
+const ve = e.getDefaultExportFromCjs(de);
 
-var z = U.Equal = G;
+var ye = {};
 
-const Z = K;
+var ge;
 
-function G(e) {
-    return new Z.EqualOperator(e);
+function requireArrayContainedBy() {
+    if (ge) return ye;
+    ge = 1;
+    "use strict";
+    Object.defineProperty(ye, "__esModule", {
+        value: true
+    });
+    ye.ArrayContainedBy = ArrayContainedBy;
+    const e = r.requireFindOperator();
+    function ArrayContainedBy(r) {
+        return new e.FindOperator("arrayContainedBy", r);
+    }
+    return ye;
 }
 
-var J = {};
+var Oe = requireArrayContainedBy();
 
-"use strict";
-
-Object.defineProperty(J, "__esModule", {
-    value: true
-});
+const qe = e.getDefaultExportFromCjs(Oe);
 
-var H = J.IsNull = W;
+var me = {};
 
-const V = t.FindOperator;
+var Ee;
 
-function W() {
-    return new V.FindOperator("isNull", undefined, false);
+function requireArrayContains() {
+    if (Ee) return me;
+    Ee = 1;
+    "use strict";
+    Object.defineProperty(me, "__esModule", {
+        value: true
+    });
+    me.ArrayContains = ArrayContains;
+    const e = r.requireFindOperator();
+    function ArrayContains(r) {
+        return new e.FindOperator("arrayContains", r);
+    }
+    return me;
 }
 
-var Y = {};
-
-"use strict";
+var je = requireArrayContains();
 
-Object.defineProperty(Y, "__esModule", {
-    value: true
-});
+const Fe = e.getDefaultExportFromCjs(je);
 
-var $ = Y.LessThan = te;
+var Ce = {};
 
-const ee = t.FindOperator;
+var xe;
 
-function te(e) {
-    return new ee.FindOperator("lessThan", e);
+function requireArrayOverlap() {
+    if (xe) return Ce;
+    xe = 1;
+    "use strict";
+    Object.defineProperty(Ce, "__esModule", {
+        value: true
+    });
+    Ce.ArrayOverlap = ArrayOverlap;
+    const e = r.requireFindOperator();
+    function ArrayOverlap(r) {
+        return new e.FindOperator("arrayOverlap", r);
+    }
+    return Ce;
 }
 
-var re = {};
-
-"use strict";
+var be = requireArrayOverlap();
 
-Object.defineProperty(re, "__esModule", {
-    value: true
-});
+const he = e.getDefaultExportFromCjs(be);
 
-var oe = re.LessThanOrEqual = se;
+var _e = {};
 
-const ne = t.FindOperator;
+var De;
 
-function se(e) {
-    return new ne.FindOperator("lessThanOrEqual", e);
+function requireBetween() {
+    if (De) return _e;
+    De = 1;
+    "use strict";
+    Object.defineProperty(_e, "__esModule", {
+        value: true
+    });
+    _e.Between = Between;
+    const e = r.requireFindOperator();
+    function Between(r, t) {
+        return new e.FindOperator("between", [ r, t ], true, true);
+    }
+    return _e;
 }
 
-var ie = {};
+var Me = requireBetween();
 
-"use strict";
+const Re = e.getDefaultExportFromCjs(Me);
 
-Object.defineProperty(ie, "__esModule", {
-    value: true
-});
+var Pe = {};
 
-var ue = ie.ILike = ce;
+var Be = {};
 
-const ae = t.FindOperator;
+var Te;
 
-function ce(e) {
-    return new ae.FindOperator("ilike", e);
+function requireEqualOperator() {
+    if (Te) return Be;
+    Te = 1;
+    "use strict";
+    Object.defineProperty(Be, "__esModule", {
+        value: true
+    });
+    Be.EqualOperator = void 0;
+    const e = r.requireFindOperator();
+    class EqualOperator extends e.FindOperator {
+        constructor(e) {
+            super("equal", e);
+            this["@instanceof"] = Symbol.for("EqualOperator");
+        }
+    }
+    Be.EqualOperator = EqualOperator;
+    return Be;
 }
 
-var de = {};
+var Se;
 
-"use strict";
+function requireEqual() {
+    if (Se) return Pe;
+    Se = 1;
+    "use strict";
+    Object.defineProperty(Pe, "__esModule", {
+        value: true
+    });
+    Pe.Equal = Equal;
+    const e = requireEqualOperator();
+    function Equal(r) {
+        return new e.EqualOperator(r);
+    }
+    return Pe;
+}
 
-Object.defineProperty(de, "__esModule", {
-    value: true
-});
+var Ie = requireEqual();
 
-var le = de.Like = ye;
+const Ne = e.getDefaultExportFromCjs(Ie);
 
-const pe = t.FindOperator;
+var Le = r.requireIn();
 
-function ye(e) {
-    return new pe.FindOperator("like", e);
-}
+const ke = e.getDefaultExportFromCjs(Le);
 
-var Oe = {};
+var we = {};
 
-"use strict";
+var Ae;
 
-Object.defineProperty(Oe, "__esModule", {
-    value: true
-});
+function requireIsNull() {
+    if (Ae) return we;
+    Ae = 1;
+    "use strict";
+    Object.defineProperty(we, "__esModule", {
+        value: true
+    });
+    we.IsNull = IsNull;
+    const e = r.requireFindOperator();
+    function IsNull() {
+        return new e.FindOperator("isNull", undefined, false);
+    }
+    return we;
+}
 
-var fe = Oe.MoreThan = ge;
+var Qe = requireIsNull();
 
-const be = t.FindOperator;
+const Ue = e.getDefaultExportFromCjs(Qe);
 
-function ge(e) {
-    return new be.FindOperator("moreThan", e);
-}
+var Je = {};
 
-var ve = {};
+var Ke;
 
-"use strict";
+function requireLessThan() {
+    if (Ke) return Je;
+    Ke = 1;
+    "use strict";
+    Object.defineProperty(Je, "__esModule", {
+        value: true
+    });
+    Je.LessThan = LessThan;
+    const e = r.requireFindOperator();
+    function LessThan(r) {
+        return new e.FindOperator("lessThan", r);
+    }
+    return Je;
+}
 
-Object.defineProperty(ve, "__esModule", {
-    value: true
-});
+var Xe = requireLessThan();
 
-var _e = ve.MoreThanOrEqual = je;
+const ze = e.getDefaultExportFromCjs(Xe);
 
-const me = t.FindOperator;
+var Ze = {};
 
-function je(e) {
-    return new me.FindOperator("moreThanOrEqual", e);
-}
+var Ge;
 
-var Pe = {};
+function requireLessThanOrEqual() {
+    if (Ge) return Ze;
+    Ge = 1;
+    "use strict";
+    Object.defineProperty(Ze, "__esModule", {
+        value: true
+    });
+    Ze.LessThanOrEqual = LessThanOrEqual;
+    const e = r.requireFindOperator();
+    function LessThanOrEqual(r) {
+        return new e.FindOperator("lessThanOrEqual", r);
+    }
+    return Ze;
+}
 
-"use strict";
+var Ve = requireLessThanOrEqual();
 
-Object.defineProperty(Pe, "__esModule", {
-    value: true
-});
+const We = e.getDefaultExportFromCjs(Ve);
 
-var he = Pe.Not = xe;
+var He = {};
 
-const Me = t.FindOperator;
+var Ye;
 
-function xe(e) {
-    return new Me.FindOperator("not", e);
+function requireILike() {
+    if (Ye) return He;
+    Ye = 1;
+    "use strict";
+    Object.defineProperty(He, "__esModule", {
+        value: true
+    });
+    He.ILike = ILike;
+    const e = r.requireFindOperator();
+    function ILike(r) {
+        return new e.FindOperator("ilike", r);
+    }
+    return He;
 }
 
-var Ee = {};
-
-"use strict";
+var $e = requireILike();
 
-Object.defineProperty(Ee, "__esModule", {
-    value: true
-});
+const er = e.getDefaultExportFromCjs($e);
 
-var Re = Ee.Raw = Se;
+var rr = {};
 
-const Be = t.FindOperator;
+var tr;
 
-function Se(e, t) {
-    if (typeof e !== "function") {
-        return new Be.FindOperator("raw", e, false);
+function requireLike() {
+    if (tr) return rr;
+    tr = 1;
+    "use strict";
+    Object.defineProperty(rr, "__esModule", {
+        value: true
+    });
+    rr.Like = Like;
+    const e = r.requireFindOperator();
+    function Like(r) {
+        return new e.FindOperator("like", r);
     }
-    return new Be.FindOperator("raw", [], true, true, e, t);
+    return rr;
 }
 
-var Fe = {};
-
-"use strict";
+var nr = requireLike();
 
-Object.defineProperty(Fe, "__esModule", {
-    value: true
-});
+const or = e.getDefaultExportFromCjs(nr);
 
-var Ie = Fe.JsonContains = Te;
+var ur = {};
 
-const qe = t.FindOperator;
+var ir;
 
-function Te(e) {
-    return new qe.FindOperator("jsonContains", e);
+function requireMoreThan() {
+    if (ir) return ur;
+    ir = 1;
+    "use strict";
+    Object.defineProperty(ur, "__esModule", {
+        value: true
+    });
+    ur.MoreThan = MoreThan;
+    const e = r.requireFindOperator();
+    function MoreThan(r) {
+        return new e.FindOperator("moreThan", r);
+    }
+    return ur;
 }
 
-var Ce = {};
+var sr = requireMoreThan();
 
-"use strict";
+const ar = e.getDefaultExportFromCjs(sr);
 
-Object.defineProperty(Ce, "__esModule", {
-    value: true
-});
+var cr = {};
 
-var Ne = {};
+var lr;
 
-"use strict";
+function requireMoreThanOrEqual() {
+    if (lr) return cr;
+    lr = 1;
+    "use strict";
+    Object.defineProperty(cr, "__esModule", {
+        value: true
+    });
+    cr.MoreThanOrEqual = MoreThanOrEqual;
+    const e = r.requireFindOperator();
+    function MoreThanOrEqual(r) {
+        return new e.FindOperator("moreThanOrEqual", r);
+    }
+    return cr;
+}
 
-Object.defineProperty(Ne, "__esModule", {
-    value: true
-});
+var pr = requireMoreThanOrEqual();
 
-var De = {};
+const fr = e.getDefaultExportFromCjs(pr);
 
-"use strict";
+var dr = {};
 
-Object.defineProperty(De, "__esModule", {
-    value: true
-});
+var vr;
 
-var ke = {};
+function requireNot() {
+    if (vr) return dr;
+    vr = 1;
+    "use strict";
+    Object.defineProperty(dr, "__esModule", {
+        value: true
+    });
+    dr.Not = Not;
+    const e = r.requireFindOperator();
+    function Not(r) {
+        return new e.FindOperator("not", r);
+    }
+    return dr;
+}
 
-"use strict";
+var yr = requireNot();
 
-Object.defineProperty(ke, "__esModule", {
-    value: true
-});
+const gr = e.getDefaultExportFromCjs(yr);
 
-var we = {};
+var Or = {};
 
-"use strict";
+var qr;
 
-Object.defineProperty(we, "__esModule", {
-    value: true
-});
+function requireRaw() {
+    if (qr) return Or;
+    qr = 1;
+    "use strict";
+    Object.defineProperty(Or, "__esModule", {
+        value: true
+    });
+    Or.Raw = Raw;
+    const e = r.requireFindOperator();
+    function Raw(r, t) {
+        if (typeof r !== "function") {
+            return new e.FindOperator("raw", r, false);
+        }
+        return new e.FindOperator("raw", [], true, true, r, t);
+    }
+    return Or;
+}
 
-var Le = {};
+var mr = requireRaw();
 
-"use strict";
+const Er = e.getDefaultExportFromCjs(mr);
 
-Object.defineProperty(Le, "__esModule", {
-    value: true
-});
+var jr = {};
 
-var Ae = {};
+var Fr;
 
-"use strict";
+function requireJsonContains() {
+    if (Fr) return jr;
+    Fr = 1;
+    "use strict";
+    Object.defineProperty(jr, "__esModule", {
+        value: true
+    });
+    jr.JsonContains = JsonContains;
+    const e = r.requireFindOperator();
+    function JsonContains(r) {
+        return new e.FindOperator("jsonContains", r);
+    }
+    return jr;
+}
 
-Object.defineProperty(Ae, "__esModule", {
-    value: true
-});
+var Cr = requireJsonContains();
 
-var Qe = {};
+const xr = e.getDefaultExportFromCjs(Cr);
 
-"use strict";
+var br = requireEqualOperator();
 
-Object.defineProperty(Qe, "__esModule", {
-    value: true
-});
+const hr = e.getDefaultExportFromCjs(br);
 
-var Ue = {};
+var _r = {};
 
-"use strict";
+var Dr;
 
-Object.defineProperty(Ue, "__esModule", {
-    value: true
-});
+function requireFindManyOptions() {
+    if (Dr) return _r;
+    Dr = 1;
+    "use strict";
+    Object.defineProperty(_r, "__esModule", {
+        value: true
+    });
+    return _r;
+}
 
-var Ke = {};
+var Mr = requireFindManyOptions();
 
-"use strict";
+const Rr = e.getDefaultExportFromCjs(Mr);
 
-Object.defineProperty(Ke, "__esModule", {
-    value: true
-});
+var Pr = {};
 
-var Xe = {};
+var Br;
 
-"use strict";
+function requireFindOneOptions() {
+    if (Br) return Pr;
+    Br = 1;
+    "use strict";
+    Object.defineProperty(Pr, "__esModule", {
+        value: true
+    });
+    return Pr;
+}
 
-Object.defineProperty(Xe, "__esModule", {
-    value: true
-});
+var Tr = requireFindOneOptions();
 
-var ze = {};
+const Sr = e.getDefaultExportFromCjs(Tr);
 
-"use strict";
+var Ir = r.requireFindOperator();
 
-Object.defineProperty(ze, "__esModule", {
-    value: true
-});
+const Nr = e.getDefaultExportFromCjs(Ir);
 
-var Ze = t.requireEntityManager();
+var Lr = {};
 
-const Ge = e.getDefaultExportFromCjs(Ze);
+var kr;
 
-var Je = t.requireAbstractRepository();
+function requireFindOperatorType() {
+    if (kr) return Lr;
+    kr = 1;
+    "use strict";
+    Object.defineProperty(Lr, "__esModule", {
+        value: true
+    });
+    return Lr;
+}
 
-const He = e.getDefaultExportFromCjs(Je);
+var wr = requireFindOperatorType();
 
-var Ve = {};
+const Ar = e.getDefaultExportFromCjs(wr);
 
-"use strict";
+var Qr = {};
 
-Object.defineProperty(Ve, "__esModule", {
-    value: true
-});
+var Ur;
 
-exports.BaseEntity = Ve.BaseEntity = void 0;
+function requireFindOptionsOrder() {
+    if (Ur) return Qr;
+    Ur = 1;
+    "use strict";
+    Object.defineProperty(Qr, "__esModule", {
+        value: true
+    });
+    return Qr;
+}
 
-const We = t.ObjectUtils;
+var Jr = requireFindOptionsOrder();
 
-class BaseEntity {
-    hasId() {
-        const e = this.constructor;
-        return e.getRepository().hasId(this);
-    }
-    save(e) {
-        const t = this.constructor;
-        return t.getRepository().save(this, e);
-    }
-    remove(e) {
-        const t = this.constructor;
-        return t.getRepository().remove(this, e);
-    }
-    softRemove(e) {
-        const t = this.constructor;
-        return t.getRepository().softRemove(this, e);
-    }
-    recover(e) {
-        const t = this.constructor;
-        return t.getRepository().recover(this, e);
-    }
-    async reload() {
-        const e = this.constructor;
-        const t = e.getRepository().metadata.getEntityIdMap(this);
-        if (!t) {
-            throw new Error(`Entity doesn't have id-s set, cannot reload entity`);
-        }
-        const r = await e.getRepository().findOneByOrFail(t);
-        We.ObjectUtils.assign(this, r);
-    }
-    static useDataSource(e) {
-        this.dataSource = e;
-    }
-    static getRepository() {
-        const e = this.dataSource;
-        if (!e) throw new Error(`DataSource is not set for this entity.`);
-        return e.getRepository(this);
-    }
-    static get target() {
-        return this.getRepository().target;
-    }
-    static hasId(e) {
-        return this.getRepository().hasId(e);
-    }
-    static getId(e) {
-        return this.getRepository().getId(e);
-    }
-    static createQueryBuilder(e) {
-        return this.getRepository().createQueryBuilder(e);
-    }
-    static create(e) {
-        return this.getRepository().create(e);
-    }
-    static merge(e, ...t) {
-        return this.getRepository().merge(e, ...t);
-    }
-    static preload(e) {
-        const t = this.getRepository();
-        return t.preload(e);
-    }
-    static save(e, t) {
-        return this.getRepository().save(e, t);
-    }
-    static remove(e, t) {
-        return this.getRepository().remove(e, t);
-    }
-    static softRemove(e, t) {
-        return this.getRepository().softRemove(e, t);
-    }
-    static insert(e) {
-        return this.getRepository().insert(e);
-    }
-    static update(e, t) {
-        return this.getRepository().update(e, t);
-    }
-    static upsert(e, t) {
-        return this.getRepository().upsert(e, t);
-    }
-    static delete(e) {
-        return this.getRepository().delete(e);
-    }
-    static exists(e) {
-        return this.getRepository().exists(e);
-    }
-    static existsBy(e) {
-        return this.getRepository().existsBy(e);
-    }
-    static count(e) {
-        return this.getRepository().count(e);
-    }
-    static countBy(e) {
-        return this.getRepository().countBy(e);
-    }
-    static sum(e, t) {
-        return this.getRepository().sum(e, t);
-    }
-    static average(e, t) {
-        return this.getRepository().average(e, t);
-    }
-    static minimum(e, t) {
-        return this.getRepository().minimum(e, t);
-    }
-    static maximum(e, t) {
-        return this.getRepository().maximum(e, t);
-    }
-    static find(e) {
-        return this.getRepository().find(e);
-    }
-    static findBy(e) {
-        return this.getRepository().findBy(e);
-    }
-    static findAndCount(e) {
-        return this.getRepository().findAndCount(e);
-    }
-    static findAndCountBy(e) {
-        return this.getRepository().findAndCountBy(e);
-    }
-    static findByIds(e) {
-        return this.getRepository().findByIds(e);
-    }
-    static findOne(e) {
-        return this.getRepository().findOne(e);
-    }
-    static findOneBy(e) {
-        return this.getRepository().findOneBy(e);
-    }
-    static findOneById(e) {
-        return this.getRepository().findOneById(e);
-    }
-    static findOneOrFail(e) {
-        return this.getRepository().findOneOrFail(e);
-    }
-    static findOneByOrFail(e) {
-        return this.getRepository().findOneByOrFail(e);
-    }
-    static query(e, t) {
-        return this.getRepository().query(e, t);
-    }
-    static clear() {
-        return this.getRepository().clear();
-    }
+const Kr = e.getDefaultExportFromCjs(Jr);
+
+var Xr = {};
+
+var zr;
+
+function requireFindOptionsRelations() {
+    if (zr) return Xr;
+    zr = 1;
+    "use strict";
+    Object.defineProperty(Xr, "__esModule", {
+        value: true
+    });
+    return Xr;
 }
 
-exports.BaseEntity = Ve.BaseEntity = BaseEntity;
+var Zr = requireFindOptionsRelations();
 
-var Ye = {};
+const Gr = e.getDefaultExportFromCjs(Zr);
 
-"use strict";
+var Vr = {};
 
-Object.defineProperty(Ye, "__esModule", {
-    value: true
-});
+var Wr;
 
-var $e = {};
+function requireFindOptionsSelect() {
+    if (Wr) return Vr;
+    Wr = 1;
+    "use strict";
+    Object.defineProperty(Vr, "__esModule", {
+        value: true
+    });
+    return Vr;
+}
 
-"use strict";
+var Hr = requireFindOptionsSelect();
 
-Object.defineProperty($e, "__esModule", {
-    value: true
-});
+const Yr = e.getDefaultExportFromCjs(Hr);
 
-var et = {};
+var $r = r.requireFindOptionsUtils();
 
-"use strict";
+const et = e.getDefaultExportFromCjs($r);
 
-Object.defineProperty(et, "__esModule", {
-    value: true
-});
+var rt = {};
 
-var tt = {};
+var tt;
 
-"use strict";
+function requireFindOptionsWhere() {
+    if (tt) return rt;
+    tt = 1;
+    "use strict";
+    Object.defineProperty(rt, "__esModule", {
+        value: true
+    });
+    return rt;
+}
 
-Object.defineProperty(tt, "__esModule", {
-    value: true
-});
+var nt = requireFindOptionsWhere();
 
-var rt = {};
+const ot = e.getDefaultExportFromCjs(nt);
 
-"use strict";
+var ut = {};
 
-Object.defineProperty(rt, "__esModule", {
-    value: true
-});
+var it;
 
-var ot = {};
+function requireFindTreeOptions() {
+    if (it) return ut;
+    it = 1;
+    "use strict";
+    Object.defineProperty(ut, "__esModule", {
+        value: true
+    });
+    return ut;
+}
 
-"use strict";
+var st = requireFindTreeOptions();
 
-Object.defineProperty(ot, "__esModule", {
-    value: true
-});
+const at = e.getDefaultExportFromCjs(st);
 
-var nt = {};
+var ct = {};
 
-"use strict";
+var lt;
 
-Object.defineProperty(nt, "__esModule", {
-    value: true
-});
+function requireJoinOptions() {
+    if (lt) return ct;
+    lt = 1;
+    "use strict";
+    Object.defineProperty(ct, "__esModule", {
+        value: true
+    });
+    return ct;
+}
 
-var st = {};
+var pt = requireJoinOptions();
 
-"use strict";
+const ft = e.getDefaultExportFromCjs(pt);
 
-Object.defineProperty(st, "__esModule", {
-    value: true
-});
+var dt = {};
 
-var it = {};
+var vt;
 
-"use strict";
+function requireOrderByCondition() {
+    if (vt) return dt;
+    vt = 1;
+    "use strict";
+    Object.defineProperty(dt, "__esModule", {
+        value: true
+    });
+    return dt;
+}
 
-Object.defineProperty(it, "__esModule", {
-    value: true
-});
+var yt = requireOrderByCondition();
 
-var ut = {};
+const gt = e.getDefaultExportFromCjs(yt);
 
-"use strict";
+var Ot = r.requireAbstractLogger();
 
-Object.defineProperty(ut, "__esModule", {
-    value: true
-});
+const qt = e.getDefaultExportFromCjs(Ot);
 
-var at = {};
+var mt = {};
 
-var ct = {};
+var Et;
 
-"use strict";
+function requireLogger() {
+    if (Et) return mt;
+    Et = 1;
+    "use strict";
+    Object.defineProperty(mt, "__esModule", {
+        value: true
+    });
+    return mt;
+}
 
-Object.defineProperty(ct, "__esModule", {
-    value: true
-});
+var jt = requireLogger();
 
-var dt = ct.BSON = void 0;
+const Ft = e.getDefaultExportFromCjs(jt);
 
-(function(e) {
+var Ct = {};
+
+var xt;
+
+function requireLoggerOptions() {
+    if (xt) return Ct;
+    xt = 1;
     "use strict";
-    Object.defineProperty(e, "__esModule", {
+    Object.defineProperty(Ct, "__esModule", {
         value: true
     });
-    e.Timestamp = e.serialize = e.ObjectId = e.MinKey = e.MaxKey = e.Long = e.Int32 = e.Double = e.deserialize = e.Decimal128 = e.DBRef = e.Code = e.BSONType = e.BSONSymbol = e.BSONRegExp = e.BSON = e.Binary = void 0;
-    const t = ct;
-    Object.defineProperty(e, "BSON", {
-        enumerable: true,
-        get: function() {
-            return t.BSON;
-        }
+    return Ct;
+}
+
+var bt = requireLoggerOptions();
+
+const ht = e.getDefaultExportFromCjs(bt);
+
+var _t = r.requireAdvancedConsoleLogger();
+
+const Dt = e.getDefaultExportFromCjs(_t);
+
+var Mt = r.requireSimpleConsoleLogger();
+
+const Rt = e.getDefaultExportFromCjs(Mt);
+
+var Pt = r.requireFileLogger();
+
+const Bt = e.getDefaultExportFromCjs(Pt);
+
+var Tt = r.requireEntityMetadata();
+
+const St = e.getDefaultExportFromCjs(Tt);
+
+var It = r.requireEntityManager();
+
+const Nt = e.getDefaultExportFromCjs(It);
+
+var Lt = r.requireAbstractRepository();
+
+const kt = e.getDefaultExportFromCjs(Lt);
+
+var wt = r.requireRepository();
+
+const At = e.getDefaultExportFromCjs(wt);
+
+var Qt = {};
+
+var Ut;
+
+function requireBaseEntity() {
+    if (Ut) return Qt;
+    Ut = 1;
+    "use strict";
+    Object.defineProperty(Qt, "__esModule", {
+        value: true
     });
-    Object.defineProperty(e, "BSONRegExp", {
-        enumerable: true,
-        get: function() {
-            return t.BSONRegExp;
+    Qt.BaseEntity = void 0;
+    const e = r.requireObjectUtils();
+    class BaseEntity {
+        hasId() {
+            const e = this.constructor;
+            return e.getRepository().hasId(this);
         }
-    });
-    Object.defineProperty(e, "BSONSymbol", {
-        enumerable: true,
-        get: function() {
-            return t.BSONSymbol;
+        save(e) {
+            const r = this.constructor;
+            return r.getRepository().save(this, e);
         }
-    });
-    Object.defineProperty(e, "BSONType", {
-        enumerable: true,
-        get: function() {
-            return t.BSONType;
+        remove(e) {
+            const r = this.constructor;
+            return r.getRepository().remove(this, e);
         }
-    });
-    Object.defineProperty(e, "Binary", {
-        enumerable: true,
-        get: function() {
-            return t.Binary;
+        softRemove(e) {
+            const r = this.constructor;
+            return r.getRepository().softRemove(this, e);
         }
-    });
-    Object.defineProperty(e, "Code", {
-        enumerable: true,
-        get: function() {
-            return t.Code;
+        recover(e) {
+            const r = this.constructor;
+            return r.getRepository().recover(this, e);
         }
-    });
-    Object.defineProperty(e, "DBRef", {
-        enumerable: true,
-        get: function() {
-            return t.DBRef;
+        async reload() {
+            const r = this.constructor;
+            const t = r.getRepository().metadata.getEntityIdMap(this);
+            if (!t) {
+                throw new Error(`Entity doesn't have id-s set, cannot reload entity`);
+            }
+            const n = await r.getRepository().findOneByOrFail(t);
+            e.ObjectUtils.assign(this, n);
         }
-    });
-    Object.defineProperty(e, "Decimal128", {
-        enumerable: true,
-        get: function() {
-            return t.Decimal128;
+        static useDataSource(e) {
+            this.dataSource = e;
         }
-    });
-    Object.defineProperty(e, "Double", {
-        enumerable: true,
-        get: function() {
-            return t.Double;
+        static getRepository() {
+            const e = this.dataSource;
+            if (!e) throw new Error(`DataSource is not set for this entity.`);
+            return e.getRepository(this);
         }
-    });
-    Object.defineProperty(e, "Int32", {
-        enumerable: true,
-        get: function() {
-            return t.Int32;
+        static get target() {
+            return this.getRepository().target;
         }
-    });
-    Object.defineProperty(e, "Long", {
-        enumerable: true,
-        get: function() {
-            return t.Long;
+        static hasId(e) {
+            return this.getRepository().hasId(e);
         }
-    });
-    Object.defineProperty(e, "MaxKey", {
-        enumerable: true,
-        get: function() {
-            return t.MaxKey;
+        static getId(e) {
+            return this.getRepository().getId(e);
         }
-    });
-    Object.defineProperty(e, "MinKey", {
-        enumerable: true,
-        get: function() {
-            return t.MinKey;
+        static createQueryBuilder(e) {
+            return this.getRepository().createQueryBuilder(e);
         }
-    });
-    Object.defineProperty(e, "ObjectId", {
-        enumerable: true,
-        get: function() {
-            return t.ObjectId;
+        static create(e) {
+            return this.getRepository().create(e);
         }
-    });
-    Object.defineProperty(e, "Timestamp", {
-        enumerable: true,
-        get: function() {
-            return t.Timestamp;
+        static merge(e, ...r) {
+            return this.getRepository().merge(e, ...r);
         }
-    });
-    Object.defineProperty(e, "deserialize", {
-        enumerable: true,
-        get: function() {
-            return t.deserialize;
+        static preload(e) {
+            const r = this.getRepository();
+            return r.preload(e);
         }
-    });
-    Object.defineProperty(e, "serialize", {
-        enumerable: true,
-        get: function() {
-            return t.serialize;
+        static save(e, r) {
+            return this.getRepository().save(e, r);
+        }
+        static remove(e, r) {
+            return this.getRepository().remove(e, r);
+        }
+        static softRemove(e, r) {
+            return this.getRepository().softRemove(e, r);
+        }
+        static insert(e) {
+            return this.getRepository().insert(e);
+        }
+        static update(e, r) {
+            return this.getRepository().update(e, r);
+        }
+        static upsert(e, r) {
+            return this.getRepository().upsert(e, r);
+        }
+        static delete(e) {
+            return this.getRepository().delete(e);
+        }
+        static exists(e) {
+            return this.getRepository().exists(e);
+        }
+        static existsBy(e) {
+            return this.getRepository().existsBy(e);
+        }
+        static count(e) {
+            return this.getRepository().count(e);
+        }
+        static countBy(e) {
+            return this.getRepository().countBy(e);
+        }
+        static sum(e, r) {
+            return this.getRepository().sum(e, r);
+        }
+        static average(e, r) {
+            return this.getRepository().average(e, r);
+        }
+        static minimum(e, r) {
+            return this.getRepository().minimum(e, r);
+        }
+        static maximum(e, r) {
+            return this.getRepository().maximum(e, r);
+        }
+        static find(e) {
+            return this.getRepository().find(e);
         }
+        static findBy(e) {
+            return this.getRepository().findBy(e);
+        }
+        static findAndCount(e) {
+            return this.getRepository().findAndCount(e);
+        }
+        static findAndCountBy(e) {
+            return this.getRepository().findAndCountBy(e);
+        }
+        static findByIds(e) {
+            return this.getRepository().findByIds(e);
+        }
+        static findOne(e) {
+            return this.getRepository().findOne(e);
+        }
+        static findOneBy(e) {
+            return this.getRepository().findOneBy(e);
+        }
+        static findOneById(e) {
+            return this.getRepository().findOneById(e);
+        }
+        static findOneOrFail(e) {
+            return this.getRepository().findOneOrFail(e);
+        }
+        static findOneByOrFail(e) {
+            return this.getRepository().findOneByOrFail(e);
+        }
+        static query(e, r) {
+            return this.getRepository().query(e, r);
+        }
+        static clear() {
+            return this.getRepository().clear();
+        }
+    }
+    Qt.BaseEntity = BaseEntity;
+    return Qt;
+}
+
+var Jt = requireBaseEntity();
+
+const Kt = e.getDefaultExportFromCjs(Jt);
+
+var Xt = r.requireTreeRepository();
+
+const zt = e.getDefaultExportFromCjs(Xt);
+
+var Zt = r.requireMongoRepository();
+
+const Gt = e.getDefaultExportFromCjs(Zt);
+
+var Vt = {};
+
+var Wt;
+
+function requireRemoveOptions() {
+    if (Wt) return Vt;
+    Wt = 1;
+    "use strict";
+    Object.defineProperty(Vt, "__esModule", {
+        value: true
+    });
+    return Vt;
+}
+
+var Ht = requireRemoveOptions();
+
+const Yt = e.getDefaultExportFromCjs(Ht);
+
+var $t = {};
+
+var en;
+
+function requireSaveOptions() {
+    if (en) return $t;
+    en = 1;
+    "use strict";
+    Object.defineProperty($t, "__esModule", {
+        value: true
     });
-})(at);
+    return $t;
+}
 
-const lt = e.getDefaultExportFromCjs(at);
+var rn = requireSaveOptions();
 
-var pt = {};
+const tn = e.getDefaultExportFromCjs(rn);
 
-"use strict";
+var nn = r.requireTableCheck();
 
-Object.defineProperty(pt, "__esModule", {
-    value: true
-});
+const on = e.getDefaultExportFromCjs(nn);
 
-var yt = {};
+var un = r.requireTableColumn();
 
-"use strict";
+const sn = e.getDefaultExportFromCjs(un);
 
-Object.defineProperty(yt, "__esModule", {
-    value: true
-});
+var an = r.requireTableExclusion();
 
-var Ot = {};
+const cn = e.getDefaultExportFromCjs(an);
 
-"use strict";
+var ln = r.requireTableForeignKey();
 
-Object.defineProperty(Ot, "__esModule", {
-    value: true
-});
+const pn = e.getDefaultExportFromCjs(ln);
 
-var ft = {};
+var fn = r.requireTableIndex();
 
-"use strict";
+const dn = e.getDefaultExportFromCjs(fn);
 
-Object.defineProperty(ft, "__esModule", {
-    value: true
-});
+var vn = r.requireTableUnique();
 
-exports.NotBrackets = ft.NotBrackets = void 0;
+const yn = e.getDefaultExportFromCjs(vn);
 
-const bt = t.Brackets;
+var gn = r.requireTable();
 
-class NotBrackets extends bt.Brackets {
-    constructor() {
-        super(...arguments);
-        this["@instanceof"] = Symbol.for("NotBrackets");
-    }
+const On = e.getDefaultExportFromCjs(gn);
+
+var qn = {};
+
+var mn;
+
+function requireTableCheckOptions() {
+    if (mn) return qn;
+    mn = 1;
+    "use strict";
+    Object.defineProperty(qn, "__esModule", {
+        value: true
+    });
+    return qn;
 }
 
-exports.NotBrackets = ft.NotBrackets = NotBrackets;
+var En = requireTableCheckOptions();
 
-var gt = t.requireMongoEntityManager();
+const jn = e.getDefaultExportFromCjs(En);
 
-const vt = e.getDefaultExportFromCjs(gt);
+var Fn = {};
 
-var _t = {};
+var Cn;
 
-"use strict";
+function requireTableColumnOptions() {
+    if (Cn) return Fn;
+    Cn = 1;
+    "use strict";
+    Object.defineProperty(Fn, "__esModule", {
+        value: true
+    });
+    return Fn;
+}
 
-Object.defineProperty(_t, "__esModule", {
-    value: true
-});
+var xn = requireTableColumnOptions();
 
-exports.LegacyOracleNamingStrategy = _t.LegacyOracleNamingStrategy = void 0;
+const bn = e.getDefaultExportFromCjs(xn);
 
-const mt = t.RandomGenerator;
+var hn = {};
 
-const jt = t.DefaultNamingStrategy;
+var _n;
 
-const Pt = t.error;
+function requireTableExclusionOptions() {
+    if (_n) return hn;
+    _n = 1;
+    "use strict";
+    Object.defineProperty(hn, "__esModule", {
+        value: true
+    });
+    return hn;
+}
 
-class LegacyOracleNamingStrategy extends jt.DefaultNamingStrategy {
-    constructor(e = "hash") {
-        super();
-        this.IDENTIFIER_MAX_SIZE = 30;
-        this.DEFAULT_COLUMN_PREFIX = "COL_";
-        this.shortenStrategy = e;
-    }
-    columnName(e, t, r) {
-        const o = super.columnName(e, t, r);
-        if (this.shortenStrategy === "truncate") {
-            return this.truncateIdentifier(o);
-        } else if (this.shortenStrategy === "hash") {
-            return this.hashIdentifier(o, this.DEFAULT_COLUMN_PREFIX);
-        } else {
-            throw new Pt.TypeORMError(`Invalid shortenStrategy`);
-        }
-    }
-    hashIdentifier(e, t) {
-        if (t.length >= this.IDENTIFIER_MAX_SIZE) {
-            throw new Pt.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
-        }
-        return t + mt.RandomGenerator.sha1(e).substring(0, this.IDENTIFIER_MAX_SIZE - t.length);
-    }
-    truncateIdentifier(e) {
-        if (e.length > this.IDENTIFIER_MAX_SIZE) {
-            return e.substring(0, this.IDENTIFIER_MAX_SIZE);
-        } else {
-            return e;
-        }
-    }
+var Dn = requireTableExclusionOptions();
+
+const Mn = e.getDefaultExportFromCjs(Dn);
+
+var Rn = {};
+
+var Pn;
+
+function requireTableForeignKeyOptions() {
+    if (Pn) return Rn;
+    Pn = 1;
+    "use strict";
+    Object.defineProperty(Rn, "__esModule", {
+        value: true
+    });
+    return Rn;
 }
 
-exports.LegacyOracleNamingStrategy = _t.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+var Bn = requireTableForeignKeyOptions();
 
-var ht = {};
+const Tn = e.getDefaultExportFromCjs(Bn);
 
-"use strict";
+var Sn = {};
 
-Object.defineProperty(ht, "__esModule", {
-    value: true
-});
+var In;
 
-exports.EntitySchema = ht.EntitySchema = void 0;
+function requireTableIndexOptions() {
+    if (In) return Sn;
+    In = 1;
+    "use strict";
+    Object.defineProperty(Sn, "__esModule", {
+        value: true
+    });
+    return Sn;
+}
 
-class EntitySchema {
-    constructor(e) {
-        this.options = e;
-        this["@instanceof"] = Symbol.for("EntitySchema");
-    }
+var Nn = requireTableIndexOptions();
+
+const Ln = e.getDefaultExportFromCjs(Nn);
+
+var kn = {};
+
+var wn;
+
+function requireTableOptions() {
+    if (wn) return kn;
+    wn = 1;
+    "use strict";
+    Object.defineProperty(kn, "__esModule", {
+        value: true
+    });
+    return kn;
 }
 
-exports.EntitySchema = ht.EntitySchema = EntitySchema;
+var An = requireTableOptions();
 
-var Mt = {};
+const Qn = e.getDefaultExportFromCjs(An);
 
-"use strict";
+var Un = {};
 
-Object.defineProperty(Mt, "__esModule", {
-    value: true
-});
+var Jn;
 
-exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = void 0;
+function requireTableUniqueOptions() {
+    if (Jn) return Un;
+    Jn = 1;
+    "use strict";
+    Object.defineProperty(Un, "__esModule", {
+        value: true
+    });
+    return Un;
+}
 
-class EntitySchemaEmbeddedColumnOptions {}
+var Kn = requireTableUniqueOptions();
 
-exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
+const Xn = e.getDefaultExportFromCjs(Kn);
 
-var xt = {};
+var zn = {};
 
-"use strict";
+var Zn;
 
-Object.defineProperty(xt, "__esModule", {
-    value: true
-});
+function requireViewOptions() {
+    if (Zn) return zn;
+    Zn = 1;
+    "use strict";
+    Object.defineProperty(zn, "__esModule", {
+        value: true
+    });
+    return zn;
+}
 
-exports.EntitySchemaOptions = xt.EntitySchemaOptions = void 0;
+var Gn = requireViewOptions();
 
-class EntitySchemaOptions {}
+const Vn = e.getDefaultExportFromCjs(Gn);
 
-exports.EntitySchemaOptions = xt.EntitySchemaOptions = EntitySchemaOptions;
+var Wn = {};
 
-Object.defineProperty(exports, "AbstractLogger", {
-    enumerable: true,
-    get: () => t.AbstractLogger_2
-});
+var Hn = {};
 
-Object.defineProperty(exports, "AdvancedConsoleLogger", {
-    enumerable: true,
-    get: () => t.AdvancedConsoleLogger_2
-});
+var Yn;
 
-Object.defineProperty(exports, "Brackets", {
-    enumerable: true,
-    get: () => t.Brackets_2
-});
+function requireBson_typings() {
+    if (Yn) return Hn;
+    Yn = 1;
+    "use strict";
+    Object.defineProperty(Hn, "__esModule", {
+        value: true
+    });
+    Hn.BSON = void 0;
+    return Hn;
+}
 
-Object.defineProperty(exports, "ConnectionOptionsReader", {
-    enumerable: true,
-    get: () => t.ConnectionOptionsReader_2
-});
+var $n;
+
+function requireTypings() {
+    if ($n) return Wn;
+    $n = 1;
+    (function(e) {
+        "use strict";
+        Object.defineProperty(e, "__esModule", {
+            value: true
+        });
+        e.Timestamp = e.serialize = e.ObjectId = e.MinKey = e.MaxKey = e.Long = e.Int32 = e.Double = e.deserialize = e.Decimal128 = e.DBRef = e.Code = e.BSONType = e.BSONSymbol = e.BSONRegExp = e.BSON = e.Binary = void 0;
+        const r = requireBson_typings();
+        Object.defineProperty(e, "BSON", {
+            enumerable: true,
+            get: function() {
+                return r.BSON;
+            }
+        });
+        Object.defineProperty(e, "BSONRegExp", {
+            enumerable: true,
+            get: function() {
+                return r.BSONRegExp;
+            }
+        });
+        Object.defineProperty(e, "BSONSymbol", {
+            enumerable: true,
+            get: function() {
+                return r.BSONSymbol;
+            }
+        });
+        Object.defineProperty(e, "BSONType", {
+            enumerable: true,
+            get: function() {
+                return r.BSONType;
+            }
+        });
+        Object.defineProperty(e, "Binary", {
+            enumerable: true,
+            get: function() {
+                return r.Binary;
+            }
+        });
+        Object.defineProperty(e, "Code", {
+            enumerable: true,
+            get: function() {
+                return r.Code;
+            }
+        });
+        Object.defineProperty(e, "DBRef", {
+            enumerable: true,
+            get: function() {
+                return r.DBRef;
+            }
+        });
+        Object.defineProperty(e, "Decimal128", {
+            enumerable: true,
+            get: function() {
+                return r.Decimal128;
+            }
+        });
+        Object.defineProperty(e, "Double", {
+            enumerable: true,
+            get: function() {
+                return r.Double;
+            }
+        });
+        Object.defineProperty(e, "Int32", {
+            enumerable: true,
+            get: function() {
+                return r.Int32;
+            }
+        });
+        Object.defineProperty(e, "Long", {
+            enumerable: true,
+            get: function() {
+                return r.Long;
+            }
+        });
+        Object.defineProperty(e, "MaxKey", {
+            enumerable: true,
+            get: function() {
+                return r.MaxKey;
+            }
+        });
+        Object.defineProperty(e, "MinKey", {
+            enumerable: true,
+            get: function() {
+                return r.MinKey;
+            }
+        });
+        Object.defineProperty(e, "ObjectId", {
+            enumerable: true,
+            get: function() {
+                return r.ObjectId;
+            }
+        });
+        Object.defineProperty(e, "Timestamp", {
+            enumerable: true,
+            get: function() {
+                return r.Timestamp;
+            }
+        });
+        Object.defineProperty(e, "deserialize", {
+            enumerable: true,
+            get: function() {
+                return r.deserialize;
+            }
+        });
+        Object.defineProperty(e, "serialize", {
+            enumerable: true,
+            get: function() {
+                return r.serialize;
+            }
+        });
+    })(Wn);
+    return Wn;
+}
 
-Object.defineProperty(exports, "DefaultNamingStrategy", {
-    enumerable: true,
-    get: () => t.DefaultNamingStrategy_2
-});
+var eo = requireTypings();
 
-Object.defineProperty(exports, "DeleteQueryBuilder", {
-    enumerable: true,
-    get: () => t.DeleteQueryBuilder_2
-});
+const ro = e.getDefaultExportFromCjs(eo);
 
-Object.defineProperty(exports, "DeleteResult", {
-    enumerable: true,
-    get: () => t.DeleteResult_2
-});
+var to = {};
 
-Object.defineProperty(exports, "EntityMetadata", {
-    enumerable: true,
-    get: () => t.EntityMetadata_2
-});
+var no;
 
-Object.defineProperty(exports, "FileLogger", {
-    enumerable: true,
-    get: () => t.FileLogger_2
-});
+function requireDatabaseType() {
+    if (no) return to;
+    no = 1;
+    "use strict";
+    Object.defineProperty(to, "__esModule", {
+        value: true
+    });
+    return to;
+}
 
-Object.defineProperty(exports, "FindOperator", {
-    enumerable: true,
-    get: () => t.FindOperator_2
-});
+var oo = requireDatabaseType();
 
-Object.defineProperty(exports, "FindOptionsUtils", {
-    enumerable: true,
-    get: () => t.FindOptionsUtils_2
-});
+const uo = e.getDefaultExportFromCjs(oo);
 
-exports.In = t.In_2;
+var io = {};
 
-Object.defineProperty(exports, "InsertQueryBuilder", {
-    enumerable: true,
-    get: () => t.InsertQueryBuilder_2
-});
+var so;
 
-Object.defineProperty(exports, "InsertResult", {
-    enumerable: true,
-    get: () => t.InsertResult_2
-});
+function requireGeoJsonTypes() {
+    if (so) return io;
+    so = 1;
+    "use strict";
+    Object.defineProperty(io, "__esModule", {
+        value: true
+    });
+    return io;
+}
 
-Object.defineProperty(exports, "InstanceChecker", {
-    enumerable: true,
-    get: () => t.InstanceChecker_2
-});
+var ao = requireGeoJsonTypes();
 
-Object.defineProperty(exports, "Migration", {
-    enumerable: true,
-    get: () => t.Migration_2
-});
+const co = e.getDefaultExportFromCjs(ao);
 
-Object.defineProperty(exports, "MigrationExecutor", {
-    enumerable: true,
-    get: () => t.MigrationExecutor_2
-});
+var lo = {};
 
-Object.defineProperty(exports, "MongoRepository", {
-    enumerable: true,
-    get: () => t.MongoRepository_2
-});
+var po;
 
-Object.defineProperty(exports, "MssqlParameter", {
-    enumerable: true,
-    get: () => t.MssqlParameter_2
-});
+function requireReplicationMode() {
+    if (po) return lo;
+    po = 1;
+    "use strict";
+    Object.defineProperty(lo, "__esModule", {
+        value: true
+    });
+    return lo;
+}
 
-Object.defineProperty(exports, "QueryBuilder", {
-    enumerable: true,
-    get: () => t.QueryBuilder_2
-});
+var fo = requireReplicationMode();
 
-Object.defineProperty(exports, "QueryResult", {
-    enumerable: true,
-    get: () => t.QueryResult_2
-});
+const vo = e.getDefaultExportFromCjs(fo);
 
-Object.defineProperty(exports, "RelationQueryBuilder", {
-    enumerable: true,
-    get: () => t.RelationQueryBuilder_2
-});
+var yo = r.requireMssqlParameter();
 
-Object.defineProperty(exports, "Repository", {
-    enumerable: true,
-    get: () => t.Repository_2
-});
+const go = e.getDefaultExportFromCjs(yo);
 
-Object.defineProperty(exports, "SelectQueryBuilder", {
-    enumerable: true,
-    get: () => t.SelectQueryBuilder_2
-});
+var Oo = r.requireConnectionOptionsReader();
 
-Object.defineProperty(exports, "SimpleConsoleLogger", {
-    enumerable: true,
-    get: () => t.SimpleConsoleLogger_2
-});
+const qo = e.getDefaultExportFromCjs(Oo);
 
-Object.defineProperty(exports, "Table", {
-    enumerable: true,
-    get: () => t.Table_2
-});
+var mo = r.requireQueryBuilder();
 
-Object.defineProperty(exports, "TableCheck", {
-    enumerable: true,
-    get: () => t.TableCheck_2
-});
+const Eo = e.getDefaultExportFromCjs(mo);
 
-Object.defineProperty(exports, "TableColumn", {
-    enumerable: true,
-    get: () => t.TableColumn_2
-});
+var jo = r.requireSelectQueryBuilder();
 
-Object.defineProperty(exports, "TableExclusion", {
-    enumerable: true,
-    get: () => t.TableExclusion_2
-});
+const Fo = e.getDefaultExportFromCjs(jo);
 
-Object.defineProperty(exports, "TableForeignKey", {
-    enumerable: true,
-    get: () => t.TableForeignKey_2
-});
+var Co = r.requireDeleteQueryBuilder();
 
-Object.defineProperty(exports, "TableIndex", {
-    enumerable: true,
-    get: () => t.TableIndex_2
-});
+const xo = e.getDefaultExportFromCjs(Co);
 
-Object.defineProperty(exports, "TableUnique", {
-    enumerable: true,
-    get: () => t.TableUnique_2
-});
+var bo = r.requireInsertQueryBuilder();
 
-Object.defineProperty(exports, "TreeRepository", {
-    enumerable: true,
-    get: () => t.TreeRepository_2
-});
+const ho = e.getDefaultExportFromCjs(bo);
 
-Object.defineProperty(exports, "TreeRepositoryUtils", {
-    enumerable: true,
-    get: () => t.TreeRepositoryUtils_2
-});
+var _o = r.requireUpdateQueryBuilder();
 
-Object.defineProperty(exports, "UpdateQueryBuilder", {
-    enumerable: true,
-    get: () => t.UpdateQueryBuilder_2
-});
+const Do = e.getDefaultExportFromCjs(_o);
 
-Object.defineProperty(exports, "UpdateResult", {
-    enumerable: true,
-    get: () => t.UpdateResult_2
-});
+var Mo = r.requireRelationQueryBuilder();
+
+const Ro = e.getDefaultExportFromCjs(Mo);
+
+var Po = r.requireBrackets();
+
+const Bo = e.getDefaultExportFromCjs(Po);
+
+var To = {};
+
+var So;
+
+function requireNotBrackets() {
+    if (So) return To;
+    So = 1;
+    "use strict";
+    Object.defineProperty(To, "__esModule", {
+        value: true
+    });
+    To.NotBrackets = void 0;
+    const e = r.requireBrackets();
+    class NotBrackets extends e.Brackets {
+        constructor() {
+            super(...arguments);
+            this["@instanceof"] = Symbol.for("NotBrackets");
+        }
+    }
+    To.NotBrackets = NotBrackets;
+    return To;
+}
+
+var Io = requireNotBrackets();
+
+const No = e.getDefaultExportFromCjs(Io);
+
+var Lo = r.requireInsertResult();
+
+const ko = e.getDefaultExportFromCjs(Lo);
+
+var wo = r.requireUpdateResult();
+
+const Ao = e.getDefaultExportFromCjs(wo);
+
+var Qo = r.requireDeleteResult();
+
+const Uo = e.getDefaultExportFromCjs(Qo);
+
+var Jo = r.requireQueryResult();
+
+const Ko = e.getDefaultExportFromCjs(Jo);
+
+var Xo = r.requireMongoEntityManager();
+
+const zo = e.getDefaultExportFromCjs(Xo);
+
+var Zo = r.requireMigration();
+
+const Go = e.getDefaultExportFromCjs(Zo);
+
+var Vo = r.requireMigrationExecutor();
+
+const Wo = e.getDefaultExportFromCjs(Vo);
+
+var Ho = r.requireDefaultNamingStrategy();
+
+const Yo = e.getDefaultExportFromCjs(Ho);
+
+var $o = {};
+
+var eu;
+
+function requireLegacyOracleNamingStrategy() {
+    if (eu) return $o;
+    eu = 1;
+    "use strict";
+    Object.defineProperty($o, "__esModule", {
+        value: true
+    });
+    $o.LegacyOracleNamingStrategy = void 0;
+    const e = r.requireRandomGenerator();
+    const t = r.requireDefaultNamingStrategy();
+    const n = r.requireError();
+    class LegacyOracleNamingStrategy extends t.DefaultNamingStrategy {
+        constructor(e = "hash") {
+            super();
+            this.IDENTIFIER_MAX_SIZE = 30;
+            this.DEFAULT_COLUMN_PREFIX = "COL_";
+            this.shortenStrategy = e;
+        }
+        columnName(e, r, t) {
+            const o = super.columnName(e, r, t);
+            if (this.shortenStrategy === "truncate") {
+                return this.truncateIdentifier(o);
+            } else if (this.shortenStrategy === "hash") {
+                return this.hashIdentifier(o, this.DEFAULT_COLUMN_PREFIX);
+            } else {
+                throw new n.TypeORMError(`Invalid shortenStrategy`);
+            }
+        }
+        hashIdentifier(r, t) {
+            if (t.length >= this.IDENTIFIER_MAX_SIZE) {
+                throw new n.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
+            }
+            return t + e.RandomGenerator.sha1(r).substring(0, this.IDENTIFIER_MAX_SIZE - t.length);
+        }
+        truncateIdentifier(e) {
+            if (e.length > this.IDENTIFIER_MAX_SIZE) {
+                return e.substring(0, this.IDENTIFIER_MAX_SIZE);
+            } else {
+                return e;
+            }
+        }
+    }
+    $o.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+    return $o;
+}
+
+var ru = requireLegacyOracleNamingStrategy();
+
+const tu = e.getDefaultExportFromCjs(ru);
+
+var nu = {};
+
+var ou;
+
+function requireEntitySchema() {
+    if (ou) return nu;
+    ou = 1;
+    "use strict";
+    Object.defineProperty(nu, "__esModule", {
+        value: true
+    });
+    nu.EntitySchema = void 0;
+    class EntitySchema {
+        constructor(e) {
+            this.options = e;
+            this["@instanceof"] = Symbol.for("EntitySchema");
+        }
+    }
+    nu.EntitySchema = EntitySchema;
+    return nu;
+}
+
+var uu = requireEntitySchema();
+
+const iu = e.getDefaultExportFromCjs(uu);
+
+var su = {};
+
+var au;
+
+function requireEntitySchemaEmbeddedColumnOptions() {
+    if (au) return su;
+    au = 1;
+    "use strict";
+    Object.defineProperty(su, "__esModule", {
+        value: true
+    });
+    su.EntitySchemaEmbeddedColumnOptions = void 0;
+    class EntitySchemaEmbeddedColumnOptions {}
+    su.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
+    return su;
+}
+
+var cu = requireEntitySchemaEmbeddedColumnOptions();
+
+const lu = e.getDefaultExportFromCjs(cu);
+
+var pu = {};
+
+var fu;
+
+function requireEntitySchemaOptions() {
+    if (fu) return pu;
+    fu = 1;
+    "use strict";
+    Object.defineProperty(pu, "__esModule", {
+        value: true
+    });
+    pu.EntitySchemaOptions = void 0;
+    class EntitySchemaOptions {}
+    pu.EntitySchemaOptions = EntitySchemaOptions;
+    return pu;
+}
+
+var du = requireEntitySchemaOptions();
+
+const vu = e.getDefaultExportFromCjs(du);
+
+var yu = r.requireInstanceChecker();
+
+const gu = e.getDefaultExportFromCjs(yu);
+
+var Ou = r.requireTreeRepositoryUtils();
+
+const qu = e.getDefaultExportFromCjs(Ou);
+
+exports.Brackets = Po.Brackets;
+
+exports.ConnectionOptionsReader = Oo.ConnectionOptionsReader;
+
+exports.DataSource = t.DataSourceExports.DataSource;
 
-exports.getFromContainer = t.getFromContainer_1;
+exports.DefaultNamingStrategy = Ho.DefaultNamingStrategy;
 
-exports.useContainer = t.useContainer_1;
+exports.DeleteQueryBuilder = Co.DeleteQueryBuilder;
 
-exports.And = _;
+exports.DeleteResult = Qo.DeleteResult;
 
-exports.Any = h;
+exports.EntitySchema = uu.EntitySchema;
 
-exports.ArrayContainedBy = R;
+exports.EntitySchemaEmbeddedColumnOptions = cu.EntitySchemaEmbeddedColumnOptions;
 
-exports.ArrayContains = I;
+exports.EntitySchemaOptions = du.EntitySchemaOptions;
 
-exports.ArrayOverlap = N;
+exports.InsertQueryBuilder = bo.InsertQueryBuilder;
 
-exports.Between = L;
+exports.InsertResult = Lo.InsertResult;
 
-exports.DataSource = r.DataSourceExports.DataSource;
+exports.InstanceChecker = yu.InstanceChecker;
 
-exports.Equal = z;
+exports.LegacyOracleNamingStrategy = ru.LegacyOracleNamingStrategy;
 
-exports.ILike = ue;
+exports.Migration = Zo.Migration;
 
-exports.IsNull = H;
+exports.MigrationExecutor = Vo.MigrationExecutor;
 
-exports.JsonContains = Ie;
+exports.MongoEntityManager = Xo.MongoEntityManager;
 
-exports.LessThan = $;
+exports.NotBrackets = Io.NotBrackets;
 
-exports.LessThanOrEqual = oe;
+exports.QueryBuilder = mo.QueryBuilder;
 
-exports.Like = le;
+exports.QueryResult = Jo.QueryResult;
 
-exports.MongoEntityManager = gt.MongoEntityManager;
+exports.RelationQueryBuilder = Mo.RelationQueryBuilder;
 
-exports.MoreThan = fe;
+exports.SelectQueryBuilder = jo.SelectQueryBuilder;
 
-exports.MoreThanOrEqual = _e;
+exports.TreeRepositoryUtils = Ou.TreeRepositoryUtils;
 
-exports.Not = he;
+exports.UpdateQueryBuilder = _o.UpdateQueryBuilder;
 
-exports.Raw = Re;
+exports.UpdateResult = wo.UpdateResult;