@m4l/components 0.1.12 → 0.1.13

package/react-lazy-load-image-component.45b56650.js

@@ -0,0 +1,784 @@
+import Ce from "react";
+import Me from "react-dom";
+var Be = { exports: {} };
+(() => {
+  var Ie = { 296: (y, f, c) => {
+    var te = /^\s+|\s+$/g, X = /^[-+]0x[0-9a-f]+$/i, A = /^0b[01]+$/i, w = /^0o[0-7]+$/i, D = parseInt, Z = typeof c.g == "object" && c.g && c.g.Object === Object && c.g, ie = typeof self == "object" && self && self.Object === Object && self, oe = Z || ie || Function("return this")(), se = Object.prototype.toString, re = Math.max, ue = Math.min, U = function() {
+      return oe.Date.now();
+    };
+    function N(p) {
+      var a = typeof p;
+      return !!p && (a == "object" || a == "function");
+    }
+    function G(p) {
+      if (typeof p == "number")
+        return p;
+      if (function(j) {
+        return typeof j == "symbol" || function(_) {
+          return !!_ && typeof _ == "object";
+        }(j) && se.call(j) == "[object Symbol]";
+      }(p))
+        return NaN;
+      if (N(p)) {
+        var a = typeof p.valueOf == "function" ? p.valueOf() : p;
+        p = N(a) ? a + "" : a;
+      }
+      if (typeof p != "string")
+        return p === 0 ? p : +p;
+      p = p.replace(te, "");
+      var P = A.test(p);
+      return P || w.test(p) ? D(p.slice(2), P ? 2 : 8) : X.test(p) ? NaN : +p;
+    }
+    y.exports = function(p, a, P) {
+      var j, _, C, F, O, L, M = 0, q = !1, V = !1, W = !0;
+      if (typeof p != "function")
+        throw new TypeError("Expected a function");
+      function S(v) {
+        var B = j, Y = _;
+        return j = _ = void 0, M = v, F = p.apply(Y, B);
+      }
+      function z(v) {
+        return M = v, O = setTimeout(J, a), q ? S(v) : F;
+      }
+      function H(v) {
+        var B = v - L;
+        return L === void 0 || B >= a || B < 0 || V && v - M >= C;
+      }
+      function J() {
+        var v = U();
+        if (H(v))
+          return K(v);
+        O = setTimeout(J, function(B) {
+          var Y = a - (B - L);
+          return V ? ue(Y, C - (B - M)) : Y;
+        }(v));
+      }
+      function K(v) {
+        return O = void 0, W && j ? S(v) : (j = _ = void 0, F);
+      }
+      function ee() {
+        var v = U(), B = H(v);
+        if (j = arguments, _ = this, L = v, B) {
+          if (O === void 0)
+            return z(L);
+          if (V)
+            return O = setTimeout(J, a), S(L);
+        }
+        return O === void 0 && (O = setTimeout(J, a)), F;
+      }
+      return a = G(a) || 0, N(P) && (q = !!P.leading, C = (V = "maxWait" in P) ? re(G(P.maxWait) || 0, a) : C, W = "trailing" in P ? !!P.trailing : W), ee.cancel = function() {
+        O !== void 0 && clearTimeout(O), M = 0, j = L = _ = O = void 0;
+      }, ee.flush = function() {
+        return O === void 0 ? F : K(U());
+      }, ee;
+    };
+  }, 96: (y, f, c) => {
+    var te = "Expected a function", X = /^\s+|\s+$/g, A = /^[-+]0x[0-9a-f]+$/i, w = /^0b[01]+$/i, D = /^0o[0-7]+$/i, Z = parseInt, ie = typeof c.g == "object" && c.g && c.g.Object === Object && c.g, oe = typeof self == "object" && self && self.Object === Object && self, se = ie || oe || Function("return this")(), re = Object.prototype.toString, ue = Math.max, U = Math.min, N = function() {
+      return se.Date.now();
+    };
+    function G(a) {
+      var P = typeof a;
+      return !!a && (P == "object" || P == "function");
+    }
+    function p(a) {
+      if (typeof a == "number")
+        return a;
+      if (function(_) {
+        return typeof _ == "symbol" || function(C) {
+          return !!C && typeof C == "object";
+        }(_) && re.call(_) == "[object Symbol]";
+      }(a))
+        return NaN;
+      if (G(a)) {
+        var P = typeof a.valueOf == "function" ? a.valueOf() : a;
+        a = G(P) ? P + "" : P;
+      }
+      if (typeof a != "string")
+        return a === 0 ? a : +a;
+      a = a.replace(X, "");
+      var j = w.test(a);
+      return j || D.test(a) ? Z(a.slice(2), j ? 2 : 8) : A.test(a) ? NaN : +a;
+    }
+    y.exports = function(a, P, j) {
+      var _ = !0, C = !0;
+      if (typeof a != "function")
+        throw new TypeError(te);
+      return G(j) && (_ = "leading" in j ? !!j.leading : _, C = "trailing" in j ? !!j.trailing : C), function(F, O, L) {
+        var M, q, V, W, S, z, H = 0, J = !1, K = !1, ee = !0;
+        if (typeof F != "function")
+          throw new TypeError(te);
+        function v(x) {
+          var $ = M, le = q;
+          return M = q = void 0, H = x, W = F.apply(le, $);
+        }
+        function B(x) {
+          return H = x, S = setTimeout(ce, O), J ? v(x) : W;
+        }
+        function Y(x) {
+          var $ = x - z;
+          return z === void 0 || $ >= O || $ < 0 || K && x - H >= V;
+        }
+        function ce() {
+          var x = N();
+          if (Y(x))
+            return pe(x);
+          S = setTimeout(ce, function($) {
+            var le = O - ($ - z);
+            return K ? U(le, V - ($ - H)) : le;
+          }(x));
+        }
+        function pe(x) {
+          return S = void 0, ee && M ? v(x) : (M = q = void 0, W);
+        }
+        function ae() {
+          var x = N(), $ = Y(x);
+          if (M = arguments, q = this, z = x, $) {
+            if (S === void 0)
+              return B(z);
+            if (K)
+              return S = setTimeout(ce, O), v(z);
+          }
+          return S === void 0 && (S = setTimeout(ce, O)), W;
+        }
+        return O = p(O) || 0, G(L) && (J = !!L.leading, V = (K = "maxWait" in L) ? ue(p(L.maxWait) || 0, O) : V, ee = "trailing" in L ? !!L.trailing : ee), ae.cancel = function() {
+          S !== void 0 && clearTimeout(S), H = 0, M = z = q = S = void 0;
+        }, ae.flush = function() {
+          return S === void 0 ? W : pe(N());
+        }, ae;
+      }(a, P, { leading: _, maxWait: P, trailing: C });
+    };
+  }, 703: (y, f, c) => {
+    var te = c(414);
+    function X() {
+    }
+    function A() {
+    }
+    A.resetWarningCache = X, y.exports = function() {
+      function w(ie, oe, se, re, ue, U) {
+        if (U !== te) {
+          var N = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");
+          throw N.name = "Invariant Violation", N;
+        }
+      }
+      function D() {
+        return w;
+      }
+      w.isRequired = w;
+      var Z = { array: w, bool: w, func: w, number: w, object: w, string: w, symbol: w, any: w, arrayOf: D, element: w, elementType: w, instanceOf: D, node: w, objectOf: D, oneOf: D, oneOfType: D, shape: D, exact: D, checkPropTypes: A, resetWarningCache: X };
+      return Z.PropTypes = Z, Z;
+    };
+  }, 697: (y, f, c) => {
+    y.exports = c(703)();
+  }, 414: (y) => {
+    y.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  } }, Oe = {};
+  function E(y) {
+    var f = Oe[y];
+    if (f !== void 0)
+      return f.exports;
+    var c = Oe[y] = { exports: {} };
+    return Ie[y](c, c.exports, E), c.exports;
+  }
+  E.n = (y) => {
+    var f = y && y.__esModule ? () => y.default : () => y;
+    return E.d(f, { a: f }), f;
+  }, E.d = (y, f) => {
+    for (var c in f)
+      E.o(f, c) && !E.o(y, c) && Object.defineProperty(y, c, { enumerable: !0, get: f[c] });
+  }, E.g = function() {
+    if (typeof globalThis == "object")
+      return globalThis;
+    try {
+      return this || new Function("return this")();
+    } catch {
+      if (typeof window == "object")
+        return window;
+    }
+  }(), E.o = (y, f) => Object.prototype.hasOwnProperty.call(y, f), E.r = (y) => {
+    typeof Symbol < "u" && Symbol.toStringTag && Object.defineProperty(y, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(y, "__esModule", { value: !0 });
+  };
+  var de = {};
+  (() => {
+    E.r(de), E.d(de, { LazyLoadComponent: () => Pe, LazyLoadImage: () => Ne, trackWindowScroll: () => J });
+    const y = Ce;
+    var f = E.n(y), c = E(697);
+    const te = Me;
+    var X = E.n(te);
+    function A() {
+      return typeof window < "u" && "IntersectionObserver" in window && "isIntersecting" in window.IntersectionObserverEntry.prototype;
+    }
+    function w(r) {
+      return (w = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+        return typeof e;
+      } : function(e) {
+        return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+      })(r);
+    }
+    function D(r, e) {
+      var i = Object.keys(r);
+      if (Object.getOwnPropertySymbols) {
+        var n = Object.getOwnPropertySymbols(r);
+        e && (n = n.filter(function(I) {
+          return Object.getOwnPropertyDescriptor(r, I).enumerable;
+        })), i.push.apply(i, n);
+      }
+      return i;
+    }
+    function Z(r, e, i) {
+      return e in r ? Object.defineProperty(r, e, { value: i, enumerable: !0, configurable: !0, writable: !0 }) : r[e] = i, r;
+    }
+    function ie(r, e) {
+      for (var i = 0; i < e.length; i++) {
+        var n = e[i];
+        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, n.key, n);
+      }
+    }
+    function oe(r, e) {
+      return (oe = Object.setPrototypeOf || function(i, n) {
+        return i.__proto__ = n, i;
+      })(r, e);
+    }
+    function se(r, e) {
+      if (e && (w(e) === "object" || typeof e == "function"))
+        return e;
+      if (e !== void 0)
+        throw new TypeError("Derived constructors may only return object or undefined");
+      return function(i) {
+        if (i === void 0)
+          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return i;
+      }(r);
+    }
+    function re(r) {
+      return (re = Object.setPrototypeOf ? Object.getPrototypeOf : function(e) {
+        return e.__proto__ || Object.getPrototypeOf(e);
+      })(r);
+    }
+    var ue = function(r) {
+      r.forEach(function(e) {
+        e.isIntersecting && e.target.onVisible();
+      });
+    }, U = {}, N = function(r) {
+      (function(t, o) {
+        if (typeof o != "function" && o !== null)
+          throw new TypeError("Super expression must either be null or a function");
+        t.prototype = Object.create(o && o.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), o && oe(t, o);
+      })(b, r);
+      var e, i, n, I, Q = (n = b, I = function() {
+        if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+          return !1;
+        if (typeof Proxy == "function")
+          return !0;
+        try {
+          return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+          })), !0;
+        } catch {
+          return !1;
+        }
+      }(), function() {
+        var t, o = re(n);
+        if (I) {
+          var s = re(this).constructor;
+          t = Reflect.construct(o, arguments, s);
+        } else
+          t = o.apply(this, arguments);
+        return se(this, t);
+      });
+      function b(t) {
+        var o;
+        if (function(u, l) {
+          if (!(u instanceof l))
+            throw new TypeError("Cannot call a class as a function");
+        }(this, b), (o = Q.call(this, t)).supportsObserver = !t.scrollPosition && t.useIntersectionObserver && A(), o.supportsObserver) {
+          var s = t.threshold;
+          o.observer = function(u) {
+            return U[u] = U[u] || new IntersectionObserver(ue, { rootMargin: u + "px" }), U[u];
+          }(s);
+        }
+        return o;
+      }
+      return e = b, (i = [{ key: "componentDidMount", value: function() {
+        this.placeholder && this.observer && (this.placeholder.onVisible = this.props.onVisible, this.observer.observe(this.placeholder)), this.supportsObserver || this.updateVisibility();
+      } }, { key: "componentWillUnmount", value: function() {
+        this.observer && this.observer.unobserve(this.placeholder);
+      } }, { key: "componentDidUpdate", value: function() {
+        this.supportsObserver || this.updateVisibility();
+      } }, { key: "getPlaceholderBoundingBox", value: function() {
+        var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.props.scrollPosition, o = this.placeholder.getBoundingClientRect(), s = X().findDOMNode(this.placeholder).style, u = { left: parseInt(s.getPropertyValue("margin-left"), 10) || 0, top: parseInt(s.getPropertyValue("margin-top"), 10) || 0 };
+        return { bottom: t.y + o.bottom + u.top, left: t.x + o.left + u.left, right: t.x + o.right + u.left, top: t.y + o.top + u.top };
+      } }, { key: "isPlaceholderInViewport", value: function() {
+        if (typeof window > "u" || !this.placeholder)
+          return !1;
+        var t = this.props, o = t.scrollPosition, s = t.threshold, u = this.getPlaceholderBoundingBox(o), l = o.y + window.innerHeight, d = o.x, m = o.x + window.innerWidth, g = o.y;
+        return Boolean(g - s <= u.bottom && l + s >= u.top && d - s <= u.right && m + s >= u.left);
+      } }, { key: "updateVisibility", value: function() {
+        this.isPlaceholderInViewport() && this.props.onVisible();
+      } }, { key: "render", value: function() {
+        var t = this, o = this.props, s = o.className, u = o.height, l = o.placeholder, d = o.style, m = o.width;
+        if (l && typeof l.type != "function")
+          return f().cloneElement(l, { ref: function(h) {
+            return t.placeholder = h;
+          } });
+        var g = function(h) {
+          for (var R = 1; R < arguments.length; R++) {
+            var T = arguments[R] != null ? arguments[R] : {};
+            R % 2 ? D(Object(T), !0).forEach(function(k) {
+              Z(h, k, T[k]);
+            }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(h, Object.getOwnPropertyDescriptors(T)) : D(Object(T)).forEach(function(k) {
+              Object.defineProperty(h, k, Object.getOwnPropertyDescriptor(T, k));
+            });
+          }
+          return h;
+        }({ display: "inline-block" }, d);
+        return m !== void 0 && (g.width = m), u !== void 0 && (g.height = u), f().createElement("span", { className: s, ref: function(h) {
+          return t.placeholder = h;
+        }, style: g }, l);
+      } }]) && ie(e.prototype, i), b;
+    }(f().Component);
+    N.propTypes = { onVisible: c.PropTypes.func.isRequired, className: c.PropTypes.string, height: c.PropTypes.oneOfType([c.PropTypes.number, c.PropTypes.string]), placeholder: c.PropTypes.element, threshold: c.PropTypes.number, useIntersectionObserver: c.PropTypes.bool, scrollPosition: c.PropTypes.shape({ x: c.PropTypes.number.isRequired, y: c.PropTypes.number.isRequired }), width: c.PropTypes.oneOfType([c.PropTypes.number, c.PropTypes.string]) }, N.defaultProps = { className: "", placeholder: null, threshold: 100, useIntersectionObserver: !0 };
+    const G = N;
+    var p = E(296), a = E.n(p), P = E(96), j = E.n(P), _ = function(r) {
+      var e = getComputedStyle(r, null);
+      return e.getPropertyValue("overflow") + e.getPropertyValue("overflow-y") + e.getPropertyValue("overflow-x");
+    };
+    const C = function(r) {
+      if (!(r instanceof HTMLElement))
+        return window;
+      for (var e = r; e && e instanceof HTMLElement; ) {
+        if (/(scroll|auto)/.test(_(e)))
+          return e;
+        e = e.parentNode;
+      }
+      return window;
+    };
+    function F(r) {
+      return (F = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+        return typeof e;
+      } : function(e) {
+        return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+      })(r);
+    }
+    var O = ["delayMethod", "delayTime"];
+    function L() {
+      return (L = Object.assign || function(r) {
+        for (var e = 1; e < arguments.length; e++) {
+          var i = arguments[e];
+          for (var n in i)
+            Object.prototype.hasOwnProperty.call(i, n) && (r[n] = i[n]);
+        }
+        return r;
+      }).apply(this, arguments);
+    }
+    function M(r, e) {
+      for (var i = 0; i < e.length; i++) {
+        var n = e[i];
+        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, n.key, n);
+      }
+    }
+    function q(r, e) {
+      return (q = Object.setPrototypeOf || function(i, n) {
+        return i.__proto__ = n, i;
+      })(r, e);
+    }
+    function V(r, e) {
+      if (e && (F(e) === "object" || typeof e == "function"))
+        return e;
+      if (e !== void 0)
+        throw new TypeError("Derived constructors may only return object or undefined");
+      return W(r);
+    }
+    function W(r) {
+      if (r === void 0)
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      return r;
+    }
+    function S(r) {
+      return (S = Object.setPrototypeOf ? Object.getPrototypeOf : function(e) {
+        return e.__proto__ || Object.getPrototypeOf(e);
+      })(r);
+    }
+    var z = function() {
+      return typeof window > "u" ? 0 : window.scrollX || window.pageXOffset;
+    }, H = function() {
+      return typeof window > "u" ? 0 : window.scrollY || window.pageYOffset;
+    };
+    const J = function(r) {
+      var e = function(i) {
+        (function(s, u) {
+          if (typeof u != "function" && u !== null)
+            throw new TypeError("Super expression must either be null or a function");
+          s.prototype = Object.create(u && u.prototype, { constructor: { value: s, writable: !0, configurable: !0 } }), u && q(s, u);
+        })(o, i);
+        var n, I, Q, b, t = (Q = o, b = function() {
+          if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+            return !1;
+          if (typeof Proxy == "function")
+            return !0;
+          try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), !0;
+          } catch {
+            return !1;
+          }
+        }(), function() {
+          var s, u = S(Q);
+          if (b) {
+            var l = S(this).constructor;
+            s = Reflect.construct(u, arguments, l);
+          } else
+            s = u.apply(this, arguments);
+          return V(this, s);
+        });
+        function o(s) {
+          var u;
+          if (function(d, m) {
+            if (!(d instanceof m))
+              throw new TypeError("Cannot call a class as a function");
+          }(this, o), (u = t.call(this, s)).useIntersectionObserver = s.useIntersectionObserver && A(), u.useIntersectionObserver)
+            return V(u);
+          var l = u.onChangeScroll.bind(W(u));
+          return s.delayMethod === "debounce" ? u.delayedScroll = a()(l, s.delayTime) : s.delayMethod === "throttle" && (u.delayedScroll = j()(l, s.delayTime)), u.state = { scrollPosition: { x: z(), y: H() } }, u.baseComponentRef = f().createRef(), u;
+        }
+        return n = o, (I = [{ key: "componentDidMount", value: function() {
+          this.addListeners();
+        } }, { key: "componentWillUnmount", value: function() {
+          this.removeListeners();
+        } }, { key: "componentDidUpdate", value: function() {
+          typeof window > "u" || this.useIntersectionObserver || C(X().findDOMNode(this.baseComponentRef.current)) !== this.scrollElement && (this.removeListeners(), this.addListeners());
+        } }, { key: "addListeners", value: function() {
+          typeof window > "u" || this.useIntersectionObserver || (this.scrollElement = C(X().findDOMNode(this.baseComponentRef.current)), this.scrollElement.addEventListener("scroll", this.delayedScroll, { passive: !0 }), window.addEventListener("resize", this.delayedScroll, { passive: !0 }), this.scrollElement !== window && window.addEventListener("scroll", this.delayedScroll, { passive: !0 }));
+        } }, { key: "removeListeners", value: function() {
+          typeof window > "u" || this.useIntersectionObserver || (this.scrollElement.removeEventListener("scroll", this.delayedScroll), window.removeEventListener("resize", this.delayedScroll), this.scrollElement !== window && window.removeEventListener("scroll", this.delayedScroll));
+        } }, { key: "onChangeScroll", value: function() {
+          this.useIntersectionObserver || this.setState({ scrollPosition: { x: z(), y: H() } });
+        } }, { key: "render", value: function() {
+          var s = this.props, u = (s.delayMethod, s.delayTime, function(d, m) {
+            if (d == null)
+              return {};
+            var g, h, R = function(k, fe) {
+              if (k == null)
+                return {};
+              var ne, ye, _e = {}, xe = Object.keys(k);
+              for (ye = 0; ye < xe.length; ye++)
+                ne = xe[ye], fe.indexOf(ne) >= 0 || (_e[ne] = k[ne]);
+              return _e;
+            }(d, m);
+            if (Object.getOwnPropertySymbols) {
+              var T = Object.getOwnPropertySymbols(d);
+              for (h = 0; h < T.length; h++)
+                g = T[h], m.indexOf(g) >= 0 || Object.prototype.propertyIsEnumerable.call(d, g) && (R[g] = d[g]);
+            }
+            return R;
+          }(s, O)), l = this.useIntersectionObserver ? null : this.state.scrollPosition;
+          return f().createElement(r, L({ forwardRef: this.baseComponentRef, scrollPosition: l }, u));
+        } }]) && M(n.prototype, I), o;
+      }(f().Component);
+      return e.propTypes = { delayMethod: c.PropTypes.oneOf(["debounce", "throttle"]), delayTime: c.PropTypes.number, useIntersectionObserver: c.PropTypes.bool }, e.defaultProps = { delayMethod: "throttle", delayTime: 300, useIntersectionObserver: !0 }, e;
+    };
+    function K(r) {
+      return (K = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+        return typeof e;
+      } : function(e) {
+        return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+      })(r);
+    }
+    function ee(r, e) {
+      for (var i = 0; i < e.length; i++) {
+        var n = e[i];
+        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, n.key, n);
+      }
+    }
+    function v(r, e) {
+      return (v = Object.setPrototypeOf || function(i, n) {
+        return i.__proto__ = n, i;
+      })(r, e);
+    }
+    function B(r, e) {
+      if (e && (K(e) === "object" || typeof e == "function"))
+        return e;
+      if (e !== void 0)
+        throw new TypeError("Derived constructors may only return object or undefined");
+      return function(i) {
+        if (i === void 0)
+          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return i;
+      }(r);
+    }
+    function Y(r) {
+      return (Y = Object.setPrototypeOf ? Object.getPrototypeOf : function(e) {
+        return e.__proto__ || Object.getPrototypeOf(e);
+      })(r);
+    }
+    var ce = function(r) {
+      (function(t, o) {
+        if (typeof o != "function" && o !== null)
+          throw new TypeError("Super expression must either be null or a function");
+        t.prototype = Object.create(o && o.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), o && v(t, o);
+      })(b, r);
+      var e, i, n, I, Q = (n = b, I = function() {
+        if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+          return !1;
+        if (typeof Proxy == "function")
+          return !0;
+        try {
+          return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+          })), !0;
+        } catch {
+          return !1;
+        }
+      }(), function() {
+        var t, o = Y(n);
+        if (I) {
+          var s = Y(this).constructor;
+          t = Reflect.construct(o, arguments, s);
+        } else
+          t = o.apply(this, arguments);
+        return B(this, t);
+      });
+      function b(t) {
+        return function(o, s) {
+          if (!(o instanceof s))
+            throw new TypeError("Cannot call a class as a function");
+        }(this, b), Q.call(this, t);
+      }
+      return e = b, (i = [{ key: "render", value: function() {
+        return f().createElement(G, this.props);
+      } }]) && ee(e.prototype, i), b;
+    }(f().Component);
+    const pe = J(ce);
+    function ae(r) {
+      return (ae = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+        return typeof e;
+      } : function(e) {
+        return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+      })(r);
+    }
+    function x(r, e) {
+      for (var i = 0; i < e.length; i++) {
+        var n = e[i];
+        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, n.key, n);
+      }
+    }
+    function $(r, e) {
+      return ($ = Object.setPrototypeOf || function(i, n) {
+        return i.__proto__ = n, i;
+      })(r, e);
+    }
+    function le(r, e) {
+      if (e && (ae(e) === "object" || typeof e == "function"))
+        return e;
+      if (e !== void 0)
+        throw new TypeError("Derived constructors may only return object or undefined");
+      return we(r);
+    }
+    function we(r) {
+      if (r === void 0)
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      return r;
+    }
+    function be(r) {
+      return (be = Object.setPrototypeOf ? Object.getPrototypeOf : function(e) {
+        return e.__proto__ || Object.getPrototypeOf(e);
+      })(r);
+    }
+    var he = function(r) {
+      (function(t, o) {
+        if (typeof o != "function" && o !== null)
+          throw new TypeError("Super expression must either be null or a function");
+        t.prototype = Object.create(o && o.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), o && $(t, o);
+      })(b, r);
+      var e, i, n, I, Q = (n = b, I = function() {
+        if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+          return !1;
+        if (typeof Proxy == "function")
+          return !0;
+        try {
+          return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+          })), !0;
+        } catch {
+          return !1;
+        }
+      }(), function() {
+        var t, o = be(n);
+        if (I) {
+          var s = be(this).constructor;
+          t = Reflect.construct(o, arguments, s);
+        } else
+          t = o.apply(this, arguments);
+        return le(this, t);
+      });
+      function b(t) {
+        var o;
+        (function(m, g) {
+          if (!(m instanceof g))
+            throw new TypeError("Cannot call a class as a function");
+        })(this, b), o = Q.call(this, t);
+        var s = t.afterLoad, u = t.beforeLoad, l = t.scrollPosition, d = t.visibleByDefault;
+        return o.state = { visible: d }, d && (u(), s()), o.onVisible = o.onVisible.bind(we(o)), o.isScrollTracked = Boolean(l && Number.isFinite(l.x) && l.x >= 0 && Number.isFinite(l.y) && l.y >= 0), o;
+      }
+      return e = b, (i = [{ key: "componentDidUpdate", value: function(t, o) {
+        o.visible !== this.state.visible && this.props.afterLoad();
+      } }, { key: "onVisible", value: function() {
+        this.props.beforeLoad(), this.setState({ visible: !0 });
+      } }, { key: "render", value: function() {
+        if (this.state.visible)
+          return this.props.children;
+        var t = this.props, o = t.className, s = t.delayMethod, u = t.delayTime, l = t.height, d = t.placeholder, m = t.scrollPosition, g = t.style, h = t.threshold, R = t.useIntersectionObserver, T = t.width;
+        return this.isScrollTracked || R && A() ? f().createElement(G, { className: o, height: l, onVisible: this.onVisible, placeholder: d, scrollPosition: m, style: g, threshold: h, useIntersectionObserver: R, width: T }) : f().createElement(pe, { className: o, delayMethod: s, delayTime: u, height: l, onVisible: this.onVisible, placeholder: d, style: g, threshold: h, width: T });
+      } }]) && x(e.prototype, i), b;
+    }(f().Component);
+    he.propTypes = { afterLoad: c.PropTypes.func, beforeLoad: c.PropTypes.func, useIntersectionObserver: c.PropTypes.bool, visibleByDefault: c.PropTypes.bool }, he.defaultProps = { afterLoad: function() {
+      return {};
+    }, beforeLoad: function() {
+      return {};
+    }, useIntersectionObserver: !0, visibleByDefault: !1 };
+    const Pe = he;
+    function je(r) {
+      return (je = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+        return typeof e;
+      } : function(e) {
+        return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+      })(r);
+    }
+    var Le = ["afterLoad", "beforeLoad", "delayMethod", "delayTime", "effect", "placeholder", "placeholderSrc", "scrollPosition", "threshold", "useIntersectionObserver", "visibleByDefault", "wrapperClassName", "wrapperProps"];
+    function Te(r, e) {
+      var i = Object.keys(r);
+      if (Object.getOwnPropertySymbols) {
+        var n = Object.getOwnPropertySymbols(r);
+        e && (n = n.filter(function(I) {
+          return Object.getOwnPropertyDescriptor(r, I).enumerable;
+        })), i.push.apply(i, n);
+      }
+      return i;
+    }
+    function Se(r) {
+      for (var e = 1; e < arguments.length; e++) {
+        var i = arguments[e] != null ? arguments[e] : {};
+        e % 2 ? Te(Object(i), !0).forEach(function(n) {
+          Re(r, n, i[n]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(i)) : Te(Object(i)).forEach(function(n) {
+          Object.defineProperty(r, n, Object.getOwnPropertyDescriptor(i, n));
+        });
+      }
+      return r;
+    }
+    function Re(r, e, i) {
+      return e in r ? Object.defineProperty(r, e, { value: i, enumerable: !0, configurable: !0, writable: !0 }) : r[e] = i, r;
+    }
+    function ve() {
+      return (ve = Object.assign || function(r) {
+        for (var e = 1; e < arguments.length; e++) {
+          var i = arguments[e];
+          for (var n in i)
+            Object.prototype.hasOwnProperty.call(i, n) && (r[n] = i[n]);
+        }
+        return r;
+      }).apply(this, arguments);
+    }
+    function ke(r, e) {
+      for (var i = 0; i < e.length; i++) {
+        var n = e[i];
+        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, n.key, n);
+      }
+    }
+    function Ee(r, e) {
+      return (Ee = Object.setPrototypeOf || function(i, n) {
+        return i.__proto__ = n, i;
+      })(r, e);
+    }
+    function De(r, e) {
+      if (e && (je(e) === "object" || typeof e == "function"))
+        return e;
+      if (e !== void 0)
+        throw new TypeError("Derived constructors may only return object or undefined");
+      return function(i) {
+        if (i === void 0)
+          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return i;
+      }(r);
+    }
+    function me(r) {
+      return (me = Object.setPrototypeOf ? Object.getPrototypeOf : function(e) {
+        return e.__proto__ || Object.getPrototypeOf(e);
+      })(r);
+    }
+    var ge = function(r) {
+      (function(t, o) {
+        if (typeof o != "function" && o !== null)
+          throw new TypeError("Super expression must either be null or a function");
+        t.prototype = Object.create(o && o.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), o && Ee(t, o);
+      })(b, r);
+      var e, i, n, I, Q = (n = b, I = function() {
+        if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+          return !1;
+        if (typeof Proxy == "function")
+          return !0;
+        try {
+          return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+          })), !0;
+        } catch {
+          return !1;
+        }
+      }(), function() {
+        var t, o = me(n);
+        if (I) {
+          var s = me(this).constructor;
+          t = Reflect.construct(o, arguments, s);
+        } else
+          t = o.apply(this, arguments);
+        return De(this, t);
+      });
+      function b(t) {
+        var o;
+        return function(s, u) {
+          if (!(s instanceof u))
+            throw new TypeError("Cannot call a class as a function");
+        }(this, b), (o = Q.call(this, t)).state = { loaded: !1 }, o;
+      }
+      return e = b, (i = [{ key: "onImageLoad", value: function() {
+        var t = this;
+        return this.state.loaded ? null : function() {
+          t.props.afterLoad(), t.setState({ loaded: !0 });
+        };
+      } }, { key: "getImg", value: function() {
+        var t = this.props, o = (t.afterLoad, t.beforeLoad, t.delayMethod, t.delayTime, t.effect, t.placeholder, t.placeholderSrc, t.scrollPosition, t.threshold, t.useIntersectionObserver, t.visibleByDefault, t.wrapperClassName, t.wrapperProps, function(s, u) {
+          if (s == null)
+            return {};
+          var l, d, m = function(h, R) {
+            if (h == null)
+              return {};
+            var T, k, fe = {}, ne = Object.keys(h);
+            for (k = 0; k < ne.length; k++)
+              T = ne[k], R.indexOf(T) >= 0 || (fe[T] = h[T]);
+            return fe;
+          }(s, u);
+          if (Object.getOwnPropertySymbols) {
+            var g = Object.getOwnPropertySymbols(s);
+            for (d = 0; d < g.length; d++)
+              l = g[d], u.indexOf(l) >= 0 || Object.prototype.propertyIsEnumerable.call(s, l) && (m[l] = s[l]);
+          }
+          return m;
+        }(t, Le));
+        return f().createElement("img", ve({ onLoad: this.onImageLoad() }, o));
+      } }, { key: "getLazyLoadImage", value: function() {
+        var t = this.props, o = t.beforeLoad, s = t.className, u = t.delayMethod, l = t.delayTime, d = t.height, m = t.placeholder, g = t.scrollPosition, h = t.style, R = t.threshold, T = t.useIntersectionObserver, k = t.visibleByDefault, fe = t.width;
+        return f().createElement(Pe, { beforeLoad: o, className: s, delayMethod: u, delayTime: l, height: d, placeholder: m, scrollPosition: g, style: h, threshold: R, useIntersectionObserver: T, visibleByDefault: k, width: fe }, this.getImg());
+      } }, { key: "getWrappedLazyLoadImage", value: function(t) {
+        var o = this.props, s = o.effect, u = o.height, l = o.placeholderSrc, d = o.width, m = o.wrapperClassName, g = o.wrapperProps, h = this.state.loaded, R = h ? " lazy-load-image-loaded" : "", T = h || !l ? {} : { backgroundImage: "url(".concat(l, ")"), backgroundSize: "100% 100%" };
+        return f().createElement("span", ve({ className: m + " lazy-load-image-background " + s + R, style: Se(Se({}, T), {}, { color: "transparent", display: "inline-block", height: u, width: d }) }, g), t);
+      } }, { key: "render", value: function() {
+        var t = this.props, o = t.effect, s = t.placeholderSrc, u = t.visibleByDefault, l = t.wrapperClassName, d = t.wrapperProps, m = this.getLazyLoadImage();
+        return (o || s) && !u || l || d ? this.getWrappedLazyLoadImage(m) : m;
+      } }]) && ke(e.prototype, i), b;
+    }(f().Component);
+    ge.propTypes = { afterLoad: c.PropTypes.func, beforeLoad: c.PropTypes.func, delayMethod: c.PropTypes.string, delayTime: c.PropTypes.number, effect: c.PropTypes.string, placeholderSrc: c.PropTypes.string, threshold: c.PropTypes.number, useIntersectionObserver: c.PropTypes.bool, visibleByDefault: c.PropTypes.bool, wrapperClassName: c.PropTypes.string, wrapperProps: c.PropTypes.object }, ge.defaultProps = { afterLoad: function() {
+      return {};
+    }, beforeLoad: function() {
+      return {};
+    }, delayMethod: "throttle", delayTime: 300, effect: "", placeholderSrc: null, threshold: 100, useIntersectionObserver: !0, visibleByDefault: !1, wrapperClassName: "" };
+    const Ne = ge;
+  })(), Be.exports = de;
+})();
+export {
+  Be as b
+};