@kong-ui-public/entities-plugins 9.273.3-pr.3869.e876c8c8a.0 → 9.273.3

package/dist/Reflect-Dx24sqoM.js

@@ -0,0 +1,826 @@
+function Ae(k, S) {
+  for (var _ = 0; _ < S.length; _++) {
+    const h = S[_];
+    if (typeof h != "string" && !Array.isArray(h)) {
+      for (const M in h)
+        if (M !== "default" && !(M in k)) {
+          const b = Object.getOwnPropertyDescriptor(h, M);
+          b && Object.defineProperty(k, M, b.get ? b : {
+            enumerable: !0,
+            get: () => h[M]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(k, Symbol.toStringTag, { value: "Module" }));
+}
+var oe = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, ue = {};
+var se;
+function Fe() {
+  if (se) return ue;
+  se = 1;
+  var k;
+  return (function(S) {
+    (function(_) {
+      var h = typeof globalThis == "object" ? globalThis : typeof oe == "object" ? oe : typeof self == "object" ? self : typeof this == "object" ? this : D(), M = b(S);
+      typeof h.Reflect < "u" && (M = b(h.Reflect, M)), _(M, h), typeof h.Reflect > "u" && (h.Reflect = S);
+      function b(E, j) {
+        return function(m, I) {
+          Object.defineProperty(E, m, { configurable: !0, writable: !0, value: I }), j && j(m, I);
+        };
+      }
+      function F() {
+        try {
+          return Function("return this;")();
+        } catch {
+        }
+      }
+      function T() {
+        try {
+          return (0, eval)("(function() { return this; })()");
+        } catch {
+        }
+      }
+      function D() {
+        return F() || T();
+      }
+    })(function(_, h) {
+      var M = Object.prototype.hasOwnProperty, b = typeof Symbol == "function", F = b && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", T = b && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", D = typeof Object.create == "function", E = { __proto__: [] } instanceof Array, j = !D && !E, m = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: D ? function() {
+          return q(/* @__PURE__ */ Object.create(null));
+        } : E ? function() {
+          return q({ __proto__: null });
+        } : function() {
+          return q({});
+        },
+        has: j ? function(e, t) {
+          return M.call(e, t);
+        } : function(e, t) {
+          return t in e;
+        },
+        get: j ? function(e, t) {
+          return M.call(e, t) ? e[t] : void 0;
+        } : function(e, t) {
+          return e[t];
+        }
+      }, I = Object.getPrototypeOf(Function), C = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : Ie(), U = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : Ce(), W = typeof WeakMap == "function" ? WeakMap : xe(), P = b ? /* @__PURE__ */ Symbol.for("@reflect-metadata:registry") : void 0, G = Re(), B = Se(G);
+      function ce(e, t, r, n) {
+        if (s(r)) {
+          if (!K(e))
+            throw new TypeError();
+          if (!ee(t))
+            throw new TypeError();
+          return ge(e, t);
+        } else {
+          if (!K(e))
+            throw new TypeError();
+          if (!y(t))
+            throw new TypeError();
+          if (!y(n) && !s(n) && !R(n))
+            throw new TypeError();
+          return R(n) && (n = void 0), r = O(r), be(e, t, r, n);
+        }
+      }
+      _("decorate", ce);
+      function de(e, t) {
+        function r(n, u) {
+          if (!y(n))
+            throw new TypeError();
+          if (!s(u) && !Ee(u))
+            throw new TypeError();
+          $(e, t, n, u);
+        }
+        return r;
+      }
+      _("metadata", de);
+      function le(e, t, r, n) {
+        if (!y(r))
+          throw new TypeError();
+        return s(n) || (n = O(n)), $(e, t, r, n);
+      }
+      _("defineMetadata", le);
+      function he(e, t, r) {
+        if (!y(t))
+          throw new TypeError();
+        return s(r) || (r = O(r)), N(e, t, r);
+      }
+      _("hasMetadata", he);
+      function ve(e, t, r) {
+        if (!y(t))
+          throw new TypeError();
+        return s(r) || (r = O(r)), H(e, t, r);
+      }
+      _("hasOwnMetadata", ve);
+      function ye(e, t, r) {
+        if (!y(t))
+          throw new TypeError();
+        return s(r) || (r = O(r)), L(e, t, r);
+      }
+      _("getMetadata", ye);
+      function pe(e, t, r) {
+        if (!y(t))
+          throw new TypeError();
+        return s(r) || (r = O(r)), Z(e, t, r);
+      }
+      _("getOwnMetadata", pe);
+      function we(e, t) {
+        if (!y(e))
+          throw new TypeError();
+        return s(t) || (t = O(t)), J(e, t);
+      }
+      _("getMetadataKeys", we);
+      function _e(e, t) {
+        if (!y(e))
+          throw new TypeError();
+        return s(t) || (t = O(t)), Q(e, t);
+      }
+      _("getOwnMetadataKeys", _e);
+      function Me(e, t, r) {
+        if (!y(t))
+          throw new TypeError();
+        if (s(r) || (r = O(r)), !y(t))
+          throw new TypeError();
+        s(r) || (r = O(r));
+        var n = x(
+          t,
+          r,
+          /*Create*/
+          !1
+        );
+        return s(n) ? !1 : n.OrdinaryDeleteMetadata(e, t, r);
+      }
+      _("deleteMetadata", Me);
+      function ge(e, t) {
+        for (var r = e.length - 1; r >= 0; --r) {
+          var n = e[r], u = n(t);
+          if (!s(u) && !R(u)) {
+            if (!ee(u))
+              throw new TypeError();
+            t = u;
+          }
+        }
+        return t;
+      }
+      function be(e, t, r, n) {
+        for (var u = e.length - 1; u >= 0; --u) {
+          var w = e[u], p = w(t, r, n);
+          if (!s(p) && !R(p)) {
+            if (!y(p))
+              throw new TypeError();
+            n = p;
+          }
+        }
+        return n;
+      }
+      function N(e, t, r) {
+        var n = H(e, t, r);
+        if (n)
+          return !0;
+        var u = z(t);
+        return R(u) ? !1 : N(e, u, r);
+      }
+      function H(e, t, r) {
+        var n = x(
+          t,
+          r,
+          /*Create*/
+          !1
+        );
+        return s(n) ? !1 : Y(n.OrdinaryHasOwnMetadata(e, t, r));
+      }
+      function L(e, t, r) {
+        var n = H(e, t, r);
+        if (n)
+          return Z(e, t, r);
+        var u = z(t);
+        if (!R(u))
+          return L(e, u, r);
+      }
+      function Z(e, t, r) {
+        var n = x(
+          t,
+          r,
+          /*Create*/
+          !1
+        );
+        if (!s(n))
+          return n.OrdinaryGetOwnMetadata(e, t, r);
+      }
+      function $(e, t, r, n) {
+        var u = x(
+          r,
+          n,
+          /*Create*/
+          !0
+        );
+        u.OrdinaryDefineOwnMetadata(e, t, r, n);
+      }
+      function J(e, t) {
+        var r = Q(e, t), n = z(e);
+        if (n === null)
+          return r;
+        var u = J(n, t);
+        if (u.length <= 0)
+          return r;
+        if (r.length <= 0)
+          return u;
+        for (var w = new U(), p = [], c = 0, a = r; c < a.length; c++) {
+          var i = a[c], f = w.has(i);
+          f || (w.add(i), p.push(i));
+        }
+        for (var o = 0, d = u; o < d.length; o++) {
+          var i = d[o], f = w.has(i);
+          f || (w.add(i), p.push(i));
+        }
+        return p;
+      }
+      function Q(e, t) {
+        var r = x(
+          e,
+          t,
+          /*create*/
+          !1
+        );
+        return r ? r.OrdinaryOwnMetadataKeys(e, t) : [];
+      }
+      function X(e) {
+        if (e === null)
+          return 1;
+        switch (typeof e) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return e === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function s(e) {
+        return e === void 0;
+      }
+      function R(e) {
+        return e === null;
+      }
+      function Oe(e) {
+        return typeof e == "symbol";
+      }
+      function y(e) {
+        return typeof e == "object" ? e !== null : typeof e == "function";
+      }
+      function me(e, t) {
+        switch (X(e)) {
+          case 0:
+            return e;
+          case 1:
+            return e;
+          case 2:
+            return e;
+          case 3:
+            return e;
+          case 4:
+            return e;
+          case 5:
+            return e;
+        }
+        var r = "string", n = te(e, F);
+        if (n !== void 0) {
+          var u = n.call(e, r);
+          if (y(u))
+            throw new TypeError();
+          return u;
+        }
+        return ke(e);
+      }
+      function ke(e, t) {
+        var r, n;
+        {
+          var u = e.toString;
+          if (A(u)) {
+            var n = u.call(e);
+            if (!y(n))
+              return n;
+          }
+          var r = e.valueOf;
+          if (A(r)) {
+            var n = r.call(e);
+            if (!y(n))
+              return n;
+          }
+        }
+        throw new TypeError();
+      }
+      function Y(e) {
+        return !!e;
+      }
+      function Te(e) {
+        return "" + e;
+      }
+      function O(e) {
+        var t = me(e);
+        return Oe(t) ? t : Te(t);
+      }
+      function K(e) {
+        return Array.isArray ? Array.isArray(e) : e instanceof Object ? e instanceof Array : Object.prototype.toString.call(e) === "[object Array]";
+      }
+      function A(e) {
+        return typeof e == "function";
+      }
+      function ee(e) {
+        return typeof e == "function";
+      }
+      function Ee(e) {
+        switch (X(e)) {
+          case 3:
+            return !0;
+          case 4:
+            return !0;
+          default:
+            return !1;
+        }
+      }
+      function V(e, t) {
+        return e === t || e !== e && t !== t;
+      }
+      function te(e, t) {
+        var r = e[t];
+        if (r != null) {
+          if (!A(r))
+            throw new TypeError();
+          return r;
+        }
+      }
+      function re(e) {
+        var t = te(e, T);
+        if (!A(t))
+          throw new TypeError();
+        var r = t.call(e);
+        if (!y(r))
+          throw new TypeError();
+        return r;
+      }
+      function ne(e) {
+        return e.value;
+      }
+      function ae(e) {
+        var t = e.next();
+        return t.done ? !1 : t;
+      }
+      function ie(e) {
+        var t = e.return;
+        t && t.call(e);
+      }
+      function z(e) {
+        var t = Object.getPrototypeOf(e);
+        if (typeof e != "function" || e === I || t !== I)
+          return t;
+        var r = e.prototype, n = r && Object.getPrototypeOf(r);
+        if (n == null || n === Object.prototype)
+          return t;
+        var u = n.constructor;
+        return typeof u != "function" || u === e ? t : u;
+      }
+      function Pe() {
+        var e;
+        !s(P) && typeof h.Reflect < "u" && !(P in h.Reflect) && typeof h.Reflect.defineMetadata == "function" && (e = je(h.Reflect));
+        var t, r, n, u = new W(), w = {
+          registerProvider: p,
+          getProvider: a,
+          setProvider: f
+        };
+        return w;
+        function p(o) {
+          if (!Object.isExtensible(w))
+            throw new Error("Cannot add provider to a frozen registry.");
+          switch (!0) {
+            case e === o:
+              break;
+            case s(t):
+              t = o;
+              break;
+            case t === o:
+              break;
+            case s(r):
+              r = o;
+              break;
+            case r === o:
+              break;
+            default:
+              n === void 0 && (n = new U()), n.add(o);
+              break;
+          }
+        }
+        function c(o, d) {
+          if (!s(t)) {
+            if (t.isProviderFor(o, d))
+              return t;
+            if (!s(r)) {
+              if (r.isProviderFor(o, d))
+                return t;
+              if (!s(n))
+                for (var l = re(n); ; ) {
+                  var v = ae(l);
+                  if (!v)
+                    return;
+                  var g = ne(v);
+                  if (g.isProviderFor(o, d))
+                    return ie(l), g;
+                }
+            }
+          }
+          if (!s(e) && e.isProviderFor(o, d))
+            return e;
+        }
+        function a(o, d) {
+          var l = u.get(o), v;
+          return s(l) || (v = l.get(d)), s(v) && (v = c(o, d), s(v) || (s(l) && (l = new C(), u.set(o, l)), l.set(d, v))), v;
+        }
+        function i(o) {
+          if (s(o))
+            throw new TypeError();
+          return t === o || r === o || !s(n) && n.has(o);
+        }
+        function f(o, d, l) {
+          if (!i(l))
+            throw new Error("Metadata provider not registered.");
+          var v = a(o, d);
+          if (v !== l) {
+            if (!s(v))
+              return !1;
+            var g = u.get(o);
+            s(g) && (g = new C(), u.set(o, g)), g.set(d, l);
+          }
+          return !0;
+        }
+      }
+      function Re() {
+        var e;
+        return !s(P) && y(h.Reflect) && Object.isExtensible(h.Reflect) && (e = h.Reflect[P]), s(e) && (e = Pe()), !s(P) && y(h.Reflect) && Object.isExtensible(h.Reflect) && Object.defineProperty(h.Reflect, P, {
+          enumerable: !1,
+          configurable: !1,
+          writable: !1,
+          value: e
+        }), e;
+      }
+      function Se(e) {
+        var t = new W(), r = {
+          isProviderFor: function(i, f) {
+            var o = t.get(i);
+            return s(o) ? !1 : o.has(f);
+          },
+          OrdinaryDefineOwnMetadata: p,
+          OrdinaryHasOwnMetadata: u,
+          OrdinaryGetOwnMetadata: w,
+          OrdinaryOwnMetadataKeys: c,
+          OrdinaryDeleteMetadata: a
+        };
+        return G.registerProvider(r), r;
+        function n(i, f, o) {
+          var d = t.get(i), l = !1;
+          if (s(d)) {
+            if (!o)
+              return;
+            d = new C(), t.set(i, d), l = !0;
+          }
+          var v = d.get(f);
+          if (s(v)) {
+            if (!o)
+              return;
+            if (v = new C(), d.set(f, v), !e.setProvider(i, f, r))
+              throw d.delete(f), l && t.delete(i), new Error("Wrong provider for target.");
+          }
+          return v;
+        }
+        function u(i, f, o) {
+          var d = n(
+            f,
+            o,
+            /*Create*/
+            !1
+          );
+          return s(d) ? !1 : Y(d.has(i));
+        }
+        function w(i, f, o) {
+          var d = n(
+            f,
+            o,
+            /*Create*/
+            !1
+          );
+          if (!s(d))
+            return d.get(i);
+        }
+        function p(i, f, o, d) {
+          var l = n(
+            o,
+            d,
+            /*Create*/
+            !0
+          );
+          l.set(i, f);
+        }
+        function c(i, f) {
+          var o = [], d = n(
+            i,
+            f,
+            /*Create*/
+            !1
+          );
+          if (s(d))
+            return o;
+          for (var l = d.keys(), v = re(l), g = 0; ; ) {
+            var fe = ae(v);
+            if (!fe)
+              return o.length = g, o;
+            var De = ne(fe);
+            try {
+              o[g] = De;
+            } catch (Ge) {
+              try {
+                ie(v);
+              } finally {
+                throw Ge;
+              }
+            }
+            g++;
+          }
+        }
+        function a(i, f, o) {
+          var d = n(
+            f,
+            o,
+            /*Create*/
+            !1
+          );
+          if (s(d) || !d.delete(i))
+            return !1;
+          if (d.size === 0) {
+            var l = t.get(f);
+            s(l) || (l.delete(o), l.size === 0 && t.delete(l));
+          }
+          return !0;
+        }
+      }
+      function je(e) {
+        var t = e.defineMetadata, r = e.hasOwnMetadata, n = e.getOwnMetadata, u = e.getOwnMetadataKeys, w = e.deleteMetadata, p = new W(), c = {
+          isProviderFor: function(a, i) {
+            var f = p.get(a);
+            return !s(f) && f.has(i) ? !0 : u(a, i).length ? (s(f) && (f = new U(), p.set(a, f)), f.add(i), !0) : !1;
+          },
+          OrdinaryDefineOwnMetadata: t,
+          OrdinaryHasOwnMetadata: r,
+          OrdinaryGetOwnMetadata: n,
+          OrdinaryOwnMetadataKeys: u,
+          OrdinaryDeleteMetadata: w
+        };
+        return c;
+      }
+      function x(e, t, r) {
+        var n = G.getProvider(e, t);
+        if (!s(n))
+          return n;
+        if (r) {
+          if (G.setProvider(e, t, B))
+            return B;
+          throw new Error("Illegal state.");
+        }
+      }
+      function Ie() {
+        var e = {}, t = [], r = (
+          /** @class */
+          (function() {
+            function c(a, i, f) {
+              this._index = 0, this._keys = a, this._values = i, this._selector = f;
+            }
+            return c.prototype["@@iterator"] = function() {
+              return this;
+            }, c.prototype[T] = function() {
+              return this;
+            }, c.prototype.next = function() {
+              var a = this._index;
+              if (a >= 0 && a < this._keys.length) {
+                var i = this._selector(this._keys[a], this._values[a]);
+                return a + 1 >= this._keys.length ? (this._index = -1, this._keys = t, this._values = t) : this._index++, { value: i, done: !1 };
+              }
+              return { value: void 0, done: !0 };
+            }, c.prototype.throw = function(a) {
+              throw this._index >= 0 && (this._index = -1, this._keys = t, this._values = t), a;
+            }, c.prototype.return = function(a) {
+              return this._index >= 0 && (this._index = -1, this._keys = t, this._values = t), { value: a, done: !0 };
+            }, c;
+          })()
+        ), n = (
+          /** @class */
+          (function() {
+            function c() {
+              this._keys = [], this._values = [], this._cacheKey = e, this._cacheIndex = -2;
+            }
+            return Object.defineProperty(c.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), c.prototype.has = function(a) {
+              return this._find(
+                a,
+                /*insert*/
+                !1
+              ) >= 0;
+            }, c.prototype.get = function(a) {
+              var i = this._find(
+                a,
+                /*insert*/
+                !1
+              );
+              return i >= 0 ? this._values[i] : void 0;
+            }, c.prototype.set = function(a, i) {
+              var f = this._find(
+                a,
+                /*insert*/
+                !0
+              );
+              return this._values[f] = i, this;
+            }, c.prototype.delete = function(a) {
+              var i = this._find(
+                a,
+                /*insert*/
+                !1
+              );
+              if (i >= 0) {
+                for (var f = this._keys.length, o = i + 1; o < f; o++)
+                  this._keys[o - 1] = this._keys[o], this._values[o - 1] = this._values[o];
+                return this._keys.length--, this._values.length--, V(a, this._cacheKey) && (this._cacheKey = e, this._cacheIndex = -2), !0;
+              }
+              return !1;
+            }, c.prototype.clear = function() {
+              this._keys.length = 0, this._values.length = 0, this._cacheKey = e, this._cacheIndex = -2;
+            }, c.prototype.keys = function() {
+              return new r(this._keys, this._values, u);
+            }, c.prototype.values = function() {
+              return new r(this._keys, this._values, w);
+            }, c.prototype.entries = function() {
+              return new r(this._keys, this._values, p);
+            }, c.prototype["@@iterator"] = function() {
+              return this.entries();
+            }, c.prototype[T] = function() {
+              return this.entries();
+            }, c.prototype._find = function(a, i) {
+              if (!V(this._cacheKey, a)) {
+                this._cacheIndex = -1;
+                for (var f = 0; f < this._keys.length; f++)
+                  if (V(this._keys[f], a)) {
+                    this._cacheIndex = f;
+                    break;
+                  }
+              }
+              return this._cacheIndex < 0 && i && (this._cacheIndex = this._keys.length, this._keys.push(a), this._values.push(void 0)), this._cacheIndex;
+            }, c;
+          })()
+        );
+        return n;
+        function u(c, a) {
+          return c;
+        }
+        function w(c, a) {
+          return a;
+        }
+        function p(c, a) {
+          return [c, a];
+        }
+      }
+      function Ce() {
+        var e = (
+          /** @class */
+          (function() {
+            function t() {
+              this._map = new C();
+            }
+            return Object.defineProperty(t.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), t.prototype.has = function(r) {
+              return this._map.has(r);
+            }, t.prototype.add = function(r) {
+              return this._map.set(r, r), this;
+            }, t.prototype.delete = function(r) {
+              return this._map.delete(r);
+            }, t.prototype.clear = function() {
+              this._map.clear();
+            }, t.prototype.keys = function() {
+              return this._map.keys();
+            }, t.prototype.values = function() {
+              return this._map.keys();
+            }, t.prototype.entries = function() {
+              return this._map.entries();
+            }, t.prototype["@@iterator"] = function() {
+              return this.keys();
+            }, t.prototype[T] = function() {
+              return this.keys();
+            }, t;
+          })()
+        );
+        return e;
+      }
+      function xe() {
+        var e = 16, t = m.create(), r = n();
+        return (
+          /** @class */
+          (function() {
+            function a() {
+              this._key = n();
+            }
+            return a.prototype.has = function(i) {
+              var f = u(
+                i,
+                /*create*/
+                !1
+              );
+              return f !== void 0 ? m.has(f, this._key) : !1;
+            }, a.prototype.get = function(i) {
+              var f = u(
+                i,
+                /*create*/
+                !1
+              );
+              return f !== void 0 ? m.get(f, this._key) : void 0;
+            }, a.prototype.set = function(i, f) {
+              var o = u(
+                i,
+                /*create*/
+                !0
+              );
+              return o[this._key] = f, this;
+            }, a.prototype.delete = function(i) {
+              var f = u(
+                i,
+                /*create*/
+                !1
+              );
+              return f !== void 0 ? delete f[this._key] : !1;
+            }, a.prototype.clear = function() {
+              this._key = n();
+            }, a;
+          })()
+        );
+        function n() {
+          var a;
+          do
+            a = "@@WeakMap@@" + c();
+          while (m.has(t, a));
+          return t[a] = !0, a;
+        }
+        function u(a, i) {
+          if (!M.call(a, r)) {
+            if (!i)
+              return;
+            Object.defineProperty(a, r, { value: m.create() });
+          }
+          return a[r];
+        }
+        function w(a, i) {
+          for (var f = 0; f < i; ++f)
+            a[f] = Math.random() * 255 | 0;
+          return a;
+        }
+        function p(a) {
+          if (typeof Uint8Array == "function") {
+            var i = new Uint8Array(a);
+            return typeof crypto < "u" ? crypto.getRandomValues(i) : typeof msCrypto < "u" ? msCrypto.getRandomValues(i) : w(i, a), i;
+          }
+          return w(new Array(a), a);
+        }
+        function c() {
+          var a = p(e);
+          a[6] = a[6] & 79 | 64, a[8] = a[8] & 191 | 128;
+          for (var i = "", f = 0; f < e; ++f) {
+            var o = a[f];
+            (f === 4 || f === 6 || f === 8) && (i += "-"), o < 16 && (i += "0"), i += o.toString(16).toLowerCase();
+          }
+          return i;
+        }
+      }
+      function q(e) {
+        return e.__ = void 0, delete e.__, e;
+      }
+    });
+  })(k || (k = {})), ue;
+}
+var Ue = Fe();
+const We = /* @__PURE__ */ Ae({
+  __proto__: null
+}, [Ue]);
+export {
+  We as R
+};