@mjhls/mjh-framework 1.0.322 → 1.0.323

package/dist/cjs/smoothscroll-95231a70.js

@@ -0,0 +1,488 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
+
+var getYoutubeId = _commonjsHelpers.createCommonjsModule(function (module, exports) {
+(function (root, factory) {
+  {
+    module.exports = factory();
+  }
+}(_commonjsHelpers.commonjsGlobal, function (exports) {
+
+  return function (url, opts) {
+    if (opts == undefined) {
+      opts = {fuzzy: true};
+    }
+
+    if (/youtu\.?be/.test(url)) {
+
+      // Look first for known patterns
+      var i;
+      var patterns = [
+        /youtu\.be\/([^#\&\?]{11})/,  // youtu.be/<id>
+        /\?v=([^#\&\?]{11})/,         // ?v=<id>
+        /\&v=([^#\&\?]{11})/,         // &v=<id>
+        /embed\/([^#\&\?]{11})/,      // embed/<id>
+        /\/v\/([^#\&\?]{11})/         // /v/<id>
+      ];
+
+      // If any pattern matches, return the ID
+      for (i = 0; i < patterns.length; ++i) {
+        if (patterns[i].test(url)) {
+          return patterns[i].exec(url)[1];
+        }
+      }
+
+      if (opts.fuzzy) {
+        // If that fails, break it apart by certain characters and look 
+        // for the 11 character key
+        var tokens = url.split(/[\/\&\?=#\.\s]/g);
+        for (i = 0; i < tokens.length; ++i) {
+          if (/^[^#\&\?]{11}$/.test(tokens[i])) {
+            return tokens[i];
+          }
+        }
+      }
+    }
+
+    return null;
+  };
+
+}));
+});
+
+var smoothscroll = _commonjsHelpers.createCommonjsModule(function (module, exports) {
+/* smoothscroll v0.4.4 - 2019 - Dustan Kasten, Jeremias Menichelli - MIT License */
+(function () {
+
+  // polyfill
+  function polyfill() {
+    // aliases
+    var w = window;
+    var d = document;
+
+    // return if scroll behavior is supported and polyfill is not forced
+    if (
+      'scrollBehavior' in d.documentElement.style &&
+      w.__forceSmoothScrollPolyfill__ !== true
+    ) {
+      return;
+    }
+
+    // globals
+    var Element = w.HTMLElement || w.Element;
+    var SCROLL_TIME = 468;
+
+    // object gathering original scroll methods
+    var original = {
+      scroll: w.scroll || w.scrollTo,
+      scrollBy: w.scrollBy,
+      elementScroll: Element.prototype.scroll || scrollElement,
+      scrollIntoView: Element.prototype.scrollIntoView
+    };
+
+    // define timing method
+    var now =
+      w.performance && w.performance.now
+        ? w.performance.now.bind(w.performance)
+        : Date.now;
+
+    /**
+     * indicates if a the current browser is made by Microsoft
+     * @method isMicrosoftBrowser
+     * @param {String} userAgent
+     * @returns {Boolean}
+     */
+    function isMicrosoftBrowser(userAgent) {
+      var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];
+
+      return new RegExp(userAgentPatterns.join('|')).test(userAgent);
+    }
+
+    /*
+     * IE has rounding bug rounding down clientHeight and clientWidth and
+     * rounding up scrollHeight and scrollWidth causing false positives
+     * on hasScrollableSpace
+     */
+    var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;
+
+    /**
+     * changes scroll position inside an element
+     * @method scrollElement
+     * @param {Number} x
+     * @param {Number} y
+     * @returns {undefined}
+     */
+    function scrollElement(x, y) {
+      this.scrollLeft = x;
+      this.scrollTop = y;
+    }
+
+    /**
+     * returns result of applying ease math function to a number
+     * @method ease
+     * @param {Number} k
+     * @returns {Number}
+     */
+    function ease(k) {
+      return 0.5 * (1 - Math.cos(Math.PI * k));
+    }
+
+    /**
+     * indicates if a smooth behavior should be applied
+     * @method shouldBailOut
+     * @param {Number|Object} firstArg
+     * @returns {Boolean}
+     */
+    function shouldBailOut(firstArg) {
+      if (
+        firstArg === null ||
+        typeof firstArg !== 'object' ||
+        firstArg.behavior === undefined ||
+        firstArg.behavior === 'auto' ||
+        firstArg.behavior === 'instant'
+      ) {
+        // first argument is not an object/null
+        // or behavior is auto, instant or undefined
+        return true;
+      }
+
+      if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {
+        // first argument is an object and behavior is smooth
+        return false;
+      }
+
+      // throw error when behavior is not supported
+      throw new TypeError(
+        'behavior member of ScrollOptions ' +
+          firstArg.behavior +
+          ' is not a valid value for enumeration ScrollBehavior.'
+      );
+    }
+
+    /**
+     * indicates if an element has scrollable space in the provided axis
+     * @method hasScrollableSpace
+     * @param {Node} el
+     * @param {String} axis
+     * @returns {Boolean}
+     */
+    function hasScrollableSpace(el, axis) {
+      if (axis === 'Y') {
+        return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;
+      }
+
+      if (axis === 'X') {
+        return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;
+      }
+    }
+
+    /**
+     * indicates if an element has a scrollable overflow property in the axis
+     * @method canOverflow
+     * @param {Node} el
+     * @param {String} axis
+     * @returns {Boolean}
+     */
+    function canOverflow(el, axis) {
+      var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];
+
+      return overflowValue === 'auto' || overflowValue === 'scroll';
+    }
+
+    /**
+     * indicates if an element can be scrolled in either axis
+     * @method isScrollable
+     * @param {Node} el
+     * @param {String} axis
+     * @returns {Boolean}
+     */
+    function isScrollable(el) {
+      var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');
+      var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');
+
+      return isScrollableY || isScrollableX;
+    }
+
+    /**
+     * finds scrollable parent of an element
+     * @method findScrollableParent
+     * @param {Node} el
+     * @returns {Node} el
+     */
+    function findScrollableParent(el) {
+      while (el !== d.body && isScrollable(el) === false) {
+        el = el.parentNode || el.host;
+      }
+
+      return el;
+    }
+
+    /**
+     * self invoked function that, given a context, steps through scrolling
+     * @method step
+     * @param {Object} context
+     * @returns {undefined}
+     */
+    function step(context) {
+      var time = now();
+      var value;
+      var currentX;
+      var currentY;
+      var elapsed = (time - context.startTime) / SCROLL_TIME;
+
+      // avoid elapsed times higher than one
+      elapsed = elapsed > 1 ? 1 : elapsed;
+
+      // apply easing to elapsed time
+      value = ease(elapsed);
+
+      currentX = context.startX + (context.x - context.startX) * value;
+      currentY = context.startY + (context.y - context.startY) * value;
+
+      context.method.call(context.scrollable, currentX, currentY);
+
+      // scroll more if we have not reached our destination
+      if (currentX !== context.x || currentY !== context.y) {
+        w.requestAnimationFrame(step.bind(w, context));
+      }
+    }
+
+    /**
+     * scrolls window or element with a smooth behavior
+     * @method smoothScroll
+     * @param {Object|Node} el
+     * @param {Number} x
+     * @param {Number} y
+     * @returns {undefined}
+     */
+    function smoothScroll(el, x, y) {
+      var scrollable;
+      var startX;
+      var startY;
+      var method;
+      var startTime = now();
+
+      // define scroll context
+      if (el === d.body) {
+        scrollable = w;
+        startX = w.scrollX || w.pageXOffset;
+        startY = w.scrollY || w.pageYOffset;
+        method = original.scroll;
+      } else {
+        scrollable = el;
+        startX = el.scrollLeft;
+        startY = el.scrollTop;
+        method = scrollElement;
+      }
+
+      // scroll looping over a frame
+      step({
+        scrollable: scrollable,
+        method: method,
+        startTime: startTime,
+        startX: startX,
+        startY: startY,
+        x: x,
+        y: y
+      });
+    }
+
+    // ORIGINAL METHODS OVERRIDES
+    // w.scroll and w.scrollTo
+    w.scroll = w.scrollTo = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        original.scroll.call(
+          w,
+          arguments[0].left !== undefined
+            ? arguments[0].left
+            : typeof arguments[0] !== 'object'
+              ? arguments[0]
+              : w.scrollX || w.pageXOffset,
+          // use top prop, second argument if present or fallback to scrollY
+          arguments[0].top !== undefined
+            ? arguments[0].top
+            : arguments[1] !== undefined
+              ? arguments[1]
+              : w.scrollY || w.pageYOffset
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        w,
+        d.body,
+        arguments[0].left !== undefined
+          ? ~~arguments[0].left
+          : w.scrollX || w.pageXOffset,
+        arguments[0].top !== undefined
+          ? ~~arguments[0].top
+          : w.scrollY || w.pageYOffset
+      );
+    };
+
+    // w.scrollBy
+    w.scrollBy = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0])) {
+        original.scrollBy.call(
+          w,
+          arguments[0].left !== undefined
+            ? arguments[0].left
+            : typeof arguments[0] !== 'object' ? arguments[0] : 0,
+          arguments[0].top !== undefined
+            ? arguments[0].top
+            : arguments[1] !== undefined ? arguments[1] : 0
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        w,
+        d.body,
+        ~~arguments[0].left + (w.scrollX || w.pageXOffset),
+        ~~arguments[0].top + (w.scrollY || w.pageYOffset)
+      );
+    };
+
+    // Element.prototype.scroll and Element.prototype.scrollTo
+    Element.prototype.scroll = Element.prototype.scrollTo = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        // if one number is passed, throw error to match Firefox implementation
+        if (typeof arguments[0] === 'number' && arguments[1] === undefined) {
+          throw new SyntaxError('Value could not be converted');
+        }
+
+        original.elementScroll.call(
+          this,
+          // use left prop, first number argument or fallback to scrollLeft
+          arguments[0].left !== undefined
+            ? ~~arguments[0].left
+            : typeof arguments[0] !== 'object' ? ~~arguments[0] : this.scrollLeft,
+          // use top prop, second argument or fallback to scrollTop
+          arguments[0].top !== undefined
+            ? ~~arguments[0].top
+            : arguments[1] !== undefined ? ~~arguments[1] : this.scrollTop
+        );
+
+        return;
+      }
+
+      var left = arguments[0].left;
+      var top = arguments[0].top;
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        this,
+        this,
+        typeof left === 'undefined' ? this.scrollLeft : ~~left,
+        typeof top === 'undefined' ? this.scrollTop : ~~top
+      );
+    };
+
+    // Element.prototype.scrollBy
+    Element.prototype.scrollBy = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        original.elementScroll.call(
+          this,
+          arguments[0].left !== undefined
+            ? ~~arguments[0].left + this.scrollLeft
+            : ~~arguments[0] + this.scrollLeft,
+          arguments[0].top !== undefined
+            ? ~~arguments[0].top + this.scrollTop
+            : ~~arguments[1] + this.scrollTop
+        );
+
+        return;
+      }
+
+      this.scroll({
+        left: ~~arguments[0].left + this.scrollLeft,
+        top: ~~arguments[0].top + this.scrollTop,
+        behavior: arguments[0].behavior
+      });
+    };
+
+    // Element.prototype.scrollIntoView
+    Element.prototype.scrollIntoView = function() {
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        original.scrollIntoView.call(
+          this,
+          arguments[0] === undefined ? true : arguments[0]
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      var scrollableParent = findScrollableParent(this);
+      var parentRects = scrollableParent.getBoundingClientRect();
+      var clientRects = this.getBoundingClientRect();
+
+      if (scrollableParent !== d.body) {
+        // reveal element inside parent
+        smoothScroll.call(
+          this,
+          scrollableParent,
+          scrollableParent.scrollLeft + clientRects.left - parentRects.left,
+          scrollableParent.scrollTop + clientRects.top - parentRects.top
+        );
+
+        // reveal parent in viewport unless is fixed
+        if (w.getComputedStyle(scrollableParent).position !== 'fixed') {
+          w.scrollBy({
+            left: parentRects.left,
+            top: parentRects.top,
+            behavior: 'smooth'
+          });
+        }
+      } else {
+        // reveal element in viewport
+        w.scrollBy({
+          left: clientRects.left,
+          top: clientRects.top,
+          behavior: 'smooth'
+        });
+      }
+    };
+  }
+
+  {
+    // commonjs
+    module.exports = { polyfill: polyfill };
+  }
+
+}());
+});
+var smoothscroll_1 = smoothscroll.polyfill;
+
+exports.getYoutubeId = getYoutubeId;
+exports.smoothscroll = smoothscroll;

package/dist/cjs/{toConsumableArray-18281c61.js → toConsumableArray-34b5e9a7.js}

@@ -2,9 +2,8 @@
 
 var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
 var _toObject = require('./_to-object-329a650b.js');
-require('./web.dom.iterable-0998bdc3.js');
-var main = require('./main-753fb093.js');
-var core_getIteratorMethod = require('./core.get-iterator-method-e049ca4a.js');
+var web_dom_iterable = require('./web.dom.iterable-8b02d65e.js');
+var main = require('./main-987c23c6.js');
 
 var _createProperty = function (object, index, value) {
   if (index in object) _toObject._objectDp.f(object, index, _toObject._propertyDesc(0, value));
@@ -20,7 +19,7 @@ _toObject._export(_toObject._export.S + _toObject._export.F * !main._iterDetect(
     var mapfn = aLen > 1 ? arguments[1] : undefined;
     var mapping = mapfn !== undefined;
     var index = 0;
-    var iterFn = core_getIteratorMethod.core_getIteratorMethod(O);
+    var iterFn = web_dom_iterable.core_getIteratorMethod(O);
     var length, result, step, iterator;
     if (mapping) mapfn = _toObject._ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
     // if object isn't iterable or it's array with default iterator - use simple case

package/dist/cjs/{web.dom.iterable-0998bdc3.js → web.dom.iterable-8b02d65e.js}

@@ -200,6 +200,38 @@ _iterDefine(String, 'String', function (iterated) {
   return { value: point, done: false };
 });
 
+// getting tag from 19.1.3.6 Object.prototype.toString()
+
+var TAG$1 = _wks('toStringTag');
+// ES3 wrong here
+var ARG = _toObject._cof(function () { return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+  try {
+    return it[key];
+  } catch (e) { /* empty */ }
+};
+
+var _classof = function (it) {
+  var O, T, B;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (T = tryGet(O = Object(it), TAG$1)) == 'string' ? T
+    // builtinTag case
+    : ARG ? _toObject._cof(O)
+    // ES3 arguments fallback
+    : (B = _toObject._cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+};
+
+var ITERATOR$1 = _wks('iterator');
+
+var core_getIteratorMethod = _toObject._core.getIteratorMethod = function (it) {
+  if (it != undefined) return it[ITERATOR$1]
+    || it['@@iterator']
+    || _iterators[_classof(it)];
+};
+
 var _iterStep = function (done, value) {
   return { value: value, done: !!done };
 };
@@ -245,6 +277,7 @@ for (var i = 0; i < DOMIterables.length; i++) {
   _iterators[NAME] = _iterators.Array;
 }
 
+exports._classof = _classof;
 exports._html = _html;
 exports._iterators = _iterators;
 exports._objectCreate = _objectCreate;
@@ -252,3 +285,4 @@ exports._objectGpo = _objectGpo;
 exports._redefine = _redefine;
 exports._setToStringTag = _setToStringTag;
 exports._wks = _wks;
+exports.core_getIteratorMethod = core_getIteratorMethod;

package/dist/esm/{ADInfeed-2aaf8622.js → ADInfeed-aadcfc25.js}

@@ -1,6 +1,6 @@
 import React__default from 'react';
 import Card from 'react-bootstrap/Card';
-import { D as DFPAdSlot } from './AdSlot-028b040f.js';
+import { D as DFPAdSlot } from './AdSlot-8946358f.js';
 
 var ADInfeed = function ADInfeed(_ref) {
   var index = _ref.index,

package/dist/esm/{AdSlot-028b040f.js → AdSlot-8946358f.js}

@@ -1,11 +1,11 @@
 import { u as unwrapExports, c as createCommonjsModule } from './_commonjsHelpers-0c4b6f40.js';
 import { b as _core } from './_to-object-b9b796ec.js';
 import { d as debounce_1, e as lib_2 } from './debounce-702eb224.js';
-import { a as main_16 } from './main-d550db5e.js';
+import { a as main_16 } from './main-cb86f95d.js';
 import React__default, { useState } from 'react';
 import PropTypes from 'prop-types';
-import { _ as _slicedToArray } from './slicedToArray-d1db3163.js';
-import { p as promise } from './promise-8fc46e97.js';
+import { _ as _slicedToArray } from './slicedToArray-a47a84a4.js';
+import { p as promise } from './promise-86cb8313.js';
 
 var $JSON = _core.JSON || (_core.JSON = { stringify: JSON.stringify });
 var stringify = function stringify(it) { // eslint-disable-line no-unused-vars

package/dist/esm/DeckContent.js

@@ -1,12 +1,11 @@
 import './_commonjsHelpers-0c4b6f40.js';
 import './_to-object-b9b796ec.js';
-import './web.dom.iterable-3be50d6c.js';
+import './web.dom.iterable-7e9bebf9.js';
 import { d as debounce_1, l as lib_3 } from './debounce-702eb224.js';
-import { m as main_39 } from './main-d550db5e.js';
-import { _ as _toConsumableArray } from './toConsumableArray-a096ca06.js';
-import './core.get-iterator-method-31c1fb1a.js';
+import { m as main_39 } from './main-cb86f95d.js';
+import { _ as _toConsumableArray } from './toConsumableArray-2718dc16.js';
 import { _ as _extends } from './extends-dbbe308d.js';
-import { a as _inherits, b as _classCallCheck, c as _possibleConstructorReturn, d as _Object$getPrototypeOf, e as _createClass } from './inherits-9d26445c.js';
+import { a as _inherits, b as _classCallCheck, c as _possibleConstructorReturn, d as _Object$getPrototypeOf, e as _createClass } from './inherits-cb536901.js';
 import React__default from 'react';
 import 'prop-types';
 import Container from 'react-bootstrap/Container';
@@ -20,10 +19,10 @@ import 'react-dom';
 import { i as imageUrlBuilder } from './index-51a80699.js';
 import { L as LazyLoad } from './index-5f9f807a.js';
 import { c as clean_html_1 } from './entities-7cc3bf45.js';
-import './slicedToArray-d1db3163.js';
-import './AdSlot-028b040f.js';
-import './promise-8fc46e97.js';
-import { A as ADInfeed } from './ADInfeed-2aaf8622.js';
+import './slicedToArray-a47a84a4.js';
+import './AdSlot-8946358f.js';
+import './promise-86cb8313.js';
+import { A as ADInfeed } from './ADInfeed-aadcfc25.js';
 
 var DeckContent = function (_React$Component) {
   _inherits(DeckContent, _React$Component);

package/dist/esm/DeckQueue.js

@@ -1,12 +1,11 @@
 import './_commonjsHelpers-0c4b6f40.js';
 import './_to-object-b9b796ec.js';
-import './web.dom.iterable-3be50d6c.js';
+import './web.dom.iterable-7e9bebf9.js';
 import { d as debounce_1, l as lib_3 } from './debounce-702eb224.js';
-import { m as main_39 } from './main-d550db5e.js';
-import { _ as _toConsumableArray } from './toConsumableArray-a096ca06.js';
-import './core.get-iterator-method-31c1fb1a.js';
+import { m as main_39 } from './main-cb86f95d.js';
+import { _ as _toConsumableArray } from './toConsumableArray-2718dc16.js';
 import { _ as _extends } from './extends-dbbe308d.js';
-import { a as _inherits, b as _classCallCheck, c as _possibleConstructorReturn, d as _Object$getPrototypeOf, e as _createClass } from './inherits-9d26445c.js';
+import { a as _inherits, b as _classCallCheck, c as _possibleConstructorReturn, d as _Object$getPrototypeOf, e as _createClass } from './inherits-cb536901.js';
 import React__default from 'react';
 import 'prop-types';
 import Container from 'react-bootstrap/Container';

package/dist/esm/{Dfp-f518314c.js → Dfp-9293acfb.js}

@@ -1,13 +1,12 @@
 import './_commonjsHelpers-0c4b6f40.js';
 import './_to-object-b9b796ec.js';
-import './web.dom.iterable-3be50d6c.js';
+import './web.dom.iterable-7e9bebf9.js';
 import { d as debounce_1, a as lib_1, e as lib_2 } from './debounce-702eb224.js';
-import './core.get-iterator-method-31c1fb1a.js';
 import React__default, { useState } from 'react';
 import PropTypes from 'prop-types';
 import { V as VisibilitySensor } from './visibility-sensor-3cea5efb.js';
 import 'react-dom';
-import { _ as _slicedToArray } from './slicedToArray-d1db3163.js';
+import { _ as _slicedToArray } from './slicedToArray-a47a84a4.js';
 
 var AD = function AD(_ref) {
   var networkID = _ref.networkID,

package/dist/esm/{Figure-af6a1f2d.js → Figure-584ac0c8.js}

@@ -1,10 +1,9 @@
 import './_commonjsHelpers-0c4b6f40.js';
 import './_to-object-b9b796ec.js';
-import './web.dom.iterable-3be50d6c.js';
-import './core.get-iterator-method-31c1fb1a.js';
+import './web.dom.iterable-7e9bebf9.js';
 import React__default, { useState } from 'react';
 import { i as imageUrlBuilder } from './index-51a80699.js';
-import { _ as _slicedToArray } from './slicedToArray-d1db3163.js';
+import { _ as _slicedToArray } from './slicedToArray-a47a84a4.js';
 import { Figure as Figure$1 } from 'react-bootstrap';
 
 var urlFor = function urlFor(source, client) {

package/dist/esm/{GridContent-dd8fe8d1.js → GridContent-ceb53300.js}

@@ -1,8 +1,8 @@
 import { d as debounce_1, l as lib_3 } from './debounce-702eb224.js';
-import { m as main_39 } from './main-d550db5e.js';
-import { _ as _toConsumableArray } from './toConsumableArray-a096ca06.js';
+import { m as main_39 } from './main-cb86f95d.js';
+import { _ as _toConsumableArray } from './toConsumableArray-2718dc16.js';
 import { _ as _extends } from './extends-dbbe308d.js';
-import { a as _inherits, b as _classCallCheck, c as _possibleConstructorReturn, d as _Object$getPrototypeOf, e as _createClass } from './inherits-9d26445c.js';
+import { a as _inherits, b as _classCallCheck, c as _possibleConstructorReturn, d as _Object$getPrototypeOf, e as _createClass } from './inherits-cb536901.js';
 import React__default, { Suspense } from 'react';
 import Container from 'react-bootstrap/Container';
 import Row from 'react-bootstrap/Row';
@@ -14,11 +14,11 @@ import { withRouter } from 'next/router';
 import { i as imageUrlBuilder } from './index-51a80699.js';
 import { L as LazyLoad } from './index-5f9f807a.js';
 import { c as clean_html_1 } from './entities-7cc3bf45.js';
-import { A as ADInfeed } from './ADInfeed-2aaf8622.js';
+import { A as ADInfeed } from './ADInfeed-aadcfc25.js';
 import { g as get_1 } from './get-36d03764.js';
 
 var Dfp = React__default.lazy(function () {
-  return import('./Dfp-f518314c.js');
+  return import('./Dfp-9293acfb.js');
 });
 
 var AD = function AD(props) {