@kong-ui-public/entities-plugins 9.206.3-pr.2584.751d7ef93.0 → 9.206.3

package/dist/Reflect-DRBLqlES.js

@@ -0,0 +1,835 @@
+function Ge(T, _) {
+  for (var v = 0; v < _.length; v++) {
+    const M = _[v];
+    if (typeof M != "string" && !Array.isArray(M)) {
+      for (const g in M)
+        if (g !== "default" && !(g in T)) {
+          const k = Object.getOwnPropertyDescriptor(M, g);
+          k && Object.defineProperty(T, g, k.get ? k : {
+            enumerable: !0,
+            get: () => M[g]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(T, Symbol.toStringTag, { value: "Module" }));
+}
+var fe = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, oe = {};
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var ue;
+(function(T) {
+  (function(_) {
+    var v = typeof globalThis == "object" ? globalThis : typeof fe == "object" ? fe : typeof self == "object" ? self : typeof this == "object" ? this : D(), M = g(T);
+    typeof v.Reflect < "u" && (M = g(v.Reflect, M)), _(M, v), typeof v.Reflect > "u" && (v.Reflect = T);
+    function g(P, I) {
+      return function(m, R) {
+        Object.defineProperty(P, m, { configurable: !0, writable: !0, value: R }), I && I(m, R);
+      };
+    }
+    function k() {
+      try {
+        return Function("return this;")();
+      } catch {
+      }
+    }
+    function E() {
+      try {
+        return (0, eval)("(function() { return this; })()");
+      } catch {
+      }
+    }
+    function D() {
+      return k() || E();
+    }
+  })(function(_, v) {
+    var M = Object.prototype.hasOwnProperty, g = typeof Symbol == "function", k = g && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", E = g && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", D = typeof Object.create == "function", P = { __proto__: [] } instanceof Array, I = !D && !P, m = {
+      // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+      create: D ? function() {
+        return z(/* @__PURE__ */ Object.create(null));
+      } : P ? function() {
+        return z({ __proto__: null });
+      } : function() {
+        return z({});
+      },
+      has: I ? function(e, t) {
+        return M.call(e, t);
+      } : function(e, t) {
+        return t in e;
+      },
+      get: I ? function(e, t) {
+        return M.call(e, t) ? e[t] : void 0;
+      } : function(e, t) {
+        return e[t];
+      }
+    }, R = Object.getPrototypeOf(Function), C = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : Ie(), F = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : Re(), U = typeof WeakMap == "function" ? WeakMap : Ce(), S = g ? Symbol.for("@reflect-metadata:registry") : void 0, G = Pe(), B = Se(G);
+    function se(e, t, r, n) {
+      if (s(r)) {
+        if (!Y(e))
+          throw new TypeError();
+        if (!K(t))
+          throw new TypeError();
+        return Me(e, t);
+      } else {
+        if (!Y(e))
+          throw new TypeError();
+        if (!y(t))
+          throw new TypeError();
+        if (!y(n) && !s(n) && !j(n))
+          throw new TypeError();
+        return j(n) && (n = void 0), r = O(r), ge(e, t, r, n);
+      }
+    }
+    _("decorate", se);
+    function ce(e, t) {
+      function r(n, u) {
+        if (!y(n))
+          throw new TypeError();
+        if (!s(u) && !Te(u))
+          throw new TypeError();
+        $(e, t, n, u);
+      }
+      return r;
+    }
+    _("metadata", ce);
+    function de(e, t, r, n) {
+      if (!y(r))
+        throw new TypeError();
+      return s(n) || (n = O(n)), $(e, t, r, n);
+    }
+    _("defineMetadata", de);
+    function le(e, t, r) {
+      if (!y(t))
+        throw new TypeError();
+      return s(r) || (r = O(r)), N(e, t, r);
+    }
+    _("hasMetadata", le);
+    function he(e, t, r) {
+      if (!y(t))
+        throw new TypeError();
+      return s(r) || (r = O(r)), W(e, t, r);
+    }
+    _("hasOwnMetadata", he);
+    function ve(e, t, r) {
+      if (!y(t))
+        throw new TypeError();
+      return s(r) || (r = O(r)), L(e, t, r);
+    }
+    _("getMetadata", ve);
+    function ye(e, t, r) {
+      if (!y(t))
+        throw new TypeError();
+      return s(r) || (r = O(r)), Z(e, t, r);
+    }
+    _("getOwnMetadata", ye);
+    function pe(e, t) {
+      if (!y(e))
+        throw new TypeError();
+      return s(t) || (t = O(t)), q(e, t);
+    }
+    _("getMetadataKeys", pe);
+    function we(e, t) {
+      if (!y(e))
+        throw new TypeError();
+      return s(t) || (t = O(t)), J(e, t);
+    }
+    _("getOwnMetadataKeys", we);
+    function _e(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", _e);
+    function Me(e, t) {
+      for (var r = e.length - 1; r >= 0; --r) {
+        var n = e[r], u = n(t);
+        if (!s(u) && !j(u)) {
+          if (!K(u))
+            throw new TypeError();
+          t = u;
+        }
+      }
+      return t;
+    }
+    function ge(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) && !j(p)) {
+          if (!y(p))
+            throw new TypeError();
+          n = p;
+        }
+      }
+      return n;
+    }
+    function N(e, t, r) {
+      var n = W(e, t, r);
+      if (n)
+        return !0;
+      var u = V(t);
+      return j(u) ? !1 : N(e, u, r);
+    }
+    function W(e, t, r) {
+      var n = x(
+        t,
+        r,
+        /*Create*/
+        !1
+      );
+      return s(n) ? !1 : X(n.OrdinaryHasOwnMetadata(e, t, r));
+    }
+    function L(e, t, r) {
+      var n = W(e, t, r);
+      if (n)
+        return Z(e, t, r);
+      var u = V(t);
+      if (!j(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 q(e, t) {
+      var r = J(e, t), n = V(e);
+      if (n === null)
+        return r;
+      var u = q(n, t);
+      if (u.length <= 0)
+        return r;
+      if (r.length <= 0)
+        return u;
+      for (var w = new F(), 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 J(e, t) {
+      var r = x(
+        e,
+        t,
+        /*create*/
+        !1
+      );
+      return r ? r.OrdinaryOwnMetadataKeys(e, t) : [];
+    }
+    function Q(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 j(e) {
+      return e === null;
+    }
+    function be(e) {
+      return typeof e == "symbol";
+    }
+    function y(e) {
+      return typeof e == "object" ? e !== null : typeof e == "function";
+    }
+    function Oe(e, t) {
+      switch (Q(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 = ee(e, k);
+      if (n !== void 0) {
+        var u = n.call(e, r);
+        if (y(u))
+          throw new TypeError();
+        return u;
+      }
+      return me(e);
+    }
+    function me(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 X(e) {
+      return !!e;
+    }
+    function ke(e) {
+      return "" + e;
+    }
+    function O(e) {
+      var t = Oe(e);
+      return be(t) ? t : ke(t);
+    }
+    function Y(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 K(e) {
+      return typeof e == "function";
+    }
+    function Te(e) {
+      switch (Q(e)) {
+        case 3:
+          return !0;
+        case 4:
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function H(e, t) {
+      return e === t || e !== e && t !== t;
+    }
+    function ee(e, t) {
+      var r = e[t];
+      if (r != null) {
+        if (!A(r))
+          throw new TypeError();
+        return r;
+      }
+    }
+    function te(e) {
+      var t = ee(e, E);
+      if (!A(t))
+        throw new TypeError();
+      var r = t.call(e);
+      if (!y(r))
+        throw new TypeError();
+      return r;
+    }
+    function re(e) {
+      return e.value;
+    }
+    function ne(e) {
+      var t = e.next();
+      return t.done ? !1 : t;
+    }
+    function ae(e) {
+      var t = e.return;
+      t && t.call(e);
+    }
+    function V(e) {
+      var t = Object.getPrototypeOf(e);
+      if (typeof e != "function" || e === R || t !== R)
+        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 Ee() {
+      var e;
+      !s(S) && typeof v.Reflect < "u" && !(S in v.Reflect) && typeof v.Reflect.defineMetadata == "function" && (e = je(v.Reflect));
+      var t, r, n, u = new U(), 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 F()), 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 = te(n); ; ) {
+                var h = ne(l);
+                if (!h)
+                  return;
+                var b = re(h);
+                if (b.isProviderFor(o, d))
+                  return ae(l), b;
+              }
+          }
+        }
+        if (!s(e) && e.isProviderFor(o, d))
+          return e;
+      }
+      function a(o, d) {
+        var l = u.get(o), h;
+        return s(l) || (h = l.get(d)), s(h) && (h = c(o, d), s(h) || (s(l) && (l = new C(), u.set(o, l)), l.set(d, h))), h;
+      }
+      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 h = a(o, d);
+        if (h !== l) {
+          if (!s(h))
+            return !1;
+          var b = u.get(o);
+          s(b) && (b = new C(), u.set(o, b)), b.set(d, l);
+        }
+        return !0;
+      }
+    }
+    function Pe() {
+      var e;
+      return !s(S) && y(v.Reflect) && Object.isExtensible(v.Reflect) && (e = v.Reflect[S]), s(e) && (e = Ee()), !s(S) && y(v.Reflect) && Object.isExtensible(v.Reflect) && Object.defineProperty(v.Reflect, S, {
+        enumerable: !1,
+        configurable: !1,
+        writable: !1,
+        value: e
+      }), e;
+    }
+    function Se(e) {
+      var t = new U(), 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 h = d.get(f);
+        if (s(h)) {
+          if (!o)
+            return;
+          if (h = new C(), d.set(f, h), !e.setProvider(i, f, r))
+            throw d.delete(f), l && t.delete(i), new Error("Wrong provider for target.");
+        }
+        return h;
+      }
+      function u(i, f, o) {
+        var d = n(
+          f,
+          o,
+          /*Create*/
+          !1
+        );
+        return s(d) ? !1 : X(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(), h = te(l), b = 0; ; ) {
+          var ie = ne(h);
+          if (!ie)
+            return o.length = b, o;
+          var xe = re(ie);
+          try {
+            o[b] = xe;
+          } catch (De) {
+            try {
+              ae(h);
+            } finally {
+              throw De;
+            }
+          }
+          b++;
+        }
+      }
+      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 U(), 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 F(), 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[E] = 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--, H(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[E] = function() {
+            return this.entries();
+          }, c.prototype._find = function(a, i) {
+            if (!H(this._cacheKey, a)) {
+              this._cacheIndex = -1;
+              for (var f = 0; f < this._keys.length; f++)
+                if (H(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 Re() {
+      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[E] = function() {
+            return this.keys();
+          }, t;
+        }()
+      );
+      return e;
+    }
+    function Ce() {
+      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 z(e) {
+      return e.__ = void 0, delete e.__, e;
+    }
+  });
+})(ue || (ue = {}));
+const Ae = /* @__PURE__ */ Ge({
+  __proto__: null,
+  default: oe
+}, [oe]);
+export {
+  Ae as R
+};