@mjhls/mjh-framework 1.0.463 → 1.0.464

package/dist/cjs/{asyncToGenerator-db08763c.js → asyncToGenerator-8e707718.js}

@@ -1,7 +1,12 @@
 'use strict';
 
 var _commonjsHelpers = require('./_commonjsHelpers-06173234.js');
-var promise = require('./promise-074978a7.js');
+var _toObject = require('./_to-object-329a650b.js');
+var core_getIteratorMethod = require('./core.get-iterator-method-41e87ec1.js');
+var _library = require('./_library-dd23b178.js');
+var _iterDetect = require('./_iter-detect-4d0352f8.js');
+require('./web.dom.iterable-43c3e277.js');
+var _setSpecies = require('./_set-species-4458e975.js');
 
 var runtime = _commonjsHelpers.createCommonjsModule(function (module) {
 /**
@@ -768,13 +773,541 @@ if (hadRuntime) {
 
 var regenerator = runtimeModule;
 
+// 7.3.20 SpeciesConstructor(O, defaultConstructor)
+
+
+var SPECIES = core_getIteratorMethod._wks('species');
+var _speciesConstructor = function (O, D) {
+  var C = _toObject._anObject(O).constructor;
+  var S;
+  return C === undefined || (S = _toObject._anObject(C)[SPECIES]) == undefined ? D : _toObject._aFunction(S);
+};
+
+// fast apply, http://jsperf.lnkit.com/fast-apply/5
+var _invoke = function (fn, args, that) {
+  var un = that === undefined;
+  switch (args.length) {
+    case 0: return un ? fn()
+                      : fn.call(that);
+    case 1: return un ? fn(args[0])
+                      : fn.call(that, args[0]);
+    case 2: return un ? fn(args[0], args[1])
+                      : fn.call(that, args[0], args[1]);
+    case 3: return un ? fn(args[0], args[1], args[2])
+                      : fn.call(that, args[0], args[1], args[2]);
+    case 4: return un ? fn(args[0], args[1], args[2], args[3])
+                      : fn.call(that, args[0], args[1], args[2], args[3]);
+  } return fn.apply(that, args);
+};
+
+var process = _toObject._global.process;
+var setTask = _toObject._global.setImmediate;
+var clearTask = _toObject._global.clearImmediate;
+var MessageChannel = _toObject._global.MessageChannel;
+var Dispatch = _toObject._global.Dispatch;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var defer, channel, port;
+var run = function () {
+  var id = +this;
+  // eslint-disable-next-line no-prototype-builtins
+  if (queue.hasOwnProperty(id)) {
+    var fn = queue[id];
+    delete queue[id];
+    fn();
+  }
+};
+var listener = function (event) {
+  run.call(event.data);
+};
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if (!setTask || !clearTask) {
+  setTask = function setImmediate(fn) {
+    var args = [];
+    var i = 1;
+    while (arguments.length > i) args.push(arguments[i++]);
+    queue[++counter] = function () {
+      // eslint-disable-next-line no-new-func
+      _invoke(typeof fn == 'function' ? fn : Function(fn), args);
+    };
+    defer(counter);
+    return counter;
+  };
+  clearTask = function clearImmediate(id) {
+    delete queue[id];
+  };
+  // Node.js 0.8-
+  if (_toObject._cof(process) == 'process') {
+    defer = function (id) {
+      process.nextTick(_toObject._ctx(run, id, 1));
+    };
+  // Sphere (JS game engine) Dispatch API
+  } else if (Dispatch && Dispatch.now) {
+    defer = function (id) {
+      Dispatch.now(_toObject._ctx(run, id, 1));
+    };
+  // Browsers with MessageChannel, includes WebWorkers
+  } else if (MessageChannel) {
+    channel = new MessageChannel();
+    port = channel.port2;
+    channel.port1.onmessage = listener;
+    defer = _toObject._ctx(port.postMessage, port, 1);
+  // Browsers with postMessage, skip WebWorkers
+  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+  } else if (_toObject._global.addEventListener && typeof postMessage == 'function' && !_toObject._global.importScripts) {
+    defer = function (id) {
+      _toObject._global.postMessage(id + '', '*');
+    };
+    _toObject._global.addEventListener('message', listener, false);
+  // IE8-
+  } else if (ONREADYSTATECHANGE in _toObject._domCreate('script')) {
+    defer = function (id) {
+      core_getIteratorMethod._html.appendChild(_toObject._domCreate('script'))[ONREADYSTATECHANGE] = function () {
+        core_getIteratorMethod._html.removeChild(this);
+        run.call(id);
+      };
+    };
+  // Rest old browsers
+  } else {
+    defer = function (id) {
+      setTimeout(_toObject._ctx(run, id, 1), 0);
+    };
+  }
+}
+var _task = {
+  set: setTask,
+  clear: clearTask
+};
+
+var macrotask = _task.set;
+var Observer = _toObject._global.MutationObserver || _toObject._global.WebKitMutationObserver;
+var process$1 = _toObject._global.process;
+var Promise$1 = _toObject._global.Promise;
+var isNode = _toObject._cof(process$1) == 'process';
+
+var _microtask = function () {
+  var head, last, notify;
+
+  var flush = function () {
+    var parent, fn;
+    if (isNode && (parent = process$1.domain)) parent.exit();
+    while (head) {
+      fn = head.fn;
+      head = head.next;
+      try {
+        fn();
+      } catch (e) {
+        if (head) notify();
+        else last = undefined;
+        throw e;
+      }
+    } last = undefined;
+    if (parent) parent.enter();
+  };
+
+  // Node.js
+  if (isNode) {
+    notify = function () {
+      process$1.nextTick(flush);
+    };
+  // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339
+  } else if (Observer && !(_toObject._global.navigator && _toObject._global.navigator.standalone)) {
+    var toggle = true;
+    var node = document.createTextNode('');
+    new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
+    notify = function () {
+      node.data = toggle = !toggle;
+    };
+  // environments with maybe non-completely correct, but existent Promise
+  } else if (Promise$1 && Promise$1.resolve) {
+    // Promise.resolve without an argument throws an error in LG WebOS 2
+    var promise = Promise$1.resolve(undefined);
+    notify = function () {
+      promise.then(flush);
+    };
+  // for other environments - macrotask based on:
+  // - setImmediate
+  // - MessageChannel
+  // - window.postMessag
+  // - onreadystatechange
+  // - setTimeout
+  } else {
+    notify = function () {
+      // strange IE + webpack dev server bug - use .call(global)
+      macrotask.call(_toObject._global, flush);
+    };
+  }
+
+  return function (fn) {
+    var task = { fn: fn, next: undefined };
+    if (last) last.next = task;
+    if (!head) {
+      head = task;
+      notify();
+    } last = task;
+  };
+};
+
+// 25.4.1.5 NewPromiseCapability(C)
+
+
+function PromiseCapability(C) {
+  var resolve, reject;
+  this.promise = new C(function ($$resolve, $$reject) {
+    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+    resolve = $$resolve;
+    reject = $$reject;
+  });
+  this.resolve = _toObject._aFunction(resolve);
+  this.reject = _toObject._aFunction(reject);
+}
+
+var f = function (C) {
+  return new PromiseCapability(C);
+};
+
+var _newPromiseCapability = {
+	f: f
+};
+
+var _perform = function (exec) {
+  try {
+    return { e: false, v: exec() };
+  } catch (e) {
+    return { e: true, v: e };
+  }
+};
+
+var navigator = _toObject._global.navigator;
+
+var _userAgent = navigator && navigator.userAgent || '';
+
+var _promiseResolve = function (C, x) {
+  _toObject._anObject(C);
+  if (_toObject._isObject(x) && x.constructor === C) return x;
+  var promiseCapability = _newPromiseCapability.f(C);
+  var resolve = promiseCapability.resolve;
+  resolve(x);
+  return promiseCapability.promise;
+};
+
+var task = _task.set;
+var microtask = _microtask();
+
+
+
+
+var PROMISE = 'Promise';
+var TypeError$1 = _toObject._global.TypeError;
+var process$2 = _toObject._global.process;
+var versions = process$2 && process$2.versions;
+var v8 = versions && versions.v8 || '';
+var $Promise = _toObject._global[PROMISE];
+var isNode$1 = core_getIteratorMethod._classof(process$2) == 'process';
+var empty = function () { /* empty */ };
+var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
+var newPromiseCapability = newGenericPromiseCapability = _newPromiseCapability.f;
+
+var USE_NATIVE = !!function () {
+  try {
+    // correct subclassing with @@species support
+    var promise = $Promise.resolve(1);
+    var FakePromise = (promise.constructor = {})[core_getIteratorMethod._wks('species')] = function (exec) {
+      exec(empty, empty);
+    };
+    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+    return (isNode$1 || typeof PromiseRejectionEvent == 'function')
+      && promise.then(empty) instanceof FakePromise
+      // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+      // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+      // we can't detect it synchronously, so just check versions
+      && v8.indexOf('6.6') !== 0
+      && _userAgent.indexOf('Chrome/66') === -1;
+  } catch (e) { /* empty */ }
+}();
+
+// helpers
+var isThenable = function (it) {
+  var then;
+  return _toObject._isObject(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+var notify = function (promise, isReject) {
+  if (promise._n) return;
+  promise._n = true;
+  var chain = promise._c;
+  microtask(function () {
+    var value = promise._v;
+    var ok = promise._s == 1;
+    var i = 0;
+    var run = function (reaction) {
+      var handler = ok ? reaction.ok : reaction.fail;
+      var resolve = reaction.resolve;
+      var reject = reaction.reject;
+      var domain = reaction.domain;
+      var result, then, exited;
+      try {
+        if (handler) {
+          if (!ok) {
+            if (promise._h == 2) onHandleUnhandled(promise);
+            promise._h = 1;
+          }
+          if (handler === true) result = value;
+          else {
+            if (domain) domain.enter();
+            result = handler(value); // may throw
+            if (domain) {
+              domain.exit();
+              exited = true;
+            }
+          }
+          if (result === reaction.promise) {
+            reject(TypeError$1('Promise-chain cycle'));
+          } else if (then = isThenable(result)) {
+            then.call(result, resolve, reject);
+          } else resolve(result);
+        } else reject(value);
+      } catch (e) {
+        if (domain && !exited) domain.exit();
+        reject(e);
+      }
+    };
+    while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
+    promise._c = [];
+    promise._n = false;
+    if (isReject && !promise._h) onUnhandled(promise);
+  });
+};
+var onUnhandled = function (promise) {
+  task.call(_toObject._global, function () {
+    var value = promise._v;
+    var unhandled = isUnhandled(promise);
+    var result, handler, console;
+    if (unhandled) {
+      result = _perform(function () {
+        if (isNode$1) {
+          process$2.emit('unhandledRejection', value, promise);
+        } else if (handler = _toObject._global.onunhandledrejection) {
+          handler({ promise: promise, reason: value });
+        } else if ((console = _toObject._global.console) && console.error) {
+          console.error('Unhandled promise rejection', value);
+        }
+      });
+      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+      promise._h = isNode$1 || isUnhandled(promise) ? 2 : 1;
+    } promise._a = undefined;
+    if (unhandled && result.e) throw result.v;
+  });
+};
+var isUnhandled = function (promise) {
+  return promise._h !== 1 && (promise._a || promise._c).length === 0;
+};
+var onHandleUnhandled = function (promise) {
+  task.call(_toObject._global, function () {
+    var handler;
+    if (isNode$1) {
+      process$2.emit('rejectionHandled', promise);
+    } else if (handler = _toObject._global.onrejectionhandled) {
+      handler({ promise: promise, reason: promise._v });
+    }
+  });
+};
+var $reject = function (value) {
+  var promise = this;
+  if (promise._d) return;
+  promise._d = true;
+  promise = promise._w || promise; // unwrap
+  promise._v = value;
+  promise._s = 2;
+  if (!promise._a) promise._a = promise._c.slice();
+  notify(promise, true);
+};
+var $resolve = function (value) {
+  var promise = this;
+  var then;
+  if (promise._d) return;
+  promise._d = true;
+  promise = promise._w || promise; // unwrap
+  try {
+    if (promise === value) throw TypeError$1("Promise can't be resolved itself");
+    if (then = isThenable(value)) {
+      microtask(function () {
+        var wrapper = { _w: promise, _d: false }; // wrap
+        try {
+          then.call(value, _toObject._ctx($resolve, wrapper, 1), _toObject._ctx($reject, wrapper, 1));
+        } catch (e) {
+          $reject.call(wrapper, e);
+        }
+      });
+    } else {
+      promise._v = value;
+      promise._s = 1;
+      notify(promise, false);
+    }
+  } catch (e) {
+    $reject.call({ _w: promise, _d: false }, e); // wrap
+  }
+};
+
+// constructor polyfill
+if (!USE_NATIVE) {
+  // 25.4.3.1 Promise(executor)
+  $Promise = function Promise(executor) {
+    _setSpecies._anInstance(this, $Promise, PROMISE, '_h');
+    _toObject._aFunction(executor);
+    Internal.call(this);
+    try {
+      executor(_toObject._ctx($resolve, this, 1), _toObject._ctx($reject, this, 1));
+    } catch (err) {
+      $reject.call(this, err);
+    }
+  };
+  // eslint-disable-next-line no-unused-vars
+  Internal = function Promise(executor) {
+    this._c = [];             // <- awaiting reactions
+    this._a = undefined;      // <- checked in isUnhandled reactions
+    this._s = 0;              // <- state
+    this._d = false;          // <- done
+    this._v = undefined;      // <- value
+    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
+    this._n = false;          // <- notify
+  };
+  Internal.prototype = _setSpecies._redefineAll($Promise.prototype, {
+    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
+    then: function then(onFulfilled, onRejected) {
+      var reaction = newPromiseCapability(_speciesConstructor(this, $Promise));
+      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+      reaction.fail = typeof onRejected == 'function' && onRejected;
+      reaction.domain = isNode$1 ? process$2.domain : undefined;
+      this._c.push(reaction);
+      if (this._a) this._a.push(reaction);
+      if (this._s) notify(this, false);
+      return reaction.promise;
+    },
+    // 25.4.5.1 Promise.prototype.catch(onRejected)
+    'catch': function (onRejected) {
+      return this.then(undefined, onRejected);
+    }
+  });
+  OwnPromiseCapability = function () {
+    var promise = new Internal();
+    this.promise = promise;
+    this.resolve = _toObject._ctx($resolve, promise, 1);
+    this.reject = _toObject._ctx($reject, promise, 1);
+  };
+  _newPromiseCapability.f = newPromiseCapability = function (C) {
+    return C === $Promise || C === Wrapper
+      ? new OwnPromiseCapability(C)
+      : newGenericPromiseCapability(C);
+  };
+}
+
+_toObject._export(_toObject._export.G + _toObject._export.W + _toObject._export.F * !USE_NATIVE, { Promise: $Promise });
+core_getIteratorMethod._setToStringTag($Promise, PROMISE);
+_setSpecies._setSpecies(PROMISE);
+Wrapper = _toObject._core[PROMISE];
+
+// statics
+_toObject._export(_toObject._export.S + _toObject._export.F * !USE_NATIVE, PROMISE, {
+  // 25.4.4.5 Promise.reject(r)
+  reject: function reject(r) {
+    var capability = newPromiseCapability(this);
+    var $$reject = capability.reject;
+    $$reject(r);
+    return capability.promise;
+  }
+});
+_toObject._export(_toObject._export.S + _toObject._export.F * (_library._library ), PROMISE, {
+  // 25.4.4.6 Promise.resolve(x)
+  resolve: function resolve(x) {
+    return _promiseResolve( this === Wrapper ? $Promise : this, x);
+  }
+});
+_toObject._export(_toObject._export.S + _toObject._export.F * !(USE_NATIVE && _iterDetect._iterDetect(function (iter) {
+  $Promise.all(iter)['catch'](empty);
+})), PROMISE, {
+  // 25.4.4.1 Promise.all(iterable)
+  all: function all(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(C);
+    var resolve = capability.resolve;
+    var reject = capability.reject;
+    var result = _perform(function () {
+      var values = [];
+      var index = 0;
+      var remaining = 1;
+      _setSpecies._forOf(iterable, false, function (promise) {
+        var $index = index++;
+        var alreadyCalled = false;
+        values.push(undefined);
+        remaining++;
+        C.resolve(promise).then(function (value) {
+          if (alreadyCalled) return;
+          alreadyCalled = true;
+          values[$index] = value;
+          --remaining || resolve(values);
+        }, reject);
+      });
+      --remaining || resolve(values);
+    });
+    if (result.e) reject(result.v);
+    return capability.promise;
+  },
+  // 25.4.4.4 Promise.race(iterable)
+  race: function race(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(C);
+    var reject = capability.reject;
+    var result = _perform(function () {
+      _setSpecies._forOf(iterable, false, function (promise) {
+        C.resolve(promise).then(capability.resolve, reject);
+      });
+    });
+    if (result.e) reject(result.v);
+    return capability.promise;
+  }
+});
+
+_toObject._export(_toObject._export.P + _toObject._export.R, 'Promise', { 'finally': function (onFinally) {
+  var C = _speciesConstructor(this, _toObject._core.Promise || _toObject._global.Promise);
+  var isFunction = typeof onFinally == 'function';
+  return this.then(
+    isFunction ? function (x) {
+      return _promiseResolve(C, onFinally()).then(function () { return x; });
+    } : onFinally,
+    isFunction ? function (e) {
+      return _promiseResolve(C, onFinally()).then(function () { throw e; });
+    } : onFinally
+  );
+} });
+
+// https://github.com/tc39/proposal-promise-try
+
+
+
+
+_toObject._export(_toObject._export.S, 'Promise', { 'try': function (callbackfn) {
+  var promiseCapability = _newPromiseCapability.f(this);
+  var result = _perform(callbackfn);
+  (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
+  return promiseCapability.promise;
+} });
+
+var promise = _toObject._core.Promise;
+
+var promise$1 = _commonjsHelpers.createCommonjsModule(function (module) {
+module.exports = { "default": promise, __esModule: true };
+});
+
+var _Promise = _commonjsHelpers.unwrapExports(promise$1);
+
 var asyncToGenerator = _commonjsHelpers.createCommonjsModule(function (module, exports) {
 
 exports.__esModule = true;
 
 
 
-var _promise2 = _interopRequireDefault(promise.promise);
+var _promise2 = _interopRequireDefault(promise$1);
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -810,5 +1343,6 @@ exports.default = function (fn) {
 
 var _asyncToGenerator = _commonjsHelpers.unwrapExports(asyncToGenerator);
 
+exports._Promise = _Promise;
 exports._asyncToGenerator = _asyncToGenerator;
 exports.regenerator = regenerator;

package/dist/cjs/getSerializers.js

@@ -28,9 +28,8 @@ var main = require('./main-00905561.js');
 var entities = require('./entities-310b46ee.js');
 var slicedToArray = require('./slicedToArray-8063ee51.js');
 require('./stringify-7c5aff47.js');
-require('./asyncToGenerator-db08763c.js');
+require('./asyncToGenerator-8e707718.js');
 require('./_set-species-4458e975.js');
-require('./promise-074978a7.js');
 var Beam = require('./Beam.js');
 require('./Segment.js');
 var AdSlot = require('./AdSlot.js');

package/dist/cjs/index.js

@@ -36,16 +36,15 @@ require('./main-00905561.js');
 require('./entities-310b46ee.js');
 require('./slicedToArray-8063ee51.js');
 require('./stringify-7c5aff47.js');
-require('./asyncToGenerator-db08763c.js');
+require('./asyncToGenerator-8e707718.js');
 require('./_set-species-4458e975.js');
-require('./promise-074978a7.js');
 var Beam = require('./Beam.js');
 var Segment = require('./Segment.js');
 var AdSlot = require('./AdSlot.js');
-require('./ADInfeed-5adbfbba.js');
+require('./ADInfeed-4b904089.js');
 var DeckContent = require('./DeckContent.js');
 require('./lodash-fc2922d0.js');
-require('./ADlgInfeed-028da9eb.js');
+require('./ADlgInfeed-f540f438.js');
 require('./_arrayMap-3b4a0f75.js');
 require('./get-5dfcdc33.js');
 var AD = require('./AD.js');

package/dist/esm/AD300x250.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import { m as main_36 } from './main-adf6ec37.js';
 import './slicedToArray-f1e40361.js';
 import './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';

package/dist/esm/AD300x250x600.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import { m as main_36 } from './main-adf6ec37.js';
 import './slicedToArray-f1e40361.js';
 import './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';

package/dist/esm/AD728x90.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import { m as main_36 } from './main-adf6ec37.js';
 import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
 import './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';

package/dist/esm/ADFloatingFooter.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import './main-adf6ec37.js';
 import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
 import { _ as _JSON$stringify } from './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';

package/dist/esm/ADGutter.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import './main-adf6ec37.js';
 import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
 import './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';

package/dist/esm/ADSponsoredResources.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import './main-adf6ec37.js';
 import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
 import './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';

package/dist/esm/ADWebcast.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import './main-adf6ec37.js';
 import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
 import './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';

package/dist/esm/ADWelcome.js

@@ -12,9 +12,8 @@ import './debounce-8cd9e09c.js';
 import './main-adf6ec37.js';
 import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
 import './stringify-e30bc114.js';
-import './asyncToGenerator-204b5a5c.js';
+import './asyncToGenerator-0379e924.js';
 import './_set-species-6f64f1c1.js';
-import './promise-53143c9a.js';
 import './Beam.js';
 import './Segment.js';
 import DFPAdSlot from './AdSlot.js';