@mjhls/mjh-framework 1.0.236 → 1.0.238

package/dist/cjs/slicedToArray-e38fb29d.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
+var _toObject = require('./_to-object-329a650b.js');
+var web_dom_iterable = require('./web.dom.iterable-0998bdc3.js');
+var core_getIteratorMethod = require('./core.get-iterator-method-e049ca4a.js');
+
+var ITERATOR = web_dom_iterable._wks('iterator');
+
+var core_isIterable = _toObject._core.isIterable = function (it) {
+  var O = Object(it);
+  return O[ITERATOR] !== undefined
+    || '@@iterator' in O
+    // eslint-disable-next-line no-prototype-builtins
+    || web_dom_iterable._iterators.hasOwnProperty(core_getIteratorMethod._classof(O));
+};
+
+var isIterable = core_isIterable;
+
+var isIterable$1 = _commonjsHelpers.createCommonjsModule(function (module) {
+module.exports = { "default": isIterable, __esModule: true };
+});
+
+_commonjsHelpers.unwrapExports(isIterable$1);
+
+var core_getIterator = _toObject._core.getIterator = function (it) {
+  var iterFn = core_getIteratorMethod.core_getIteratorMethod(it);
+  if (typeof iterFn != 'function') throw TypeError(it + ' is not iterable!');
+  return _toObject._anObject(iterFn.call(it));
+};
+
+var getIterator = core_getIterator;
+
+var getIterator$1 = _commonjsHelpers.createCommonjsModule(function (module) {
+module.exports = { "default": getIterator, __esModule: true };
+});
+
+_commonjsHelpers.unwrapExports(getIterator$1);
+
+var slicedToArray = _commonjsHelpers.createCommonjsModule(function (module, exports) {
+
+exports.__esModule = true;
+
+
+
+var _isIterable3 = _interopRequireDefault(isIterable$1);
+
+
+
+var _getIterator3 = _interopRequireDefault(getIterator$1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function () {
+  function sliceIterator(arr, i) {
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+
+    try {
+      for (var _i = (0, _getIterator3.default)(arr), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"]) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+
+    return _arr;
+  }
+
+  return function (arr, i) {
+    if (Array.isArray(arr)) {
+      return arr;
+    } else if ((0, _isIterable3.default)(Object(arr))) {
+      return sliceIterator(arr, i);
+    } else {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance");
+    }
+  };
+}();
+});
+
+var _slicedToArray = _commonjsHelpers.unwrapExports(slicedToArray);
+
+exports._slicedToArray = _slicedToArray;

package/dist/cjs/toConsumableArray-7e4caf3c.js

@@ -0,0 +1,123 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
+var _toObject = require('./_to-object-329a650b.js');
+var web_dom_iterable = require('./web.dom.iterable-0998bdc3.js');
+var core_getIteratorMethod = require('./core.get-iterator-method-e049ca4a.js');
+
+// call something on iterator step with safe closing on error
+
+var _iterCall = function (iterator, fn, value, entries) {
+  try {
+    return entries ? fn(_toObject._anObject(value)[0], value[1]) : fn(value);
+  // 7.4.6 IteratorClose(iterator, completion)
+  } catch (e) {
+    var ret = iterator['return'];
+    if (ret !== undefined) _toObject._anObject(ret.call(iterator));
+    throw e;
+  }
+};
+
+// check on default Array iterator
+
+var ITERATOR = web_dom_iterable._wks('iterator');
+var ArrayProto = Array.prototype;
+
+var _isArrayIter = function (it) {
+  return it !== undefined && (web_dom_iterable._iterators.Array === it || ArrayProto[ITERATOR] === it);
+};
+
+var _createProperty = function (object, index, value) {
+  if (index in object) _toObject._objectDp.f(object, index, _toObject._propertyDesc(0, value));
+  else object[index] = value;
+};
+
+var ITERATOR$1 = web_dom_iterable._wks('iterator');
+var SAFE_CLOSING = false;
+
+try {
+  var riter = [7][ITERATOR$1]();
+  riter['return'] = function () { SAFE_CLOSING = true; };
+  // eslint-disable-next-line no-throw-literal
+  Array.from(riter, function () { throw 2; });
+} catch (e) { /* empty */ }
+
+var _iterDetect = function (exec, skipClosing) {
+  if (!skipClosing && !SAFE_CLOSING) return false;
+  var safe = false;
+  try {
+    var arr = [7];
+    var iter = arr[ITERATOR$1]();
+    iter.next = function () { return { done: safe = true }; };
+    arr[ITERATOR$1] = function () { return iter; };
+    exec(arr);
+  } catch (e) { /* empty */ }
+  return safe;
+};
+
+_toObject._export(_toObject._export.S + _toObject._export.F * !_iterDetect(function (iter) { Array.from(iter); }), 'Array', {
+  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
+  from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+    var O = _toObject._toObject(arrayLike);
+    var C = typeof this == 'function' ? this : Array;
+    var aLen = arguments.length;
+    var mapfn = aLen > 1 ? arguments[1] : undefined;
+    var mapping = mapfn !== undefined;
+    var index = 0;
+    var iterFn = core_getIteratorMethod.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
+    if (iterFn != undefined && !(C == Array && _isArrayIter(iterFn))) {
+      for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
+        _createProperty(result, index, mapping ? _iterCall(iterator, mapfn, [step.value, index], true) : step.value);
+      }
+    } else {
+      length = _toObject._toLength(O.length);
+      for (result = new C(length); length > index; index++) {
+        _createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
+      }
+    }
+    result.length = index;
+    return result;
+  }
+});
+
+var from_1 = _toObject._core.Array.from;
+
+var from_1$1 = _commonjsHelpers.createCommonjsModule(function (module) {
+module.exports = { "default": from_1, __esModule: true };
+});
+
+var _Array$from = _commonjsHelpers.unwrapExports(from_1$1);
+
+var toConsumableArray = _commonjsHelpers.createCommonjsModule(function (module, exports) {
+
+exports.__esModule = true;
+
+
+
+var _from2 = _interopRequireDefault(from_1$1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  } else {
+    return (0, _from2.default)(arr);
+  }
+};
+});
+
+var _toConsumableArray = _commonjsHelpers.unwrapExports(toConsumableArray);
+
+exports._Array$from = _Array$from;
+exports._isArrayIter = _isArrayIter;
+exports._iterCall = _iterCall;
+exports._iterDetect = _iterDetect;
+exports._toConsumableArray = _toConsumableArray;

package/dist/cjs/{visibility-sensor-8936e703.js → visibility-sensor-b72d9527.js}

@@ -2,9 +2,9 @@
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
 var React = require('react');
 var React__default = _interopDefault(React);
-var _commonjsHelpers = require('./_commonjsHelpers-3fc1f64e.js');
 var reactDom = _interopDefault(require('react-dom'));
 
 var moment = _commonjsHelpers.createCommonjsModule(function (module, exports) {

package/dist/cjs/web.dom.iterable-0998bdc3.js

@@ -0,0 +1,254 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
+var _toObject = require('./_to-object-329a650b.js');
+
+// true  -> String#at
+// false -> String#codePointAt
+var _stringAt = function (TO_STRING) {
+  return function (that, pos) {
+    var s = String(_toObject._defined(that));
+    var i = _toObject._toInteger(pos);
+    var l = s.length;
+    var a, b;
+    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
+    a = s.charCodeAt(i);
+    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
+      ? TO_STRING ? s.charAt(i) : a
+      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+  };
+};
+
+var _redefine = _toObject._hide;
+
+var _iterators = {};
+
+var _objectDps = _toObject._descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
+  _toObject._anObject(O);
+  var keys = _toObject._objectKeys(Properties);
+  var length = keys.length;
+  var i = 0;
+  var P;
+  while (length > i) _toObject._objectDp.f(O, P = keys[i++], Properties[P]);
+  return O;
+};
+
+var document = _toObject._global.document;
+var _html = document && document.documentElement;
+
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+
+
+
+var IE_PROTO = _toObject._sharedKey('IE_PROTO');
+var Empty = function () { /* empty */ };
+var PROTOTYPE = 'prototype';
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var createDict = function () {
+  // Thrash, waste and sodomy: IE GC bug
+  var iframe = _toObject._domCreate('iframe');
+  var i = _toObject._enumBugKeys.length;
+  var lt = '<';
+  var gt = '>';
+  var iframeDocument;
+  iframe.style.display = 'none';
+  _html.appendChild(iframe);
+  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+  // createDict = iframe.contentWindow.Object;
+  // html.removeChild(iframe);
+  iframeDocument = iframe.contentWindow.document;
+  iframeDocument.open();
+  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
+  iframeDocument.close();
+  createDict = iframeDocument.F;
+  while (i--) delete createDict[PROTOTYPE][_toObject._enumBugKeys[i]];
+  return createDict();
+};
+
+var _objectCreate = Object.create || function create(O, Properties) {
+  var result;
+  if (O !== null) {
+    Empty[PROTOTYPE] = _toObject._anObject(O);
+    result = new Empty();
+    Empty[PROTOTYPE] = null;
+    // add "__proto__" for Object.getPrototypeOf polyfill
+    result[IE_PROTO] = O;
+  } else result = createDict();
+  return Properties === undefined ? result : _objectDps(result, Properties);
+};
+
+var _wks = _commonjsHelpers.createCommonjsModule(function (module) {
+var store = _toObject._shared('wks');
+
+var Symbol = _toObject._global.Symbol;
+var USE_SYMBOL = typeof Symbol == 'function';
+
+var $exports = module.exports = function (name) {
+  return store[name] || (store[name] =
+    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : _toObject._uid)('Symbol.' + name));
+};
+
+$exports.store = store;
+});
+
+var def = _toObject._objectDp.f;
+
+var TAG = _wks('toStringTag');
+
+var _setToStringTag = function (it, tag, stat) {
+  if (it && !_toObject._has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
+};
+
+var IteratorPrototype = {};
+
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+_toObject._hide(IteratorPrototype, _wks('iterator'), function () { return this; });
+
+var _iterCreate = function (Constructor, NAME, next) {
+  Constructor.prototype = _objectCreate(IteratorPrototype, { next: _toObject._propertyDesc(1, next) });
+  _setToStringTag(Constructor, NAME + ' Iterator');
+};
+
+// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+
+
+var IE_PROTO$1 = _toObject._sharedKey('IE_PROTO');
+var ObjectProto = Object.prototype;
+
+var _objectGpo = Object.getPrototypeOf || function (O) {
+  O = _toObject._toObject(O);
+  if (_toObject._has(O, IE_PROTO$1)) return O[IE_PROTO$1];
+  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+    return O.constructor.prototype;
+  } return O instanceof Object ? ObjectProto : null;
+};
+
+var ITERATOR = _wks('iterator');
+var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
+var FF_ITERATOR = '@@iterator';
+var KEYS = 'keys';
+var VALUES = 'values';
+
+var returnThis = function () { return this; };
+
+var _iterDefine = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
+  _iterCreate(Constructor, NAME, next);
+  var getMethod = function (kind) {
+    if (!BUGGY && kind in proto) return proto[kind];
+    switch (kind) {
+      case KEYS: return function keys() { return new Constructor(this, kind); };
+      case VALUES: return function values() { return new Constructor(this, kind); };
+    } return function entries() { return new Constructor(this, kind); };
+  };
+  var TAG = NAME + ' Iterator';
+  var DEF_VALUES = DEFAULT == VALUES;
+  var VALUES_BUG = false;
+  var proto = Base.prototype;
+  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
+  var $default = $native || getMethod(DEFAULT);
+  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
+  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
+  var methods, key, IteratorPrototype;
+  // Fix native
+  if ($anyNative) {
+    IteratorPrototype = _objectGpo($anyNative.call(new Base()));
+    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
+      // Set @@toStringTag to native iterators
+      _setToStringTag(IteratorPrototype, TAG, true);
+    }
+  }
+  // fix Array#{values, @@iterator}.name in V8 / FF
+  if (DEF_VALUES && $native && $native.name !== VALUES) {
+    VALUES_BUG = true;
+    $default = function values() { return $native.call(this); };
+  }
+  // Define iterator
+  if (( FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
+    _toObject._hide(proto, ITERATOR, $default);
+  }
+  // Plug for library
+  _iterators[NAME] = $default;
+  _iterators[TAG] = returnThis;
+  if (DEFAULT) {
+    methods = {
+      values: DEF_VALUES ? $default : getMethod(VALUES),
+      keys: IS_SET ? $default : getMethod(KEYS),
+      entries: $entries
+    };
+    if (FORCED) for (key in methods) {
+      if (!(key in proto)) _redefine(proto, key, methods[key]);
+    } else _toObject._export(_toObject._export.P + _toObject._export.F * (BUGGY || VALUES_BUG), NAME, methods);
+  }
+  return methods;
+};
+
+var $at = _stringAt(true);
+
+// 21.1.3.27 String.prototype[@@iterator]()
+_iterDefine(String, 'String', function (iterated) {
+  this._t = String(iterated); // target
+  this._i = 0;                // next index
+// 21.1.5.2.1 %StringIteratorPrototype%.next()
+}, function () {
+  var O = this._t;
+  var index = this._i;
+  var point;
+  if (index >= O.length) return { value: undefined, done: true };
+  point = $at(O, index);
+  this._i += point.length;
+  return { value: point, done: false };
+});
+
+var _iterStep = function (done, value) {
+  return { value: value, done: !!done };
+};
+
+// 22.1.3.4 Array.prototype.entries()
+// 22.1.3.13 Array.prototype.keys()
+// 22.1.3.29 Array.prototype.values()
+// 22.1.3.30 Array.prototype[@@iterator]()
+var es6_array_iterator = _iterDefine(Array, 'Array', function (iterated, kind) {
+  this._t = _toObject._toIobject(iterated); // target
+  this._i = 0;                   // next index
+  this._k = kind;                // kind
+// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+}, function () {
+  var O = this._t;
+  var kind = this._k;
+  var index = this._i++;
+  if (!O || index >= O.length) {
+    this._t = undefined;
+    return _iterStep(1);
+  }
+  if (kind == 'keys') return _iterStep(0, index);
+  if (kind == 'values') return _iterStep(0, O[index]);
+  return _iterStep(0, [index, O[index]]);
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+_iterators.Arguments = _iterators.Array;
+
+var TO_STRING_TAG = _wks('toStringTag');
+
+var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
+  'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
+  'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
+  'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
+  'TextTrackList,TouchList').split(',');
+
+for (var i = 0; i < DOMIterables.length; i++) {
+  var NAME = DOMIterables[i];
+  var Collection = _toObject._global[NAME];
+  var proto = Collection && Collection.prototype;
+  if (proto && !proto[TO_STRING_TAG]) _toObject._hide(proto, TO_STRING_TAG, NAME);
+  _iterators[NAME] = _iterators.Array;
+}
+
+exports._html = _html;
+exports._iterators = _iterators;
+exports._objectCreate = _objectCreate;
+exports._objectGpo = _objectGpo;
+exports._redefine = _redefine;
+exports._setToStringTag = _setToStringTag;
+exports._wks = _wks;

package/dist/esm/AdSlot-017b8051.js

@@ -0,0 +1,64 @@
+import React__default, { useState } from 'react';
+import { b as lib_2 } from './index-fa84ea96.js';
+import PropTypes from 'prop-types';
+import { d as debounce_1 } from './debounce-fa7fbf11.js';
+import { _ as _slicedToArray } from './slicedToArray-eb7eca9e.js';
+
+var DFPAdSlot = function DFPAdSlot(_ref) {
+  var adUnit = _ref.adUnit,
+      sizeMapping = _ref.sizeMapping,
+      className = _ref.className,
+      slotId = _ref.slotId,
+      sizes = _ref.sizes,
+      _ref$targeting = _ref.targeting,
+      targeting = _ref$targeting === undefined ? {} : _ref$targeting;
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      adRendered = _useState2[0],
+      setAdRendered = _useState2[1];
+
+  var _useState3 = useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      adRefreshable = _useState4[0],
+      setAdRefreshable = _useState4[1];
+
+  var handleVisibilityChange = debounce_1(function (_ref2) {
+    var event = _ref2.event;
+
+    if (event.inViewPercentage <= 0) {
+      setAdRefreshable(false);
+    } else {
+      setAdRefreshable(true);
+    }
+  }, 500);
+
+  return React__default.createElement(
+    'div',
+    { className: className },
+    React__default.createElement(lib_2, {
+      slotId: slotId,
+      sizes: sizes,
+      adUnit: adUnit,
+      sizeMapping: sizeMapping,
+      targetingArguments: targeting,
+      onSlotRender: function onSlotRender(eventData) {
+        setAdRendered(true);
+      },
+      onSlotVisibilityChanged: handleVisibilityChange,
+      shouldRefresh: function shouldRefresh() {
+        if (adRendered && adRefreshable) return true;else return false;
+      }
+    })
+  );
+};
+
+DFPAdSlot.propTypes = {
+  adUnit: PropTypes.string.isRequired,
+  slotId: PropTypes.string,
+  className: PropTypes.string,
+  sizeMapping: PropTypes.array,
+  sizes: PropTypes.array
+};
+
+export { DFPAdSlot as D };

package/dist/esm/DeckContent.js

@@ -1,38 +1,44 @@
+import './_commonjsHelpers-0c4b6f40.js';
+import './_to-object-86553f76.js';
+import './web.dom.iterable-f05d2f57.js';
+import { a as _inherits, b as _classCallCheck, c as _possibleConstructorReturn, d as _Object$getPrototypeOf, e as _createClass } from './inherits-a82a4471.js';
+import { _ as _toConsumableArray } from './toConsumableArray-08d50169.js';
+import './core.get-iterator-method-709061dc.js';
+import { _ as _extends } from './extends-7f88fa22.js';
 import React__default from 'react';
-import './_commonjsHelpers-ae1b5db5.js';
-import { l as lib_3 } from './index-70f7c966.js';
+import { l as lib_3 } from './index-fa84ea96.js';
 import 'prop-types';
 import Container from 'react-bootstrap/Container';
 import Row from 'react-bootstrap/Row';
 import Col from 'react-bootstrap/Col';
 import Card from 'react-bootstrap/Card';
-import { I as InfiniteScroll, V as VisibilitySensor, m as moment } from './visibility-sensor-71e50a91.js';
+import { V as VisibilitySensor, m as moment, I as InfiniteScroll } from './visibility-sensor-336093e1.js';
 import 'next/link';
 import { withRouter } from 'next/router';
-import { d as debounce_1 } from './debounce-dc0c02e5.js';
+import { d as debounce_1 } from './debounce-fa7fbf11.js';
 import 'react-dom';
-import { i as imageUrlBuilder } from './index-ca4ff5cb.js';
-import { L as LazyLoad } from './index-3c1ee9ab.js';
-import { m as main_36 } from './main-e84e7749.js';
-import { c as clean_html_1 } from './entities-e85d3a4a.js';
-import { i as inherits, c as createClass, a as classCallCheck, p as possibleConstructorReturn, _ as _extends, t as toConsumableArray } from './_babelHelpers-c212c59c.js';
-import { D as DFPAdSlot } from './AdSlot-c40f4438.js';
+import { i as imageUrlBuilder } from './index-3849e3fe.js';
+import { L as LazyLoad } from './index-5f9f807a.js';
+import { m as main_36 } from './main-eecf7b27.js';
+import { c as clean_html_1 } from './entities-7cc3bf45.js';
+import './slicedToArray-eb7eca9e.js';
+import { D as DFPAdSlot } from './AdSlot-017b8051.js';
 
 var DeckContent = function (_React$Component) {
-  inherits(DeckContent, _React$Component);
+  _inherits(DeckContent, _React$Component);
 
   function DeckContent() {
     var _ref;
 
     var _temp, _this, _ret;
 
-    classCallCheck(this, DeckContent);
+    _classCallCheck(this, DeckContent);
 
     for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
 
-    return _ret = (_temp = (_this = possibleConstructorReturn(this, (_ref = DeckContent.__proto__ || Object.getPrototypeOf(DeckContent)).call.apply(_ref, [this].concat(args))), _this), _this.mapping = _this.props.mapping, _this.data = _this.props.dataRecord || [], _this.query = _this.props.query, _this.params = _this.props.params, _this.pointer = _this.props.pointer ? _this.props.pointer : false, _this.pointerArray = _this.props.pointerArray ? _this.props.pointerArray : false, _this.defaultImage = _this.props.defaultImage ? _this.props.defaultImage : '/placeholder.jpg', _this.state = {
+    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = DeckContent.__proto__ || _Object$getPrototypeOf(DeckContent)).call.apply(_ref, [this].concat(args))), _this), _this.mapping = _this.props.mapping, _this.data = _this.props.dataRecord || [], _this.query = _this.props.query, _this.params = _this.props.params, _this.pointer = _this.props.pointer ? _this.props.pointer : false, _this.pointerArray = _this.props.pointerArray ? _this.props.pointerArray : false, _this.defaultImage = _this.props.defaultImage ? _this.props.defaultImage : '/placeholder.jpg', _this.state = {
       data: _this.data,
       dataKeptToCompareNewDatarecord: _this.data,
       per: _this.params ? _this.params.to : 2,
@@ -83,7 +89,7 @@ var DeckContent = function (_React$Component) {
         _this.setState(function () {
           if (dataArr.length > 0) {
             return {
-              data: [].concat(toConsumableArray(data), toConsumableArray(dataArr)),
+              data: [].concat(_toConsumableArray(data), _toConsumableArray(dataArr)),
               scrolling: true
             };
           } else {
@@ -225,7 +231,7 @@ var DeckContent = function (_React$Component) {
       var numberOfItemsBeforeAd = 6;
 
       var insert = function insert(arr, index, newElement) {
-        return [].concat(toConsumableArray(arr.slice(0, index)), [newElement], toConsumableArray(arr.slice(index)));
+        return [].concat(_toConsumableArray(arr.slice(0, index)), [newElement], _toConsumableArray(arr.slice(index)));
       };
       var articles = [];
       if (showBI) {
@@ -374,10 +380,10 @@ var DeckContent = function (_React$Component) {
           'Next >>'
         )
       );
-    }, _temp), possibleConstructorReturn(_this, _ret);
+    }, _temp), _possibleConstructorReturn(_this, _ret);
   }
 
-  createClass(DeckContent, [{
+  _createClass(DeckContent, [{
     key: 'componentDidUpdate',
     value: function componentDidUpdate(prevProps, prevState) {
       if (this.state.dataKeptToCompareNewDatarecord !== this.props.dataRecord) {
@@ -472,6 +478,7 @@ var DeckContent = function (_React$Component) {
       );
     }
   }]);
+
   return DeckContent;
 }(React__default.Component);