panjareh/pollyfills/polyfill.min.js

Panjareh using aparat and phoenix-video-player to play videos on desktops and tvs.

/* Polyfill service v3.109.0
 * Disable minification (remove `.min` from URL path) for more info */

(function (self, undefined) {
  function Call(t, l) {
    var n = arguments.length > 2 ? arguments[2] : [];
    if (!1 === IsCallable(t))
      throw new TypeError(
        Object.prototype.toString.call(t) + "is not a function."
      );
    return t.apply(l, n);
  }
  function CreateDataProperty(e, r, t) {
    var a = { value: t, writable: !0, enumerable: !0, configurable: !0 };
    try {
      return Object.defineProperty(e, r, a), !0;
    } catch (n) {
      return !1;
    }
  }
  function CreateMethodProperty(e, r, t) {
    var a = { value: t, writable: !0, enumerable: !1, configurable: !0 };
    Object.defineProperty(e, r, a);
  }
  function Get(n, t) {
    return n[t];
  }
  function HasOwnProperty(r, t) {
    return Object.prototype.hasOwnProperty.call(r, t);
  }
  function IsCallable(n) {
    return "function" == typeof n;
  }
  function SameValueNonNumber(e, n) {
    return e === n;
  }
  function ToBoolean(o) {
    return Boolean(o);
  }
  function ToObject(e) {
    if (null === e || e === undefined) throw TypeError();
    return Object(e);
  }
  function GetV(t, e) {
    return ToObject(t)[e];
  }
  function GetMethod(e, n) {
    var r = GetV(e, n);
    if (null === r || r === undefined) return undefined;
    if (!1 === IsCallable(r)) throw new TypeError("Method not callable: " + n);
    return r;
  }
  function Type(e) {
    switch (typeof e) {
      case "undefined":
        return "undefined";
      case "boolean":
        return "boolean";
      case "number":
        return "number";
      case "string":
        return "string";
      case "symbol":
        return "symbol";
      default:
        return null === e
          ? "null"
          : "Symbol" in self &&
            (e instanceof self.Symbol || e.constructor === self.Symbol)
          ? "symbol"
          : "object";
    }
  }
  function CreateIterResultObject(e, r) {
    if ("boolean" !== Type(r)) throw new Error();
    var t = {};
    return (
      CreateDataProperty(t, "value", e), CreateDataProperty(t, "done", r), t
    );
  }
  function GetPrototypeFromConstructor(t, o) {
    var r = Get(t, "prototype");
    return "object" !== Type(r) && (r = o), r;
  }
  function OrdinaryCreateFromConstructor(r, e) {
    var t = arguments[2] || {},
      o = GetPrototypeFromConstructor(r, e),
      a = Object.create(o);
    for (var n in t)
      Object.prototype.hasOwnProperty.call(t, n) &&
        Object.defineProperty(a, n, {
          configurable: !0,
          enumerable: !1,
          writable: !0,
          value: t[n],
        });
    return a;
  }
  function IteratorClose(r, t) {
    if ("object" !== Type(r["[[Iterator]]"]))
      throw new Error(
        Object.prototype.toString.call(r["[[Iterator]]"]) + "is not an Object."
      );
    var e = r["[[Iterator]]"],
      o = GetMethod(e, "return");
    if (o === undefined) return t;
    try {
      var n = Call(o, e);
    } catch (c) {
      var a = c;
    }
    if (t) return t;
    if (a) throw a;
    if ("object" !== Type(n))
      throw new TypeError("Iterator's return method returned a non-object.");
    return t;
  }
  function IteratorComplete(t) {
    if ("object" !== Type(t))
      throw new Error(Object.prototype.toString.call(t) + "is not an Object.");
    return ToBoolean(Get(t, "done"));
  }
  function IteratorNext(t) {
    if (arguments.length < 2)
      var e = Call(t["[[NextMethod]]"], t["[[Iterator]]"]);
    else e = Call(t["[[NextMethod]]"], t["[[Iterator]]"], [arguments[1]]);
    if ("object" !== Type(e)) throw new TypeError("bad iterator");
    return e;
  }
  function IteratorStep(t) {
    var r = IteratorNext(t);
    return !0 !== IteratorComplete(r) && r;
  }
  function IteratorValue(t) {
    if ("object" !== Type(t))
      throw new Error(Object.prototype.toString.call(t) + "is not an Object.");
    return Get(t, "value");
  }
  function OrdinaryToPrimitive(r, t) {
    if ("string" === t) var e = ["toString", "valueOf"];
    else e = ["valueOf", "toString"];
    for (var i = 0; i < e.length; ++i) {
      var n = e[i],
        a = Get(r, n);
      if (IsCallable(a)) {
        var o = Call(a, r);
        if ("object" !== Type(o)) return o;
      }
    }
    throw new TypeError("Cannot convert to primitive.");
  }
  function SameValueZero(n, e) {
    return (
      Type(n) === Type(e) &&
      ("number" === Type(n)
        ? !(!isNaN(n) || !isNaN(e)) ||
          (1 / n === Infinity && 1 / e == -Infinity) ||
          (1 / n == -Infinity && 1 / e === Infinity) ||
          n === e
        : SameValueNonNumber(n, e))
    );
  }
  function ToInteger(n) {
    if ("symbol" === Type(n))
      throw new TypeError("Cannot convert a Symbol value to a number");
    var t = Number(n);
    return isNaN(t)
      ? 0
      : 1 / t === Infinity ||
        1 / t == -Infinity ||
        t === Infinity ||
        t === -Infinity
      ? t
      : (t < 0 ? -1 : 1) * Math.floor(Math.abs(t));
  }
  function ToLength(n) {
    var t = ToInteger(n);
    return t <= 0 ? 0 : Math.min(t, Math.pow(2, 53) - 1);
  }
  function ToPrimitive(e) {
    var t = arguments.length > 1 ? arguments[1] : undefined;
    if ("object" === Type(e)) {
      if (arguments.length < 2) var i = "default";
      else t === String ? (i = "string") : t === Number && (i = "number");
      var r =
        "function" == typeof self.Symbol &&
        "symbol" == typeof self.Symbol.toPrimitive
          ? GetMethod(e, self.Symbol.toPrimitive)
          : undefined;
      if (r !== undefined) {
        var n = Call(r, e, [i]);
        if ("object" !== Type(n)) return n;
        throw new TypeError("Cannot convert exotic object to primitive.");
      }
      return "default" === i && (i = "number"), OrdinaryToPrimitive(e, i);
    }
    return e;
  }
  function ToString(t) {
    switch (Type(t)) {
      case "symbol":
        throw new TypeError("Cannot convert a Symbol value to a string");
      case "object":
        return ToString(ToPrimitive(t, String));
      default:
        return String(t);
    }
  }
  function ToPropertyKey(r) {
    var i = ToPrimitive(r, String);
    return "symbol" === Type(i) ? i : ToString(i);
  }
  CreateMethodProperty(Array.prototype, "includes", function e(r) {
    "use strict";
    var t = ToObject(this),
      o = ToLength(Get(t, "length"));
    if (0 === o) return !1;
    var n = ToInteger(arguments[1]);
    if (n >= 0) var a = n;
    else (a = o + n) < 0 && (a = 0);
    for (; a < o; ) {
      var i = Get(t, ToString(a));
      if (SameValueZero(r, i)) return !0;
      a += 1;
    }
    return !1;
  });
  !(function () {
    var e = Object.getOwnPropertyDescriptor,
      t = function () {
        try {
          return (
            1 ===
            Object.defineProperty(document.createElement("div"), "one", {
              get: function () {
                return 1;
              },
            }).one
          );
        } catch (e) {
          return !1;
        }
      },
      r = {}.toString,
      n = "".split;
    CreateMethodProperty(Object, "getOwnPropertyDescriptor", function c(o, i) {
      var a = ToObject(o);
      a =
        ("string" === Type(a) || a instanceof String) &&
        "[object String]" == r.call(o)
          ? n.call(o, "")
          : Object(o);
      var u = ToPropertyKey(i);
      if (t)
        try {
          return e(a, u);
        } catch (l) {}
      if (HasOwnProperty(a, u))
        return { enumerable: !0, configurable: !0, writable: !0, value: a[u] };
    });
  })();
  CreateMethodProperty(
    Object,
    "keys",
    (function () {
      "use strict";
      function t() {
        var t;
        try {
          t = Object.create({});
        } catch (r) {
          return !0;
        }
        return o.call(t, "__proto__");
      }
      function r(t) {
        var r = n.call(t),
          e = "[object Arguments]" === r;
        return (
          e ||
            (e =
              "[object Array]" !== r &&
              null !== t &&
              "object" == typeof t &&
              "number" == typeof t.length &&
              t.length >= 0 &&
              "[object Function]" === n.call(t.callee)),
          e
        );
      }
      var e = Object.prototype.hasOwnProperty,
        n = Object.prototype.toString,
        o = Object.prototype.propertyIsEnumerable,
        c = !o.call({ toString: null }, "toString"),
        l = o.call(function () {}, "prototype"),
        i = [
          "toString",
          "toLocaleString",
          "valueOf",
          "hasOwnProperty",
          "isPrototypeOf",
          "propertyIsEnumerable",
          "constructor",
        ],
        u = function (t) {
          var r = t.constructor;
          return r && r.prototype === t;
        },
        a = {
          $console: !0,
          $external: !0,
          $frame: !0,
          $frameElement: !0,
          $frames: !0,
          $innerHeight: !0,
          $innerWidth: !0,
          $outerHeight: !0,
          $outerWidth: !0,
          $pageXOffset: !0,
          $pageYOffset: !0,
          $parent: !0,
          $scrollLeft: !0,
          $scrollTop: !0,
          $scrollX: !0,
          $scrollY: !0,
          $self: !0,
          $webkitIndexedDB: !0,
          $webkitStorageInfo: !0,
          $window: !0,
        },
        f = (function () {
          if ("undefined" == typeof window) return !1;
          for (var t in window)
            try {
              if (
                !a["$" + t] &&
                e.call(window, t) &&
                null !== window[t] &&
                "object" == typeof window[t]
              )
                try {
                  u(window[t]);
                } catch (r) {
                  return !0;
                }
            } catch (r) {
              return !0;
            }
          return !1;
        })(),
        p = function (t) {
          if ("undefined" == typeof window || !f) return u(t);
          try {
            return u(t);
          } catch (r) {
            return !1;
          }
        };
      return function s(o) {
        var u = "[object Function]" === n.call(o),
          a = r(o),
          f = "[object String]" === n.call(o),
          s = [];
        if (o === undefined || null === o)
          throw new TypeError("Cannot convert undefined or null to object");
        var y = l && u;
        if (f && o.length > 0 && !e.call(o, 0))
          for (var h = 0; h < o.length; ++h) s.push(String(h));
        if (a && o.length > 0)
          for (var g = 0; g < o.length; ++g) s.push(String(g));
        else
          for (var w in o)
            (t() && "__proto__" === w) ||
              (y && "prototype" === w) ||
              !e.call(o, w) ||
              s.push(String(w));
        if (c)
          for (var d = p(o), $ = 0; $ < i.length; ++$)
            (d && "constructor" === i[$]) || !e.call(o, i[$]) || s.push(i[$]);
        return s;
      };
    })()
  );
  !(function () {
    var t = {}.toString,
      e = "".split,
      r = [].concat,
      o = Object.prototype.hasOwnProperty,
      c = Object.getOwnPropertyNames || Object.keys,
      n = "object" == typeof self ? c(self) : [];
    CreateMethodProperty(Object, "getOwnPropertyNames", function l(a) {
      var p = ToObject(a);
      if ("[object Window]" === t.call(p))
        try {
          return c(p);
        } catch (j) {
          return r.call([], n);
        }
      p = "[object String]" == t.call(p) ? e.call(p, "") : Object(p);
      for (
        var i = c(p), s = ["length", "prototype"], O = 0;
        O < s.length;
        O++
      ) {
        var b = s[O];
        o.call(p, b) && !i.includes(b) && i.push(b);
      }
      if (i.includes("__proto__")) {
        var f = i.indexOf("__proto__");
        i.splice(f, 1);
      }
      return i;
    });
  })();
  !(function (e, r, n) {
    "use strict";
    function t(e) {
      if ("symbol" === Type(e)) return e;
      throw TypeError(e + " is not a symbol");
    }
    var u,
      o = (function () {
        try {
          var r = {};
          return (
            e.defineProperty(r, "t", {
              configurable: !0,
              enumerable: !1,
              get: function () {
                return !0;
              },
              set: undefined,
            }),
            !!r.t
          );
        } catch (n) {
          return !1;
        }
      })(),
      i = 0,
      a = "" + Math.random(),
      c = "__
symbol:",
      l = c.length,
      f = "__
symbol@@" + a,
      s = {},
      v = "defineProperty",
      y = "defineProperties",
      b = "getOwnPropertyNames",
      p = "getOwnPropertyDescriptor",
      h = "propertyIsEnumerable",
      m = e.prototype,
      d = m.hasOwnProperty,
      g = m[h],
      w = m.toString,
      S = Array.prototype.concat,
      P = e.getOwnPropertyNames ? e.getOwnPropertyNames(self) : [],
      O = e[b],
      j = function $(e) {
        if ("[object Window]" === w.call(e))
          try {
            return O(e);
          } catch (r) {
            return S.call([], P);
          }
        return O(e);
      },
      E = e[p],
      N = e.create,
      T = e.keys,
      _ = e.freeze || e,
      k = e[v],
      F = e[y],
      I = E(e, b),
      x = function (e, r, n) {
        if (!d.call(e, f))
          try {
            k(e, f, {
              enumerable: !1,
              configurable: !1,
              writable: !1,
              value: {},
            });
          } catch (t) {
            e[f] = {};
          }
        e[f]["@@" + r] = n;
      },
      z = function (e, r) {
        var n = N(e);
        return (
          j(r).forEach(function (e) {
            q.call(r, e) && L(n, e, r[e]);
          }),
          n
        );
      },
      A = function (e) {
        var r = N(e);
        return (r.enumerable = !1), r;
      },
      D = function ee() {},
      M = function (e) {
        return e != f && !d.call(H, e);
      },
      W = function (e) {
        return e != f && d.call(H, e);
      },
      q = function re(e) {
        var r = "" + e;
        return W(r)
          ? d.call(this, r) && this[f] && this[f]["@@" + r]
          : g.call(this, e);
      },
      B = function (r) {
        var n = {
          enumerable: !1,
          configurable: !0,
          get: D,
          set: function (e) {
            u(this, r, {
              enumerable: !1,
              configurable: !0,
              writable: !0,
              value: e,
            }),
              x(this, r, !0);
          },
        };
        try {
          k(m, r, n);
        } catch (o) {
          m[r] = n.value;
        }
        H[r] = k(e(r), "constructor", J);
        var t = E(G.prototype, "description");
        return t && k(H[r], "description", t), _(H[r]);
      },
      C = function (e) {
        var r = t(e);
        if (Y) {
          var n = V(r);
          if ("" !== n) return n.slice(1, -1);
        }
        if (s[r] !== undefined) return s[r];
        var u = r.toString(),
          o = u.lastIndexOf("0.");
        return (u = u.slice(10, o)), "" === u ? undefined : u;
      },
      G = function ne() {
        var r = arguments[0];
        if (this instanceof ne)
          throw new TypeError("Symbol is not a constructor");
        var n = c.concat(r || "", a, ++i);
        r === undefined ||
          (null !== r && !isNaN(r) && "" !== String(r)) ||
          (s[n] = String(r));
        var t = B(n);
        return (
          o ||
            e.defineProperty(t, "description", {
              configurable: !0,
              enumerable: !1,
              value: C(t),
            }),
          t
        );
      },
      H = N(null),
      J = { value: G },
      K = function (e) {
        return H[e];
      },
      L = function te(e, r, n) {
        var t = "" + r;
        return (
          W(t)
            ? (u(e, t, n.enumerable ? A(n) : n), x(e, t, !!n.enumerable))
            : k(e, r, n),
          e
        );
      },
      Q = function (e) {
        return function (r) {
          return d.call(e, f) && d.call(e[f], "@@" + r);
        };
      },
      R = function ue(e) {
        return j(e)
          .filter(e === m ? Q(e) : W)
          .map(K);
      };
    (I.value = L),
      k(e, v, I),
      (I.value = R),
      k(e, "getOwnPropertySymbols", I),
      (I.value = function oe(e) {
        return j(e).filter(M);
      }),
      k(e, b, I),
      (I.value = function ie(e, r) {
        var n = R(r);
        return (
          n.length
            ? T(r)
                .concat(n)
                .forEach(function (n) {
                  q.call(r, n) && L(e, n, r[n]);
                })
            : F(e, r),
          e
        );
      }),
      k(e, y, I),
      (I.value = q),
      k(m, h, I),
      (I.value = G),
      k(n, "Symbol", I),
      (I.value = function (e) {
        var r = c.concat(c, e, a);
        return r in m ? H[r] : B(r);
      }),
      k(G, "for", I),
      (I.value = function (e) {
        if (M(e)) throw new TypeError(e + " is not a symbol");
        return d.call(H, e) ? e.slice(2 * l, -a.length) : void 0;
      }),
      k(G, "keyFor", I),
      (I.value = function ae(e, r) {
        var n = E(e, r);
        return n && W(r) && (n.enumerable = q.call(e, r)), n;
      }),
      k(e, p, I),
      (I.value = function ce(e, r) {
        return 1 === arguments.length || void 0 === r ? N(e) : z(e, r);
      }),
      k(e, "create", I);
    var U =
      null ===
      function () {
        return this;
      }.call(null);
    if (
      ((I.value = U
        ? function () {
            var e = w.call(this);
            return "[object String]" === e && W(this) ? "[object Symbol]" : e;
          }
        : function () {
            if (this === window) return "[object Null]";
            var e = w.call(this);
            return "[object String]" === e && W(this) ? "[object Symbol]" : e;
          }),
      k(m, "toString", I),
      (u = function (e, r, n) {
        var t = E(m, r);
        delete m[r], k(e, r, n), e !== m && k(m, r, t);
      }),
      (function () {
        try {
          var r = {};
          return (
            e.defineProperty(r, "t", {
              configurable: !0,
              enumerable: !1,
              get: function () {
                return !0;
              },
              set: undefined,
            }),
            !!r.t
          );
        } catch (n) {
          return !1;
        }
      })())
    ) {
      var V;
      try {
        V = Function("s", "var v = s.valueOf(); return { [v]() {} }[v].name;");
      } catch (Z) {}
      var X = function () {},
        Y = V && "inferred" === X.name ? V : null;
      e.defineProperty(n.Symbol.prototype, "description", {
        configurable: !0,
        enumerable: !1,
        get: function () {
          return C(this);
        },
      });
    }
  })(Object, 0, self);
  Object.defineProperty(self.Symbol, "iterator", {
    value: self.Symbol("iterator"),
  });
  function GetIterator(t) {
    var e = arguments.length > 1 ? arguments[1] : GetMethod(t, Symbol.iterator),
      r = Call(e, t);
    if ("object" !== Type(r)) throw new TypeError("bad iterator");
    var o = GetV(r, "next"),
      a = Object.create(null);
    return (
      (a["[[Iterator]]"] = r),
      (a["[[NextMethod]]"] = o),
      (a["[[Done]]"] = !1),
      a
    );
  }
  Object.defineProperty(Symbol, "species", { value: Symbol("species") });
  !(function (e) {
    function t(e, t) {
      if ("object" != typeof e)
        throw new TypeError(
          "createSetIterator called on incompatible receiver " +
            Object.prototype.toString.call(e)
        );
      if (!0 !== e._es6Set)
        throw new TypeError(
          "createSetIterator called on incompatible receiver " +
            Object.prototype.toString.call(e)
        );
      var r = Object.create(i);
      return (
        Object.defineProperty(r, "[[IteratedSet]]", {
          configurable: !0,
          enumerable: !1,
          writable: !0,
          value: e,
        }),
        Object.defineProperty(r, "[[SetNextIndex]]", {
          configurable: !0,
          enumerable: !1,
          writable: !0,
          value: 0,
        }),
        Object.defineProperty(r, "[[SetIterationKind]]", {
          configurable: !0,
          enumerable: !1,
          writable: !0,
          value: t,
        }),
        r
      );
    }
    var r = (function () {
        try {
          var e = {};
          return (
            Object.defineProperty(e, "t", {
              configurable: !0,
              enumerable: !1,
              get: function () {
                return !0;
              },
              set: undefined,
            }),
            !!e.t
          );
        } catch (t) {
          return !1;
        }
      })(),
      o = Symbol("undef"),
      n = function c() {
        if (!(this instanceof c))
          throw new TypeError('Constructor Set requires "new"');
        var e = OrdinaryCreateFromConstructor(this, c.prototype, {
          _values: [],
          _size: 0,
          _es6Set: !0,
        });
        r ||
          Object.defineProperty(e, "size", {
            configurable: !0,
            enumerable: !1,
            writable: !0,
            value: 0,
          });
        var t = arguments.length > 0 ? arguments[0] : undefined;
        if (null === t || t === undefined) return e;
        var o = e.add;
        if (!IsCallable(o))
          throw new TypeError("Set.prototype.add is not a function");
        try {
          for (var n = GetIterator(t); ; ) {
            var a = IteratorStep(n);
            if (!1 === a) return e;
            var i = IteratorValue(a);
            try {
              o.call(e, i);
            } catch (y) {
              return IteratorClose(n, y);
            }
          }
        } catch (y) {
          if (
            !Array.isArray(t) &&
            "[object Arguments]" !== Object.prototype.toString.call(t) &&
            !t.callee
          )
            throw y;
          var l,
            p = t.length;
          for (l = 0; l < p; l++) o.call(e, t[l]);
        }
        return e;
      };
    Object.defineProperty(n, "prototype", {
      configurable: !1,
      enumerable: !1,
      writable: !1,
      value: {},
    }),
      r
        ? Object.defineProperty(n, Symbol.species, {
            configurable: !0,
            enumerable: !1,
            get: function () {
              return this;
            },
            set: undefined,
          })
        : CreateMethodProperty(n, Symbol.species, n),
      CreateMethodProperty(n.prototype, "add", function p(e) {
        var t = this;
        if ("object" != typeof t)
          throw new TypeError(
            "Method Set.prototype.add called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        if (!0 !== t._es6Set)
          throw new TypeError(
            "Method Set.prototype.add called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        for (var n = t._values, a = 0; a < n.length; a++) {
          var i = n[a];
          if (i !== o && SameValueZero(i, e)) return t;
        }
        return (
          0 === e && 1 / e == -Infinity && (e = 0),
          t._values.push(e),
          (this._size = ++this._size),
          r || (this.size = this._size),
          t
        );
      }),
      CreateMethodProperty(n.prototype, "clear", function y() {
        var e = this;
        if ("object" != typeof e)
          throw new TypeError(
            "Method Set.prototype.clear called on incompatible receiver " +
              Object.prototype.toString.call(e)
          );
        if (!0 !== e._es6Set)
          throw new TypeError(
            "Method Set.prototype.clear called on incompatible receiver " +
              Object.prototype.toString.call(e)
          );
        for (var t = e._values, n = 0; n < t.length; n++) t[n] = o;
        return (this._size = 0), r || (this.size = this._size), undefined;
      }),
      CreateMethodProperty(n.prototype, "constructor", n),
      CreateMethodProperty(n.prototype, "delete", function (e) {
        var t = this;
        if ("object" != typeof t)
          throw new TypeError(
            "Method Set.prototype.delete called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        if (!0 !== t._es6Set)
          throw new TypeError(
            "Method Set.prototype.delete called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        for (var n = t._values, a = 0; a < n.length; a++) {
          var i = n[a];
          if (i !== o && SameValueZero(i, e))
            return (
              (n[a] = o),
              (this._size = --this._size),
              r || (this.size = this._size),
              !0
            );
        }
        return !1;
      }),
      CreateMethodProperty(n.prototype, "entries", function u() {
        return t(this, "key+value");
      }),
      CreateMethodProperty(n.prototype, "forEach", function f(e) {
        var t = this;
        if ("object" != typeof t)
          throw new TypeError(
            "Method Set.prototype.forEach called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        if (!0 !== t._es6Set)
          throw new TypeError(
            "Method Set.prototype.forEach called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        if (!IsCallable(e))
          throw new TypeError(
            Object.prototype.toString.call(e) + " is not a function."
          );
        if (arguments[1]) var r = arguments[1];
        for (var n = t._values, a = 0; a < n.length; a++) {
          var i = n[a];
          i !== o && e.call(r, i, i, t);
        }
        return undefined;
      }),
      CreateMethodProperty(n.prototype, "has", function d(e) {
        var t = this;
        if ("object" != typeof t)
          throw new TypeError(
            "Method Set.prototype.forEach called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        if (!0 !== t._es6Set)
          throw new TypeError(
            "Method Set.prototype.forEach called on incompatible receiver " +
              Object.prototype.toString.call(t)
          );
        for (var r = t._values, n = 0; n < r.length; n++) {
          var a = r[n];
          if (a !== o && SameValueZero(a, e)) return !0;
        }
        return !1;
      });
    var a = function h() {
      return t(this, "value");
    };
    CreateMethodProperty(n.prototype, "values", a),
      CreateMethodProperty(n.prototype, "keys", a),
      r &&
        Object.defineProperty(n.prototype, "size", {
          configurable: !0,
          enumerable: !1,
          get: function () {
            var e = this;
            if ("object" != typeof e)
              throw new TypeError(
                "Method Set.prototype.size called on incompatible receiver " +
                  Object.prototype.toString.call(e)
              );
            if (!0 !== e._es6Set)
              throw new TypeError(
                "Method Set.prototype.size called on incompatible receiver " +
                  Object.prototype.toString.call(e)
              );
            for (var t = e._values, r = 0, n = 0; n < t.length; n++) {
              t[n] !== o && (r += 1);
            }
            return r;
          },
          set: undefined,
        }),
      CreateMethodProperty(n.prototype, Symbol.iterator, a),
      "name" in n ||
        Object.defineProperty(n, "name", {
          configurable: !0,
          enumerable: !1,
          writable: !1,
          value: "Set",
        });
    var i = {};
    Object.defineProperty(i, "isSetIterator", {
      configurable: !1,
      enumerable: !1,
      writable: !1,
      value: !0,
    }),
      CreateMethodProperty(i, "next", function b() {
        var e = this;
        if ("object" != typeof e)
          throw new TypeError(
            "Method %SetIteratorPrototype%.next called on incompatible receiver " +
              Object.prototype.toString.call(e)
          );
        if (!e.isSetIterator)
          throw new TypeError(
            "Method %SetIteratorPrototype%.next called on incompatible receiver " +
              Object.prototype.toString.call(e)
          );
        var t = e["[[IteratedSet]]"],
          r = e["[[SetNextIndex]]"],
          n = e["[[SetIterationKind]]"];
        if (t === undefined) return CreateIterResultObject(undefined, !0);
        if (!t._es6Set)
          throw new Error(
            Object.prototype.toString.call(t) +
              " does not have [[SetData]] internal slot."
          );
        for (var a = t._values, i = a.length; r < i; ) {
          var l = a[r];
          if (((r += 1), (e["[[SetNextIndex]]"] = r), l !== o))
            return "key+value" === n
              ? CreateIterResultObject([l, l], !1)
              : CreateIterResultObject(l, !1);
        }
        return (
          (e["[[IteratedSet]]"] = undefined),
          CreateIterResultObject(undefined, !0)
        );
      }),
      CreateMethodProperty(i, Symbol.iterator, function s() {
        return this;
      });
    try {
      CreateMethodProperty(e, "Set", n);
    } catch (l) {
      e.Set = n;
    }
  })(self);
})(
  ("object" === typeof window && window) ||
    ("object" === typeof self && self) ||
    ("object" === typeof global && global) ||
    {}
);