@vonage/vivid 3.0.0-next.10 → 3.0.0-next.101

package/shared/icon.js

@@ -1,27 +1,24 @@
-import { g as global$e, r as redefine$3, w as wellKnownSymbol$8, a as getBuiltIn$4, o as objectDefineProperty, d as descriptors, b as objectIsPrototypeOf, f as functionUncurryThis, c as functionBindNative, e as aCallable$4, i as iterators, h as classofRaw$1, j as isCallable$5, k as getMethod$2, l as functionCall, m as anObject$5, t as tryToString$3, n as lengthOfArrayLike$1, p as fails$4, q as inspectSource$2, s as engineUserAgent, u as html$1, v as documentCreateElement, x as hasOwnProperty_1, y as objectGetOwnPropertyDescriptor, z as isObject$2, _ as _export, A as objectSetPrototypeOf, B as setToStringTag$1, C as isForced_1, D as engineV8Version, E as internalState, F as requireObjectCoercible$1, G as functionName } from './web.dom-collections.iterator.js';
+import { c as classofRaw, g as global$8, w as wellKnownSymbol$6, a as getBuiltIn$5, o as objectDefineProperty, d as descriptors, b as objectIsPrototypeOf, f as functionUncurryThis, e as fails$4, i as isCallable$6, h as inspectSource$2, t as tryToString$3, j as anObject$5, k as isNullOrUndefined$2, l as functionBindNative, m as aCallable$6, n as engineUserAgent, p as documentCreateElement, q as hasOwnProperty_1, r as objectGetOwnPropertyDescriptor, s as isForced_1, u as engineV8Version, _ as _export, v as defineBuiltIn$3, x as functionCall, y as internalState, z as isObject$2, A as getMethod$2, B as lengthOfArrayLike$1, C as functionName } from './export.js';
+import { h as html$1, o as objectSetPrototypeOf, s as setToStringTag$1, i as iterators } from './iterators.js';
+import { c as classof$3 } from './to-string.js';
+import { w as whitespaces$1, s as stringTrim } from './string-trim.js';
 import { F as FoundationElement, _ as __decorate, a as attr, b as __metadata, o as observable } from './index.js';
 import { _ as _curry1, a as _curry2, b as _has } from './_has.js';
 
-var global$d = global$e;
+var classof$2 = classofRaw;
+var global$7 = global$8;
 
-var nativePromiseConstructor = global$d.Promise;
+var engineIsNode = classof$2(global$7.process) == 'process';
 
-var redefine$2 = redefine$3.exports;
-
-var redefineAll$1 = function (target, src, options) {
-  for (var key in src) redefine$2(target, key, src[key], options);
-  return target;
-};
-
-var getBuiltIn$3 = getBuiltIn$4;
+var getBuiltIn$4 = getBuiltIn$5;
 var definePropertyModule = objectDefineProperty;
-var wellKnownSymbol$7 = wellKnownSymbol$8;
+var wellKnownSymbol$5 = wellKnownSymbol$6;
 var DESCRIPTORS = descriptors;
 
-var SPECIES$2 = wellKnownSymbol$7('species');
+var SPECIES$2 = wellKnownSymbol$5('species');
 
 var setSpecies$1 = function (CONSTRUCTOR_NAME) {
-  var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
+  var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME);
   var defineProperty = definePropertyModule.f;
 
   if (DESCRIPTORS && Constructor && !Constructor[SPECIES$2]) {
@@ -32,255 +29,31 @@ var setSpecies$1 = function (CONSTRUCTOR_NAME) {
   }
 };
 
-var global$c = global$e;
 var isPrototypeOf$1 = objectIsPrototypeOf;
 
-var TypeError$6 = global$c.TypeError;
+var $TypeError$5 = TypeError;
 
 var anInstance$1 = function (it, Prototype) {
   if (isPrototypeOf$1(Prototype, it)) return it;
-  throw TypeError$6('Incorrect invocation');
-};
-
-var uncurryThis$3 = functionUncurryThis;
-var aCallable$3 = aCallable$4;
-var NATIVE_BIND$1 = functionBindNative;
-
-var bind$4 = uncurryThis$3(uncurryThis$3.bind);
-
-// optional / simple context binding
-var functionBindContext = function (fn, that) {
-  aCallable$3(fn);
-  return that === undefined ? fn : NATIVE_BIND$1 ? bind$4(fn, that) : function (/* ...args */) {
-    return fn.apply(that, arguments);
-  };
-};
-
-var wellKnownSymbol$6 = wellKnownSymbol$8;
-var Iterators$1 = iterators;
-
-var ITERATOR$2 = wellKnownSymbol$6('iterator');
-var ArrayPrototype = Array.prototype;
-
-// check on default Array iterator
-var isArrayIteratorMethod$1 = function (it) {
-  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
-};
-
-var wellKnownSymbol$5 = wellKnownSymbol$8;
-
-var TO_STRING_TAG$1 = wellKnownSymbol$5('toStringTag');
-var test = {};
-
-test[TO_STRING_TAG$1] = 'z';
-
-var toStringTagSupport = String(test) === '[object z]';
-
-var global$b = global$e;
-var TO_STRING_TAG_SUPPORT = toStringTagSupport;
-var isCallable$4 = isCallable$5;
-var classofRaw = classofRaw$1;
-var wellKnownSymbol$4 = wellKnownSymbol$8;
-
-var TO_STRING_TAG = wellKnownSymbol$4('toStringTag');
-var Object$1 = global$b.Object;
-
-// ES3 wrong here
-var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
-
-// fallback for IE11 Script Access Denied error
-var tryGet = function (it, key) {
-  try {
-    return it[key];
-  } catch (error) { /* empty */ }
-};
-
-// getting tag from ES6+ `Object.prototype.toString`
-var classof$4 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
-  var O, tag, result;
-  return it === undefined ? 'Undefined' : it === null ? 'Null'
-    // @@toStringTag case
-    : typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG)) == 'string' ? tag
-    // builtinTag case
-    : CORRECT_ARGUMENTS ? classofRaw(O)
-    // ES3 arguments fallback
-    : (result = classofRaw(O)) == 'Object' && isCallable$4(O.callee) ? 'Arguments' : result;
-};
-
-var classof$3 = classof$4;
-var getMethod$1 = getMethod$2;
-var Iterators = iterators;
-var wellKnownSymbol$3 = wellKnownSymbol$8;
-
-var ITERATOR$1 = wellKnownSymbol$3('iterator');
-
-var getIteratorMethod$2 = function (it) {
-  if (it != undefined) return getMethod$1(it, ITERATOR$1)
-    || getMethod$1(it, '@@iterator')
-    || Iterators[classof$3(it)];
-};
-
-var global$a = global$e;
-var call$4 = functionCall;
-var aCallable$2 = aCallable$4;
-var anObject$4 = anObject$5;
-var tryToString$2 = tryToString$3;
-var getIteratorMethod$1 = getIteratorMethod$2;
-
-var TypeError$5 = global$a.TypeError;
-
-var getIterator$1 = function (argument, usingIterator) {
-  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
-  if (aCallable$2(iteratorMethod)) return anObject$4(call$4(iteratorMethod, argument));
-  throw TypeError$5(tryToString$2(argument) + ' is not iterable');
-};
-
-var call$3 = functionCall;
-var anObject$3 = anObject$5;
-var getMethod = getMethod$2;
-
-var iteratorClose$1 = function (iterator, kind, value) {
-  var innerResult, innerError;
-  anObject$3(iterator);
-  try {
-    innerResult = getMethod(iterator, 'return');
-    if (!innerResult) {
-      if (kind === 'throw') throw value;
-      return value;
-    }
-    innerResult = call$3(innerResult, iterator);
-  } catch (error) {
-    innerError = true;
-    innerResult = error;
-  }
-  if (kind === 'throw') throw value;
-  if (innerError) throw innerResult;
-  anObject$3(innerResult);
-  return value;
-};
-
-var global$9 = global$e;
-var bind$3 = functionBindContext;
-var call$2 = functionCall;
-var anObject$2 = anObject$5;
-var tryToString$1 = tryToString$3;
-var isArrayIteratorMethod = isArrayIteratorMethod$1;
-var lengthOfArrayLike = lengthOfArrayLike$1;
-var isPrototypeOf = objectIsPrototypeOf;
-var getIterator = getIterator$1;
-var getIteratorMethod = getIteratorMethod$2;
-var iteratorClose = iteratorClose$1;
-
-var TypeError$4 = global$9.TypeError;
-
-var Result = function (stopped, result) {
-  this.stopped = stopped;
-  this.result = result;
-};
-
-var ResultPrototype = Result.prototype;
-
-var iterate$1 = function (iterable, unboundFunction, options) {
-  var that = options && options.that;
-  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
-  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
-  var INTERRUPTED = !!(options && options.INTERRUPTED);
-  var fn = bind$3(unboundFunction, that);
-  var iterator, iterFn, index, length, result, next, step;
-
-  var stop = function (condition) {
-    if (iterator) iteratorClose(iterator, 'normal', condition);
-    return new Result(true, condition);
-  };
-
-  var callFn = function (value) {
-    if (AS_ENTRIES) {
-      anObject$2(value);
-      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
-    } return INTERRUPTED ? fn(value, stop) : fn(value);
-  };
-
-  if (IS_ITERATOR) {
-    iterator = iterable;
-  } else {
-    iterFn = getIteratorMethod(iterable);
-    if (!iterFn) throw TypeError$4(tryToString$1(iterable) + ' is not iterable');
-    // optimisation for array iterators
-    if (isArrayIteratorMethod(iterFn)) {
-      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
-        result = callFn(iterable[index]);
-        if (result && isPrototypeOf(ResultPrototype, result)) return result;
-      } return new Result(false);
-    }
-    iterator = getIterator(iterable, iterFn);
-  }
-
-  next = iterator.next;
-  while (!(step = call$2(next, iterator)).done) {
-    try {
-      result = callFn(step.value);
-    } catch (error) {
-      iteratorClose(iterator, 'throw', error);
-    }
-    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
-  } return new Result(false);
-};
-
-var wellKnownSymbol$2 = wellKnownSymbol$8;
-
-var ITERATOR = wellKnownSymbol$2('iterator');
-var SAFE_CLOSING = false;
-
-try {
-  var called = 0;
-  var iteratorWithReturn = {
-    next: function () {
-      return { done: !!called++ };
-    },
-    'return': function () {
-      SAFE_CLOSING = true;
-    }
-  };
-  iteratorWithReturn[ITERATOR] = function () {
-    return this;
-  };
-  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
-  Array.from(iteratorWithReturn, function () { throw 2; });
-} catch (error) { /* empty */ }
-
-var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
-  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
-  var ITERATION_SUPPORT = false;
-  try {
-    var object = {};
-    object[ITERATOR] = function () {
-      return {
-        next: function () {
-          return { done: ITERATION_SUPPORT = true };
-        }
-      };
-    };
-    exec(object);
-  } catch (error) { /* empty */ }
-  return ITERATION_SUPPORT;
+  throw $TypeError$5('Incorrect invocation');
 };
 
 var uncurryThis$2 = functionUncurryThis;
 var fails$3 = fails$4;
-var isCallable$3 = isCallable$5;
-var classof$2 = classof$4;
-var getBuiltIn$2 = getBuiltIn$4;
+var isCallable$5 = isCallable$6;
+var classof$1 = classof$3;
+var getBuiltIn$3 = getBuiltIn$5;
 var inspectSource$1 = inspectSource$2;
 
 var noop = function () { /* empty */ };
 var empty = [];
-var construct = getBuiltIn$2('Reflect', 'construct');
+var construct = getBuiltIn$3('Reflect', 'construct');
 var constructorRegExp = /^\s*(?:class|function)\b/;
 var exec = uncurryThis$2(constructorRegExp.exec);
 var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
 
 var isConstructorModern = function isConstructor(argument) {
-  if (!isCallable$3(argument)) return false;
+  if (!isCallable$5(argument)) return false;
   try {
     construct(noop, empty, argument);
     return true;
@@ -290,8 +63,8 @@ var isConstructorModern = function isConstructor(argument) {
 };
 
 var isConstructorLegacy = function isConstructor(argument) {
-  if (!isCallable$3(argument)) return false;
-  switch (classof$2(argument)) {
+  if (!isCallable$5(argument)) return false;
+  switch (classof$1(argument)) {
     case 'AsyncFunction':
     case 'GeneratorFunction':
     case 'AsyncGeneratorFunction': return false;
@@ -318,53 +91,65 @@ var isConstructor$1 = !construct || fails$3(function () {
     || called;
 }) ? isConstructorLegacy : isConstructorModern;
 
-var global$8 = global$e;
 var isConstructor = isConstructor$1;
-var tryToString = tryToString$3;
+var tryToString$2 = tryToString$3;
 
-var TypeError$3 = global$8.TypeError;
+var $TypeError$4 = TypeError;
 
 // `Assert: IsConstructor(argument) is true`
 var aConstructor$1 = function (argument) {
   if (isConstructor(argument)) return argument;
-  throw TypeError$3(tryToString(argument) + ' is not a constructor');
+  throw $TypeError$4(tryToString$2(argument) + ' is not a constructor');
 };
 
-var anObject$1 = anObject$5;
+var anObject$4 = anObject$5;
 var aConstructor = aConstructor$1;
-var wellKnownSymbol$1 = wellKnownSymbol$8;
+var isNullOrUndefined$1 = isNullOrUndefined$2;
+var wellKnownSymbol$4 = wellKnownSymbol$6;
 
-var SPECIES$1 = wellKnownSymbol$1('species');
+var SPECIES$1 = wellKnownSymbol$4('species');
 
 // `SpeciesConstructor` abstract operation
 // https://tc39.es/ecma262/#sec-speciesconstructor
 var speciesConstructor$2 = function (O, defaultConstructor) {
-  var C = anObject$1(O).constructor;
+  var C = anObject$4(O).constructor;
   var S;
-  return C === undefined || (S = anObject$1(C)[SPECIES$1]) == undefined ? defaultConstructor : aConstructor(S);
+  return C === undefined || isNullOrUndefined$1(S = anObject$4(C)[SPECIES$1]) ? defaultConstructor : aConstructor(S);
 };
 
-var NATIVE_BIND = functionBindNative;
+var NATIVE_BIND$1 = functionBindNative;
 
 var FunctionPrototype = Function.prototype;
 var apply$1 = FunctionPrototype.apply;
-var call$1 = FunctionPrototype.call;
+var call$7 = FunctionPrototype.call;
 
 // eslint-disable-next-line es/no-reflect -- safe
-var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$1.bind(apply$1) : function () {
-  return call$1.apply(apply$1, arguments);
+var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$7.bind(apply$1) : function () {
+  return call$7.apply(apply$1, arguments);
 });
 
 var uncurryThis$1 = functionUncurryThis;
+var aCallable$5 = aCallable$6;
+var NATIVE_BIND = functionBindNative;
+
+var bind$4 = uncurryThis$1(uncurryThis$1.bind);
 
-var arraySlice$1 = uncurryThis$1([].slice);
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable$5(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind$4(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
 
-var global$7 = global$e;
+var uncurryThis = functionUncurryThis;
 
-var TypeError$2 = global$7.TypeError;
+var arraySlice$1 = uncurryThis([].slice);
+
+var $TypeError$3 = TypeError;
 
 var validateArgumentsLength$1 = function (passed, required) {
-  if (passed < required) throw TypeError$2('Not enough arguments');
+  if (passed < required) throw $TypeError$3('Not enough arguments');
   return passed;
 };
 
@@ -372,15 +157,10 @@ var userAgent$2 = engineUserAgent;
 
 var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
 
-var classof$1 = classofRaw$1;
-var global$6 = global$e;
-
-var engineIsNode = classof$1(global$6.process) == 'process';
-
-var global$5 = global$e;
+var global$6 = global$8;
 var apply = functionApply;
-var bind$2 = functionBindContext;
-var isCallable$2 = isCallable$5;
+var bind$3 = functionBindContext;
+var isCallable$4 = isCallable$6;
 var hasOwn = hasOwnProperty_1;
 var fails$2 = fails$4;
 var html = html$1;
@@ -388,23 +168,23 @@ var arraySlice = arraySlice$1;
 var createElement = documentCreateElement;
 var validateArgumentsLength = validateArgumentsLength$1;
 var IS_IOS$1 = engineIsIos;
-var IS_NODE$2 = engineIsNode;
-
-var set = global$5.setImmediate;
-var clear = global$5.clearImmediate;
-var process$2 = global$5.process;
-var Dispatch = global$5.Dispatch;
-var Function$1 = global$5.Function;
-var MessageChannel = global$5.MessageChannel;
-var String$2 = global$5.String;
+var IS_NODE$3 = engineIsNode;
+
+var set = global$6.setImmediate;
+var clear = global$6.clearImmediate;
+var process$2 = global$6.process;
+var Dispatch = global$6.Dispatch;
+var Function$1 = global$6.Function;
+var MessageChannel = global$6.MessageChannel;
+var String$1 = global$6.String;
 var counter = 0;
 var queue$1 = {};
 var ONREADYSTATECHANGE = 'onreadystatechange';
-var location, defer, channel, port;
+var $location, defer, channel, port;
 
 try {
   // Deno throws a ReferenceError on `location` access without `--location` flag
-  location = global$5.location;
+  $location = global$6.location;
 } catch (error) { /* empty */ }
 
 var run = function (id) {
@@ -427,14 +207,14 @@ var listener = function (event) {
 
 var post = function (id) {
   // old engines have not location.origin
-  global$5.postMessage(String$2(id), location.protocol + '//' + location.host);
+  global$6.postMessage(String$1(id), $location.protocol + '//' + $location.host);
 };
 
 // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
 if (!set || !clear) {
   set = function setImmediate(handler) {
     validateArgumentsLength(arguments.length, 1);
-    var fn = isCallable$2(handler) ? handler : Function$1(handler);
+    var fn = isCallable$4(handler) ? handler : Function$1(handler);
     var args = arraySlice(arguments, 1);
     queue$1[++counter] = function () {
       apply(fn, undefined, args);
@@ -446,7 +226,7 @@ if (!set || !clear) {
     delete queue$1[id];
   };
   // Node.js 0.8-
-  if (IS_NODE$2) {
+  if (IS_NODE$3) {
     defer = function (id) {
       process$2.nextTick(runner(id));
     };
@@ -461,18 +241,18 @@ if (!set || !clear) {
     channel = new MessageChannel();
     port = channel.port2;
     channel.port1.onmessage = listener;
-    defer = bind$2(port.postMessage, port);
+    defer = bind$3(port.postMessage, port);
   // Browsers with postMessage, skip WebWorkers
   // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
   } else if (
-    global$5.addEventListener &&
-    isCallable$2(global$5.postMessage) &&
-    !global$5.importScripts &&
-    location && location.protocol !== 'file:' &&
+    global$6.addEventListener &&
+    isCallable$4(global$6.postMessage) &&
+    !global$6.importScripts &&
+    $location && $location.protocol !== 'file:' &&
     !fails$2(post)
   ) {
     defer = post;
-    global$5.addEventListener('message', listener, false);
+    global$6.addEventListener('message', listener, false);
   // IE8-
   } else if (ONREADYSTATECHANGE in createElement('script')) {
     defer = function (id) {
@@ -495,29 +275,29 @@ var task$1 = {
 };
 
 var userAgent$1 = engineUserAgent;
-var global$4 = global$e;
+var global$5 = global$8;
 
-var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$4.Pebble !== undefined;
+var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$5.Pebble !== undefined;
 
 var userAgent = engineUserAgent;
 
 var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
 
-var global$3 = global$e;
-var bind$1 = functionBindContext;
+var global$4 = global$8;
+var bind$2 = functionBindContext;
 var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
 var macrotask = task$1.set;
 var IS_IOS = engineIsIos;
 var IS_IOS_PEBBLE = engineIsIosPebble;
 var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
-var IS_NODE$1 = engineIsNode;
+var IS_NODE$2 = engineIsNode;
 
-var MutationObserver = global$3.MutationObserver || global$3.WebKitMutationObserver;
-var document$1 = global$3.document;
-var process$1 = global$3.process;
-var Promise$1 = global$3.Promise;
+var MutationObserver = global$4.MutationObserver || global$4.WebKitMutationObserver;
+var document$2 = global$4.document;
+var process$1 = global$4.process;
+var Promise$1 = global$4.Promise;
 // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
-var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$3, 'queueMicrotask');
+var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$4, 'queueMicrotask');
 var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
 
 var flush, head, last, notify$1, toggle, node, promise, then;
@@ -526,7 +306,7 @@ var flush, head, last, notify$1, toggle, node, promise, then;
 if (!queueMicrotask) {
   flush = function () {
     var parent, fn;
-    if (IS_NODE$1 && (parent = process$1.domain)) parent.exit();
+    if (IS_NODE$2 && (parent = process$1.domain)) parent.exit();
     while (head) {
       fn = head.fn;
       head = head.next;
@@ -543,9 +323,9 @@ if (!queueMicrotask) {
 
   // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
   // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
-  if (!IS_IOS && !IS_NODE$1 && !IS_WEBOS_WEBKIT && MutationObserver && document$1) {
+  if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
     toggle = true;
-    node = document$1.createTextNode('');
+    node = document$2.createTextNode('');
     new MutationObserver(flush).observe(node, { characterData: true });
     notify$1 = function () {
       node.data = toggle = !toggle;
@@ -556,24 +336,24 @@ if (!queueMicrotask) {
     promise = Promise$1.resolve(undefined);
     // workaround of WebKit ~ iOS Safari 10.1 bug
     promise.constructor = Promise$1;
-    then = bind$1(promise.then, promise);
+    then = bind$2(promise.then, promise);
     notify$1 = function () {
       then(flush);
     };
   // Node.js without promises
-  } else if (IS_NODE$1) {
+  } else if (IS_NODE$2) {
     notify$1 = function () {
       process$1.nextTick(flush);
     };
   // for other environments - macrotask based on:
   // - setImmediate
   // - MessageChannel
-  // - window.postMessag
+  // - window.postMessage
   // - onreadystatechange
   // - setTimeout
   } else {
     // strange IE + webpack dev server bug - use .bind(global)
-    macrotask = bind$1(macrotask, global$3);
+    macrotask = bind$2(macrotask, global$4);
     notify$1 = function () {
       macrotask(flush);
     };
@@ -589,50 +369,16 @@ var microtask$1 = queueMicrotask || function (fn) {
   } last = task;
 };
 
-var newPromiseCapability$2 = {};
-
-var aCallable$1 = aCallable$4;
-
-var PromiseCapability = function (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 = aCallable$1(resolve);
-  this.reject = aCallable$1(reject);
-};
-
-// `NewPromiseCapability` abstract operation
-// https://tc39.es/ecma262/#sec-newpromisecapability
-newPromiseCapability$2.f = function (C) {
-  return new PromiseCapability(C);
-};
-
-var anObject = anObject$5;
-var isObject$1 = isObject$2;
-var newPromiseCapability$1 = newPromiseCapability$2;
-
-var promiseResolve$2 = function (C, x) {
-  anObject(C);
-  if (isObject$1(x) && x.constructor === C) return x;
-  var promiseCapability = newPromiseCapability$1.f(C);
-  var resolve = promiseCapability.resolve;
-  resolve(x);
-  return promiseCapability.promise;
-};
-
-var global$2 = global$e;
+var global$3 = global$8;
 
 var hostReportErrors$1 = function (a, b) {
-  var console = global$2.console;
+  var console = global$3.console;
   if (console && console.error) {
     arguments.length == 1 ? console.error(a) : console.error(a, b);
   }
 };
 
-var perform$1 = function (exec) {
+var perform$3 = function (exec) {
   try {
     return { error: false, value: exec() };
   } catch (error) {
@@ -664,57 +410,128 @@ Queue$1.prototype = {
 
 var queue = Queue$1;
 
-var engineIsBrowser = typeof window == 'object';
+var global$2 = global$8;
 
-var $$2 = _export;
-var global$1 = global$e;
-var getBuiltIn$1 = getBuiltIn$4;
-var call = functionCall;
-var NativePromise$1 = nativePromiseConstructor;
-var redefine$1 = redefine$3.exports;
-var redefineAll = redefineAll$1;
+var promiseNativeConstructor = global$2.Promise;
+
+/* global Deno -- Deno case */
+
+var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
+
+var IS_DENO$1 = engineIsDeno;
+var IS_NODE$1 = engineIsNode;
+
+var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1
+  && typeof window == 'object'
+  && typeof document == 'object';
+
+var global$1 = global$8;
+var NativePromiseConstructor$4 = promiseNativeConstructor;
+var isCallable$3 = isCallable$6;
+var isForced = isForced_1;
+var inspectSource = inspectSource$2;
+var wellKnownSymbol$3 = wellKnownSymbol$6;
+var IS_BROWSER = engineIsBrowser;
+var IS_DENO = engineIsDeno;
+var V8_VERSION = engineV8Version;
+
+NativePromiseConstructor$4 && NativePromiseConstructor$4.prototype;
+var SPECIES = wellKnownSymbol$3('species');
+var SUBCLASSING = false;
+var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$3(global$1.PromiseRejectionEvent);
+
+var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () {
+  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$4);
+  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$4);
+  // 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
+  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
+  // We can't use @@species feature detection in V8 since it causes
+  // deoptimization and performance degradation
+  // https://github.com/zloirock/core-js/issues/679
+  if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
+    // Detect correctness of subclassing with @@species support
+    var promise = new NativePromiseConstructor$4(function (resolve) { resolve(1); });
+    var FakePromise = function (exec) {
+      exec(function () { /* empty */ }, function () { /* empty */ });
+    };
+    var constructor = promise.constructor = {};
+    constructor[SPECIES] = FakePromise;
+    SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
+    if (!SUBCLASSING) return true;
+  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+  } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1;
+});
+
+var promiseConstructorDetection = {
+  CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5,
+  REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1,
+  SUBCLASSING: SUBCLASSING
+};
+
+var newPromiseCapability$2 = {};
+
+var aCallable$4 = aCallable$6;
+
+var $TypeError$2 = TypeError;
+
+var PromiseCapability = function (C) {
+  var resolve, reject;
+  this.promise = new C(function ($$resolve, $$reject) {
+    if (resolve !== undefined || reject !== undefined) throw $TypeError$2('Bad Promise constructor');
+    resolve = $$resolve;
+    reject = $$reject;
+  });
+  this.resolve = aCallable$4(resolve);
+  this.reject = aCallable$4(reject);
+};
+
+// `NewPromiseCapability` abstract operation
+// https://tc39.es/ecma262/#sec-newpromisecapability
+newPromiseCapability$2.f = function (C) {
+  return new PromiseCapability(C);
+};
+
+var $$7 = _export;
+var IS_NODE = engineIsNode;
+var global = global$8;
+var call$6 = functionCall;
+var defineBuiltIn$2 = defineBuiltIn$3;
 var setPrototypeOf = objectSetPrototypeOf;
 var setToStringTag = setToStringTag$1;
 var setSpecies = setSpecies$1;
-var aCallable = aCallable$4;
-var isCallable$1 = isCallable$5;
-var isObject = isObject$2;
+var aCallable$3 = aCallable$6;
+var isCallable$2 = isCallable$6;
+var isObject$1 = isObject$2;
 var anInstance = anInstance$1;
-var inspectSource = inspectSource$2;
-var iterate = iterate$1;
-var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
 var speciesConstructor$1 = speciesConstructor$2;
 var task = task$1.set;
 var microtask = microtask$1;
-var promiseResolve$1 = promiseResolve$2;
 var hostReportErrors = hostReportErrors$1;
-var newPromiseCapabilityModule = newPromiseCapability$2;
-var perform = perform$1;
+var perform$2 = perform$3;
 var Queue = queue;
 var InternalStateModule = internalState;
-var isForced = isForced_1;
-var wellKnownSymbol = wellKnownSymbol$8;
-var IS_BROWSER = engineIsBrowser;
-var IS_NODE = engineIsNode;
-var V8_VERSION = engineV8Version;
+var NativePromiseConstructor$3 = promiseNativeConstructor;
+var PromiseConstructorDetection = promiseConstructorDetection;
+var newPromiseCapabilityModule$3 = newPromiseCapability$2;
 
-var SPECIES = wellKnownSymbol('species');
 var PROMISE = 'Promise';
-
-var getInternalState = InternalStateModule.getterFor(PROMISE);
-var setInternalState = InternalStateModule.set;
+var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR;
+var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
+var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
 var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
-var NativePromisePrototype = NativePromise$1 && NativePromise$1.prototype;
-var PromiseConstructor = NativePromise$1;
-var PromisePrototype = NativePromisePrototype;
-var TypeError$1 = global$1.TypeError;
-var document = global$1.document;
-var process = global$1.process;
-var newPromiseCapability = newPromiseCapabilityModule.f;
-var newGenericPromiseCapability = newPromiseCapability;
-
-var DISPATCH_EVENT = !!(document && document.createEvent && global$1.dispatchEvent);
-var NATIVE_REJECTION_EVENT = isCallable$1(global$1.PromiseRejectionEvent);
+var setInternalState = InternalStateModule.set;
+var NativePromisePrototype$2 = NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
+var PromiseConstructor = NativePromiseConstructor$3;
+var PromisePrototype = NativePromisePrototype$2;
+var TypeError$1 = global.TypeError;
+var document$1 = global.document;
+var process = global.process;
+var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
+var newGenericPromiseCapability = newPromiseCapability$1;
+
+var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global.dispatchEvent);
 var UNHANDLED_REJECTION = 'unhandledrejection';
 var REJECTION_HANDLED = 'rejectionhandled';
 var PENDING = 0;
@@ -722,42 +539,13 @@ var FULFILLED = 1;
 var REJECTED = 2;
 var HANDLED = 1;
 var UNHANDLED = 2;
-var SUBCLASSING = false;
 
 var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
 
-var FORCED = isForced(PROMISE, function () {
-  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);
-  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);
-  // 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
-  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
-  // We can't use @@species feature detection in V8 since it causes
-  // deoptimization and performance degradation
-  // https://github.com/zloirock/core-js/issues/679
-  if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;
-  // Detect correctness of subclassing with @@species support
-  var promise = new PromiseConstructor(function (resolve) { resolve(1); });
-  var FakePromise = function (exec) {
-    exec(function () { /* empty */ }, function () { /* empty */ });
-  };
-  var constructor = promise.constructor = {};
-  constructor[SPECIES] = FakePromise;
-  SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
-  if (!SUBCLASSING) return true;
-  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
-  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;
-});
-
-var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
-  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
-});
-
 // helpers
 var isThenable = function (it) {
   var then;
-  return isObject(it) && isCallable$1(then = it.then) ? then : false;
+  return isObject$1(it) && isCallable$2(then = it.then) ? then : false;
 };
 
 var callReaction = function (reaction, state) {
@@ -786,7 +574,7 @@ var callReaction = function (reaction, state) {
       if (result === reaction.promise) {
         reject(TypeError$1('Promise-chain cycle'));
       } else if (then = isThenable(result)) {
-        call(then, result, resolve, reject);
+        call$6(then, result, resolve, reject);
       } else resolve(result);
     } else reject(value);
   } catch (error) {
@@ -812,24 +600,24 @@ var notify = function (state, isReject) {
 var dispatchEvent = function (name, promise, reason) {
   var event, handler;
   if (DISPATCH_EVENT) {
-    event = document.createEvent('Event');
+    event = document$1.createEvent('Event');
     event.promise = promise;
     event.reason = reason;
     event.initEvent(name, false, true);
-    global$1.dispatchEvent(event);
+    global.dispatchEvent(event);
   } else event = { promise: promise, reason: reason };
-  if (!NATIVE_REJECTION_EVENT && (handler = global$1['on' + name])) handler(event);
+  if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);
   else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
 };
 
 var onUnhandled = function (state) {
-  call(task, global$1, function () {
+  call$6(task, global, function () {
     var promise = state.facade;
     var value = state.value;
     var IS_UNHANDLED = isUnhandled(state);
     var result;
     if (IS_UNHANDLED) {
-      result = perform(function () {
+      result = perform$2(function () {
         if (IS_NODE) {
           process.emit('unhandledRejection', value, promise);
         } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
@@ -846,7 +634,7 @@ var isUnhandled = function (state) {
 };
 
 var onHandleUnhandled = function (state) {
-  call(task, global$1, function () {
+  call$6(task, global, function () {
     var promise = state.facade;
     if (IS_NODE) {
       process.emit('rejectionHandled', promise);
@@ -854,7 +642,7 @@ var onHandleUnhandled = function (state) {
   });
 };
 
-var bind = function (fn, state, unwrap) {
+var bind$1 = function (fn, state, unwrap) {
   return function (value) {
     fn(state, value, unwrap);
   };
@@ -880,9 +668,9 @@ var internalResolve = function (state, value, unwrap) {
       microtask(function () {
         var wrapper = { done: false };
         try {
-          call(then, value,
-            bind(internalResolve, wrapper, state),
-            bind(internalReject, wrapper, state)
+          call$6(then, value,
+            bind$1(internalResolve, wrapper, state),
+            bind$1(internalReject, wrapper, state)
           );
         } catch (error) {
           internalReject(wrapper, error, state);
@@ -899,20 +687,22 @@ var internalResolve = function (state, value, unwrap) {
 };
 
 // constructor polyfill
-if (FORCED) {
+if (FORCED_PROMISE_CONSTRUCTOR$4) {
   // 25.4.3.1 Promise(executor)
   PromiseConstructor = function Promise(executor) {
     anInstance(this, PromisePrototype);
-    aCallable(executor);
-    call(Internal, this);
-    var state = getInternalState(this);
+    aCallable$3(executor);
+    call$6(Internal, this);
+    var state = getInternalPromiseState(this);
     try {
-      executor(bind(internalResolve, state), bind(internalReject, state));
+      executor(bind$1(internalResolve, state), bind$1(internalReject, state));
     } catch (error) {
       internalReject(state, error);
     }
   };
+
   PromisePrototype = PromiseConstructor.prototype;
+
   // eslint-disable-next-line no-unused-vars -- required for `.length`
   Internal = function Promise(executor) {
     setInternalState(this, {
@@ -926,117 +716,275 @@ if (FORCED) {
       value: undefined
     });
   };
-  Internal.prototype = redefineAll(PromisePrototype, {
-    // `Promise.prototype.then` method
-    // https://tc39.es/ecma262/#sec-promise.prototype.then
-    // eslint-disable-next-line unicorn/no-thenable -- safe
-    then: function then(onFulfilled, onRejected) {
-      var state = getInternalPromiseState(this);
-      var reaction = newPromiseCapability(speciesConstructor$1(this, PromiseConstructor));
-      state.parent = true;
-      reaction.ok = isCallable$1(onFulfilled) ? onFulfilled : true;
-      reaction.fail = isCallable$1(onRejected) && onRejected;
-      reaction.domain = IS_NODE ? process.domain : undefined;
-      if (state.state == PENDING) state.reactions.add(reaction);
-      else microtask(function () {
-        callReaction(reaction, state);
-      });
-      return reaction.promise;
-    },
-    // `Promise.prototype.catch` method
-    // https://tc39.es/ecma262/#sec-promise.prototype.catch
-    'catch': function (onRejected) {
-      return this.then(undefined, onRejected);
-    }
+
+  // `Promise.prototype.then` method
+  // https://tc39.es/ecma262/#sec-promise.prototype.then
+  Internal.prototype = defineBuiltIn$2(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
+    var state = getInternalPromiseState(this);
+    var reaction = newPromiseCapability$1(speciesConstructor$1(this, PromiseConstructor));
+    state.parent = true;
+    reaction.ok = isCallable$2(onFulfilled) ? onFulfilled : true;
+    reaction.fail = isCallable$2(onRejected) && onRejected;
+    reaction.domain = IS_NODE ? process.domain : undefined;
+    if (state.state == PENDING) state.reactions.add(reaction);
+    else microtask(function () {
+      callReaction(reaction, state);
+    });
+    return reaction.promise;
   });
+
   OwnPromiseCapability = function () {
     var promise = new Internal();
-    var state = getInternalState(promise);
+    var state = getInternalPromiseState(promise);
     this.promise = promise;
-    this.resolve = bind(internalResolve, state);
-    this.reject = bind(internalReject, state);
+    this.resolve = bind$1(internalResolve, state);
+    this.reject = bind$1(internalReject, state);
   };
-  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+
+  newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) {
     return C === PromiseConstructor || C === PromiseWrapper
       ? new OwnPromiseCapability(C)
       : newGenericPromiseCapability(C);
   };
 
-  if (isCallable$1(NativePromise$1) && NativePromisePrototype !== Object.prototype) {
-    nativeThen = NativePromisePrototype.then;
+  if (isCallable$2(NativePromiseConstructor$3) && NativePromisePrototype$2 !== Object.prototype) {
+    nativeThen = NativePromisePrototype$2.then;
 
-    if (!SUBCLASSING) {
+    if (!NATIVE_PROMISE_SUBCLASSING) {
       // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
-      redefine$1(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
+      defineBuiltIn$2(NativePromisePrototype$2, 'then', function then(onFulfilled, onRejected) {
         var that = this;
         return new PromiseConstructor(function (resolve, reject) {
-          call(nativeThen, that, resolve, reject);
+          call$6(nativeThen, that, resolve, reject);
         }).then(onFulfilled, onRejected);
       // https://github.com/zloirock/core-js/issues/640
       }, { unsafe: true });
-
-      // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
-      redefine$1(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });
     }
 
     // make `.constructor === Promise` work for native promise-based APIs
     try {
-      delete NativePromisePrototype.constructor;
+      delete NativePromisePrototype$2.constructor;
     } catch (error) { /* empty */ }
 
     // make `instanceof Promise` work for native promise-based APIs
     if (setPrototypeOf) {
-      setPrototypeOf(NativePromisePrototype, PromisePrototype);
+      setPrototypeOf(NativePromisePrototype$2, PromisePrototype);
     }
   }
 }
 
-$$2({ global: true, wrap: true, forced: FORCED }, {
+$$7({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
   Promise: PromiseConstructor
 });
 
 setToStringTag(PromiseConstructor, PROMISE, false);
 setSpecies(PROMISE);
 
-PromiseWrapper = getBuiltIn$1(PROMISE);
+var wellKnownSymbol$2 = wellKnownSymbol$6;
+var Iterators$1 = iterators;
 
-// statics
-$$2({ target: PROMISE, stat: true, forced: FORCED }, {
-  // `Promise.reject` method
-  // https://tc39.es/ecma262/#sec-promise.reject
-  reject: function reject(r) {
-    var capability = newPromiseCapability(this);
-    call(capability.reject, undefined, r);
-    return capability.promise;
+var ITERATOR$2 = wellKnownSymbol$2('iterator');
+var ArrayPrototype = Array.prototype;
+
+// check on default Array iterator
+var isArrayIteratorMethod$1 = function (it) {
+  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
+};
+
+var classof = classof$3;
+var getMethod$1 = getMethod$2;
+var isNullOrUndefined = isNullOrUndefined$2;
+var Iterators = iterators;
+var wellKnownSymbol$1 = wellKnownSymbol$6;
+
+var ITERATOR$1 = wellKnownSymbol$1('iterator');
+
+var getIteratorMethod$2 = function (it) {
+  if (!isNullOrUndefined(it)) return getMethod$1(it, ITERATOR$1)
+    || getMethod$1(it, '@@iterator')
+    || Iterators[classof(it)];
+};
+
+var call$5 = functionCall;
+var aCallable$2 = aCallable$6;
+var anObject$3 = anObject$5;
+var tryToString$1 = tryToString$3;
+var getIteratorMethod$1 = getIteratorMethod$2;
+
+var $TypeError$1 = TypeError;
+
+var getIterator$1 = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
+  if (aCallable$2(iteratorMethod)) return anObject$3(call$5(iteratorMethod, argument));
+  throw $TypeError$1(tryToString$1(argument) + ' is not iterable');
+};
+
+var call$4 = functionCall;
+var anObject$2 = anObject$5;
+var getMethod = getMethod$2;
+
+var iteratorClose$1 = function (iterator, kind, value) {
+  var innerResult, innerError;
+  anObject$2(iterator);
+  try {
+    innerResult = getMethod(iterator, 'return');
+    if (!innerResult) {
+      if (kind === 'throw') throw value;
+      return value;
+    }
+    innerResult = call$4(innerResult, iterator);
+  } catch (error) {
+    innerError = true;
+    innerResult = error;
   }
-});
+  if (kind === 'throw') throw value;
+  if (innerError) throw innerResult;
+  anObject$2(innerResult);
+  return value;
+};
 
-$$2({ target: PROMISE, stat: true, forced: FORCED }, {
-  // `Promise.resolve` method
-  // https://tc39.es/ecma262/#sec-promise.resolve
-  resolve: function resolve(x) {
-    return promiseResolve$1(this, x);
+var bind = functionBindContext;
+var call$3 = functionCall;
+var anObject$1 = anObject$5;
+var tryToString = tryToString$3;
+var isArrayIteratorMethod = isArrayIteratorMethod$1;
+var lengthOfArrayLike = lengthOfArrayLike$1;
+var isPrototypeOf = objectIsPrototypeOf;
+var getIterator = getIterator$1;
+var getIteratorMethod = getIteratorMethod$2;
+var iteratorClose = iteratorClose$1;
+
+var $TypeError = TypeError;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+var iterate$2 = function (iterable, unboundFunction, options) {
+  var that = options && options.that;
+  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_RECORD = !!(options && options.IS_RECORD);
+  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+  var INTERRUPTED = !!(options && options.INTERRUPTED);
+  var fn = bind(unboundFunction, that);
+  var iterator, iterFn, index, length, result, next, step;
+
+  var stop = function (condition) {
+    if (iterator) iteratorClose(iterator, 'normal', condition);
+    return new Result(true, condition);
+  };
+
+  var callFn = function (value) {
+    if (AS_ENTRIES) {
+      anObject$1(value);
+      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+    } return INTERRUPTED ? fn(value, stop) : fn(value);
+  };
+
+  if (IS_RECORD) {
+    iterator = iterable.iterator;
+  } else if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod(iterable);
+    if (!iterFn) throw $TypeError(tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+        result = callFn(iterable[index]);
+        if (result && isPrototypeOf(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
   }
+
+  next = IS_RECORD ? iterable.next : iterator.next;
+  while (!(step = call$3(next, iterator)).done) {
+    try {
+      result = callFn(step.value);
+    } catch (error) {
+      iteratorClose(iterator, 'throw', error);
+    }
+    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+var wellKnownSymbol = wellKnownSymbol$6;
+
+var ITERATOR = wellKnownSymbol('iterator');
+var SAFE_CLOSING = false;
+
+try {
+  var called = 0;
+  var iteratorWithReturn = {
+    next: function () {
+      return { done: !!called++ };
+    },
+    'return': function () {
+      SAFE_CLOSING = true;
+    }
+  };
+  iteratorWithReturn[ITERATOR] = function () {
+    return this;
+  };
+  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
+  Array.from(iteratorWithReturn, function () { throw 2; });
+} catch (error) { /* empty */ }
+
+var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
+  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
+  var ITERATION_SUPPORT = false;
+  try {
+    var object = {};
+    object[ITERATOR] = function () {
+      return {
+        next: function () {
+          return { done: ITERATION_SUPPORT = true };
+        }
+      };
+    };
+    exec(object);
+  } catch (error) { /* empty */ }
+  return ITERATION_SUPPORT;
+};
+
+var NativePromiseConstructor$2 = promiseNativeConstructor;
+var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
+var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR;
+
+var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration(function (iterable) {
+  NativePromiseConstructor$2.all(iterable).then(undefined, function () { /* empty */ });
 });
 
-$$2({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
-  // `Promise.all` method
-  // https://tc39.es/ecma262/#sec-promise.all
+var $$6 = _export;
+var call$2 = functionCall;
+var aCallable$1 = aCallable$6;
+var newPromiseCapabilityModule$2 = newPromiseCapability$2;
+var perform$1 = perform$3;
+var iterate$1 = iterate$2;
+var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
+
+// `Promise.all` method
+// https://tc39.es/ecma262/#sec-promise.all
+$$6({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
   all: function all(iterable) {
     var C = this;
-    var capability = newPromiseCapability(C);
+    var capability = newPromiseCapabilityModule$2.f(C);
     var resolve = capability.resolve;
     var reject = capability.reject;
-    var result = perform(function () {
-      var $promiseResolve = aCallable(C.resolve);
+    var result = perform$1(function () {
+      var $promiseResolve = aCallable$1(C.resolve);
       var values = [];
       var counter = 0;
       var remaining = 1;
-      iterate(iterable, function (promise) {
+      iterate$1(iterable, function (promise) {
         var index = counter++;
         var alreadyCalled = false;
         remaining++;
-        call($promiseResolve, C, promise).then(function (value) {
+        call$2($promiseResolve, C, promise).then(function (value) {
           if (alreadyCalled) return;
           alreadyCalled = true;
           values[index] = value;
@@ -1047,17 +995,53 @@ $$2({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
     });
     if (result.error) reject(result.value);
     return capability.promise;
-  },
-  // `Promise.race` method
-  // https://tc39.es/ecma262/#sec-promise.race
+  }
+});
+
+var $$5 = _export;
+var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
+var NativePromiseConstructor$1 = promiseNativeConstructor;
+var getBuiltIn$2 = getBuiltIn$5;
+var isCallable$1 = isCallable$6;
+var defineBuiltIn$1 = defineBuiltIn$3;
+
+var NativePromisePrototype$1 = NativePromiseConstructor$1 && NativePromiseConstructor$1.prototype;
+
+// `Promise.prototype.catch` method
+// https://tc39.es/ecma262/#sec-promise.prototype.catch
+$$5({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
+  'catch': function (onRejected) {
+    return this.then(undefined, onRejected);
+  }
+});
+
+// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
+if (isCallable$1(NativePromiseConstructor$1)) {
+  var method$1 = getBuiltIn$2('Promise').prototype['catch'];
+  if (NativePromisePrototype$1['catch'] !== method$1) {
+    defineBuiltIn$1(NativePromisePrototype$1, 'catch', method$1, { unsafe: true });
+  }
+}
+
+var $$4 = _export;
+var call$1 = functionCall;
+var aCallable = aCallable$6;
+var newPromiseCapabilityModule$1 = newPromiseCapability$2;
+var perform = perform$3;
+var iterate = iterate$2;
+var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
+
+// `Promise.race` method
+// https://tc39.es/ecma262/#sec-promise.race
+$$4({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
   race: function race(iterable) {
     var C = this;
-    var capability = newPromiseCapability(C);
+    var capability = newPromiseCapabilityModule$1.f(C);
     var reject = capability.reject;
     var result = perform(function () {
       var $promiseResolve = aCallable(C.resolve);
       iterate(iterable, function (promise) {
-        call($promiseResolve, C, promise).then(capability.resolve, reject);
+        call$1($promiseResolve, C, promise).then(capability.resolve, reject);
       });
     });
     if (result.error) reject(result.value);
@@ -1065,55 +1049,52 @@ $$2({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
   }
 });
 
-var global = global$e;
-var classof = classof$4;
+var $$3 = _export;
+var call = functionCall;
+var newPromiseCapabilityModule = newPromiseCapability$2;
+var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
+
+// `Promise.reject` method
+// https://tc39.es/ecma262/#sec-promise.reject
+$$3({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
+  reject: function reject(r) {
+    var capability = newPromiseCapabilityModule.f(this);
+    call(capability.reject, undefined, r);
+    return capability.promise;
+  }
+});
 
-var String$1 = global.String;
+var anObject = anObject$5;
+var isObject = isObject$2;
+var newPromiseCapability = newPromiseCapability$2;
 
-var toString$1 = function (argument) {
-  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
-  return String$1(argument);
+var promiseResolve$2 = function (C, x) {
+  anObject(C);
+  if (isObject(x) && x.constructor === C) return x;
+  var promiseCapability = newPromiseCapability.f(C);
+  var resolve = promiseCapability.resolve;
+  resolve(x);
+  return promiseCapability.promise;
 };
 
-// a string of all valid unicode whitespaces
-var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
-  '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
+var $$2 = _export;
+var getBuiltIn$1 = getBuiltIn$5;
+var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
+var promiseResolve$1 = promiseResolve$2;
 
-var uncurryThis = functionUncurryThis;
-var requireObjectCoercible = requireObjectCoercible$1;
-var toString = toString$1;
-var whitespaces$1 = whitespaces$2;
-
-var replace = uncurryThis(''.replace);
-var whitespace = '[' + whitespaces$1 + ']';
-var ltrim = RegExp('^' + whitespace + whitespace + '*');
-var rtrim = RegExp(whitespace + whitespace + '*$');
-
-// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
-var createMethod = function (TYPE) {
-  return function ($this) {
-    var string = toString(requireObjectCoercible($this));
-    if (TYPE & 1) string = replace(string, ltrim, '');
-    if (TYPE & 2) string = replace(string, rtrim, '');
-    return string;
-  };
-};
+getBuiltIn$1('Promise');
 
-var stringTrim = {
-  // `String.prototype.{ trimLeft, trimStart }` methods
-  // https://tc39.es/ecma262/#sec-string.prototype.trimstart
-  start: createMethod(1),
-  // `String.prototype.{ trimRight, trimEnd }` methods
-  // https://tc39.es/ecma262/#sec-string.prototype.trimend
-  end: createMethod(2),
-  // `String.prototype.trim` method
-  // https://tc39.es/ecma262/#sec-string.prototype.trim
-  trim: createMethod(3)
-};
+// `Promise.resolve` method
+// https://tc39.es/ecma262/#sec-promise.resolve
+$$2({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+  resolve: function resolve(x) {
+    return promiseResolve$1(this, x);
+  }
+});
 
 var PROPER_FUNCTION_NAME = functionName.PROPER;
 var fails$1 = fails$4;
-var whitespaces = whitespaces$2;
+var whitespaces = whitespaces$1;
 
 var non = '\u200B\u0085\u180E';
 
@@ -1140,18 +1121,20 @@ $$1({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {
 });
 
 var $ = _export;
-var NativePromise = nativePromiseConstructor;
+var NativePromiseConstructor = promiseNativeConstructor;
 var fails = fails$4;
-var getBuiltIn = getBuiltIn$4;
-var isCallable = isCallable$5;
+var getBuiltIn = getBuiltIn$5;
+var isCallable = isCallable$6;
 var speciesConstructor = speciesConstructor$2;
 var promiseResolve = promiseResolve$2;
-var redefine = redefine$3.exports;
+var defineBuiltIn = defineBuiltIn$3;
+
+var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
 
 // Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829
-var NON_GENERIC = !!NativePromise && fails(function () {
+var NON_GENERIC = !!NativePromiseConstructor && fails(function () {
   // eslint-disable-next-line unicorn/no-thenable -- required for testing
-  NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });
+  NativePromisePrototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });
 });
 
 // `Promise.prototype.finally` method
@@ -1172,10 +1155,10 @@ $({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {
 });
 
 // makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`
-if (isCallable(NativePromise)) {
+if (isCallable(NativePromiseConstructor)) {
   var method = getBuiltIn('Promise').prototype['finally'];
-  if (NativePromise.prototype['finally'] !== method) {
-    redefine(NativePromise.prototype, 'finally', method, { unsafe: true });
+  if (NativePromisePrototype['finally'] !== method) {
+    defineBuiltIn(NativePromisePrototype, 'finally', method, { unsafe: true });
   }
 }
 
@@ -1332,12 +1315,10 @@ const PLACEHOLDER_ICON = `<svg width="80%" height="80%" viewBox="0 0 64 64">
 </svg>`;
 
 const BASE_URL = 'https://icon.resources.vonage.com';
-const ICON_SET_VERSION = '4.0.27';
+const ICON_SET_VERSION = '4.0.30';
 const PLACEHOLDER_DELAY = 500;
 const PLACEHOLDER_TIMEOUT = 2000;
-
 const baseUrlTemplate = (resource, version) => [BASE_URL, `v${version}`, resource].join('/');
-
 const assertIsValidResponse = ({
   ok,
   headers
@@ -1346,48 +1327,35 @@ const assertIsValidResponse = ({
     throw new Error('Something went wrong');
   }
 };
-
 const extractSvg = response => {
   assertIsValidResponse(response);
   return response.text();
 };
-
 const loadSvg = iconId => fetch(baseUrlTemplate([iconId, 'svg'].join('.'), ICON_SET_VERSION)).then(extractSvg);
-
 const resolveIcon = memoizeWith$1(identity$1, (iconId = '') => iconId.trim() ? loadSvg(iconId) : Promise.resolve(''));
 class Icon extends FoundationElement {
-  constructor() {
-    super(...arguments);
-    this.svg = '';
-  }
-
   async typeChanged() {
-    this.svg = '';
+    this.svg = undefined;
     let timeout = setTimeout(() => {
       this.svg = PLACEHOLDER_ICON;
       timeout = setTimeout(() => {
         if (this.svg === PLACEHOLDER_ICON) {
-          this.svg = '';
+          this.svg = undefined;
         }
       }, PLACEHOLDER_TIMEOUT);
     }, PLACEHOLDER_DELAY);
     await resolveIcon(this.type).then(svg => {
       this.svg = svg;
     }).catch(() => {
-      this.svg = '';
+      this.svg = undefined;
     }).finally(() => {
       clearTimeout(timeout);
     });
   }
-
 }
-
 __decorate([attr, __metadata("design:type", String)], Icon.prototype, "connotation", void 0);
-
 __decorate([attr, __metadata("design:type", String)], Icon.prototype, "size", void 0);
-
-__decorate([observable, __metadata("design:type", Object)], Icon.prototype, "svg", void 0);
-
+__decorate([observable, __metadata("design:type", String)], Icon.prototype, "svg", void 0);
 __decorate([attr, __metadata("design:type", String)], Icon.prototype, "type", void 0);
 
-export { Icon as I, functionApply as f, speciesConstructor$2 as s, toString$1 as t };
+export { Icon as I };