@monerium/sdk 2.0.0-alpha.2 → 2.0.0

package/dist/index.es.js

@@ -0,0 +1,780 @@
+var ie = Object.defineProperty;
+var oe = (e, t, i) =>
+  t in e
+    ? ie(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i })
+    : (e[t] = i);
+var j = (e, t, i) => (oe(e, typeof t != "symbol" ? t + "" : t, i), i),
+  F = (e, t, i) => {
+    if (!t.has(e)) throw TypeError("Cannot " + i);
+  };
+var E = (e, t, i) => (
+    F(e, t, "read from private field"), i ? i.call(e) : t.get(e)
+  ),
+  P = (e, t, i) => {
+    if (t.has(e))
+      throw TypeError("Cannot add the same private member more than once");
+    t instanceof WeakSet ? t.add(e) : t.set(e, i);
+  },
+  D = (e, t, i, c) => (
+    F(e, t, "write to private field"), c ? c.call(e, i) : t.set(e, i), i
+  );
+var x = (e, t, i) => (F(e, t, "access private method"), i);
+const se = {
+  environments: {
+    production: {
+      api: "https://api.monerium.app",
+      web: "https://monerium.app",
+    },
+    sandbox: {
+      api: "https://api.monerium.dev",
+      web: "https://sandbox.monerium.dev",
+    },
+  },
+};
+var U =
+  typeof globalThis < "u"
+    ? globalThis
+    : typeof window < "u"
+    ? window
+    : typeof global < "u"
+    ? global
+    : typeof self < "u"
+    ? self
+    : {};
+function ae(e) {
+  if (e.__esModule) return e;
+  var t = e.default;
+  if (typeof t == "function") {
+    var i = function c() {
+      if (this instanceof c) {
+        var y = [null];
+        y.push.apply(y, arguments);
+        var p = Function.bind.apply(t, y);
+        return new p();
+      }
+      return t.apply(this, arguments);
+    };
+    i.prototype = t.prototype;
+  } else i = {};
+  return (
+    Object.defineProperty(i, "__esModule", { value: !0 }),
+    Object.keys(e).forEach(function (c) {
+      var y = Object.getOwnPropertyDescriptor(e, c);
+      Object.defineProperty(
+        i,
+        c,
+        y.get
+          ? y
+          : {
+              enumerable: !0,
+              get: function () {
+                return e[c];
+              },
+            }
+      );
+    }),
+    i
+  );
+}
+var M = {},
+  ce = {
+    get exports() {
+      return M;
+    },
+    set exports(e) {
+      M = e;
+    },
+  };
+function ue(e) {
+  throw new Error(
+    'Could not dynamically require "' +
+      e +
+      '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.'
+  );
+}
+var L = {},
+  fe = {
+    get exports() {
+      return L;
+    },
+    set exports(e) {
+      L = e;
+    },
+  };
+const le = {},
+  he = /* @__PURE__ */ Object.freeze(
+    /* @__PURE__ */ Object.defineProperty(
+      {
+        __proto__: null,
+        default: le,
+      },
+      Symbol.toStringTag,
+      { value: "Module" }
+    )
+  ),
+  pe = /* @__PURE__ */ ae(he);
+var Q;
+function G() {
+  return (
+    Q ||
+      ((Q = 1),
+      (function (e, t) {
+        (function (i, c) {
+          e.exports = c();
+        })(U, function () {
+          var i =
+            i ||
+            (function (c, y) {
+              var p;
+              if (
+                (typeof window < "u" && window.crypto && (p = window.crypto),
+                typeof self < "u" && self.crypto && (p = self.crypto),
+                typeof globalThis < "u" &&
+                  globalThis.crypto &&
+                  (p = globalThis.crypto),
+                !p &&
+                  typeof window < "u" &&
+                  window.msCrypto &&
+                  (p = window.msCrypto),
+                !p && typeof U < "u" && U.crypto && (p = U.crypto),
+                !p && typeof ue == "function")
+              )
+                try {
+                  p = pe;
+                } catch {}
+              var R = function () {
+                  if (p) {
+                    if (typeof p.getRandomValues == "function")
+                      try {
+                        return p.getRandomValues(new Uint32Array(1))[0];
+                      } catch {}
+                    if (typeof p.randomBytes == "function")
+                      try {
+                        return p.randomBytes(4).readInt32LE();
+                      } catch {}
+                  }
+                  throw new Error(
+                    "Native crypto module could not be used to get secure random number."
+                  );
+                },
+                k =
+                  Object.create ||
+                  (function () {
+                    function r() {}
+                    return function (n) {
+                      var s;
+                      return (
+                        (r.prototype = n),
+                        (s = new r()),
+                        (r.prototype = null),
+                        s
+                      );
+                    };
+                  })(),
+                a = {},
+                w = (a.lib = {}),
+                d = (w.Base = (function () {
+                  return {
+                    extend: function (r) {
+                      var n = k(this);
+                      return (
+                        r && n.mixIn(r),
+                        (!n.hasOwnProperty("init") || this.init === n.init) &&
+                          (n.init = function () {
+                            n.$super.init.apply(this, arguments);
+                          }),
+                        (n.init.prototype = n),
+                        (n.$super = this),
+                        n
+                      );
+                    },
+                    create: function () {
+                      var r = this.extend();
+                      return r.init.apply(r, arguments), r;
+                    },
+                    init: function () {},
+                    mixIn: function (r) {
+                      for (var n in r) r.hasOwnProperty(n) && (this[n] = r[n]);
+                      r.hasOwnProperty("toString") &&
+                        (this.toString = r.toString);
+                    },
+                    clone: function () {
+                      return this.init.prototype.extend(this);
+                    },
+                  };
+                })()),
+                l = (w.WordArray = d.extend({
+                  init: function (r, n) {
+                    (r = this.words = r || []),
+                      n != y
+                        ? (this.sigBytes = n)
+                        : (this.sigBytes = r.length * 4);
+                  },
+                  toString: function (r) {
+                    return (r || f).stringify(this);
+                  },
+                  concat: function (r) {
+                    var n = this.words,
+                      s = r.words,
+                      u = this.sigBytes,
+                      g = r.sigBytes;
+                    if ((this.clamp(), u % 4))
+                      for (var m = 0; m < g; m++) {
+                        var b = (s[m >>> 2] >>> (24 - (m % 4) * 8)) & 255;
+                        n[(u + m) >>> 2] |= b << (24 - ((u + m) % 4) * 8);
+                      }
+                    else
+                      for (var B = 0; B < g; B += 4)
+                        n[(u + B) >>> 2] = s[B >>> 2];
+                    return (this.sigBytes += g), this;
+                  },
+                  clamp: function () {
+                    var r = this.words,
+                      n = this.sigBytes;
+                    (r[n >>> 2] &= 4294967295 << (32 - (n % 4) * 8)),
+                      (r.length = c.ceil(n / 4));
+                  },
+                  clone: function () {
+                    var r = d.clone.call(this);
+                    return (r.words = this.words.slice(0)), r;
+                  },
+                  random: function (r) {
+                    for (var n = [], s = 0; s < r; s += 4) n.push(R());
+                    return new l.init(n, r);
+                  },
+                })),
+                _ = (a.enc = {}),
+                f = (_.Hex = {
+                  stringify: function (r) {
+                    for (
+                      var n = r.words, s = r.sigBytes, u = [], g = 0;
+                      g < s;
+                      g++
+                    ) {
+                      var m = (n[g >>> 2] >>> (24 - (g % 4) * 8)) & 255;
+                      u.push((m >>> 4).toString(16)),
+                        u.push((m & 15).toString(16));
+                    }
+                    return u.join("");
+                  },
+                  parse: function (r) {
+                    for (var n = r.length, s = [], u = 0; u < n; u += 2)
+                      s[u >>> 3] |=
+                        parseInt(r.substr(u, 2), 16) << (24 - (u % 8) * 4);
+                    return new l.init(s, n / 2);
+                  },
+                }),
+                v = (_.Latin1 = {
+                  stringify: function (r) {
+                    for (
+                      var n = r.words, s = r.sigBytes, u = [], g = 0;
+                      g < s;
+                      g++
+                    ) {
+                      var m = (n[g >>> 2] >>> (24 - (g % 4) * 8)) & 255;
+                      u.push(String.fromCharCode(m));
+                    }
+                    return u.join("");
+                  },
+                  parse: function (r) {
+                    for (var n = r.length, s = [], u = 0; u < n; u++)
+                      s[u >>> 2] |=
+                        (r.charCodeAt(u) & 255) << (24 - (u % 4) * 8);
+                    return new l.init(s, n);
+                  },
+                }),
+                o = (_.Utf8 = {
+                  stringify: function (r) {
+                    try {
+                      return decodeURIComponent(escape(v.stringify(r)));
+                    } catch {
+                      throw new Error("Malformed UTF-8 data");
+                    }
+                  },
+                  parse: function (r) {
+                    return v.parse(unescape(encodeURIComponent(r)));
+                  },
+                }),
+                h = (w.BufferedBlockAlgorithm = d.extend({
+                  reset: function () {
+                    (this._data = new l.init()), (this._nDataBytes = 0);
+                  },
+                  _append: function (r) {
+                    typeof r == "string" && (r = o.parse(r)),
+                      this._data.concat(r),
+                      (this._nDataBytes += r.sigBytes);
+                  },
+                  _process: function (r) {
+                    var n,
+                      s = this._data,
+                      u = s.words,
+                      g = s.sigBytes,
+                      m = this.blockSize,
+                      b = m * 4,
+                      B = g / b;
+                    r
+                      ? (B = c.ceil(B))
+                      : (B = c.max((B | 0) - this._minBufferSize, 0));
+                    var W = B * m,
+                      H = c.min(W * 4, g);
+                    if (W) {
+                      for (var $ = 0; $ < W; $ += m) this._doProcessBlock(u, $);
+                      (n = u.splice(0, W)), (s.sigBytes -= H);
+                    }
+                    return new l.init(n, H);
+                  },
+                  clone: function () {
+                    var r = d.clone.call(this);
+                    return (r._data = this._data.clone()), r;
+                  },
+                  _minBufferSize: 0,
+                }));
+              w.Hasher = h.extend({
+                cfg: d.extend(),
+                init: function (r) {
+                  (this.cfg = this.cfg.extend(r)), this.reset();
+                },
+                reset: function () {
+                  h.reset.call(this), this._doReset();
+                },
+                update: function (r) {
+                  return this._append(r), this._process(), this;
+                },
+                finalize: function (r) {
+                  r && this._append(r);
+                  var n = this._doFinalize();
+                  return n;
+                },
+                blockSize: 16,
+                _createHelper: function (r) {
+                  return function (n, s) {
+                    return new r.init(s).finalize(n);
+                  };
+                },
+                _createHmacHelper: function (r) {
+                  return function (n, s) {
+                    return new C.HMAC.init(r, s).finalize(n);
+                  };
+                },
+              });
+              var C = (a.algo = {});
+              return a;
+            })(Math);
+          return i;
+        });
+      })(fe)),
+    L
+  );
+}
+(function (e, t) {
+  (function (i, c) {
+    e.exports = c(G());
+  })(U, function (i) {
+    return (
+      (function () {
+        var c = i,
+          y = c.lib,
+          p = y.WordArray,
+          R = c.enc;
+        R.Base64url = {
+          stringify: function (a, w = !0) {
+            var d = a.words,
+              l = a.sigBytes,
+              _ = w ? this._safe_map : this._map;
+            a.clamp();
+            for (var f = [], v = 0; v < l; v += 3)
+              for (
+                var o = (d[v >>> 2] >>> (24 - (v % 4) * 8)) & 255,
+                  h = (d[(v + 1) >>> 2] >>> (24 - ((v + 1) % 4) * 8)) & 255,
+                  C = (d[(v + 2) >>> 2] >>> (24 - ((v + 2) % 4) * 8)) & 255,
+                  r = (o << 16) | (h << 8) | C,
+                  n = 0;
+                n < 4 && v + n * 0.75 < l;
+                n++
+              )
+                f.push(_.charAt((r >>> (6 * (3 - n))) & 63));
+            var s = _.charAt(64);
+            if (s) for (; f.length % 4; ) f.push(s);
+            return f.join("");
+          },
+          parse: function (a, w = !0) {
+            var d = a.length,
+              l = w ? this._safe_map : this._map,
+              _ = this._reverseMap;
+            if (!_) {
+              _ = this._reverseMap = [];
+              for (var f = 0; f < l.length; f++) _[l.charCodeAt(f)] = f;
+            }
+            var v = l.charAt(64);
+            if (v) {
+              var o = a.indexOf(v);
+              o !== -1 && (d = o);
+            }
+            return k(a, d, _);
+          },
+          _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+          _safe_map:
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+        };
+        function k(a, w, d) {
+          for (var l = [], _ = 0, f = 0; f < w; f++)
+            if (f % 4) {
+              var v = d[a.charCodeAt(f - 1)] << ((f % 4) * 2),
+                o = d[a.charCodeAt(f)] >>> (6 - (f % 4) * 2),
+                h = v | o;
+              (l[_ >>> 2] |= h << (24 - (_ % 4) * 8)), _++;
+            }
+          return p.create(l, _);
+        }
+      })(),
+      i.enc.Base64url
+    );
+  });
+})(ce);
+var V = {},
+  ve = {
+    get exports() {
+      return V;
+    },
+    set exports(e) {
+      V = e;
+    },
+  };
+(function (e, t) {
+  (function (i, c) {
+    e.exports = c(G());
+  })(U, function (i) {
+    return (
+      (function (c) {
+        var y = i,
+          p = y.lib,
+          R = p.WordArray,
+          k = p.Hasher,
+          a = y.algo,
+          w = [],
+          d = [];
+        (function () {
+          function f(C) {
+            for (var r = c.sqrt(C), n = 2; n <= r; n++) if (!(C % n)) return !1;
+            return !0;
+          }
+          function v(C) {
+            return ((C - (C | 0)) * 4294967296) | 0;
+          }
+          for (var o = 2, h = 0; h < 64; )
+            f(o) &&
+              (h < 8 && (w[h] = v(c.pow(o, 1 / 2))),
+              (d[h] = v(c.pow(o, 1 / 3))),
+              h++),
+              o++;
+        })();
+        var l = [],
+          _ = (a.SHA256 = k.extend({
+            _doReset: function () {
+              this._hash = new R.init(w.slice(0));
+            },
+            _doProcessBlock: function (f, v) {
+              for (
+                var o = this._hash.words,
+                  h = o[0],
+                  C = o[1],
+                  r = o[2],
+                  n = o[3],
+                  s = o[4],
+                  u = o[5],
+                  g = o[6],
+                  m = o[7],
+                  b = 0;
+                b < 64;
+                b++
+              ) {
+                if (b < 16) l[b] = f[v + b] | 0;
+                else {
+                  var B = l[b - 15],
+                    W =
+                      ((B << 25) | (B >>> 7)) ^
+                      ((B << 14) | (B >>> 18)) ^
+                      (B >>> 3),
+                    H = l[b - 2],
+                    $ =
+                      ((H << 15) | (H >>> 17)) ^
+                      ((H << 13) | (H >>> 19)) ^
+                      (H >>> 10);
+                  l[b] = W + l[b - 7] + $ + l[b - 16];
+                }
+                var Y = (s & u) ^ (~s & g),
+                  ee = (h & C) ^ (h & r) ^ (C & r),
+                  re =
+                    ((h << 30) | (h >>> 2)) ^
+                    ((h << 19) | (h >>> 13)) ^
+                    ((h << 10) | (h >>> 22)),
+                  te =
+                    ((s << 26) | (s >>> 6)) ^
+                    ((s << 21) | (s >>> 11)) ^
+                    ((s << 7) | (s >>> 25)),
+                  J = m + te + Y + d[b] + l[b],
+                  ne = re + ee;
+                (m = g),
+                  (g = u),
+                  (u = s),
+                  (s = (n + J) | 0),
+                  (n = r),
+                  (r = C),
+                  (C = h),
+                  (h = (J + ne) | 0);
+              }
+              (o[0] = (o[0] + h) | 0),
+                (o[1] = (o[1] + C) | 0),
+                (o[2] = (o[2] + r) | 0),
+                (o[3] = (o[3] + n) | 0),
+                (o[4] = (o[4] + s) | 0),
+                (o[5] = (o[5] + u) | 0),
+                (o[6] = (o[6] + g) | 0),
+                (o[7] = (o[7] + m) | 0);
+            },
+            _doFinalize: function () {
+              var f = this._data,
+                v = f.words,
+                o = this._nDataBytes * 8,
+                h = f.sigBytes * 8;
+              return (
+                (v[h >>> 5] |= 128 << (24 - (h % 32))),
+                (v[(((h + 64) >>> 9) << 4) + 14] = c.floor(o / 4294967296)),
+                (v[(((h + 64) >>> 9) << 4) + 15] = o),
+                (f.sigBytes = v.length * 4),
+                this._process(),
+                this._hash
+              );
+            },
+            clone: function () {
+              var f = k.clone.call(this);
+              return (f._hash = this._hash.clone()), f;
+            },
+          }));
+        (y.SHA256 = k._createHelper(_)),
+          (y.HmacSHA256 = k._createHmacHelper(_));
+      })(Math),
+      i.SHA256
+    );
+  });
+})(ve);
+var N = {},
+  de = {
+    get exports() {
+      return N;
+    },
+    set exports(e) {
+      N = e;
+    },
+  };
+(function (e, t) {
+  (function (i, c) {
+    e.exports = c(G());
+  })(U, function (i) {
+    return (
+      (function () {
+        if (typeof ArrayBuffer == "function") {
+          var c = i,
+            y = c.lib,
+            p = y.WordArray,
+            R = p.init,
+            k = (p.init = function (a) {
+              if (
+                (a instanceof ArrayBuffer && (a = new Uint8Array(a)),
+                (a instanceof Int8Array ||
+                  (typeof Uint8ClampedArray < "u" &&
+                    a instanceof Uint8ClampedArray) ||
+                  a instanceof Int16Array ||
+                  a instanceof Uint16Array ||
+                  a instanceof Int32Array ||
+                  a instanceof Uint32Array ||
+                  a instanceof Float32Array ||
+                  a instanceof Float64Array) &&
+                  (a = new Uint8Array(a.buffer, a.byteOffset, a.byteLength)),
+                a instanceof Uint8Array)
+              ) {
+                for (var w = a.byteLength, d = [], l = 0; l < w; l++)
+                  d[l >>> 2] |= a[l] << (24 - (l % 4) * 8);
+                R.call(this, d, w);
+              } else R.apply(this, arguments);
+            });
+          k.prototype = p;
+        }
+      })(),
+      i.lib.WordArray
+    );
+  });
+})(de);
+var O, z, S, A, T, X, q, Z, I, K;
+class Re {
+  constructor(t = "sandbox") {
+    P(this, S);
+    P(this, T);
+    P(this, q);
+    P(this, I);
+    P(this, O, void 0);
+    P(this, z, void 0);
+    j(this, "codeVerifier");
+    j(this, "bearerProfile");
+    D(this, O, se.environments[t]);
+  }
+  async auth(t) {
+    let i;
+    if (x(this, T, X).call(this, t))
+      i = { ...t, grant_type: "authorization_code" };
+    else if (x(this, q, Z).call(this, t))
+      i = { ...t, grant_type: "refresh_token" };
+    else if (x(this, I, K).call(this, t))
+      i = { ...t, grant_type: "client_credentials" };
+    else throw new Error("Authentication method could not be detected.");
+    (this.bearerProfile = await x(this, S, A).call(
+      this,
+      "post",
+      "auth/token",
+      new URLSearchParams(i),
+      !0
+    )),
+      D(this, z, `Bearer ${this.bearerProfile.access_token}`);
+  }
+  pkceRequest(t) {
+    this.codeVerifier = N.random(64).toString();
+    const i = M.stringify(V(this.codeVerifier)),
+      c = {
+        ...t,
+        code_challenge: i,
+        code_challenge_method: "S256",
+        response_type: "code",
+      };
+    return `${E(this, O).api}/auth?${new URLSearchParams(c)}`;
+  }
+  getAuthContext() {
+    return x(this, S, A).call(this, "get", "auth/context");
+  }
+  getProfile(t) {
+    return x(this, S, A).call(this, "get", `profiles/${t}`);
+  }
+  getBalances(t) {
+    return t
+      ? x(this, S, A).call(this, "get", `profiles/${t}/balances`)
+      : x(this, S, A).call(this, "get", "balances");
+  }
+  getOrders(t) {
+    const i = new URLSearchParams(t);
+    return x(this, S, A).call(this, "get", `orders?${i}`);
+  }
+  getOrder(t) {
+    return x(this, S, A).call(this, "get", `orders/${t}`);
+  }
+  getTokens() {
+    return x(this, S, A).call(this, "get", "tokens");
+  }
+  linkAddress(t, i) {
+    return x(this, S, A).call(
+      this,
+      "post",
+      `profiles/${t}/addresses`,
+      JSON.stringify(i)
+    );
+  }
+  placeOrder(t, i) {
+    return i
+      ? x(this, S, A).call(
+          this,
+          "post",
+          `profiles/${i}/orders`,
+          JSON.stringify(t)
+        )
+      : x(this, S, A).call(this, "post", "orders", JSON.stringify(t));
+  }
+  uploadSupportingDocument(t) {
+    const i = new URLSearchParams(t);
+    return x(this, S, A).call(this, "post", "files/supporting-document", i, !0);
+  }
+}
+(O = new WeakMap()),
+  (z = new WeakMap()),
+  (S = new WeakSet()),
+  (A = async function (t, i, c, y) {
+    const p = await fetch(`${E(this, O).api}/${i}`, {
+        method: t,
+        headers: {
+          "Content-Type": `application/${y ? "x-www-form-urlencoded" : "json"}`,
+          Authorization: E(this, z) || "",
+        },
+        body: c,
+      }),
+      R = await p.json();
+    if (p.ok) return R;
+    throw R;
+  }),
+  (T = new WeakSet()),
+  (X = function (t) {
+    return t.code != null;
+  }),
+  (q = new WeakSet()),
+  (Z = function (t) {
+    return t.refresh_token != null;
+  }),
+  (I = new WeakSet()),
+  (K = function (t) {
+    return t.client_secret != null;
+  });
+var ge = /* @__PURE__ */ ((e) => (
+    (e.eur = "eur"), (e.usd = "usd"), (e.gbp = "gbp"), (e.isk = "isk"), e
+  ))(ge || {}),
+  ye = /* @__PURE__ */ ((e) => (
+    (e.corporate = "corporate"), (e.personal = "personal"), e
+  ))(ye || {}),
+  _e = /* @__PURE__ */ ((e) => ((e.read = "read"), (e.write = "write"), e))(
+    _e || {}
+  ),
+  me = /* @__PURE__ */ ((e) => (
+    (e.absent = "absent"),
+    (e.submitted = "submitted"),
+    (e.pending = "pending"),
+    (e.confirmed = "confirmed"),
+    e
+  ))(me || {}),
+  we = /* @__PURE__ */ ((e) => (
+    (e.approved = "approved"),
+    (e.rejected = "rejected"),
+    (e.unknown = "unknown"),
+    e
+  ))(we || {}),
+  be = /* @__PURE__ */ ((e) => ((e.iban = "iban"), (e.scan = "scan"), e))(
+    be || {}
+  ),
+  Be = /* @__PURE__ */ ((e) => (
+    (e.polygon = "polygon"), (e.ethereum = "ethereum"), (e.gnosis = "gnosis"), e
+  ))(Be || {}),
+  xe = /* @__PURE__ */ ((e) => (
+    (e.mainnet = "mainnet"),
+    (e.chiado = "chiado"),
+    (e.goerli = "goerli"),
+    (e.mumbai = "mumbai"),
+    e
+  ))(xe || {}),
+  Ce = /* @__PURE__ */ ((e) => ((e.redeem = "redeem"), (e.issue = "issue"), e))(
+    Ce || {}
+  ),
+  Se = /* @__PURE__ */ ((e) => (
+    (e.placed = "placed"),
+    (e.pending = "pending"),
+    (e.processed = "processed"),
+    (e.rejected = "rejected"),
+    e
+  ))(Se || {});
+export {
+  Be as Chain,
+  ge as Currency,
+  we as KYCOutcome,
+  me as KYCState,
+  Re as MoneriumClient,
+  xe as Network,
+  Ce as OrderKind,
+  Se as OrderState,
+  be as PaymentStandard,
+  _e as Permission,
+  ye as ProfileType,
+};
+//# sourceMappingURL=index.es.js.map