@fluidattacks/design 3.1.12 → 3.1.13

package/dist/index-maWH3JYC.mjs

@@ -0,0 +1,3561 @@
+import { jsx as mi } from "react/jsx-runtime";
+import _i from "react";
+import { u as bi } from "./use-cloudinary-image-BCxwj15o.mjs";
+import "lodash";
+var ae = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Sr = { exports: {} };
+(function(t, e) {
+  var r = 200, o = "__lodash_hash_undefined__", s = 9007199254740991, u = "[object Arguments]", p = "[object Array]", h = "[object Boolean]", m = "[object Date]", g = "[object Error]", O = "[object Function]", X = "[object GeneratorFunction]", q = "[object Map]", ve = "[object Number]", me = "[object Object]", Z = "[object Promise]", _e = "[object RegExp]", ue = "[object Set]", ut = "[object String]", ct = "[object Symbol]", Le = "[object WeakMap]", Fe = "[object ArrayBuffer]", be = "[object DataView]", Ve = "[object Float32Array]", De = "[object Float64Array]", lt = "[object Int8Array]", L = "[object Int16Array]", we = "[object Int32Array]", ft = "[object Uint8Array]", dt = "[object Uint8ClampedArray]", pt = "[object Uint16Array]", ht = "[object Uint32Array]", F = /[\\^$.*+?()[\]{}|]/g, ee = /\w*$/, ce = /^\[object .+?Constructor\]$/, te = /^(?:0|[1-9]\d*)$/, C = {};
+  C[u] = C[p] = C[Fe] = C[be] = C[h] = C[m] = C[Ve] = C[De] = C[lt] = C[L] = C[we] = C[q] = C[ve] = C[me] = C[_e] = C[ue] = C[ut] = C[ct] = C[ft] = C[dt] = C[pt] = C[ht] = !0, C[g] = C[O] = C[Le] = !1;
+  var Ne = typeof ae == "object" && ae && ae.Object === Object && ae, Ee = typeof self == "object" && self && self.Object === Object && self, A = Ne || Ee || Function("return this")(), Be = e && !e.nodeType && e, Ue = Be && !0 && t && !t.nodeType && t, Qe = Ue && Ue.exports === Be;
+  function gt(i, c) {
+    return i.set(c[0], c[1]), i;
+  }
+  function Ge(i, c) {
+    return i.add(c), i;
+  }
+  function z(i, c) {
+    for (var f = -1, v = i ? i.length : 0; ++f < v && c(i[f], f, i) !== !1; )
+      ;
+    return i;
+  }
+  function qe(i, c) {
+    for (var f = -1, v = c.length, j = i.length; ++f < v; )
+      i[j + f] = c[f];
+    return i;
+  }
+  function yt(i, c, f, v) {
+    for (var j = -1, k = i ? i.length : 0; ++j < k; )
+      f = c(f, i[j], j, i);
+    return f;
+  }
+  function ze(i, c) {
+    for (var f = -1, v = Array(i); ++f < i; )
+      v[f] = c(f);
+    return v;
+  }
+  function vt(i, c) {
+    return i == null ? void 0 : i[c];
+  }
+  function Oe(i) {
+    var c = !1;
+    if (i != null && typeof i.toString != "function")
+      try {
+        c = !!(i + "");
+      } catch {
+      }
+    return c;
+  }
+  function Ae(i) {
+    var c = -1, f = Array(i.size);
+    return i.forEach(function(v, j) {
+      f[++c] = [j, v];
+    }), f;
+  }
+  function Ye(i, c) {
+    return function(f) {
+      return i(c(f));
+    };
+  }
+  function le(i) {
+    var c = -1, f = Array(i.size);
+    return i.forEach(function(v) {
+      f[++c] = v;
+    }), f;
+  }
+  var mt = Array.prototype, _t = Function.prototype, fe = Object.prototype, de = A["__core-js_shared__"], We = function() {
+    var i = /[^.]+$/.exec(de && de.keys && de.keys.IE_PROTO || "");
+    return i ? "Symbol(src)_1." + i : "";
+  }(), He = _t.toString, G = fe.hasOwnProperty, Se = fe.toString, Ut = RegExp(
+    "^" + He.call(G).replace(F, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+  ), Te = Qe ? A.Buffer : void 0, bt = A.Symbol, wt = A.Uint8Array, Qt = Ye(Object.getPrototypeOf, Object), re = Object.create, Et = fe.propertyIsEnumerable, Gt = mt.splice, Ot = Object.getOwnPropertySymbols, At = Te ? Te.isBuffer : void 0, qt = Ye(Object.keys, Object), Ce = b(A, "DataView"), pe = b(A, "Map"), ne = b(A, "Promise"), Re = b(A, "Set"), xe = b(A, "WeakMap"), Y = b(Object, "create"), Je = ge(Ce), Ke = ge(pe), zt = ge(ne), Yt = ge(Re), Wt = ge(xe), Pe = bt ? bt.prototype : void 0, St = Pe ? Pe.valueOf : void 0;
+  function W(i) {
+    var c = -1, f = i ? i.length : 0;
+    for (this.clear(); ++c < f; ) {
+      var v = i[c];
+      this.set(v[0], v[1]);
+    }
+  }
+  function Ht() {
+    this.__data__ = Y ? Y(null) : {};
+  }
+  function Jt(i) {
+    return this.has(i) && delete this.__data__[i];
+  }
+  function Kt(i) {
+    var c = this.__data__;
+    if (Y) {
+      var f = c[i];
+      return f === o ? void 0 : f;
+    }
+    return G.call(c, i) ? c[i] : void 0;
+  }
+  function Xt(i) {
+    var c = this.__data__;
+    return Y ? c[i] !== void 0 : G.call(c, i);
+  }
+  function Zt(i, c) {
+    var f = this.__data__;
+    return f[i] = Y && c === void 0 ? o : c, this;
+  }
+  W.prototype.clear = Ht, W.prototype.delete = Jt, W.prototype.get = Kt, W.prototype.has = Xt, W.prototype.set = Zt;
+  function V(i) {
+    var c = -1, f = i ? i.length : 0;
+    for (this.clear(); ++c < f; ) {
+      var v = i[c];
+      this.set(v[0], v[1]);
+    }
+  }
+  function er() {
+    this.__data__ = [];
+  }
+  function D(i) {
+    var c = this.__data__, f = he(c, i);
+    if (f < 0)
+      return !1;
+    var v = c.length - 1;
+    return f == v ? c.pop() : Gt.call(c, f, 1), !0;
+  }
+  function tr(i) {
+    var c = this.__data__, f = he(c, i);
+    return f < 0 ? void 0 : c[f][1];
+  }
+  function rr(i) {
+    return he(this.__data__, i) > -1;
+  }
+  function nr(i, c) {
+    var f = this.__data__, v = he(f, i);
+    return v < 0 ? f.push([i, c]) : f[v][1] = c, this;
+  }
+  V.prototype.clear = er, V.prototype.delete = D, V.prototype.get = tr, V.prototype.has = rr, V.prototype.set = nr;
+  function ie(i) {
+    var c = -1, f = i ? i.length : 0;
+    for (this.clear(); ++c < f; ) {
+      var v = i[c];
+      this.set(v[0], v[1]);
+    }
+  }
+  function ir() {
+    this.__data__ = {
+      hash: new W(),
+      map: new (pe || V)(),
+      string: new W()
+    };
+  }
+  function or(i) {
+    return _(this, i).delete(i);
+  }
+  function ar(i) {
+    return _(this, i).get(i);
+  }
+  function sr(i) {
+    return _(this, i).has(i);
+  }
+  function ur(i, c) {
+    return _(this, i).set(i, c), this;
+  }
+  ie.prototype.clear = ir, ie.prototype.delete = or, ie.prototype.get = ar, ie.prototype.has = sr, ie.prototype.set = ur;
+  function oe(i) {
+    this.__data__ = new V(i);
+  }
+  function Xe() {
+    this.__data__ = new V();
+  }
+  function Tt(i) {
+    return this.__data__.delete(i);
+  }
+  function cr(i) {
+    return this.__data__.get(i);
+  }
+  function lr(i) {
+    return this.__data__.has(i);
+  }
+  function Ct(i, c) {
+    var f = this.__data__;
+    if (f instanceof V) {
+      var v = f.__data__;
+      if (!pe || v.length < r - 1)
+        return v.push([i, c]), this;
+      f = this.__data__ = new ie(v);
+    }
+    return f.set(i, c), this;
+  }
+  oe.prototype.clear = Xe, oe.prototype.delete = Tt, oe.prototype.get = cr, oe.prototype.has = lr, oe.prototype.set = Ct;
+  function fr(i, c) {
+    var f = br(i) || fi(i) ? ze(i.length, String) : [], v = f.length, j = !!v;
+    for (var k in i)
+      G.call(i, k) && !(j && (k == "length" || N(k, v))) && f.push(k);
+    return f;
+  }
+  function Ze(i, c, f) {
+    var v = i[c];
+    (!(G.call(i, c) && Kr(v, f)) || f === void 0 && !(c in i)) && (i[c] = f);
+  }
+  function he(i, c) {
+    for (var f = i.length; f--; )
+      if (Kr(i[f][0], c))
+        return f;
+    return -1;
+  }
+  function Rt(i, c) {
+    return i && d(c, wr(c), i);
+  }
+  function et(i, c, f, v, j, k, J) {
+    var I;
+    if (v && (I = k ? v(i, j, k, J) : v(i)), I !== void 0)
+      return I;
+    if (!$t(i))
+      return i;
+    var en = br(i);
+    if (en) {
+      if (I = $(i), !c)
+        return l(i, I);
+    } else {
+      var je = P(i), tn = je == O || je == X;
+      if (pi(i))
+        return hr(i, c);
+      if (je == me || je == u || tn && !k) {
+        if (Oe(i))
+          return k ? i : {};
+        if (I = M(tn ? {} : i), !c)
+          return y(i, Rt(I, i));
+      } else {
+        if (!C[je])
+          return k ? i : {};
+        I = H(i, je, et, c);
+      }
+    }
+    J || (J = new oe());
+    var rn = J.get(i);
+    if (rn)
+      return rn;
+    if (J.set(i, I), !en)
+      var nn = f ? E(i) : wr(i);
+    return z(nn || i, function(Er, kt) {
+      nn && (kt = Er, Er = i[kt]), Ze(I, kt, et(Er, c, f, v, kt, i, J));
+    }), I;
+  }
+  function xt(i) {
+    return $t(i) ? re(i) : {};
+  }
+  function Pt(i, c, f) {
+    var v = c(i);
+    return br(i) ? v : qe(v, f(i));
+  }
+  function dr(i) {
+    return Se.call(i);
+  }
+  function pr(i) {
+    if (!$t(i) || Mt(i))
+      return !1;
+    var c = Zr(i) || Oe(i) ? Ut : ce;
+    return c.test(ge(i));
+  }
+  function jt(i) {
+    if (!rt(i))
+      return qt(i);
+    var c = [];
+    for (var f in Object(i))
+      G.call(i, f) && f != "constructor" && c.push(f);
+    return c;
+  }
+  function hr(i, c) {
+    if (c)
+      return i.slice();
+    var f = new i.constructor(i.length);
+    return i.copy(f), f;
+  }
+  function tt(i) {
+    var c = new i.constructor(i.byteLength);
+    return new wt(c).set(new wt(i)), c;
+  }
+  function gr(i, c) {
+    var f = c ? tt(i.buffer) : i.buffer;
+    return new i.constructor(f, i.byteOffset, i.byteLength);
+  }
+  function yr(i, c, f) {
+    var v = c ? f(Ae(i), !0) : Ae(i);
+    return yt(v, gt, new i.constructor());
+  }
+  function vr(i) {
+    var c = new i.constructor(i.source, ee.exec(i));
+    return c.lastIndex = i.lastIndex, c;
+  }
+  function mr(i, c, f) {
+    var v = c ? f(le(i), !0) : le(i);
+    return yt(v, Ge, new i.constructor());
+  }
+  function n(i) {
+    return St ? Object(St.call(i)) : {};
+  }
+  function a(i, c) {
+    var f = c ? tt(i.buffer) : i.buffer;
+    return new i.constructor(f, i.byteOffset, i.length);
+  }
+  function l(i, c) {
+    var f = -1, v = i.length;
+    for (c || (c = Array(v)); ++f < v; )
+      c[f] = i[f];
+    return c;
+  }
+  function d(i, c, f, v) {
+    f || (f = {});
+    for (var j = -1, k = c.length; ++j < k; ) {
+      var J = c[j], I = void 0;
+      Ze(f, J, I === void 0 ? i[J] : I);
+    }
+    return f;
+  }
+  function y(i, c) {
+    return d(i, x(i), c);
+  }
+  function E(i) {
+    return Pt(i, wr, x);
+  }
+  function _(i, c) {
+    var f = i.__data__;
+    return _r(c) ? f[typeof c == "string" ? "string" : "hash"] : f.map;
+  }
+  function b(i, c) {
+    var f = vt(i, c);
+    return pr(f) ? f : void 0;
+  }
+  var x = Ot ? Ye(Ot, Object) : yi, P = dr;
+  (Ce && P(new Ce(new ArrayBuffer(1))) != be || pe && P(new pe()) != q || ne && P(ne.resolve()) != Z || Re && P(new Re()) != ue || xe && P(new xe()) != Le) && (P = function(i) {
+    var c = Se.call(i), f = c == me ? i.constructor : void 0, v = f ? ge(f) : void 0;
+    if (v)
+      switch (v) {
+        case Je:
+          return be;
+        case Ke:
+          return q;
+        case zt:
+          return Z;
+        case Yt:
+          return ue;
+        case Wt:
+          return Le;
+      }
+    return c;
+  });
+  function $(i) {
+    var c = i.length, f = i.constructor(c);
+    return c && typeof i[0] == "string" && G.call(i, "index") && (f.index = i.index, f.input = i.input), f;
+  }
+  function M(i) {
+    return typeof i.constructor == "function" && !rt(i) ? xt(Qt(i)) : {};
+  }
+  function H(i, c, f, v) {
+    var j = i.constructor;
+    switch (c) {
+      case Fe:
+        return tt(i);
+      case h:
+      case m:
+        return new j(+i);
+      case be:
+        return gr(i, v);
+      case Ve:
+      case De:
+      case lt:
+      case L:
+      case we:
+      case ft:
+      case dt:
+      case pt:
+      case ht:
+        return a(i, v);
+      case q:
+        return yr(i, v, f);
+      case ve:
+      case ut:
+        return new j(i);
+      case _e:
+        return vr(i);
+      case ue:
+        return mr(i, v, f);
+      case ct:
+        return n(i);
+    }
+  }
+  function N(i, c) {
+    return c = c ?? s, !!c && (typeof i == "number" || te.test(i)) && i > -1 && i % 1 == 0 && i < c;
+  }
+  function _r(i) {
+    var c = typeof i;
+    return c == "string" || c == "number" || c == "symbol" || c == "boolean" ? i !== "__proto__" : i === null;
+  }
+  function Mt(i) {
+    return !!We && We in i;
+  }
+  function rt(i) {
+    var c = i && i.constructor, f = typeof c == "function" && c.prototype || fe;
+    return i === f;
+  }
+  function ge(i) {
+    if (i != null) {
+      try {
+        return He.call(i);
+      } catch {
+      }
+      try {
+        return i + "";
+      } catch {
+      }
+    }
+    return "";
+  }
+  function li(i) {
+    return et(i, !0, !0);
+  }
+  function Kr(i, c) {
+    return i === c || i !== i && c !== c;
+  }
+  function fi(i) {
+    return di(i) && G.call(i, "callee") && (!Et.call(i, "callee") || Se.call(i) == u);
+  }
+  var br = Array.isArray;
+  function Xr(i) {
+    return i != null && hi(i.length) && !Zr(i);
+  }
+  function di(i) {
+    return gi(i) && Xr(i);
+  }
+  var pi = At || vi;
+  function Zr(i) {
+    var c = $t(i) ? Se.call(i) : "";
+    return c == O || c == X;
+  }
+  function hi(i) {
+    return typeof i == "number" && i > -1 && i % 1 == 0 && i <= s;
+  }
+  function $t(i) {
+    var c = typeof i;
+    return !!i && (c == "object" || c == "function");
+  }
+  function gi(i) {
+    return !!i && typeof i == "object";
+  }
+  function wr(i) {
+    return Xr(i) ? fr(i) : jt(i);
+  }
+  function yi() {
+    return [];
+  }
+  function vi() {
+    return !1;
+  }
+  t.exports = li;
+})(Sr, Sr.exports);
+var se = Sr.exports, Tr = function() {
+  return Tr = Object.assign || function(e) {
+    for (var r, o = 1, s = arguments.length; o < s; o++) {
+      r = arguments[o];
+      for (var u in r) Object.prototype.hasOwnProperty.call(r, u) && (e[u] = r[u]);
+    }
+    return e;
+  }, Tr.apply(this, arguments);
+};
+function wi(t, e, r, o) {
+  function s(u) {
+    return u instanceof r ? u : new r(function(p) {
+      p(u);
+    });
+  }
+  return new (r || (r = Promise))(function(u, p) {
+    function h(O) {
+      try {
+        g(o.next(O));
+      } catch (X) {
+        p(X);
+      }
+    }
+    function m(O) {
+      try {
+        g(o.throw(O));
+      } catch (X) {
+        p(X);
+      }
+    }
+    function g(O) {
+      O.done ? u(O.value) : s(O.value).then(h, m);
+    }
+    g((o = o.apply(t, [])).next());
+  });
+}
+function Ei(t, e) {
+  var r = { label: 0, sent: function() {
+    if (u[0] & 1) throw u[1];
+    return u[1];
+  }, trys: [], ops: [] }, o, s, u, p = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return p.next = h(0), p.throw = h(1), p.return = h(2), typeof Symbol == "function" && (p[Symbol.iterator] = function() {
+    return this;
+  }), p;
+  function h(g) {
+    return function(O) {
+      return m([g, O]);
+    };
+  }
+  function m(g) {
+    if (o) throw new TypeError("Generator is already executing.");
+    for (; p && (p = 0, g[0] && (r = 0)), r; ) try {
+      if (o = 1, s && (u = g[0] & 2 ? s.return : g[0] ? s.throw || ((u = s.return) && u.call(s), 0) : s.next) && !(u = u.call(s, g[1])).done) return u;
+      switch (s = 0, u && (g = [g[0] & 2, u.value]), g[0]) {
+        case 0:
+        case 1:
+          u = g;
+          break;
+        case 4:
+          return r.label++, { value: g[1], done: !1 };
+        case 5:
+          r.label++, s = g[1], g = [0];
+          continue;
+        case 7:
+          g = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (u = r.trys, !(u = u.length > 0 && u[u.length - 1]) && (g[0] === 6 || g[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (g[0] === 3 && (!u || g[1] > u[0] && g[1] < u[3])) {
+            r.label = g[1];
+            break;
+          }
+          if (g[0] === 6 && r.label < u[1]) {
+            r.label = u[1], u = g;
+            break;
+          }
+          if (u && r.label < u[2]) {
+            r.label = u[2], r.ops.push(g);
+            break;
+          }
+          u[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      g = e.call(t, r);
+    } catch (O) {
+      g = [6, O], s = 0;
+    } finally {
+      o = u = 0;
+    }
+    if (g[0] & 5) throw g[1];
+    return { value: g[0] ? g[1] : void 0, done: !0 };
+  }
+}
+function It(t, e, r, o, s) {
+  return wi(this, void 0, void 0, function() {
+    var u, p;
+    return Ei(this, function(h) {
+      switch (h.label) {
+        case 0:
+          if (r === void 0)
+            return [
+              2
+              /*return*/
+            ];
+          p = 0, h.label = 1;
+        case 1:
+          return p < r.length ? [4, r[p](t, e, o, s, r)] : [3, 4];
+        case 2:
+          if (u = h.sent(), u === "canceled")
+            return [3, 4];
+          h.label = 3;
+        case 3:
+          return p++, [3, 1];
+        case 4:
+          return u !== "canceled" ? [2, u] : [
+            2
+            /*return*/
+          ];
+      }
+    });
+  });
+}
+var Cr = function(t, e) {
+  return e === void 0 && (e = {}), t ? {
+    trackedAnalytics: Tr({ sdkCode: t.sdkCode, sdkSemver: t.sdkSemver, techVersion: t.techVersion }, e)
+  } : null;
+}, Oi = (
+  /** @class */
+  function() {
+    function t(e, r, o, s) {
+      var u = this;
+      this.isMounted = !0, this.imgElement = e, this.htmlPluginState = { cleanupCallbacks: [], pluginEventSubscription: [] };
+      var p = se(r);
+      It(e, p, o, this.htmlPluginState, s).then(function(h) {
+        if (u.isMounted) {
+          u.htmlPluginState.pluginEventSubscription.forEach(function(g) {
+            g();
+          });
+          var m = Cr(s, h);
+          u.imgElement.setAttribute("src", p.toURL(m));
+        }
+      });
+    }
+    return t.prototype.update = function(e, r, o) {
+      var s = this, u = se(e);
+      It(this.imgElement, u, r, this.htmlPluginState).then(function(p) {
+        if (s.isMounted) {
+          var h = Cr(o, p);
+          s.imgElement.setAttribute("src", u.toURL(h));
+        }
+      });
+    }, t.prototype.unmount = function() {
+      this.isMounted = !1;
+    }, t;
+  }()
+);
+class R {
+  /**
+   *
+   * @param {QualifierValue | QualifierValue[] | any[] | string | number}qualifierValue
+   */
+  constructor(e) {
+    this.values = [], this.delimiter = ":", this.hasValue(e) && this.addValue(e);
+  }
+  /**
+   * @description Joins the provided values with the provided delimiter
+   */
+  toString() {
+    return this.values.join(this.delimiter);
+  }
+  /**
+   * @description Checks if the provided argument has a value
+   * @param {any} v
+   * @private
+   * @return {boolean}
+   */
+  hasValue(e) {
+    return typeof e < "u" && e !== null && e !== "";
+  }
+  /**
+   * @desc Adds a value for the this qualifier instance
+   * @param {any} value
+   * @return {this}
+   */
+  addValue(e) {
+    return Array.isArray(e) ? this.values = this.values.concat(e) : this.values.push(e), this.values = this.values.filter((r) => this.hasValue(r)), this;
+  }
+  /**
+   * @description Sets the delimiter for this instance
+   * @param delimiter
+   */
+  setDelimiter(e) {
+    return this.delimiter = e, this;
+  }
+}
+class Ai extends Error {
+  constructor(e = "Unsupported") {
+    super(e);
+  }
+}
+function Ir(t) {
+  return new Ai(t);
+}
+function Si() {
+  return this._qualifierModel || { error: Ir(`unsupported qualifier ${this.constructor.name}`) };
+}
+class Ti {
+  constructor() {
+    this._qualifierModel = {};
+  }
+  toJson() {
+    return Si.apply(this);
+  }
+}
+class w extends Ti {
+  constructor(e, r) {
+    super(), this.delimiter = "_", this.key = e, r instanceof R ? this.qualifierValue = r : (this.qualifierValue = new R(), this.qualifierValue.addValue(r));
+  }
+  toString() {
+    const { key: e, delimiter: r, qualifierValue: o } = this;
+    return `${e}${r}${o.toString()}`;
+  }
+  addValue(e) {
+    return this.qualifierValue.addValue(e), this;
+  }
+}
+class B extends w {
+  constructor(e, r) {
+    let o;
+    r ? o = new R([e, `${r}`]).setDelimiter(":") : o = e, super("fl", o), this.flagValue = r;
+  }
+  toString() {
+    return super.toString().replace(/\./g, "%2E");
+  }
+  getFlagValue() {
+    return this.flagValue;
+  }
+}
+function Ci(t, e) {
+  const r = Array.from(t.entries());
+  return e.forEach((o) => {
+    r.push(["fl", o]);
+  }), r.sort().map((o) => o[1]);
+}
+function Ri() {
+  var t, e, r;
+  const o = this._actionModel && Object.keys(this._actionModel).length, s = (r = (e = (t = this._actionModel) === null || t === void 0 ? void 0 : t.source) === null || e === void 0 ? void 0 : e.transformation) === null || r === void 0 ? void 0 : r.error;
+  return s && s instanceof Error ? { error: s } : o ? this._actionModel : { error: Ir(`unsupported action ${this.constructor.name}`) };
+}
+class xi {
+  constructor() {
+    this._actionModel = {};
+  }
+  toJson() {
+    return Ri.apply(this);
+  }
+}
+class U extends xi {
+  constructor() {
+    super(...arguments), this.qualifiers = /* @__PURE__ */ new Map(), this.flags = [], this.delimiter = ",", this.actionTag = "";
+  }
+  prepareQualifiers() {
+  }
+  /**
+   * @description Returns the custom name tag that was given to this action
+   * @return {string}
+   */
+  getActionTag() {
+    return this.actionTag;
+  }
+  /**
+   * @description Sets the custom name tag for this action
+   * @return {this}
+   */
+  setActionTag(e) {
+    return this.actionTag = e, this;
+  }
+  /**
+   * @description Calls toString() on all child qualifiers (implicitly by using .join()).
+   * @return {string}
+   */
+  toString() {
+    return this.prepareQualifiers(), Ci(this.qualifiers, this.flags).join(this.delimiter);
+  }
+  /**
+   * @description Adds the parameter to the action.
+   * @param {SDK.Qualifier} qualifier
+   * @return {this}
+   */
+  addQualifier(e) {
+    if (typeof e == "string") {
+      const [r, o] = e.toLowerCase().split("_");
+      r === "fl" ? this.flags.push(new B(o)) : this.qualifiers.set(r, new w(r, o));
+    } else
+      this.qualifiers.set(e.key, e);
+    return this;
+  }
+  /**
+   * @description Adds a flag to the current action.
+   * @param {Qualifiers.Flag} flag
+   * @return {this}
+   */
+  addFlag(e) {
+    return typeof e == "string" ? this.flags.push(new B(e)) : e instanceof B && this.flags.push(e), this;
+  }
+  addValueToQualifier(e, r) {
+    return this.qualifiers.get(e).addValue(r), this;
+  }
+}
+class Lr extends U {
+  constructor(e) {
+    super(), this.regionType = e, this._actionModel.regionType = e;
+  }
+}
+class Vt extends Lr {
+  constructor() {
+    super("custom");
+  }
+  /**
+   * @description The x position in pixels.
+   * @param {number | string} x
+   */
+  x(e) {
+    return this._actionModel.x = e, this.addQualifier(new w("x", e)), this;
+  }
+  /**
+   * @description The y position in pixels.
+   * @param {number | string} y
+   */
+  y(e) {
+    return this._actionModel.y = e, this.addQualifier(new w("y", e)), this;
+  }
+  /**
+   * @description The width of the region in pixels.
+   * @param {number | string} width
+   */
+  width(e) {
+    return this._actionModel.width = e, this.addQualifier(new w("w", e)), this;
+  }
+  /**
+   * @description The height of the region in pixels.
+   * @param {number | string} height
+   */
+  height(e) {
+    return this._actionModel.height = e, this.addQualifier(new w("h", e)), this;
+  }
+  static fromJson(e) {
+    const r = new Vt();
+    return e.width && r.width(e.width), e.height && r.height(e.height), e.x && r.x(e.x), e.y && r.y(e.y), r;
+  }
+}
+function Pi() {
+  return new Vt();
+}
+function yn() {
+  return new Lr("faces");
+}
+function ji() {
+  return new Lr("ocr_text");
+}
+class Mi extends U {
+  constructor(e) {
+    super(), this._actionModel = {}, this._strength = e, this._actionModel.actionType = "blur", this._actionModel.strength = e;
+  }
+  /**
+   * @description Specifies the region to blur.
+   * @param {NamedRegion} blurRegion
+   */
+  region(e) {
+    return this._region = e, this._actionModel.region = e.toJson(), this;
+  }
+  /**
+   * @description Sets the strength of the blur effect.
+   * @param {number | string} strength
+   */
+  strength(e) {
+    return this._strength = e, this._actionModel.strength = e, this;
+  }
+  prepareQualifiers() {
+    const e = this._strength ? `:${this._strength}` : "";
+    "_region" in this ? (this._region.qualifiers.forEach((o) => this.addQualifier(o)), this._region.regionType === "custom" && this.addQualifier(new w("e", `blur_region${e}`)), this._region.regionType === "ocr_text" && (this.addQualifier(new w("e", `blur_region${e}`)), this.addQualifier(new w("g", "ocr_text"))), this._region.regionType === "faces" && this.addQualifier(new w("e", `blur_faces${e}`))) : this.addQualifier(new w("e", `blur${e}`));
+  }
+  static fromJson(e) {
+    const { strength: r, region: o } = e, s = new this(r);
+    return r && s.strength(r), o && o.regionType === "faces" && s.region(yn()), o && o.regionType === "ocr_text" && s.region(ji()), o && o.regionType === "custom" && s.region(Vt.fromJson(o)), s;
+  }
+}
+function ye(t) {
+  const e = {};
+  return Object.keys(t).forEach((r) => {
+    e[t[r]] = r;
+  }), e;
+}
+const vn = {
+  limitFit: "limit",
+  limitFill: "lfill",
+  minimumFit: "mfit",
+  thumbnail: "thumb",
+  limitPad: "lpad",
+  minimumPad: "mpad",
+  autoPad: "auto_pad"
+}, $i = {
+  colorSpace: "cs",
+  dpr: "dpr",
+  density: "dn",
+  defaultImage: "d",
+  format: "f",
+  quality: "q"
+}, mn = {
+  redEye: "redeye",
+  advancedRedEye: "adv_redeye",
+  oilPaint: "oil_paint",
+  unsharpMask: "unsharp_mask",
+  makeTransparent: "make_transparent",
+  generativeRestore: "gen_restore",
+  upscale: "upscale"
+}, _n = {
+  autoBest: "auto:best",
+  autoEco: "auto:eco",
+  autoGood: "auto:good",
+  autoLow: "auto:low",
+  jpegminiHigh: "jpegmini:1",
+  jpegminiMedium: "jpegmini:2",
+  jpegminiBest: "jpegmini:0"
+}, ki = {
+  fullHd: "full_hd",
+  fullHdWifi: "full_hd_wifi",
+  fullHdLean: "full_hd_lean",
+  hdLean: "hd_lean"
+}, bn = {
+  444: "CHROMA_444",
+  420: "CHROMA_420"
+}, Ii = {
+  noCmyk: "no_cmyk",
+  keepCmyk: "keep_cmyk",
+  tinySrgb: "tinysrgb",
+  srgbTrueColor: "srgb:truecolor"
+}, Li = ye(bn);
+ye(Ii);
+const Fi = ye(vn), Vi = ye($i), wn = ye(mn);
+ye(_n);
+ye(ki);
+class En extends U {
+  constructor(e, r) {
+    super(), this._actionModel = {}, this._actionModel.actionType = wn[e] || e;
+    const o = this.createEffectQualifier(e, r);
+    this.addQualifier(o);
+  }
+  createEffectQualifier(e, r) {
+    let o;
+    return r ? o = new R([e, `${r}`]).setDelimiter(":") : o = new R(e), new w("e", o);
+  }
+  static fromJson(e) {
+    const { actionType: r, level: o, strength: s } = e, u = mn[r] || r;
+    return new this(u, o || s);
+  }
+}
+class Di extends En {
+  constructor(e, r) {
+    super(e, r), this.LEVEL_NAME = "level", this._actionModel = {}, this.effectType = e, this._actionModel.actionType = wn[e] || e, r && this.setLevel(r);
+  }
+  /**
+   *
+   * @description Sets the effect level for the action
+   * @param {string | number} level - The strength of the effect
+   * @protected
+   */
+  setLevel(e) {
+    this._actionModel[this.LEVEL_NAME] = e;
+    const r = this.createEffectQualifier(this.effectType, e);
+    return this.addQualifier(r), this;
+  }
+}
+function Dt(t) {
+  return t && (t.match(/^#/) ? `rgb:${t.substr(1)}` : t);
+}
+class Ni extends U {
+  constructor() {
+    super(), this._actionModel = {}, this._actionModel.actionType = "vectorize";
+  }
+  /**
+   * @description The number of colors. (Range: 2 to 30, Server default: 10)
+   * @param {number | string} num
+   * @return {this}
+   */
+  numOfColors(e) {
+    return this._actionModel.numOfColors = e, this._numOfColors = e, this;
+  }
+  /**
+   * @description The level of detail. Specify either a percentage of the original image (Range: 0.0 to 1.0) or an absolute number of pixels (Range: 0 to 1000). (Server default: 300)
+   * @param {number | string} num
+   * @return {this}
+   */
+  detailsLevel(e) {
+    return this._actionModel.detailLevel = e, this._detailsLevel = e, this;
+  }
+  /**
+   * @description The size of speckles to suppress. Specify either a percentage of the original image (Range: 0.0 to 1.0) or an absolute number of pixels (Range: 0 to 100, Server default: 2)
+   * @param {number | string} num
+   * @return {this}
+   */
+  despeckleLevel(e) {
+    return this._actionModel.despeckleLevel = e, this._despeckleLevel = e, this;
+  }
+  /**
+   * @description The corner threshold. Specify 100 for no smoothing (polygon corners), 0 for completely smooth corners. (Range: 0 to 100, Default: 25)
+   * @param {number | string} num
+   * @return {this}
+   */
+  cornersLevel(e) {
+    return this._actionModel.cornersLevel = e, this._cornersLevel = e, this;
+  }
+  /**
+   * @description The optimization value. Specify 100 for least optimization and the largest file. (Range: 0 to 100, Server default: 100).
+   * @param {number} num
+   * @return {this}
+   */
+  paths(e) {
+    return this._actionModel.paths = e, this._paths = e, this;
+  }
+  prepareQualifiers() {
+    let e = "vectorize";
+    this._numOfColors && (e += `:${new R(`colors:${this._numOfColors}`).toString()}`), this._detailsLevel && (e += `:${new R(`detail:${this._detailsLevel}`).toString()}`), this._despeckleLevel && (e += `:${new R(`despeckle:${this._despeckleLevel}`).toString()}`), this._paths && (e += `:${new R(`paths:${this._paths}`).toString()}`), this._cornersLevel && (e += `:${new R(`corners:${this._cornersLevel}`).toString()}`), this.addQualifier(new w("e", e));
+  }
+  static fromJson(e) {
+    const { actionType: r, paths: o, cornersLevel: s, despeckleLevel: u, detailLevel: p, numOfColors: h } = e, m = new this();
+    return o && m.paths(o), s && m.cornersLevel(s), u && m.despeckleLevel(u), p && m.detailsLevel(p), h && m.numOfColors(h), m;
+  }
+}
+class Bi extends Di {
+  level(e) {
+    return this._actionModel.level = e, this.setLevel(e);
+  }
+}
+class Ui extends U {
+  constructor() {
+    super(), this._actionModel = {}, this._actionModel.actionType = "assistColorblind", this.addQualifier(new w("e", new R("assist_colorblind")));
+  }
+  /**
+   * @description Replaces problematic colors with colors that are easier to differentiate.
+   * @return {this}
+   */
+  xray() {
+    return this._actionModel.type = "xray", this.addQualifier(new w("e", new R(["assist_colorblind", "xray"]).setDelimiter(":")));
+  }
+  /**
+   * @description Applies stripes of the specified intensity to help people with common color blind conditions to differentiate between colors that are similar for them.
+   * @param {number | string} strength The intensity of the stripes. (Range: 1 to 100, Server default: 10)
+   * @return {this}
+   */
+  stripesStrength(e) {
+    return this._actionModel.type = "stripes", this._actionModel.stripesStrength = e, this.addQualifier(new w("e", new R(["assist_colorblind", e]).setDelimiter(":")));
+  }
+  static fromJson(e) {
+    const { actionType: r, type: o, stripesStrength: s } = e, u = new this();
+    return o === "xray" && u.xray(), o === "stripes" && s && u.stripesStrength(s), u;
+  }
+}
+class Qi extends Bi {
+  /**
+   * @description The color to use for colorization. Specify HTML name or RGB hex code. (Server default: gray)
+   * @param {string} color HTML name(red, green, etc.) or RGB hex code. (Server default: gray)
+   * @return {this}
+   */
+  color(e) {
+    return this._actionModel.color = e, this.addQualifier(new w("co", new R(Dt(e))));
+  }
+  static fromJson(e) {
+    const { actionType: r, level: o, color: s } = e, u = new this(r, o);
+    return s && u.color(s), u;
+  }
+}
+class Gi extends U {
+  constructor(e) {
+    super(), this._actionModel = {}, this._squareSize = e, this._actionModel.actionType = "pixelate", this._actionModel.squareSize = e;
+  }
+  /**
+   * @description Specifies the region to piexlate.
+   * @param {NamedRegion} pixelateRegion
+   */
+  region(e) {
+    return this._region = e, this._actionModel.region = { regionType: this._region.regionType }, this;
+  }
+  /**
+   * @description Sets the squareSize of the pixelate effect.
+   * @param {number | string} squareSize
+   */
+  squareSize(e) {
+    return this._squareSize = e, this._actionModel.squareSize = e, this;
+  }
+  prepareQualifiers() {
+    const e = this._squareSize ? `:${this._squareSize}` : "";
+    "_region" in this ? (this._region.qualifiers.forEach((o) => this.addQualifier(o)), this._region.regionType === "custom" && this.addQualifier(new w("e", `pixelate_region${e}`)), this._region.regionType === "ocr_text" && (this.addQualifier(new w("e", `pixelate_region${e}`)), this.addQualifier(new w("g", "ocr_text"))), this._region.regionType === "faces" && this.addQualifier(new w("e", `pixelate_faces${e}`))) : this.addQualifier(new w("e", `pixelate${e}`));
+  }
+  static fromJson(e) {
+    const { region: r, squareSize: o } = e, s = new this(o);
+    return o && s.squareSize(o), r && r.regionType === "faces" && s.region(yn()), r && r.regionType === "custom" && s.region(Pi()), s;
+  }
+}
+function qi(t) {
+  return new Mi(t);
+}
+function zi() {
+  return new En("grayscale");
+}
+function on(t) {
+  return new Qi("colorize", t);
+}
+function Yi() {
+  return new Ni();
+}
+function Wi() {
+  return new Ui();
+}
+function Hi(t) {
+  return new Gi(t);
+}
+class Ji extends U {
+  constructor(e) {
+    super(), this._actionModel = {}, this.addQualifier(new w("b", new R(Dt(e)).setDelimiter("_"))), this._actionModel.color = e, this._actionModel.actionType = "backgroundColor";
+  }
+  static fromJson(e) {
+    const { color: r } = e;
+    return new this(r);
+  }
+}
+class an {
+  constructor(e) {
+    this.raw = e;
+  }
+  toString() {
+    return this.raw;
+  }
+  toJson() {
+    return { error: Ir(`unsupported action ${this.constructor.name}`) };
+  }
+}
+function Ki(t) {
+  const e = t;
+  return "error" in e && !!e.error;
+}
+function Xi() {
+  return new B("ignore_aspect_ratio");
+}
+function Zi() {
+  return new B("lossy");
+}
+function eo() {
+  return new B("preserve_transparency");
+}
+function to(t) {
+  return new B("progressive", t);
+}
+function ro() {
+  return new B("region_relative");
+}
+function no() {
+  return new B("relative");
+}
+class Fr extends R {
+  constructor(e) {
+    super(e), this.val = e;
+  }
+  getValue() {
+    return this.val;
+  }
+}
+class On extends U {
+  /**
+   * @param {string} deliveryKey A generic Delivery Action Key (such as q, f, dn, etc.)
+   * @param {string} deliveryType A Format Qualifiers for the action, such as Quality.auto()
+   * @param {string} modelProperty internal model property of the action, for example quality uses `level` while dpr uses `density`
+   * @see Visit {@link Actions.Delivery|Delivery} for an example
+   */
+  constructor(e, r, o) {
+    super(), this._actionModel = {};
+    let s;
+    r instanceof Fr ? s = r.getValue() : s = r, this._actionModel.actionType = Vi[e], this._actionModel[o] = s, this.addQualifier(new w(e, r));
+  }
+}
+class io extends B {
+  constructor(e) {
+    super("progressive", e);
+  }
+}
+class Rr extends On {
+  constructor(e, r) {
+    super(e, r, "formatType");
+  }
+  /**
+   * @description Uses lossy compression when delivering animated GIF files.
+   * @return {this}
+   */
+  lossy() {
+    return this._actionModel.lossy = !0, this.addFlag(Zi()), this;
+  }
+  /**
+   * @description Uses progressive compression when delivering JPG file format.
+   * @return {this}
+   */
+  progressive(e) {
+    return e instanceof io ? (this._actionModel.progressive = { mode: e.getFlagValue() }, this.addFlag(e)) : (this._actionModel.progressive = { mode: e }, this.addFlag(to(e))), this;
+  }
+  /**
+   * @description Ensures that images with a transparency channel are delivered in PNG format.
+   */
+  preserveTransparency() {
+    return this._actionModel.preserveTransparency = !0, this.addFlag(eo()), this;
+  }
+  static fromJson(e) {
+    const { formatType: r, lossy: o, progressive: s, preserveTransparency: u } = e;
+    let p;
+    return r ? p = new this("f", r) : p = new this("f"), s && (s.mode ? p.progressive(s.mode) : p.progressive()), o && p.lossy(), u && p.preserveTransparency(), p;
+  }
+}
+class ke {
+  constructor() {
+    this.actions = [];
+  }
+  /**
+   * @param {SDK.Action | string} action
+   * @return {this}
+   */
+  addAction(e) {
+    let r;
+    if (typeof e == "string") {
+      if (e.indexOf("/") >= 0)
+        throw "addAction cannot accept a string with a forward slash in it - /, use .addTransformation() instead";
+      r = new an(e);
+    } else
+      r = e;
+    return this.actions.push(r), this;
+  }
+  /**
+   * @description Allows the injection of a raw transformation as a string into the transformation, or a Transformation instance that was previously created
+   * @param {string | SDK.Transformation} tx
+   * @example
+   * import {Transformation} from "@cloudinary/url-gen";
+   *
+   * const transformation = new Transformation();
+   * transformation.addTransformation('w_100/w_200/w_300');
+   * @return {this}
+   */
+  addTransformation(e) {
+    return e instanceof ke ? this.actions = this.actions.concat(e.actions) : this.actions.push(new an(e)), this;
+  }
+  /**
+   * @return {string}
+   */
+  toString() {
+    return this.actions.map((e) => e.toString()).filter((e) => e).join("/");
+  }
+  /**
+   * @description Delivers an animated GIF.
+   * @param {AnimatedAction} animatedAction
+   * @return {this}
+   */
+  animated(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Adds a border around the image.
+   * @param {Border} borderAction
+   * @return {this}
+   */
+  border(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Adjusts the shape of the delivered image. </br>
+   * <b>Learn more:</b> {@link https://cloudinary.com/documentation/effects_and_artistic_enhancements#distort|Shape changes and distortion effects}
+   * @param {IReshape} reshapeAction
+   * @return {this}
+   */
+  reshape(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Resize the asset using provided resize action
+   * @param {ResizeSimpleAction} resizeAction
+   * @return {this}
+   */
+  resize(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @desc An alias to Action Delivery.quality
+   * @param {string|number} quality
+   * @return {this}
+   */
+  quality(e) {
+    return this.addAction(new Rr("q", e)), this;
+  }
+  /**
+   * @desc An alias to Action Delivery.format
+   * @param {string} format
+   * @return {this}
+   */
+  format(e) {
+    return this.addAction(new Rr("f", e)), this;
+  }
+  /**
+   * @description Rounds the specified corners of an image.
+   * @param roundCornersAction
+   * @return {this}
+   */
+  roundCorners(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Adds an overlay over the base image.
+   * @param {LayerAction} overlayAction
+   * @return {this}
+   */
+  overlay(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Adds an underlay under the base image.
+   * @param {LayerAction} underlayAction
+   * @return {this}
+   */
+  underlay(e) {
+    return e.setLayerType("u"), this.addAction(e);
+  }
+  /**
+   * @description Defines an new user variable.
+   * @param {VariableAction} variableAction
+   * @return {this}
+   */
+  addVariable(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Specifies a condition to be met before applying a transformation.
+   * @param {ConditionalAction} conditionAction
+   * @return {this}
+   */
+  conditional(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Applies a filter or an effect on an asset.
+   * @param {SimpleEffectAction} effectAction
+   * @return {this}
+   */
+  effect(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Applies adjustment effect on an asset.
+   * @param action
+   * @return {this}
+   */
+  adjust(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Rotates the asset by the given angle.
+   * @param {RotateAction} rotateAction
+   * @return {this}
+   */
+  rotate(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Applies a pre-defined named transformation of the given name.
+   * @param {NamedTransformation} namedTransformation
+   * @return {this}
+   */
+  namedTransformation(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Applies delivery action.
+   * @param deliveryAction
+   * @return {this}
+   */
+  delivery(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Sets the color of the background.
+   * @param {Qualifiers.Color} color
+   * @return {this}
+   */
+  backgroundColor(e) {
+    return this.addAction(new Ji(e));
+  }
+  /**
+   * @description Adds a layer in a Photoshop document.
+   * @param action
+   * @return {this}
+   */
+  psdTools(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Extracts an image or a page using an index, a range, or a name from a layered media asset.
+   * @param action
+   * @return {this}
+   */
+  extract(e) {
+    return this.addAction(e);
+  }
+  /**
+   * @description Adds a flag as a separate action.
+   * @param {Qualifiers.Flag | string} flagQualifier
+   * @return {this}
+   */
+  addFlag(e) {
+    const r = new U();
+    let o = e;
+    return typeof e == "string" && (o = new B(e)), r.addQualifier(o), this.addAction(r);
+  }
+  /**
+   * @description Inject a custom function into the image transformation pipeline.
+   * @return {this}
+   */
+  customFunction(e) {
+    return this.addAction(e);
+  }
+  /**
+   * Transcodes the video (or audio) to another format.
+   * @param {Action} action
+   * @return {this}
+   */
+  transcode(e) {
+    return this.addAction(e);
+  }
+  /**
+   * Applies the specified video edit action.
+   *
+   * @param {videoEditType} action
+   * @return {this}
+   */
+  videoEdit(e) {
+    return this.addAction(e);
+  }
+  toJson() {
+    const e = [];
+    for (const r of this.actions) {
+      const o = r.toJson();
+      if (Ki(o))
+        return o;
+      e.push(o);
+    }
+    return { actions: e };
+  }
+}
+function sn(t) {
+  const e = t.toString();
+  return e.match(/[A-Z]/gi) || e.length > 1 && e[0] === "0" ? e : !isNaN(parseFloat(e)) && e.indexOf(":") === -1 && e.indexOf(".") === -1 ? `${e}.0` : e;
+}
+class oo extends R {
+}
+class ao extends U {
+  /**
+   * @param {string} cropType
+   * @param {number | string} cropWidth The required width of a transformed asset.
+   * @param {number | string} cropHeight The required height of a transformed asset.
+   */
+  constructor(e, r, o) {
+    super(), this._actionModel = { dimensions: {} }, this._actionModel.actionType = Fi[e] || e, this.addQualifier(new w("c", e)), r && this.width(r), o && this.height(o);
+  }
+  /**
+   * @description Sets the height of the resize
+   * @param {string | number} x The height in pixels (if an integer is specified) or as a percentage (if a float is specified).
+   */
+  height(e) {
+    return this._actionModel.dimensions.height = e, this.addQualifier(new w("h", e));
+  }
+  /**
+   * @description Sets the width of the resize
+   * @param {string | number} x The width in pixels (if an integer is specified) or as a percentage (if a float is specified).
+   */
+  width(e) {
+    return this._actionModel.dimensions.width = e, this.addQualifier(new w("w", e));
+  }
+  /**
+   * @description Sets the aspect ratio of the asset.
+   * For a list of supported types see {@link Qualifiers.AspectRatio|
+    * AspectRatio values}
+   * @param {AspectRatioType|number|string} ratio The new aspect ratio, specified as a percentage or ratio.
+   * @return {this}
+   */
+  aspectRatio(e) {
+    if (e instanceof oo)
+      return this._actionModel.dimensions.aspectRatio = `${e}`, this.addQualifier(new w("ar", e));
+    if (typeof e == "number" || typeof e == "string")
+      return this._actionModel.dimensions.aspectRatio = sn(e), this.addQualifier(new w("ar", sn(e)));
+    if (e instanceof B)
+      return this._actionModel.dimensions.aspectRatio = `${e.qualifierValue}`, this.addFlag(e);
+  }
+  /**
+   * @description Modifies percentage-based width & height parameters of overlays and underlays (e.g., 1.0) to be relative to the containing image instead of the added layer.
+   * @return {this}
+   */
+  relative() {
+    return this._actionModel.relative = !0, this.addFlag(no());
+  }
+  /**
+   * @description Modifies percentage-based width & height parameters of overlays and underlays (e.g., 1.0) to be relative to the overlaid region
+   * @return {this}
+   */
+  regionRelative() {
+    return this._actionModel.regionRelative = !0, this.addFlag(ro());
+  }
+  static fromJson(e) {
+    const { actionType: r, dimensions: o, relative: s, regionRelative: u } = e, { aspectRatio: p, width: h, height: m } = o, g = vn[r] || r, O = new this(g, h, m);
+    return p && O.aspectRatio(p === "ignore_aspect_ratio" ? Xi() : p), s && O.relative(), u && O.regionRelative(), O;
+  }
+}
+class Vr extends w {
+  /**
+   * @param value, an array containing (GravityObject | AutoGravity | string) or a string;
+   */
+  constructor(e) {
+    super("g", new R(e));
+  }
+}
+class An extends Vr {
+  constructor() {
+    super("auto");
+  }
+  /**
+   * @description Autofocuses on objects, allowing their priority within the algorithm to be configured.
+   * @param {AutoFocus} AutoFocusObjects
+   */
+  autoFocus(...e) {
+    return this.addValue(e), this;
+  }
+}
+class Sn extends Vr {
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * @description Specifies the gravity to use if none of the other gravity objects are found.
+   * @param {Qualifiers.Gravity.AutoGravity} val
+   */
+  fallbackGravity(e) {
+    return this.addValue(e.qualifierValue), this;
+  }
+}
+class Tn extends Vr {
+  constructor(e) {
+    super(e);
+  }
+}
+function so(t) {
+  return new Tn(t);
+}
+function Cn(...t) {
+  const e = [...t];
+  return new Sn(e);
+}
+function Rn() {
+  return new An();
+}
+class $e extends R {
+  constructor(e) {
+    super(), this.name = e;
+  }
+  toString() {
+    return this.name;
+  }
+}
+function uo() {
+  return new $e("ocr_text");
+}
+function co(t) {
+  return t && `${t}`.split(":")[0] === "auto";
+}
+function lo(t) {
+  const e = Dr(t);
+  return ["north", "center", "east", "west", "south", "north_west", "south_east", "south_west", "north_east"].includes(e);
+}
+function Dr(t) {
+  return `${t}`.replace("g_", "");
+}
+function fo(t) {
+  return {
+    compass: Dr(t),
+    gravityType: "direction"
+  };
+}
+function po(t) {
+  return Dr(t) === "ocr_text";
+}
+function ho() {
+  return {
+    gravityType: "ocr"
+  };
+}
+function go(t) {
+  return `${t.qualifierValue}`.split(":")[0] === "auto";
+}
+function yo(t) {
+  const r = t.toString().split("_"), o = {
+    object: r[0]
+  };
+  return r.length > 1 && (r[1] === "avoid" ? o.avoid = !0 : o.weight = +r[1]), o;
+}
+function xn(t) {
+  let e;
+  const r = t === "auto" ? new An() : t;
+  return `${t}`.startsWith("auto:") ? e = `${t}`.split(":").filter((s) => s !== "auto") : e = r.qualifierValue.values.filter((s) => s !== "auto"), {
+    gravityType: "auto",
+    autoFocus: e.map(yo)
+  };
+}
+function vo(t) {
+  const e = `${t}`.split(":").includes("auto"), r = t.qualifierValue.values, s = {
+    gravityType: "object",
+    focusOnObjects: (e ? r.slice(0, r.length - 1) : r).map((u) => `${u}`)
+  };
+  if (e) {
+    const u = r[r.length - 1].values.slice(1), p = Rn().autoFocus(...u);
+    s.fallbackGravity = xn(p);
+  }
+  return s;
+}
+function mo(t) {
+  const r = t.split(":").map((o) => new $e(o));
+  return new Sn(r);
+}
+function _o(t) {
+  return lo(t) ? fo(t) : po(t) ? ho() : co(t) || go(t) ? xn(t) : vo(typeof t == "string" ? mo(t) : t);
+}
+class Nr extends R {
+  constructor(e, r) {
+    super(), this._weight = r, this.focusOn = e, this.shouldAvoid = !1;
+  }
+  /**
+   * @summary qualifier
+   * @description Specifies the object to focus on automatically
+   * Accepts an AutoFocusObject (which is just a wrapper for a FocusOn object, but with extra method: avoid, weight)
+   * @param {Qualifiers.FocusOn} obj The object to focus on.
+   * @param {number} weight
+   */
+  static focusOn(e, r) {
+    const o = e instanceof $e ? e : new $e(e);
+    return new Nr(o, r);
+  }
+  shouldAddWeight() {
+    return typeof this._weight == "number" || typeof this._weight == "string" || this.shouldAvoid;
+  }
+  /**
+   * @summary qualifier
+   * @desc Get the name of the of the object
+   */
+  getName() {
+    return this.focusOn.name;
+  }
+  /**
+   * @summary qualifier
+   * @desc Get the weight for the object
+   */
+  getWeight() {
+    return this.shouldAvoid ? "avoid" : this._weight;
+  }
+  /**
+   * @summary qualifier
+   * @desc Return the string representation of this QualifierValue
+   */
+  toString() {
+    return this.shouldAddWeight() ? `${this.getName()}_${this.getWeight()}` : `${this.getName()}`;
+  }
+  /**
+   * @summary qualifier
+   * @description Sets the importance level of the object within the automatic gravity algorithm
+   * @param {numebr} w The focus weight for the object
+   * @return {this}
+   */
+  weight(e) {
+    return this._weight = e, this;
+  }
+  /**
+   * @summary qualifier
+   * @description Attempts to avoid the detected object in the image
+   * @return {this}
+   */
+  avoid() {
+    return this.shouldAvoid = !0, this;
+  }
+}
+class Pn extends R {
+  constructor(e) {
+    super(), this.val = e;
+  }
+  toString() {
+    return this.val;
+  }
+}
+function bo(t) {
+  return t.gravityType === "direction";
+}
+function wo(t) {
+  return t.gravityType === "ocr";
+}
+function Eo(t) {
+  return t.gravityType === "auto";
+}
+function Oo(t) {
+  const { object: e, weight: r, avoid: o } = t, s = new Nr(new $e(e));
+  return (r || r === 0) && s.weight(r), o && s.avoid(), s;
+}
+function jn(t) {
+  const r = (t.autoFocus || []).map(Oo);
+  return Rn().autoFocus(...r);
+}
+function Ao(t) {
+  const e = (t.focusOnObjects || []).map((o) => new $e(o)), r = Cn(...e);
+  if (t.fallbackGravity) {
+    const o = jn(t.fallbackGravity);
+    r.fallbackGravity(o);
+  }
+  return r;
+}
+function So(t) {
+  return bo(t) ? new Tn(new Pn(t.compass)) : wo(t) ? Cn(uo()) : Eo(t) ? jn(t) : Ao(t);
+}
+class Br extends ao {
+  /**
+   * @description Which part of the original image to include.
+   * @param {Qualifiers.Gravity} gravity
+   */
+  gravity(e) {
+    this._actionModel.gravity = _o(e);
+    const r = typeof e == "string" ? new w("g", e) : e;
+    return this.addQualifier(r);
+  }
+  static fromJson(e) {
+    const r = super.fromJson.apply(this, [e]);
+    return e.gravity && r.gravity(So(e.gravity)), r;
+  }
+}
+class ot extends w {
+  constructor(e) {
+    super("b"), e && this.addValue(e);
+  }
+}
+const Mn = 100, To = 0;
+class Co extends ot {
+  /**
+   * @description Sets the intensity of the blur.
+   * @param {number} value - The intensity of the blur.
+   */
+  intensity(e) {
+    return this.intensityLevel = e, this;
+  }
+  /**
+   * @description Sets the brightness of the background.
+   * @param {number} value - The brightness of the background.
+   */
+  brightness(e) {
+    return this.brightnessLevel = e, this;
+  }
+  /**
+   * @description
+   * Stringify the qualifier
+   * BackgroundQualifiers don't have a value, but instead override the toString() function
+   */
+  toString() {
+    const e = this.intensityLevel !== void 0 ? `:${this.intensityLevel}` : "", r = this.brightnessLevel !== void 0 ? this.intensityLevel !== void 0 ? `:${this.brightnessLevel}` : `:${Mn}:${this.brightnessLevel}` : "";
+    return `b_blurred${e}${r}`;
+  }
+}
+var $n = Co;
+class Ur extends ot {
+  constructor() {
+    super(), this._palette = [];
+  }
+  /**
+   * @description Selects the strongest contrasting color to use for padding.
+   * @return {this}
+   */
+  contrast() {
+    return this._contrast = !0, this;
+  }
+  /**
+   * @description Defines the custom colors to use when resizing using content-aware padding.
+   * @param {...string} colors One or more colors - Example: palette('green', 'red', blue')
+   * @return {this}
+   */
+  palette(...e) {
+    return this._palette = e.map((r) => Dt(r)), this;
+  }
+}
+class kn extends Ur {
+  /**
+   * @description
+   * Stringify the qualifier
+   * BackgroundQualifiers don't have a value, but instead override the toString() function.
+   */
+  toString() {
+    return `
+    b_auto:border
+    ${this._contrast ? "_contrast" : ""}
+    ${this._palette.length ? `:palette_${this._palette.join("_")}` : ""}
+    `.replace(/\s+/g, "");
+  }
+}
+class In extends Ur {
+  /**
+   *
+   * @description Sets the number of predominant colors to use (2 or 4).
+   * @param {number} num
+   * @return {this}
+   */
+  gradientColors(e) {
+    return this._gradientColors = e, this;
+  }
+  /**
+   * @description Sets the direction for a background gradient fade effect.
+   * @param {Qualifiers.GradientDirection | GradientDirectionType | string} direction Use one of these functions
+   * provided by {@link Qualifiers.GradientDirection|GradientDirection}
+   * @return {this}
+   */
+  gradientDirection(e) {
+    return this._gradientDirection = e, this;
+  }
+}
+class Ln extends In {
+  /**
+   * @description
+   * Stringify the qualifier
+   * BackgroundQualifiers don't have a value, but instead override the toString() function.
+   */
+  toString() {
+    return `
+    b_auto:border_gradient
+    ${this._contrast ? "_contrast" : ""}
+    ${this._gradientColors ? `:${this._gradientColors}` : ""}
+    ${this._gradientDirection ? `:${this._gradientDirection}` : ""}
+    ${this._palette.length ? `:palette_${this._palette.join("_")}` : ""}
+    `.replace(/\s+/g, "");
+  }
+}
+class Fn extends In {
+  /**
+   * @description
+   * Stringify the qualifier
+   * BackgroundQualifiers don't have a value, but instead override the toString() function.
+   */
+  toString() {
+    return `
+    b_auto:predominant_gradient
+    ${this._contrast ? "_contrast" : ""}
+    ${this._gradientColors ? `:${this._gradientColors}` : ""}
+    ${this._gradientDirection ? `:${this._gradientDirection}` : ""}
+    ${this._palette.length ? `:palette_${this._palette.join("_")}` : ""}
+    `.replace(/\s+/g, "");
+  }
+}
+class Vn extends Ur {
+  /**
+   * @description
+   * Stringify the qualifier
+   * BackgroundQualifiers don't have a value, but instead override the toString() function.
+   */
+  toString() {
+    return `
+    b_auto:predominant
+    ${this._contrast ? "_contrast" : ""}
+    ${this._palette.length ? `:palette_${this._palette.join("_")}` : ""}
+    `.replace(/\s+/g, "");
+  }
+}
+class Dn extends ot {
+  constructor() {
+    super("gen_fill"), this._backgroundType = "generativeFill";
+  }
+  prompt(e) {
+    return this._prompt = e, this;
+  }
+  getPrompt() {
+    return this._prompt;
+  }
+  getBackgroundType() {
+    return this._backgroundType;
+  }
+  /**
+   * @description
+   * Override the toString() function to explicitly stringify the qualifier.
+   */
+  toString() {
+    return `b_gen_fill${this._prompt ? `:prompt_${this._prompt}` : ""}`;
+  }
+}
+function Nn(t) {
+  return `${t}`.replace("b_", "");
+}
+function Ro() {
+  return { backgroundType: "auto" };
+}
+function xo(t) {
+  const { intensityLevel: e, brightnessLevel: r } = t, o = {
+    backgroundType: "blurred"
+  };
+  return (e || e === 0) && (o.intensity = e), (r || r === 0) && (o.brightness = r), o;
+}
+function Qr(t) {
+  const e = t._contrast, r = t._palette, o = {
+    backgroundType: ""
+  };
+  return e && (o.contrast = !0), r && (o.palette = r), o;
+}
+function Po(t) {
+  return Object.assign(Object.assign({}, Qr(t)), { backgroundType: "border" });
+}
+function Bn(t) {
+  const e = t._gradientColors, r = `${t._gradientDirection}`, o = Qr(t);
+  return e && (o.gradientColors = e), r && (o.gradientDirection = r), o;
+}
+function jo(t) {
+  return Object.assign(Object.assign({}, Bn(t)), { backgroundType: "borderGradient" });
+}
+function Mo(t) {
+  return {
+    backgroundType: "color",
+    color: Nn(t)
+  };
+}
+function $o(t) {
+  return Object.assign(Object.assign({}, Qr(t)), { backgroundType: "predominant" });
+}
+function ko(t) {
+  return Object.assign(Object.assign({}, Bn(t)), { backgroundType: "predominantGradient" });
+}
+function Io(t) {
+  return Object.assign({ backgroundType: t.getBackgroundType() }, t.getPrompt() ? { prompt: t.getPrompt() } : {});
+}
+function Lo(t) {
+  return Nn(t) === "auto" ? Ro() : t instanceof $n ? xo(t) : t instanceof kn ? Po(t) : t instanceof Ln ? jo(t) : t instanceof Vn ? $o(t) : t instanceof Fn ? ko(t) : t instanceof Dn ? Io(t) : Mo(t);
+}
+function Fo() {
+  return new Fr("svg");
+}
+function Gr() {
+  return new Fr("auto");
+}
+function Un() {
+  return new kn();
+}
+function Qn() {
+  return new ot("auto");
+}
+function Gn() {
+  return new Ln();
+}
+function qn() {
+  return new Fn();
+}
+function zn() {
+  return new Vn();
+}
+function Yn(t) {
+  return new ot(Dt(t));
+}
+function Vo() {
+  return new $n();
+}
+function Wn() {
+  return new Dn();
+}
+const Hn = {
+  auto: Qn,
+  border: Un,
+  borderGradient: Gn,
+  predominantGradient: qn,
+  predominant: zn,
+  color: Yn,
+  blurred: Vo,
+  generativeFill: Wn
+};
+function Do(t) {
+  const { brightness: e, intensity: r } = t, o = Hn.blurred();
+  return o.brightness(e ?? To), o.intensity(r ?? Mn), o;
+}
+function un(t, e) {
+  const { gradientColors: r, gradientDirection: o, contrast: s, palette: u } = e;
+  return s && t.contrast(), u && t.palette(...u), r && t.gradientColors(+r), o && t.gradientDirection(o), t;
+}
+function cn(t, e) {
+  const { contrast: r, palette: o } = e;
+  return r && t.contrast(), o && t.palette(...o), t;
+}
+function No(t, e) {
+  const { prompt: r } = e;
+  return r && t.prompt(r), t;
+}
+function Bo(t) {
+  const { backgroundType: e } = t;
+  switch (e) {
+    case "auto":
+      return Qn();
+    case "blurred":
+      return Do(t);
+    case "border":
+      return cn(Un(), t);
+    case "borderGradient":
+      return un(Gn(), t);
+    case "predominant":
+      return cn(zn(), t);
+    case "predominantGradient":
+      return un(qn(), t);
+    case "generativeFill":
+      return No(Wn(), t);
+    default:
+      return Yn(t.color);
+  }
+}
+class Uo extends Br {
+  /**
+   * @description Sets the background.
+   * @param {Qualifiers.Background} backgroundQualifier Defines the background color to use instead of
+   * transparent background areas or when resizing with padding.
+   */
+  background(e) {
+    return this._actionModel.background = Lo(e), this.addQualifier(e);
+  }
+  /**
+   * @description Horizontal position for custom-coordinates based padding.
+   * @param {number} x The x position.
+   */
+  offsetX(e) {
+    return this._actionModel.x = e, this.addQualifier(new w("x", e));
+  }
+  /**
+   * @description Vertical position for custom-coordinates based padding
+   * @param {number} y The y position.
+   */
+  offsetY(e) {
+    return this._actionModel.y = e, this.addQualifier(new w("y", e));
+  }
+  static fromJson(e) {
+    const r = super.fromJson.apply(this, [e]);
+    return e.background && r.background(Bo(e.background)), e.x && r.offsetX(e.x), e.y && r.offsetY(e.y), e.zoom && r.zoom(e.zoom), r;
+  }
+}
+class Qo extends Br {
+  /**
+   * @description Horizontal position for custom-coordinates based cropping.
+   * @param {number} x The x position.
+   */
+  x(e) {
+    return this._actionModel.x = e, this.addQualifier(new w("x", e));
+  }
+  /**
+   * @description Vertical position for custom-coordinates based cropping
+   * @param {number} y The y position.
+   */
+  y(e) {
+    return this._actionModel.y = e, this.addQualifier(new w("y", e));
+  }
+  /**
+   * @description Controls how much of the original image surrounding the face to keep when using either the 'crop' or 'thumb' cropping modes with face detection.
+   * @param {number | string} z The zoom factor. (Default: 1.0)
+   */
+  zoom(e) {
+    return this._actionModel.zoom = e, this.addQualifier(new w("z", e));
+  }
+  static fromJson(e) {
+    const r = super.fromJson.apply(this, [e]);
+    return e.x && r.x(e.x), e.y && r.y(e.y), e.zoom && r.zoom(e.zoom), r;
+  }
+}
+class Go extends Br {
+  /**
+   * @description Absolute X position when used with Gravity.xyCenter {@link Qualifiers.Gravity.GravityQualifier}}
+   * @param {number} x The x position.
+   */
+  x(e) {
+    return this._actionModel.x = e, this.addQualifier(new w("x", e));
+  }
+  /**
+   * @description Absolute Y position when used with Gravity.xyCenter {@link Qualifiers.Gravity.GravityQualifier}}
+   * @param {number} y The y position.
+   */
+  y(e) {
+    return this._actionModel.y = e, this.addQualifier(new w("y", e));
+  }
+  static fromJson(e) {
+    const r = super.fromJson.apply(this, [e]);
+    return e.x && r.x(e.x), e.y && r.y(e.y), r;
+  }
+}
+function qo(t, e) {
+  return new Qo("crop", t, e);
+}
+function zo(t, e) {
+  return new Go("fill", t, e);
+}
+function Yo(t, e) {
+  return new Uo("pad", t, e);
+}
+class Wo extends On {
+  /**
+   * @param {Qualifiers.Quality} qualityValue a Quality value
+   */
+  constructor(e) {
+    super("q", e.toString(), "level");
+  }
+  /**
+   * Selet the Chroma sub sampling</br>
+   * <b>Learn more</b>: {@link https://cloudinary.com/documentation/image_optimization#toggle_chroma_subsampling|Toggling chroma subsampling}
+   * @param {420 | 444 | number} type The chroma sub sampling type
+   */
+  chromaSubSampling(e) {
+    this._actionModel.chromaSubSampling = bn[e];
+    const r = new R([this._actionModel.level, e]);
+    return r.setDelimiter(":"), this.addQualifier(new w("q", r));
+  }
+  /**
+   * Controls the final quality by setting a maximum quantization percentage
+   * @param {number} val
+   */
+  quantization(e) {
+    this._actionModel.quantization = e;
+    const r = new R([this._actionModel.level, `qmax_${e}`]).setDelimiter(":");
+    return this.addQualifier(new w("q", r));
+  }
+  static fromJson(e) {
+    const { level: r, chromaSubSampling: o, quantization: s } = e, u = _n[r] || r, p = new this(u);
+    if (o) {
+      const h = Li[o.toUpperCase()];
+      h && p.chromaSubSampling(+h);
+    }
+    return s && p.quantization(s), p;
+  }
+}
+function Nt(t) {
+  return new Rr("f", t);
+}
+function Bt(t) {
+  return new Wo(t);
+}
+function Ho() {
+  return new Pn("north_east");
+}
+on(70).color("black"), on(40).color("white"), zi(), Wi();
+var Jo = new ke().effect(Yi()).delivery(Bt("auto")).delivery(Nt(Fo())), Ko = new ke().effect(Hi()).delivery(Bt("auto")).delivery(Nt(Gr())), Xo = new ke().effect(qi(2e3)).delivery(Bt("auto")).delivery(Nt(Gr())), Zo = new ke().resize(Yo("iw_div_2").aspectRatio(1).background(Hn.auto())).resize(qo(1, 1).gravity(so(Ho()))).resize(zo().height("ih").width("iw")).delivery(Bt("auto")).delivery(Nt(Gr())), ln = {
+  vectorize: Jo,
+  pixelate: Ko,
+  blur: Xo,
+  "predominant-color": Zo
+}, fn = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==", dn = {
+  flv: "x-flv",
+  "3gp": "3gpp",
+  mov: "quicktime",
+  mpg: "mpeg",
+  avi: "x-msvideo",
+  wmv: "x-ms-wmv",
+  ogv: "ogg",
+  webm: "webm",
+  mp4: "mp4"
+}, pn = "?_a=", ea = (
+  /** @class */
+  function() {
+    function t(e, r, o, s, u, p, h) {
+      var m = this;
+      this.mimeType = "video", this.mimeSubTypes = dn, this.videoElement = e, this.originalVideo = r, this.videoOptions = h, this.htmlPluginState = { cleanupCallbacks: [], pluginEventSubscription: [] };
+      var g = se(r);
+      It(e, r, s, this.htmlPluginState).then(function() {
+        m.htmlPluginState.pluginEventSubscription.forEach(function(O) {
+          O();
+        }), m.setVideoAttributes(u, p), m.handleSourceToVideo(g, o);
+      });
+    }
+    return t.prototype.handleSourceToVideo = function(e, r) {
+      var o = this;
+      if (r)
+        this.generateUserSources(e, r);
+      else {
+        var s = ["webm", "mp4", "ogv"];
+        s.forEach(function(u) {
+          o.appendSourceTag(se(e), u);
+        });
+      }
+    }, t.prototype.generateUserSources = function(e, r) {
+      var o = this;
+      r.map(function(s) {
+        var u = s.type, p = s.codecs, h = s.transcode;
+        return o.appendSourceTag(se(e).transcode(h), u, o.buildMimeType(u, p));
+      });
+    }, t.prototype.appendSourceTag = function(e, r, o) {
+      var s, u = document.createElement("source"), p = (s = this.videoOptions) === null || s === void 0 ? void 0 : s.useFetchFormat;
+      p && e.format(r);
+      var h = e.toURL(), m = h.split(pn), g = m[1] ? "".concat(pn).concat(m[1]) : "", O = p ? "" : ".".concat(r);
+      u.src = "".concat(m[0]).concat(O).concat(g), u.type = o || "video/".concat(dn[r] || r), this.videoElement.appendChild(u);
+    }, t.prototype.buildMimeType = function(e, r) {
+      var o = "".concat(this.mimeType, "/").concat(this.mimeSubTypes[e] || e);
+      return r && (o += "; codecs=" + (Array.isArray(r) ? r.join(", ") : r)), o;
+    }, t.prototype.setVideoAttributes = function(e, r) {
+      var o;
+      if (e === void 0 && (e = {}), r === "auto") {
+        var s = se(this.originalVideo);
+        e.poster = s.quality("auto").format("jpg").addTransformation("so_auto").toURL();
+      } else r && (e.poster = (o = r.toURL) === null || o === void 0 ? void 0 : o.call(r));
+      for (var u = 0, p = Object.entries(e); u < p.length; u++) {
+        var h = p[u], m = h[0], g = h[1];
+        g && this.videoElement.setAttribute(m, m === "poster" ? g : "");
+      }
+    }, t.prototype.update = function(e, r, o, s, u) {
+      var p = this;
+      if (e !== this.originalVideo) {
+        for (var h = this.videoElement.getElementsByTagName("SOURCE"); h[0]; )
+          h[0].parentNode.removeChild(h[0]);
+        It(this.videoElement, e, o, this.htmlPluginState).then(function() {
+          p.setVideoAttributes(s, u), p.handleSourceToVideo(e, r), p.videoElement.load();
+        });
+      }
+    }, t;
+  }()
+), ta = typeof ae == "object" && ae && ae.Object === Object && ae, ra = typeof self == "object" && self && self.Object === Object && self;
+ta || ra || Function("return this")();
+function qr() {
+  return typeof window < "u";
+}
+function na(t) {
+  return t instanceof HTMLImageElement;
+}
+function ia(t) {
+  var e = {}, r = e.rootMargin, o = r === void 0 ? "0px" : r, s = e.threshold, u = s === void 0 ? 0.1 : s;
+  return oa.bind(null, o, u);
+}
+function oa(t, e, r, o, s, u) {
+  return t === void 0 && (t = "0px"), e === void 0 && (e = 0.1), qr() ? new Promise(function(p) {
+    var h = function() {
+      return p({ lazyload: !0 });
+    }, m = sa(r, h, t, e);
+    s.cleanupCallbacks.push(function() {
+      m(), p("canceled");
+    });
+  }) : !1;
+}
+function aa() {
+  return window && "IntersectionObserver" in window;
+}
+function sa(t, e, r, o) {
+  try {
+    if (!aa())
+      return e(), function() {
+      };
+    var s = new IntersectionObserver(function(u) {
+      u.forEach(function(p) {
+        p.isIntersecting && (s.unobserve(p.target), e());
+      });
+    }, { rootMargin: r, threshold: o });
+    return s.observe(t), function() {
+      t && s.observe(t);
+    };
+  } catch {
+    e();
+  }
+}
+function ua(t) {
+  var e = {}, r = e.mode, o = r === void 0 ? "vectorize" : r;
+  return ca.bind(null, o);
+}
+function ca(t, e, r, o, s, u) {
+  ln[t] || (t = "vectorize");
+  var p = ln[t].actions, h = se(r);
+  if (p.forEach(function(g) {
+    h.addAction(g);
+  }), !qr())
+    return r.transformation = h.transformation, !0;
+  if (na(e)) {
+    h.transformation.actions.forEach(function(g, O) {
+      g instanceof U && g.getActionTag() === "responsive" && delete h.transformation.actions[O];
+    });
+    var m = Cr(s, { placeholder: !0 });
+    return e.src = h.toURL(m), e.onerror = function() {
+      e.src = fn;
+    }, new Promise(function(g) {
+      e.onload = function() {
+        g();
+      };
+    }).then(function() {
+      return new Promise(function(g) {
+        o.cleanupCallbacks.push(function() {
+          e.src = fn, g("canceled");
+        });
+        var O = new Image();
+        O.src = r.toURL(m), O.onload = function() {
+          g({ placeholder: !0 });
+        }, O.onerror = function() {
+          g({ placeholder: !0 });
+        };
+      });
+    });
+  }
+}
+function la(t, e, r) {
+  var o = se(e);
+  if (t)
+    for (var s = 0; s < t.length; s++) {
+      var u = t[s](null, o);
+      if (!u)
+        break;
+    }
+  return o.toURL({ trackedAnalytics: r });
+}
+function Lt(t) {
+  t.cleanupCallbacks.forEach(function(e) {
+    e();
+  });
+}
+var xr = function(t, e) {
+  return xr = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, o) {
+    r.__proto__ = o;
+  } || function(r, o) {
+    for (var s in o) Object.prototype.hasOwnProperty.call(o, s) && (r[s] = o[s]);
+  }, xr(t, e);
+};
+function Jn(t, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Class extends value " + String(e) + " is not a constructor or null");
+  xr(t, e);
+  function r() {
+    this.constructor = t;
+  }
+  t.prototype = e === null ? Object.create(e) : (r.prototype = e.prototype, new r());
+}
+var nt = function() {
+  return nt = Object.assign || function(e) {
+    for (var r, o = 1, s = arguments.length; o < s; o++) {
+      r = arguments[o];
+      for (var u in r) Object.prototype.hasOwnProperty.call(r, u) && (e[u] = r[u]);
+    }
+    return e;
+  }, nt.apply(this, arguments);
+};
+function Kn(t, e) {
+  var r = {};
+  for (var o in t) Object.prototype.hasOwnProperty.call(t, o) && e.indexOf(o) < 0 && (r[o] = t[o]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var s = 0, o = Object.getOwnPropertySymbols(t); s < o.length; s++)
+      e.indexOf(o[s]) < 0 && Object.prototype.propertyIsEnumerable.call(t, o[s]) && (r[o[s]] = t[o[s]]);
+  return r;
+}
+var it = { exports: {} }, T = {};
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var hn = Object.getOwnPropertySymbols, fa = Object.prototype.hasOwnProperty, da = Object.prototype.propertyIsEnumerable;
+function pa(t) {
+  if (t == null)
+    throw new TypeError("Object.assign cannot be called with null or undefined");
+  return Object(t);
+}
+function ha() {
+  try {
+    if (!Object.assign)
+      return !1;
+    var t = new String("abc");
+    if (t[5] = "de", Object.getOwnPropertyNames(t)[0] === "5")
+      return !1;
+    for (var e = {}, r = 0; r < 10; r++)
+      e["_" + String.fromCharCode(r)] = r;
+    var o = Object.getOwnPropertyNames(e).map(function(u) {
+      return e[u];
+    });
+    if (o.join("") !== "0123456789")
+      return !1;
+    var s = {};
+    return "abcdefghijklmnopqrst".split("").forEach(function(u) {
+      s[u] = u;
+    }), Object.keys(Object.assign({}, s)).join("") === "abcdefghijklmnopqrst";
+  } catch {
+    return !1;
+  }
+}
+var Xn = ha() ? Object.assign : function(t, e) {
+  for (var r, o = pa(t), s, u = 1; u < arguments.length; u++) {
+    r = Object(arguments[u]);
+    for (var p in r)
+      fa.call(r, p) && (o[p] = r[p]);
+    if (hn) {
+      s = hn(r);
+      for (var h = 0; h < s.length; h++)
+        da.call(r, s[h]) && (o[s[h]] = r[s[h]]);
+    }
+  }
+  return o;
+};
+/** @license React v16.14.0
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var zr = Xn, Q = typeof Symbol == "function" && Symbol.for, at = Q ? Symbol.for("react.element") : 60103, ga = Q ? Symbol.for("react.portal") : 60106, ya = Q ? Symbol.for("react.fragment") : 60107, va = Q ? Symbol.for("react.strict_mode") : 60108, ma = Q ? Symbol.for("react.profiler") : 60114, _a = Q ? Symbol.for("react.provider") : 60109, ba = Q ? Symbol.for("react.context") : 60110, wa = Q ? Symbol.for("react.forward_ref") : 60112, Ea = Q ? Symbol.for("react.suspense") : 60113, Oa = Q ? Symbol.for("react.memo") : 60115, Aa = Q ? Symbol.for("react.lazy") : 60116, gn = typeof Symbol == "function" && Symbol.iterator;
+function st(t) {
+  for (var e = "https://reactjs.org/docs/error-decoder.html?invariant=" + t, r = 1; r < arguments.length; r++) e += "&args[]=" + encodeURIComponent(arguments[r]);
+  return "Minified React error #" + t + "; visit " + e + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+}
+var Zn = { isMounted: function() {
+  return !1;
+}, enqueueForceUpdate: function() {
+}, enqueueReplaceState: function() {
+}, enqueueSetState: function() {
+} }, ei = {};
+function Ie(t, e, r) {
+  this.props = t, this.context = e, this.refs = ei, this.updater = r || Zn;
+}
+Ie.prototype.isReactComponent = {};
+Ie.prototype.setState = function(t, e) {
+  if (typeof t != "object" && typeof t != "function" && t != null) throw Error(st(85));
+  this.updater.enqueueSetState(this, t, e, "setState");
+};
+Ie.prototype.forceUpdate = function(t) {
+  this.updater.enqueueForceUpdate(this, t, "forceUpdate");
+};
+function ti() {
+}
+ti.prototype = Ie.prototype;
+function Yr(t, e, r) {
+  this.props = t, this.context = e, this.refs = ei, this.updater = r || Zn;
+}
+var Wr = Yr.prototype = new ti();
+Wr.constructor = Yr;
+zr(Wr, Ie.prototype);
+Wr.isPureReactComponent = !0;
+var Hr = { current: null }, ri = Object.prototype.hasOwnProperty, ni = { key: !0, ref: !0, __self: !0, __source: !0 };
+function ii(t, e, r) {
+  var o, s = {}, u = null, p = null;
+  if (e != null) for (o in e.ref !== void 0 && (p = e.ref), e.key !== void 0 && (u = "" + e.key), e) ri.call(e, o) && !ni.hasOwnProperty(o) && (s[o] = e[o]);
+  var h = arguments.length - 2;
+  if (h === 1) s.children = r;
+  else if (1 < h) {
+    for (var m = Array(h), g = 0; g < h; g++) m[g] = arguments[g + 2];
+    s.children = m;
+  }
+  if (t && t.defaultProps) for (o in h = t.defaultProps, h) s[o] === void 0 && (s[o] = h[o]);
+  return { $$typeof: at, type: t, key: u, ref: p, props: s, _owner: Hr.current };
+}
+function Sa(t, e) {
+  return { $$typeof: at, type: t.type, key: e, ref: t.ref, props: t.props, _owner: t._owner };
+}
+function Jr(t) {
+  return typeof t == "object" && t !== null && t.$$typeof === at;
+}
+function Ta(t) {
+  var e = { "=": "=0", ":": "=2" };
+  return "$" + ("" + t).replace(/[=:]/g, function(r) {
+    return e[r];
+  });
+}
+var oi = /\/+/g, Ft = [];
+function ai(t, e, r, o) {
+  if (Ft.length) {
+    var s = Ft.pop();
+    return s.result = t, s.keyPrefix = e, s.func = r, s.context = o, s.count = 0, s;
+  }
+  return { result: t, keyPrefix: e, func: r, context: o, count: 0 };
+}
+function si(t) {
+  t.result = null, t.keyPrefix = null, t.func = null, t.context = null, t.count = 0, 10 > Ft.length && Ft.push(t);
+}
+function Pr(t, e, r, o) {
+  var s = typeof t;
+  (s === "undefined" || s === "boolean") && (t = null);
+  var u = !1;
+  if (t === null) u = !0;
+  else switch (s) {
+    case "string":
+    case "number":
+      u = !0;
+      break;
+    case "object":
+      switch (t.$$typeof) {
+        case at:
+        case ga:
+          u = !0;
+      }
+  }
+  if (u) return r(o, t, e === "" ? "." + Or(t, 0) : e), 1;
+  if (u = 0, e = e === "" ? "." : e + ":", Array.isArray(t)) for (var p = 0; p < t.length; p++) {
+    s = t[p];
+    var h = e + Or(s, p);
+    u += Pr(s, h, r, o);
+  }
+  else if (t === null || typeof t != "object" ? h = null : (h = gn && t[gn] || t["@@iterator"], h = typeof h == "function" ? h : null), typeof h == "function") for (t = h.call(t), p = 0; !(s = t.next()).done; ) s = s.value, h = e + Or(s, p++), u += Pr(s, h, r, o);
+  else if (s === "object") throw r = "" + t, Error(st(31, r === "[object Object]" ? "object with keys {" + Object.keys(t).join(", ") + "}" : r, ""));
+  return u;
+}
+function jr(t, e, r) {
+  return t == null ? 0 : Pr(t, "", e, r);
+}
+function Or(t, e) {
+  return typeof t == "object" && t !== null && t.key != null ? Ta(t.key) : e.toString(36);
+}
+function Ca(t, e) {
+  t.func.call(t.context, e, t.count++);
+}
+function Ra(t, e, r) {
+  var o = t.result, s = t.keyPrefix;
+  t = t.func.call(t.context, e, t.count++), Array.isArray(t) ? Mr(t, o, r, function(u) {
+    return u;
+  }) : t != null && (Jr(t) && (t = Sa(t, s + (!t.key || e && e.key === t.key ? "" : ("" + t.key).replace(oi, "$&/") + "/") + r)), o.push(t));
+}
+function Mr(t, e, r, o, s) {
+  var u = "";
+  r != null && (u = ("" + r).replace(oi, "$&/") + "/"), e = ai(e, u, o, s), jr(t, Ra, e), si(e);
+}
+var ui = { current: null };
+function K() {
+  var t = ui.current;
+  if (t === null) throw Error(st(321));
+  return t;
+}
+var xa = { ReactCurrentDispatcher: ui, ReactCurrentBatchConfig: { suspense: null }, ReactCurrentOwner: Hr, IsSomeRendererActing: { current: !1 }, assign: zr };
+T.Children = { map: function(t, e, r) {
+  if (t == null) return t;
+  var o = [];
+  return Mr(t, o, null, e, r), o;
+}, forEach: function(t, e, r) {
+  if (t == null) return t;
+  e = ai(null, null, e, r), jr(t, Ca, e), si(e);
+}, count: function(t) {
+  return jr(t, function() {
+    return null;
+  }, null);
+}, toArray: function(t) {
+  var e = [];
+  return Mr(t, e, null, function(r) {
+    return r;
+  }), e;
+}, only: function(t) {
+  if (!Jr(t)) throw Error(st(143));
+  return t;
+} };
+T.Component = Ie;
+T.Fragment = ya;
+T.Profiler = ma;
+T.PureComponent = Yr;
+T.StrictMode = va;
+T.Suspense = Ea;
+T.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = xa;
+T.cloneElement = function(t, e, r) {
+  if (t == null) throw Error(st(267, t));
+  var o = zr({}, t.props), s = t.key, u = t.ref, p = t._owner;
+  if (e != null) {
+    if (e.ref !== void 0 && (u = e.ref, p = Hr.current), e.key !== void 0 && (s = "" + e.key), t.type && t.type.defaultProps) var h = t.type.defaultProps;
+    for (m in e) ri.call(e, m) && !ni.hasOwnProperty(m) && (o[m] = e[m] === void 0 && h !== void 0 ? h[m] : e[m]);
+  }
+  var m = arguments.length - 2;
+  if (m === 1) o.children = r;
+  else if (1 < m) {
+    h = Array(m);
+    for (var g = 0; g < m; g++) h[g] = arguments[g + 2];
+    o.children = h;
+  }
+  return {
+    $$typeof: at,
+    type: t.type,
+    key: s,
+    ref: u,
+    props: o,
+    _owner: p
+  };
+};
+T.createContext = function(t, e) {
+  return e === void 0 && (e = null), t = { $$typeof: ba, _calculateChangedBits: e, _currentValue: t, _currentValue2: t, _threadCount: 0, Provider: null, Consumer: null }, t.Provider = { $$typeof: _a, _context: t }, t.Consumer = t;
+};
+T.createElement = ii;
+T.createFactory = function(t) {
+  var e = ii.bind(null, t);
+  return e.type = t, e;
+};
+T.createRef = function() {
+  return { current: null };
+};
+T.forwardRef = function(t) {
+  return { $$typeof: wa, render: t };
+};
+T.isValidElement = Jr;
+T.lazy = function(t) {
+  return { $$typeof: Aa, _ctor: t, _status: -1, _result: null };
+};
+T.memo = function(t, e) {
+  return { $$typeof: Oa, type: t, compare: e === void 0 ? null : e };
+};
+T.useCallback = function(t, e) {
+  return K().useCallback(t, e);
+};
+T.useContext = function(t, e) {
+  return K().useContext(t, e);
+};
+T.useDebugValue = function() {
+};
+T.useEffect = function(t, e) {
+  return K().useEffect(t, e);
+};
+T.useImperativeHandle = function(t, e, r) {
+  return K().useImperativeHandle(t, e, r);
+};
+T.useLayoutEffect = function(t, e) {
+  return K().useLayoutEffect(t, e);
+};
+T.useMemo = function(t, e) {
+  return K().useMemo(t, e);
+};
+T.useReducer = function(t, e, r) {
+  return K().useReducer(t, e, r);
+};
+T.useRef = function(t) {
+  return K().useRef(t);
+};
+T.useState = function(t) {
+  return K().useState(t);
+};
+T.version = "16.14.0";
+var S = {}, Pa = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED", ja = Pa, Ma = Function.call.bind(Object.prototype.hasOwnProperty), $r = function() {
+};
+if (process.env.NODE_ENV !== "production") {
+  var $a = ja, kr = {}, ka = Ma;
+  $r = function(t) {
+    var e = "Warning: " + t;
+    typeof console < "u" && console.error(e);
+    try {
+      throw new Error(e);
+    } catch {
+    }
+  };
+}
+function ci(t, e, r, o, s) {
+  if (process.env.NODE_ENV !== "production") {
+    for (var u in t)
+      if (ka(t, u)) {
+        var p;
+        try {
+          if (typeof t[u] != "function") {
+            var h = Error(
+              (o || "React class") + ": " + r + " type `" + u + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof t[u] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+            );
+            throw h.name = "Invariant Violation", h;
+          }
+          p = t[u](e, u, o, r, null, $a);
+        } catch (g) {
+          p = g;
+        }
+        if (p && !(p instanceof Error) && $r(
+          (o || "React class") + ": type specification of " + r + " `" + u + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof p + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+        ), p instanceof Error && !(p.message in kr)) {
+          kr[p.message] = !0;
+          var m = s ? s() : "";
+          $r(
+            "Failed " + r + " type: " + p.message + (m ?? "")
+          );
+        }
+      }
+  }
+}
+ci.resetWarningCache = function() {
+  process.env.NODE_ENV !== "production" && (kr = {});
+};
+var Ia = ci;
+/** @license React v16.14.0
+ * react.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+process.env.NODE_ENV !== "production" && function() {
+  var t = Xn, e = Ia, r = "16.14.0", o = typeof Symbol == "function" && Symbol.for, s = o ? Symbol.for("react.element") : 60103, u = o ? Symbol.for("react.portal") : 60106, p = o ? Symbol.for("react.fragment") : 60107, h = o ? Symbol.for("react.strict_mode") : 60108, m = o ? Symbol.for("react.profiler") : 60114, g = o ? Symbol.for("react.provider") : 60109, O = o ? Symbol.for("react.context") : 60110, X = o ? Symbol.for("react.concurrent_mode") : 60111, q = o ? Symbol.for("react.forward_ref") : 60112, ve = o ? Symbol.for("react.suspense") : 60113, me = o ? Symbol.for("react.suspense_list") : 60120, Z = o ? Symbol.for("react.memo") : 60115, _e = o ? Symbol.for("react.lazy") : 60116, ue = o ? Symbol.for("react.block") : 60121, ut = o ? Symbol.for("react.fundamental") : 60117, ct = o ? Symbol.for("react.responder") : 60118, Le = o ? Symbol.for("react.scope") : 60119, Fe = typeof Symbol == "function" && Symbol.iterator, be = "@@iterator";
+  function Ve(n) {
+    if (n === null || typeof n != "object")
+      return null;
+    var a = Fe && n[Fe] || n[be];
+    return typeof a == "function" ? a : null;
+  }
+  var De = {
+    /**
+     * @internal
+     * @type {ReactComponent}
+     */
+    current: null
+  }, lt = {
+    suspense: null
+  }, L = {
+    /**
+     * @internal
+     * @type {ReactComponent}
+     */
+    current: null
+  }, we = /^(.*)[\\\/]/;
+  function ft(n, a, l) {
+    var d = "";
+    if (a) {
+      var y = a.fileName, E = y.replace(we, "");
+      if (/^index\./.test(E)) {
+        var _ = y.match(we);
+        if (_) {
+          var b = _[1];
+          if (b) {
+            var x = b.replace(we, "");
+            E = x + "/" + E;
+          }
+        }
+      }
+      d = " (at " + E + ":" + a.lineNumber + ")";
+    } else l && (d = " (created by " + l + ")");
+    return `
+    in ` + (n || "Unknown") + d;
+  }
+  var dt = 1;
+  function pt(n) {
+    return n._status === dt ? n._result : null;
+  }
+  function ht(n, a, l) {
+    var d = a.displayName || a.name || "";
+    return n.displayName || (d !== "" ? l + "(" + d + ")" : l);
+  }
+  function F(n) {
+    if (n == null)
+      return null;
+    if (typeof n.tag == "number" && A("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue."), typeof n == "function")
+      return n.displayName || n.name || null;
+    if (typeof n == "string")
+      return n;
+    switch (n) {
+      case p:
+        return "Fragment";
+      case u:
+        return "Portal";
+      case m:
+        return "Profiler";
+      case h:
+        return "StrictMode";
+      case ve:
+        return "Suspense";
+      case me:
+        return "SuspenseList";
+    }
+    if (typeof n == "object")
+      switch (n.$$typeof) {
+        case O:
+          return "Context.Consumer";
+        case g:
+          return "Context.Provider";
+        case q:
+          return ht(n, n.render, "ForwardRef");
+        case Z:
+          return F(n.type);
+        case ue:
+          return F(n.render);
+        case _e: {
+          var a = n, l = pt(a);
+          if (l)
+            return F(l);
+          break;
+        }
+      }
+    return null;
+  }
+  var ee = {}, ce = null;
+  function te(n) {
+    ce = n;
+  }
+  ee.getCurrentStack = null, ee.getStackAddendum = function() {
+    var n = "";
+    if (ce) {
+      var a = F(ce.type), l = ce._owner;
+      n += ft(a, ce._source, l && F(l.type));
+    }
+    var d = ee.getCurrentStack;
+    return d && (n += d() || ""), n;
+  };
+  var C = {
+    current: !1
+  }, Ne = {
+    ReactCurrentDispatcher: De,
+    ReactCurrentBatchConfig: lt,
+    ReactCurrentOwner: L,
+    IsSomeRendererActing: C,
+    // Used by renderers to avoid bundling object-assign twice in UMD bundles:
+    assign: t
+  };
+  t(Ne, {
+    // These should not be included in production.
+    ReactDebugCurrentFrame: ee,
+    // Shim for React DOM 16.0.0 which still destructured (but not used) this.
+    // TODO: remove in React 17.0.
+    ReactComponentTreeHook: {}
+  });
+  function Ee(n) {
+    {
+      for (var a = arguments.length, l = new Array(a > 1 ? a - 1 : 0), d = 1; d < a; d++)
+        l[d - 1] = arguments[d];
+      Be("warn", n, l);
+    }
+  }
+  function A(n) {
+    {
+      for (var a = arguments.length, l = new Array(a > 1 ? a - 1 : 0), d = 1; d < a; d++)
+        l[d - 1] = arguments[d];
+      Be("error", n, l);
+    }
+  }
+  function Be(n, a, l) {
+    {
+      var d = l.length > 0 && typeof l[l.length - 1] == "string" && l[l.length - 1].indexOf(`
+    in`) === 0;
+      if (!d) {
+        var y = Ne.ReactDebugCurrentFrame, E = y.getStackAddendum();
+        E !== "" && (a += "%s", l = l.concat([E]));
+      }
+      var _ = l.map(function(P) {
+        return "" + P;
+      });
+      _.unshift("Warning: " + a), Function.prototype.apply.call(console[n], console, _);
+      try {
+        var b = 0, x = "Warning: " + a.replace(/%s/g, function() {
+          return l[b++];
+        });
+        throw new Error(x);
+      } catch {
+      }
+    }
+  }
+  var Ue = {};
+  function Qe(n, a) {
+    {
+      var l = n.constructor, d = l && (l.displayName || l.name) || "ReactClass", y = d + "." + a;
+      if (Ue[y])
+        return;
+      A("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", a, d), Ue[y] = !0;
+    }
+  }
+  var gt = {
+    /**
+     * Checks whether or not this composite component is mounted.
+     * @param {ReactClass} publicInstance The instance we want to test.
+     * @return {boolean} True if mounted, false otherwise.
+     * @protected
+     * @final
+     */
+    isMounted: function(n) {
+      return !1;
+    },
+    /**
+     * Forces an update. This should only be invoked when it is known with
+     * certainty that we are **not** in a DOM transaction.
+     *
+     * You may want to call this when you know that some deeper aspect of the
+     * component's state has changed but `setState` was not called.
+     *
+     * This will not invoke `shouldComponentUpdate`, but it will invoke
+     * `componentWillUpdate` and `componentDidUpdate`.
+     *
+     * @param {ReactClass} publicInstance The instance that should rerender.
+     * @param {?function} callback Called after component is updated.
+     * @param {?string} callerName name of the calling function in the public API.
+     * @internal
+     */
+    enqueueForceUpdate: function(n, a, l) {
+      Qe(n, "forceUpdate");
+    },
+    /**
+     * Replaces all of the state. Always use this or `setState` to mutate state.
+     * You should treat `this.state` as immutable.
+     *
+     * There is no guarantee that `this.state` will be immediately updated, so
+     * accessing `this.state` after calling this method may return the old value.
+     *
+     * @param {ReactClass} publicInstance The instance that should rerender.
+     * @param {object} completeState Next state.
+     * @param {?function} callback Called after component is updated.
+     * @param {?string} callerName name of the calling function in the public API.
+     * @internal
+     */
+    enqueueReplaceState: function(n, a, l, d) {
+      Qe(n, "replaceState");
+    },
+    /**
+     * Sets a subset of the state. This only exists because _pendingState is
+     * internal. This provides a merging strategy that is not available to deep
+     * properties which is confusing. TODO: Expose pendingState or don't use it
+     * during the merge.
+     *
+     * @param {ReactClass} publicInstance The instance that should rerender.
+     * @param {object} partialState Next partial state to be merged with state.
+     * @param {?function} callback Called after component is updated.
+     * @param {?string} Name of the calling function in the public API.
+     * @internal
+     */
+    enqueueSetState: function(n, a, l, d) {
+      Qe(n, "setState");
+    }
+  }, Ge = {};
+  Object.freeze(Ge);
+  function z(n, a, l) {
+    this.props = n, this.context = a, this.refs = Ge, this.updater = l || gt;
+  }
+  z.prototype.isReactComponent = {}, z.prototype.setState = function(n, a) {
+    if (!(typeof n == "object" || typeof n == "function" || n == null))
+      throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+    this.updater.enqueueSetState(this, n, a, "setState");
+  }, z.prototype.forceUpdate = function(n) {
+    this.updater.enqueueForceUpdate(this, n, "forceUpdate");
+  };
+  {
+    var qe = {
+      isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
+      replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
+    }, yt = function(n, a) {
+      Object.defineProperty(z.prototype, n, {
+        get: function() {
+          Ee("%s(...) is deprecated in plain JavaScript React classes. %s", a[0], a[1]);
+        }
+      });
+    };
+    for (var ze in qe)
+      qe.hasOwnProperty(ze) && yt(ze, qe[ze]);
+  }
+  function vt() {
+  }
+  vt.prototype = z.prototype;
+  function Oe(n, a, l) {
+    this.props = n, this.context = a, this.refs = Ge, this.updater = l || gt;
+  }
+  var Ae = Oe.prototype = new vt();
+  Ae.constructor = Oe, t(Ae, z.prototype), Ae.isPureReactComponent = !0;
+  function Ye() {
+    var n = {
+      current: null
+    };
+    return Object.seal(n), n;
+  }
+  var le = Object.prototype.hasOwnProperty, mt = {
+    key: !0,
+    ref: !0,
+    __self: !0,
+    __source: !0
+  }, _t, fe, de;
+  de = {};
+  function We(n) {
+    if (le.call(n, "ref")) {
+      var a = Object.getOwnPropertyDescriptor(n, "ref").get;
+      if (a && a.isReactWarning)
+        return !1;
+    }
+    return n.ref !== void 0;
+  }
+  function He(n) {
+    if (le.call(n, "key")) {
+      var a = Object.getOwnPropertyDescriptor(n, "key").get;
+      if (a && a.isReactWarning)
+        return !1;
+    }
+    return n.key !== void 0;
+  }
+  function G(n, a) {
+    var l = function() {
+      _t || (_t = !0, A("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://fb.me/react-special-props)", a));
+    };
+    l.isReactWarning = !0, Object.defineProperty(n, "key", {
+      get: l,
+      configurable: !0
+    });
+  }
+  function Se(n, a) {
+    var l = function() {
+      fe || (fe = !0, A("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://fb.me/react-special-props)", a));
+    };
+    l.isReactWarning = !0, Object.defineProperty(n, "ref", {
+      get: l,
+      configurable: !0
+    });
+  }
+  function Ut(n) {
+    if (typeof n.ref == "string" && L.current && n.__self && L.current.stateNode !== n.__self) {
+      var a = F(L.current.type);
+      de[a] || (A('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://fb.me/react-strict-mode-string-ref', F(L.current.type), n.ref), de[a] = !0);
+    }
+  }
+  var Te = function(n, a, l, d, y, E, _) {
+    var b = {
+      // This tag allows us to uniquely identify this as a React Element
+      $$typeof: s,
+      // Built-in properties that belong on the element
+      type: n,
+      key: a,
+      ref: l,
+      props: _,
+      // Record the component responsible for creating this element.
+      _owner: E
+    };
+    return b._store = {}, Object.defineProperty(b._store, "validated", {
+      configurable: !1,
+      enumerable: !1,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(b, "_self", {
+      configurable: !1,
+      enumerable: !1,
+      writable: !1,
+      value: d
+    }), Object.defineProperty(b, "_source", {
+      configurable: !1,
+      enumerable: !1,
+      writable: !1,
+      value: y
+    }), Object.freeze && (Object.freeze(b.props), Object.freeze(b)), b;
+  };
+  function bt(n, a, l) {
+    var d, y = {}, E = null, _ = null, b = null, x = null;
+    if (a != null) {
+      We(a) && (_ = a.ref, Ut(a)), He(a) && (E = "" + a.key), b = a.__self === void 0 ? null : a.__self, x = a.__source === void 0 ? null : a.__source;
+      for (d in a)
+        le.call(a, d) && !mt.hasOwnProperty(d) && (y[d] = a[d]);
+    }
+    var P = arguments.length - 2;
+    if (P === 1)
+      y.children = l;
+    else if (P > 1) {
+      for (var $ = Array(P), M = 0; M < P; M++)
+        $[M] = arguments[M + 2];
+      Object.freeze && Object.freeze($), y.children = $;
+    }
+    if (n && n.defaultProps) {
+      var H = n.defaultProps;
+      for (d in H)
+        y[d] === void 0 && (y[d] = H[d]);
+    }
+    if (E || _) {
+      var N = typeof n == "function" ? n.displayName || n.name || "Unknown" : n;
+      E && G(y, N), _ && Se(y, N);
+    }
+    return Te(n, E, _, b, x, L.current, y);
+  }
+  function wt(n, a) {
+    var l = Te(n.type, a, n.ref, n._self, n._source, n._owner, n.props);
+    return l;
+  }
+  function Qt(n, a, l) {
+    if (n == null)
+      throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + n + ".");
+    var d, y = t({}, n.props), E = n.key, _ = n.ref, b = n._self, x = n._source, P = n._owner;
+    if (a != null) {
+      We(a) && (_ = a.ref, P = L.current), He(a) && (E = "" + a.key);
+      var $;
+      n.type && n.type.defaultProps && ($ = n.type.defaultProps);
+      for (d in a)
+        le.call(a, d) && !mt.hasOwnProperty(d) && (a[d] === void 0 && $ !== void 0 ? y[d] = $[d] : y[d] = a[d]);
+    }
+    var M = arguments.length - 2;
+    if (M === 1)
+      y.children = l;
+    else if (M > 1) {
+      for (var H = Array(M), N = 0; N < M; N++)
+        H[N] = arguments[N + 2];
+      y.children = H;
+    }
+    return Te(n.type, E, _, b, x, P, y);
+  }
+  function re(n) {
+    return typeof n == "object" && n !== null && n.$$typeof === s;
+  }
+  var Et = ".", Gt = ":";
+  function Ot(n) {
+    var a = /[=:]/g, l = {
+      "=": "=0",
+      ":": "=2"
+    }, d = ("" + n).replace(a, function(y) {
+      return l[y];
+    });
+    return "$" + d;
+  }
+  var At = !1, qt = /\/+/g;
+  function Ce(n) {
+    return ("" + n).replace(qt, "$&/");
+  }
+  var pe = 10, ne = [];
+  function Re(n, a, l, d) {
+    if (ne.length) {
+      var y = ne.pop();
+      return y.result = n, y.keyPrefix = a, y.func = l, y.context = d, y.count = 0, y;
+    } else
+      return {
+        result: n,
+        keyPrefix: a,
+        func: l,
+        context: d,
+        count: 0
+      };
+  }
+  function xe(n) {
+    n.result = null, n.keyPrefix = null, n.func = null, n.context = null, n.count = 0, ne.length < pe && ne.push(n);
+  }
+  function Y(n, a, l, d) {
+    var y = typeof n;
+    (y === "undefined" || y === "boolean") && (n = null);
+    var E = !1;
+    if (n === null)
+      E = !0;
+    else
+      switch (y) {
+        case "string":
+        case "number":
+          E = !0;
+          break;
+        case "object":
+          switch (n.$$typeof) {
+            case s:
+            case u:
+              E = !0;
+          }
+      }
+    if (E)
+      return l(
+        d,
+        n,
+        // If it's the only child, treat the name as if it was wrapped in an array
+        // so that it's consistent if the number of children grows.
+        a === "" ? Et + Ke(n, 0) : a
+      ), 1;
+    var _, b, x = 0, P = a === "" ? Et : a + Gt;
+    if (Array.isArray(n))
+      for (var $ = 0; $ < n.length; $++)
+        _ = n[$], b = P + Ke(_, $), x += Y(_, b, l, d);
+    else {
+      var M = Ve(n);
+      if (typeof M == "function") {
+        M === n.entries && (At || Ee("Using Maps as children is deprecated and will be removed in a future major release. Consider converting children to an array of keyed ReactElements instead."), At = !0);
+        for (var H = M.call(n), N, _r = 0; !(N = H.next()).done; )
+          _ = N.value, b = P + Ke(_, _r++), x += Y(_, b, l, d);
+      } else if (y === "object") {
+        var Mt = "";
+        Mt = " If you meant to render a collection of children, use an array instead." + ee.getStackAddendum();
+        var rt = "" + n;
+        throw Error("Objects are not valid as a React child (found: " + (rt === "[object Object]" ? "object with keys {" + Object.keys(n).join(", ") + "}" : rt) + ")." + Mt);
+      }
+    }
+    return x;
+  }
+  function Je(n, a, l) {
+    return n == null ? 0 : Y(n, "", a, l);
+  }
+  function Ke(n, a) {
+    return typeof n == "object" && n !== null && n.key != null ? Ot(n.key) : a.toString(36);
+  }
+  function zt(n, a, l) {
+    var d = n.func, y = n.context;
+    d.call(y, a, n.count++);
+  }
+  function Yt(n, a, l) {
+    if (n == null)
+      return n;
+    var d = Re(null, null, a, l);
+    Je(n, zt, d), xe(d);
+  }
+  function Wt(n, a, l) {
+    var d = n.result, y = n.keyPrefix, E = n.func, _ = n.context, b = E.call(_, a, n.count++);
+    Array.isArray(b) ? Pe(b, d, l, function(x) {
+      return x;
+    }) : b != null && (re(b) && (b = wt(
+      b,
+      // Keep both the (mapped) and old keys if they differ, just as
+      // traverseAllChildren used to do for objects as children
+      y + (b.key && (!a || a.key !== b.key) ? Ce(b.key) + "/" : "") + l
+    )), d.push(b));
+  }
+  function Pe(n, a, l, d, y) {
+    var E = "";
+    l != null && (E = Ce(l) + "/");
+    var _ = Re(a, E, d, y);
+    Je(n, Wt, _), xe(_);
+  }
+  function St(n, a, l) {
+    if (n == null)
+      return n;
+    var d = [];
+    return Pe(n, d, null, a, l), d;
+  }
+  function W(n) {
+    return Je(n, function() {
+      return null;
+    }, null);
+  }
+  function Ht(n) {
+    var a = [];
+    return Pe(n, a, null, function(l) {
+      return l;
+    }), a;
+  }
+  function Jt(n) {
+    if (!re(n))
+      throw Error("React.Children.only expected to receive a single React element child.");
+    return n;
+  }
+  function Kt(n, a) {
+    a === void 0 ? a = null : a !== null && typeof a != "function" && A("createContext: Expected the optional second argument to be a function. Instead received: %s", a);
+    var l = {
+      $$typeof: O,
+      _calculateChangedBits: a,
+      // As a workaround to support multiple concurrent renderers, we categorize
+      // some renderers as primary and others as secondary. We only expect
+      // there to be two concurrent renderers at most: React Native (primary) and
+      // Fabric (secondary); React DOM (primary) and React ART (secondary).
+      // Secondary renderers store their context values on separate fields.
+      _currentValue: n,
+      _currentValue2: n,
+      // Used to track how many concurrent renderers this context currently
+      // supports within in a single renderer. Such as parallel server rendering.
+      _threadCount: 0,
+      // These are circular
+      Provider: null,
+      Consumer: null
+    };
+    l.Provider = {
+      $$typeof: g,
+      _context: l
+    };
+    var d = !1, y = !1;
+    {
+      var E = {
+        $$typeof: O,
+        _context: l,
+        _calculateChangedBits: l._calculateChangedBits
+      };
+      Object.defineProperties(E, {
+        Provider: {
+          get: function() {
+            return y || (y = !0, A("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?")), l.Provider;
+          },
+          set: function(_) {
+            l.Provider = _;
+          }
+        },
+        _currentValue: {
+          get: function() {
+            return l._currentValue;
+          },
+          set: function(_) {
+            l._currentValue = _;
+          }
+        },
+        _currentValue2: {
+          get: function() {
+            return l._currentValue2;
+          },
+          set: function(_) {
+            l._currentValue2 = _;
+          }
+        },
+        _threadCount: {
+          get: function() {
+            return l._threadCount;
+          },
+          set: function(_) {
+            l._threadCount = _;
+          }
+        },
+        Consumer: {
+          get: function() {
+            return d || (d = !0, A("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?")), l.Consumer;
+          }
+        }
+      }), l.Consumer = E;
+    }
+    return l._currentRenderer = null, l._currentRenderer2 = null, l;
+  }
+  function Xt(n) {
+    var a = {
+      $$typeof: _e,
+      _ctor: n,
+      // React uses these fields to store the result.
+      _status: -1,
+      _result: null
+    };
+    {
+      var l, d;
+      Object.defineProperties(a, {
+        defaultProps: {
+          configurable: !0,
+          get: function() {
+            return l;
+          },
+          set: function(y) {
+            A("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), l = y, Object.defineProperty(a, "defaultProps", {
+              enumerable: !0
+            });
+          }
+        },
+        propTypes: {
+          configurable: !0,
+          get: function() {
+            return d;
+          },
+          set: function(y) {
+            A("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), d = y, Object.defineProperty(a, "propTypes", {
+              enumerable: !0
+            });
+          }
+        }
+      });
+    }
+    return a;
+  }
+  function Zt(n) {
+    return n != null && n.$$typeof === Z ? A("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof n != "function" ? A("forwardRef requires a render function but was given %s.", n === null ? "null" : typeof n) : n.length !== 0 && n.length !== 2 && A("forwardRef render functions accept exactly two parameters: props and ref. %s", n.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."), n != null && (n.defaultProps != null || n.propTypes != null) && A("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?"), {
+      $$typeof: q,
+      render: n
+    };
+  }
+  function V(n) {
+    return typeof n == "string" || typeof n == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+    n === p || n === X || n === m || n === h || n === ve || n === me || typeof n == "object" && n !== null && (n.$$typeof === _e || n.$$typeof === Z || n.$$typeof === g || n.$$typeof === O || n.$$typeof === q || n.$$typeof === ut || n.$$typeof === ct || n.$$typeof === Le || n.$$typeof === ue);
+  }
+  function er(n, a) {
+    return V(n) || A("memo: The first argument must be a component. Instead received: %s", n === null ? "null" : typeof n), {
+      $$typeof: Z,
+      type: n,
+      compare: a === void 0 ? null : a
+    };
+  }
+  function D() {
+    var n = De.current;
+    if (n === null)
+      throw Error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem.`);
+    return n;
+  }
+  function tr(n, a) {
+    var l = D();
+    if (a !== void 0 && A("useContext() second argument is reserved for future use in React. Passing it is not supported. You passed: %s.%s", a, typeof a == "number" && Array.isArray(arguments[2]) ? `
+
+Did you call array.map(useContext)? Calling Hooks inside a loop is not supported. Learn more at https://fb.me/rules-of-hooks` : ""), n._context !== void 0) {
+      var d = n._context;
+      d.Consumer === n ? A("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?") : d.Provider === n && A("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
+    }
+    return l.useContext(n, a);
+  }
+  function rr(n) {
+    var a = D();
+    return a.useState(n);
+  }
+  function nr(n, a, l) {
+    var d = D();
+    return d.useReducer(n, a, l);
+  }
+  function ie(n) {
+    var a = D();
+    return a.useRef(n);
+  }
+  function ir(n, a) {
+    var l = D();
+    return l.useEffect(n, a);
+  }
+  function or(n, a) {
+    var l = D();
+    return l.useLayoutEffect(n, a);
+  }
+  function ar(n, a) {
+    var l = D();
+    return l.useCallback(n, a);
+  }
+  function sr(n, a) {
+    var l = D();
+    return l.useMemo(n, a);
+  }
+  function ur(n, a, l) {
+    var d = D();
+    return d.useImperativeHandle(n, a, l);
+  }
+  function oe(n, a) {
+    {
+      var l = D();
+      return l.useDebugValue(n, a);
+    }
+  }
+  var Xe;
+  Xe = !1;
+  function Tt() {
+    if (L.current) {
+      var n = F(L.current.type);
+      if (n)
+        return `
+
+Check the render method of \`` + n + "`.";
+    }
+    return "";
+  }
+  function cr(n) {
+    if (n !== void 0) {
+      var a = n.fileName.replace(/^.*[\\\/]/, ""), l = n.lineNumber;
+      return `
+
+Check your code at ` + a + ":" + l + ".";
+    }
+    return "";
+  }
+  function lr(n) {
+    return n != null ? cr(n.__source) : "";
+  }
+  var Ct = {};
+  function fr(n) {
+    var a = Tt();
+    if (!a) {
+      var l = typeof n == "string" ? n : n.displayName || n.name;
+      l && (a = `
+
+Check the top-level render call using <` + l + ">.");
+    }
+    return a;
+  }
+  function Ze(n, a) {
+    if (!(!n._store || n._store.validated || n.key != null)) {
+      n._store.validated = !0;
+      var l = fr(a);
+      if (!Ct[l]) {
+        Ct[l] = !0;
+        var d = "";
+        n && n._owner && n._owner !== L.current && (d = " It was passed a child from " + F(n._owner.type) + "."), te(n), A('Each child in a list should have a unique "key" prop.%s%s See https://fb.me/react-warning-keys for more information.', l, d), te(null);
+      }
+    }
+  }
+  function he(n, a) {
+    if (typeof n == "object") {
+      if (Array.isArray(n))
+        for (var l = 0; l < n.length; l++) {
+          var d = n[l];
+          re(d) && Ze(d, a);
+        }
+      else if (re(n))
+        n._store && (n._store.validated = !0);
+      else if (n) {
+        var y = Ve(n);
+        if (typeof y == "function" && y !== n.entries)
+          for (var E = y.call(n), _; !(_ = E.next()).done; )
+            re(_.value) && Ze(_.value, a);
+      }
+    }
+  }
+  function Rt(n) {
+    {
+      var a = n.type;
+      if (a == null || typeof a == "string")
+        return;
+      var l = F(a), d;
+      if (typeof a == "function")
+        d = a.propTypes;
+      else if (typeof a == "object" && (a.$$typeof === q || // Note: Memo only checks outer props here.
+      // Inner props are checked in the reconciler.
+      a.$$typeof === Z))
+        d = a.propTypes;
+      else
+        return;
+      d ? (te(n), e(d, n.props, "prop", l, ee.getStackAddendum), te(null)) : a.PropTypes !== void 0 && !Xe && (Xe = !0, A("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", l || "Unknown")), typeof a.getDefaultProps == "function" && !a.getDefaultProps.isReactClassApproved && A("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+    }
+  }
+  function et(n) {
+    {
+      te(n);
+      for (var a = Object.keys(n.props), l = 0; l < a.length; l++) {
+        var d = a[l];
+        if (d !== "children" && d !== "key") {
+          A("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", d);
+          break;
+        }
+      }
+      n.ref !== null && A("Invalid attribute `ref` supplied to `React.Fragment`."), te(null);
+    }
+  }
+  function xt(n, a, l) {
+    var d = V(n);
+    if (!d) {
+      var y = "";
+      (n === void 0 || typeof n == "object" && n !== null && Object.keys(n).length === 0) && (y += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+      var E = lr(a);
+      E ? y += E : y += Tt();
+      var _;
+      n === null ? _ = "null" : Array.isArray(n) ? _ = "array" : n !== void 0 && n.$$typeof === s ? (_ = "<" + (F(n.type) || "Unknown") + " />", y = " Did you accidentally export a JSX literal instead of a component?") : _ = typeof n, A("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", _, y);
+    }
+    var b = bt.apply(this, arguments);
+    if (b == null)
+      return b;
+    if (d)
+      for (var x = 2; x < arguments.length; x++)
+        he(arguments[x], n);
+    return n === p ? et(b) : Rt(b), b;
+  }
+  var Pt = !1;
+  function dr(n) {
+    var a = xt.bind(null, n);
+    return a.type = n, Pt || (Pt = !0, Ee("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.")), Object.defineProperty(a, "type", {
+      enumerable: !1,
+      get: function() {
+        return Ee("Factory.type is deprecated. Access the class directly before passing it to createFactory."), Object.defineProperty(this, "type", {
+          value: n
+        }), n;
+      }
+    }), a;
+  }
+  function pr(n, a, l) {
+    for (var d = Qt.apply(this, arguments), y = 2; y < arguments.length; y++)
+      he(arguments[y], d.type);
+    return Rt(d), d;
+  }
+  try {
+    var jt = Object.freeze({}), hr = /* @__PURE__ */ new Map([[jt, null]]), tt = /* @__PURE__ */ new Set([jt]);
+    hr.set(0, 0), tt.add(0);
+  } catch {
+  }
+  var gr = xt, yr = pr, vr = dr, mr = {
+    map: St,
+    forEach: Yt,
+    count: W,
+    toArray: Ht,
+    only: Jt
+  };
+  S.Children = mr, S.Component = z, S.Fragment = p, S.Profiler = m, S.PureComponent = Oe, S.StrictMode = h, S.Suspense = ve, S.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Ne, S.cloneElement = yr, S.createContext = Kt, S.createElement = gr, S.createFactory = vr, S.createRef = Ye, S.forwardRef = Zt, S.isValidElement = re, S.lazy = Xt, S.memo = er, S.useCallback = ar, S.useContext = tr, S.useDebugValue = oe, S.useEffect = ir, S.useImperativeHandle = ur, S.useLayoutEffect = or, S.useMemo = sr, S.useReducer = nr, S.useRef = ie, S.useState = rr, S.version = r;
+}();
+process.env.NODE_ENV === "production" ? it.exports = T : it.exports = S;
+var Me = it.exports, Ar = {
+  sdkSemver: "1.13.1",
+  techVersion: Me.version,
+  sdkCode: "J"
+}, La = (
+  /** @class */
+  function(t) {
+    Jn(e, t);
+    function e(r) {
+      var o = t.call(this, r) || this;
+      return o.imageRef = Me.createRef(), o;
+    }
+    return e.prototype.componentDidMount = function() {
+      this.htmlLayerInstance = new Oi(this.imageRef.current, this.props.cldImg, this.props.plugins, Ar);
+    }, e.prototype.componentDidUpdate = function() {
+      Lt(this.htmlLayerInstance.htmlPluginState), this.htmlLayerInstance.update(this.props.cldImg, this.props.plugins, Ar);
+    }, e.prototype.componentWillUnmount = function() {
+      Lt(this.htmlLayerInstance.htmlPluginState), this.htmlLayerInstance.unmount();
+    }, e.prototype.render = function() {
+      var r = this.props;
+      r.cldImg, r.plugins;
+      var o = Kn(r, ["cldImg", "plugins"]);
+      if (qr())
+        return Me.createElement("img", nt({ suppressHydrationWarning: !0 }, o, { ref: this.imageRef }));
+      var s = la(this.props.plugins, this.props.cldImg, Ar);
+      return Me.createElement("img", nt({}, o, { src: s }));
+    }, e;
+  }(Me.Component)
+), Fa = ["controls", "loop", "muted", "poster", "preload", "autoplay", "playsinline"];
+(function(t) {
+  Jn(e, t);
+  function e(r) {
+    var o = t.call(this, r) || this;
+    return o.videoRef = it.exports.createRef(), o.attachRef = o.attachRef.bind(o), o;
+  }
+  return e.prototype.componentDidMount = function() {
+    this.htmlVideoLayerInstance = new ea(this.videoRef && this.videoRef.current, this.props.cldVid, this.props.sources, this.props.plugins, this.getVideoAttributes(), this.props.cldPoster, {
+      useFetchFormat: this.props.useFetchFormat
+    });
+  }, e.prototype.componentDidUpdate = function() {
+    Lt(this.htmlVideoLayerInstance.htmlPluginState), this.htmlVideoLayerInstance.update(this.props.cldVid, this.props.sources, this.props.plugins, this.getVideoAttributes(), this.props.cldPoster);
+  }, e.prototype.componentWillUnmount = function() {
+    Lt(this.htmlVideoLayerInstance.htmlPluginState);
+  }, e.prototype.getVideoAttributes = function() {
+    var r = this, o = {};
+    return Fa.forEach(function(s) {
+      s in r.props && (o[s] = r.props[s]);
+    }), o;
+  }, e.prototype.attachRef = function(r) {
+    this.videoRef.current = r;
+    var o = this.props.innerRef;
+    o && (o instanceof Function ? o(r) : o.current = r);
+  }, e.prototype.render = function() {
+    var r = this.props;
+    r.cldVid, r.cldPoster, r.plugins, r.sources, r.innerRef, r.useFetchFormat;
+    var o = Kn(r, ["cldVid", "cldPoster", "plugins", "sources", "innerRef", "useFetchFormat"]);
+    return Me.createElement("video", nt({}, o, { ref: this.attachRef }));
+  }, e;
+})(it.exports.Component);
+const Va = ({
+  alt: t = "img",
+  height: e = "",
+  width: r = "",
+  plugins: o = [ia(), ua()],
+  publicId: s
+}) => {
+  const u = bi({ publicId: s });
+  return /* @__PURE__ */ mi(
+    La,
+    {
+      alt: t,
+      cldImg: u,
+      height: e,
+      plugins: o,
+      width: r
+    }
+  );
+}, Qa = _i.memo(Va);
+export {
+  Qa as M,
+  ua as p
+};