text: /*!
   * @license deepcopy.js Copyright(c) 2013 sasa+1
   * https://github.com/sasaplus1/deepcopy.js
   * Released under the MIT license.
   *
   * type-detect
   * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
   * MIT Licensed
   */
  (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  	typeof define === 'function' && define.amd ? define(factory) :
  	(global.deepcopy = factory());
  }(this, (function () { 'use strict';
  
  	var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
  	function createCommonjsModule(fn, module) {
  		return module = { exports: {} }, fn(module, module.exports), module.exports;
  	}
  
  	var _global = createCommonjsModule(function (module) {
  	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  	var global = module.exports = typeof window != 'undefined' && window.Math == Math
  	  ? window : typeof self != 'undefined' && self.Math == Math ? self
  	  // eslint-disable-next-line no-new-func
  	  : Function('return this')();
  	if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
  	});
  
  	var hasOwnProperty = {}.hasOwnProperty;
  	var _has = function (it, key) {
  	  return hasOwnProperty.call(it, key);
  	};
  
  	var _fails = function (exec) {
  	  try {
  	    return !!exec();
  	  } catch (e) {
  	    return true;
  	  }
  	};
  
  	// Thank's IE8 for his funny defineProperty
  	var _descriptors = !_fails(function () {
  	  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
  	});
  
  	var _core = createCommonjsModule(function (module) {
  	var core = module.exports = { version: '2.5.4' };
  	if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
  	});
  	var _core_1 = _core.version;
  
  	var _isObject = function (it) {
  	  return typeof it === 'object' ? it !== null : typeof it === 'function';
  	};
  
  	var _anObject = function (it) {
  	  if (!_isObject(it)) throw TypeError(it + ' is not an object!');
  	  return it;
  	};
  
  	var document$1 = _global.document;
  	// typeof document.createElement is 'object' in old IE
  	var is = _isObject(document$1) && _isObject(document$1.createElement);
  	var _domCreate = function (it) {
  	  return is ? document$1.createElement(it) : {};
  	};
  
  	var _ie8DomDefine = !_descriptors && !_fails(function () {
  	  return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;
  	});
  
  	// 7.1.1 ToPrimitive(input [, PreferredType])
  
  	// instead of the ES6 spec version, we didn't implement @@toPrimitive case
  	// and the second argument - flag - preferred type is a string
  	var _toPrimitive = function (it, S) {
  	  if (!_isObject(it)) return it;
  	  var fn, val;
  	  if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
  	  if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val;
  	  if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;
  	  throw TypeError("Can't convert object to primitive value");
  	};
  
  	var dP = Object.defineProperty;
  
  	var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {
  	  _anObject(O);
  	  P = _toPrimitive(P, true);
  	  _anObject(Attributes);
  	  if (_ie8DomDefine) try {
  	    return dP(O, P, Attributes);
  	  } catch (e) { /* empty */ }
  	  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
  	  if ('value' in Attributes) O[P] = Attributes.value;
  	  return O;
  	};
  
  	var _objectDp = {
  		f: f
  	};
  
  	var _propertyDesc = function (bitmap, value) {
  	  return {
  	    enumerable: !(bitmap & 1),
  	    configurable: !(bitmap & 2),
  	    writable: !(bitmap & 4),
  	    value: value
  	  };
  	};
  
  	var _hide = _descriptors ? function (object, key, value) {
  	  return _objectDp.f(object, key, _propertyDesc(1, value));
  	} : function (object, key, value) {
  	  object[key] = value;
  	  return object;
  	};
  
  	var id = 0;
  	var px = Math.random();
  	var _uid = function (key) {
  	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  	};
  
  	var _redefine = createCommonjsModule(function (module) {
  	var SRC = _uid('src');
  	var TO_STRING = 'toString';
  	var $toString = Function[TO_STRING];
  	var TPL = ('' + $toString).split(TO_STRING);
  
  	_core.inspectSource = function (it) {
  	  return $toString.call(it);
  	};
  
  	(module.exports = function (O, key, val, safe) {
  	  var isFunction = typeof val == 'function';
  	  if (isFunction) _has(val, 'name') || _hide(val, 'name', key);
  	  if (O[key] === val) return;
  	  if (isFunction) _has(val, SRC) || _hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
  	  if (O === _global) {
  	    O[key] = val;
  	  } else if (!safe) {
  	    delete O[key];
  	    _hide(O, key, val);
  	  } else if (O[key]) {
  	    O[key] = val;
  	  } else {
  	    _hide(O, key, val);
  	  }
  	// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
  	})(Function.prototype, TO_STRING, function toString() {
  	  return typeof this == 'function' && this[SRC] || $toString.call(this);
  	});
  	});
  
  	var _aFunction = function (it) {
  	  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
  	  return it;
  	};
  
  	// optional / simple context binding
  
  	var _ctx = function (fn, that, length) {
  	  _aFunction(fn);
  	  if (that === undefined) return fn;
  	  switch (length) {
  	    case 1: return function (a) {
  	      return fn.call(that, a);
  	    };
  	    case 2: return function (a, b) {
  	      return fn.call(that, a, b);
  	    };
  	    case 3: return function (a, b, c) {
  	      return fn.call(that, a, b, c);
  	    };
  	  }
  	  return function (/* ...args */) {
  	    return fn.apply(that, arguments);
  	  };
  	};
  
  	var PROTOTYPE = 'prototype';
  
  	var $export = function (type, name, source) {
  	  var IS_FORCED = type & $export.F;
  	  var IS_GLOBAL = type & $export.G;
  	  var IS_STATIC = type & $export.S;
  	  var IS_PROTO = type & $export.P;
  	  var IS_BIND = type & $export.B;
  	  var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE];
  	  var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});
  	  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
  	  var key, own, out, exp;
  	  if (IS_GLOBAL) source = name;
  	  for (key in source) {
  	    // contains in native
  	    own = !IS_FORCED && target && target[key] !== undefined;
  	    // export native or passed
  	    out = (own ? target : source)[key];
  	    // bind timers to global for call from export context
  	    exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out;
  	    // extend global
  	    if (target) _redefine(target, key, out, type & $export.U);
  	    // export
  	    if (exports[key] != out) _hide(exports, key, exp);
  	    if (IS_PROTO && expProto[key] != out) expProto[key] = out;
  	  }
  	};
  	_global.core = _core;
  	// type bitmap
  	$export.F = 1;   // forced
  	$export.G = 2;   // global
  	$export.S = 4;   // static
  	$export.P = 8;   // proto
  	$export.B = 16;  // bind
  	$export.W = 32;  // wrap
  	$export.U = 64;  // safe
  	$export.R = 128; // real proto method for `library`
  	var _export = $export;
  
  	var _meta = createCommonjsModule(function (module) {
  	var META = _uid('meta');
  
  
  	var setDesc = _objectDp.f;
  	var id = 0;
  	var isExtensible = Object.isExtensible || function () {
  	  return true;
  	};
  	var FREEZE = !_fails(function () {
  	  return isExtensible(Object.preventExtensions({}));
  	});
  	var setMeta = function (it) {
  	  setDesc(it, META, { value: {
  	    i: 'O' + ++id, // object ID
  	    w: {}          // weak collections IDs
  	  } });
  	};
  	var fastKey = function (it, create) {
  	  // return primitive with prefix
  	  if (!_isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
  	  if (!_has(it, META)) {
  	    // can't set metadata to uncaught frozen object
  	    if (!isExtensible(it)) return 'F';
  	    // not necessary to add metadata
  	    if (!create) return 'E';
  	    // add missing metadata
  	    setMeta(it);
  	  // return object ID
  	  } return it[META].i;
  	};
  	var getWeak = function (it, create) {
  	  if (!_has(it, META)) {
  	    // can't set metadata to uncaught frozen object
  	    if (!isExtensible(it)) return true;
  	    // not necessary to add metadata
  	    if (!create) return false;
  	    // add missing metadata
  	    setMeta(it);
  	  // return hash weak collections IDs
  	  } return it[META].w;
  	};
  	// add metadata on freeze-family methods calling
  	var onFreeze = function (it) {
  	  if (FREEZE && meta.NEED && isExtensible(it) && !_has(it, META)) setMeta(it);
  	  return it;
  	};
  	var meta = module.exports = {
  	  KEY: META,
  	  NEED: false,
  	  fastKey: fastKey,
  	  getWeak: getWeak,
  	  onFreeze: onFreeze
  	};
  	});
  	var _meta_1 = _meta.KEY;
  	var _meta_2 = _meta.NEED;
  	var _meta_3 = _meta.fastKey;
  	var _meta_4 = _meta.getWeak;
  	var _meta_5 = _meta.onFreeze;
  
  	var SHARED = '__core-js_shared__';
  	var store = _global[SHARED] || (_global[SHARED] = {});
  	var _shared = function (key) {
  	  return store[key] || (store[key] = {});
  	};
  
  	var _wks = createCommonjsModule(function (module) {
  	var store = _shared('wks');
  
  	var Symbol = _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 : _uid)('Symbol.' + name));
  	};
  
  	$exports.store = store;
  	});
  
  	var def = _objectDp.f;
  
  	var TAG = _wks('toStringTag');
  
  	var _setToStringTag = function (it, tag, stat) {
  	  if (it && !_has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
  	};
  
  	var f$1 = _wks;
  
  	var _wksExt = {
  		f: f$1
  	};
  
  	var _library = false;
  
  	var defineProperty = _objectDp.f;
  	var _wksDefine = function (name) {
  	  var $Symbol = _core.Symbol || (_core.Symbol = _library ? {} : _global.Symbol || {});
  	  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: _wksExt.f(name) });
  	};
  
  	var toString = {}.toString;
  
  	var _cof = function (it) {
  	  return toString.call(it).slice(8, -1);
  	};
  
  	// fallback for non-array-like ES3 and non-enumerable old V8 strings
  
  	// eslint-disable-next-line no-prototype-builtins
  	var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
  	  return _cof(it) == 'String' ? it.split('') : Object(it);
  	};
  
  	// 7.2.1 RequireObjectCoercible(argument)
  	var _defined = function (it) {
  	  if (it == undefined) throw TypeError("Can't call method on  " + it);
  	  return it;
  	};
  
  	// to indexed object, toObject with fallback for non-array-like ES3 strings
  
  
  	var _toIobject = function (it) {
  	  return _iobject(_defined(it));
  	};
  
  	// 7.1.4 ToInteger
  	var ceil = Math.ceil;
  	var floor = Math.floor;
  	var _toInteger = function (it) {
  	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  	};
  
  	// 7.1.15 ToLength
  
  	var min = Math.min;
  	var _toLength = function (it) {
  	  return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  	};
  
  	var max = Math.max;
  	var min$1 = Math.min;
  	var _toAbsoluteIndex = function (index, length) {
  	  index = _toInteger(index);
  	  return index < 0 ? max(index + length, 0) : min$1(index, length);
  	};
  
  	// false -> Array#indexOf
  	// true  -> Array#includes
  
  
  
  	var _arrayIncludes = function (IS_INCLUDES) {
  	  return function ($this, el, fromIndex) {
  	    var O = _toIobject($this);
  	    var length = _toLength(O.length);
  	    var index = _toAbsoluteIndex(fromIndex, length);
  	    var value;
  	    // Array#includes uses SameValueZero equality algorithm
  	    // eslint-disable-next-line no-self-compare
  	    if (IS_INCLUDES && el != el) while (length > index) {
  	      value = O[index++];
  	      // eslint-disable-next-line no-self-compare
  	      if (value != value) return true;
  	    // Array#indexOf ignores holes, Array#includes - not
  	    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
  	      if (O[index] === el) return IS_INCLUDES || index || 0;
  	    } return !IS_INCLUDES && -1;
  	  };
  	};
  
  	var shared = _shared('keys');
  
  	var _sharedKey = function (key) {
  	  return shared[key] || (shared[key] = _uid(key));
  	};
  
  	var arrayIndexOf = _arrayIncludes(false);
  	var IE_PROTO = _sharedKey('IE_PROTO');
  
  	var _objectKeysInternal = function (object, names) {
  	  var O = _toIobject(object);
  	  var i = 0;
  	  var result = [];
  	  var key;
  	  for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key);
  	  // Don't enum bug & hidden keys
  	  while (names.length > i) if (_has(O, key = names[i++])) {
  	    ~arrayIndexOf(result, key) || result.push(key);
  	  }
  	  return result;
  	};
  
  	// IE 8- don't enum bug keys
  	var _enumBugKeys = (
  	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  	).split(',');
  
  	// 19.1.2.14 / 15.2.3.14 Object.keys(O)
  
  
  
  	var _objectKeys = Object.keys || function keys(O) {
  	  return _objectKeysInternal(O, _enumBugKeys);
  	};
  
  	var f$2 = Object.getOwnPropertySymbols;
  
  	var _objectGops = {
  		f: f$2
  	};
  
  	var f$3 = {}.propertyIsEnumerable;
  
  	var _objectPie = {
  		f: f$3
  	};
  
  	// all enumerable object keys, includes symbols
  
  
  
  	var _enumKeys = function (it) {
  	  var result = _objectKeys(it);
  	  var getSymbols = _objectGops.f;
  	  if (getSymbols) {
  	    var symbols = getSymbols(it);
  	    var isEnum = _objectPie.f;
  	    var i = 0;
  	    var key;
  	    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);
  	  } return result;
  	};
  
  	// 7.2.2 IsArray(argument)
  
  	var _isArray = Array.isArray || function isArray(arg) {
  	  return _cof(arg) == 'Array';
  	};
  
  	var _objectDps = _descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
  	  _anObject(O);
  	  var keys = _objectKeys(Properties);
  	  var length = keys.length;
  	  var i = 0;
  	  var P;
  	  while (length > i) _objectDp.f(O, P = keys[i++], Properties[P]);
  	  return O;
  	};
  
  	var document$2 = _global.document;
  	var _html = document$2 && document$2.documentElement;
  
  	// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  
  
  
  	var IE_PROTO$1 = _sharedKey('IE_PROTO');
  	var Empty = function () { /* empty */ };
  	var PROTOTYPE$1 = '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 = _domCreate('iframe');
  	  var i = _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$1][_enumBugKeys[i]];
  	  return createDict();
  	};
  
  	var _objectCreate = Object.create || function create(O, Properties) {
  	  var result;
  	  if (O !== null) {
  	    Empty[PROTOTYPE$1] = _anObject(O);
  	    result = new Empty();
  	    Empty[PROTOTYPE$1] = null;
  	    // add "__proto__" for Object.getPrototypeOf polyfill
  	    result[IE_PROTO$1] = O;
  	  } else result = createDict();
  	  return Properties === undefined ? result : _objectDps(result, Properties);
  	};
  
  	// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
  
  	var hiddenKeys = _enumBugKeys.concat('length', 'prototype');
  
  	var f$4 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  	  return _objectKeysInternal(O, hiddenKeys);
  	};
  
  	var _objectGopn = {
  		f: f$4
  	};
  
  	// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
  
  	var gOPN = _objectGopn.f;
  	var toString$1 = {}.toString;
  
  	var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
  	  ? Object.getOwnPropertyNames(window) : [];
  
  	var getWindowNames = function (it) {
  	  try {
  	    return gOPN(it);
  	  } catch (e) {
  	    return windowNames.slice();
  	  }
  	};
  
  	var f$5 = function getOwnPropertyNames(it) {
  	  return windowNames && toString$1.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(_toIobject(it));
  	};
  
  	var _objectGopnExt = {
  		f: f$5
  	};
  
  	var gOPD = Object.getOwnPropertyDescriptor;
  
  	var f$6 = _descriptors ? gOPD : function getOwnPropertyDescriptor(O, P) {
  	  O = _toIobject(O);
  	  P = _toPrimitive(P, true);
  	  if (_ie8DomDefine) try {
  	    return gOPD(O, P);
  	  } catch (e) { /* empty */ }
  	  if (_has(O, P)) return _propertyDesc(!_objectPie.f.call(O, P), O[P]);
  	};
  
  	var _objectGopd = {
  		f: f$6
  	};
  
  	// ECMAScript 6 symbols shim
  
  
  
  
  
  	var META = _meta.KEY;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  	var gOPD$1 = _objectGopd.f;
  	var dP$1 = _objectDp.f;
  	var gOPN$1 = _objectGopnExt.f;
  	var $Symbol = _global.Symbol;
  	var $JSON = _global.JSON;
  	var _stringify = $JSON && $JSON.stringify;
  	var PROTOTYPE$2 = 'prototype';
  	var HIDDEN = _wks('_hidden');
  	var TO_PRIMITIVE = _wks('toPrimitive');
  	var isEnum = {}.propertyIsEnumerable;
  	var SymbolRegistry = _shared('symbol-registry');
  	var AllSymbols = _shared('symbols');
  	var OPSymbols = _shared('op-symbols');
  	var ObjectProto = Object[PROTOTYPE$2];
  	var USE_NATIVE = typeof $Symbol == 'function';
  	var QObject = _global.QObject;
  	// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
  	var setter = !QObject || !QObject[PROTOTYPE$2] || !QObject[PROTOTYPE$2].findChild;
  
  	// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
  	var setSymbolDesc = _descriptors && _fails(function () {
  	  return _objectCreate(dP$1({}, 'a', {
  	    get: function () { return dP$1(this, 'a', { value: 7 }).a; }
  	  })).a != 7;
  	}) ? function (it, key, D) {
  	  var protoDesc = gOPD$1(ObjectProto, key);
  	  if (protoDesc) delete ObjectProto[key];
  	  dP$1(it, key, D);
  	  if (protoDesc && it !== ObjectProto) dP$1(ObjectProto, key, protoDesc);
  	} : dP$1;
  
  	var wrap = function (tag) {
  	  var sym = AllSymbols[tag] = _objectCreate($Symbol[PROTOTYPE$2]);
  	  sym._k = tag;
  	  return sym;
  	};
  
  	var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {
  	  return typeof it == 'symbol';
  	} : function (it) {
  	  return it instanceof $Symbol;
  	};
  
  	var $defineProperty = function defineProperty(it, key, D) {
  	  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
  	  _anObject(it);
  	  key = _toPrimitive(key, true);
  	  _anObject(D);
  	  if (_has(AllSymbols, key)) {
  	    if (!D.enumerable) {
  	      if (!_has(it, HIDDEN)) dP$1(it, HIDDEN, _propertyDesc(1, {}));
  	      it[HIDDEN][key] = true;
  	    } else {
  	      if (_has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
  	      D = _objectCreate(D, { enumerable: _propertyDesc(0, false) });
  	    } return setSymbolDesc(it, key, D);
  	  } return dP$1(it, key, D);
  	};
  	var $defineProperties = function defineProperties(it, P) {
  	  _anObject(it);
  	  var keys = _enumKeys(P = _toIobject(P));
  	  var i = 0;
  	  var l = keys.length;
  	  var key;
  	  while (l > i) $defineProperty(it, key = keys[i++], P[key]);
  	  return it;
  	};
  	var $create = function create(it, P) {
  	  return P === undefined ? _objectCreate(it) : $defineProperties(_objectCreate(it), P);
  	};
  	var $propertyIsEnumerable = function propertyIsEnumerable(key) {
  	  var E = isEnum.call(this, key = _toPrimitive(key, true));
  	  if (this === ObjectProto && _has(AllSymbols, key) && !_has(OPSymbols, key)) return false;
  	  return E || !_has(this, key) || !_has(AllSymbols, key) || _has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
  	};
  	var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
  	  it = _toIobject(it);
  	  key = _toPrimitive(key, true);
  	  if (it === ObjectProto && _has(AllSymbols, key) && !_has(OPSymbols, key)) return;
  	  var D = gOPD$1(it, key);
  	  if (D && _has(AllSymbols, key) && !(_has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
  	  return D;
  	};
  	var $getOwnPropertyNames = function getOwnPropertyNames(it) {
  	  var names = gOPN$1(_toIobject(it));
  	  var result = [];
  	  var i = 0;
  	  var key;
  	  while (names.length > i) {
  	    if (!_has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);
  	  } return result;
  	};
  	var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
  	  var IS_OP = it === ObjectProto;
  	  var names = gOPN$1(IS_OP ? OPSymbols : _toIobject(it));
  	  var result = [];
  	  var i = 0;
  	  var key;
  	  while (names.length > i) {
  	    if (_has(AllSymbols, key = names[i++]) && (IS_OP ? _has(ObjectProto, key) : true)) result.push(AllSymbols[key]);
  	  } return result;
  	};
  
  	// 19.4.1.1 Symbol([description])
  	if (!USE_NATIVE) {
  	  $Symbol = function Symbol() {
  	    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
  	    var tag = _uid(arguments.length > 0 ? arguments[0] : undefined);
  	    var $set = function (value) {
  	      if (this === ObjectProto) $set.call(OPSymbols, value);
  	      if (_has(this, HIDDEN) && _has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
  	      setSymbolDesc(this, tag, _propertyDesc(1, value));
  	    };
  	    if (_descriptors && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });
  	    return wrap(tag);
  	  };
  	  _redefine($Symbol[PROTOTYPE$2], 'toString', function toString() {
  	    return this._k;
  	  });
  
  	  _objectGopd.f = $getOwnPropertyDescriptor;
  	  _objectDp.f = $defineProperty;
  	  _objectGopn.f = _objectGopnExt.f = $getOwnPropertyNames;
  	  _objectPie.f = $propertyIsEnumerable;
  	  _objectGops.f = $getOwnPropertySymbols;
  
  	  if (_descriptors && !_library) {
  	    _redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
  	  }
  
  	  _wksExt.f = function (name) {
  	    return wrap(_wks(name));
  	  };
  	}
  
  	_export(_export.G + _export.W + _export.F * !USE_NATIVE, { Symbol: $Symbol });
  
  	for (var es6Symbols = (
  	  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
  	  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
  	).split(','), j = 0; es6Symbols.length > j;)_wks(es6Symbols[j++]);
  
  	for (var wellKnownSymbols = _objectKeys(_wks.store), k = 0; wellKnownSymbols.length > k;) _wksDefine(wellKnownSymbols[k++]);
  
  	_export(_export.S + _export.F * !USE_NATIVE, 'Symbol', {
  	  // 19.4.2.1 Symbol.for(key)
  	  'for': function (key) {
  	    return _has(SymbolRegistry, key += '')
  	      ? SymbolRegistry[key]
  	      : SymbolRegistry[key] = $Symbol(key);
  	  },
  	  // 19.4.2.5 Symbol.keyFor(sym)
  	  keyFor: function keyFor(sym) {
  	    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
  	    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;
  	  },
  	  useSetter: function () { setter = true; },
  	  useSimple: function () { setter = false; }
  	});
  
  	_export(_export.S + _export.F * !USE_NATIVE, 'Object', {
  	  // 19.1.2.2 Object.create(O [, Properties])
  	  create: $create,
  	  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
  	  defineProperty: $defineProperty,
  	  // 19.1.2.3 Object.defineProperties(O, Properties)
  	  defineProperties: $defineProperties,
  	  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  	  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  	  // 19.1.2.7 Object.getOwnPropertyNames(O)
  	  getOwnPropertyNames: $getOwnPropertyNames,
  	  // 19.1.2.8 Object.getOwnPropertySymbols(O)
  	  getOwnPropertySymbols: $getOwnPropertySymbols
  	});
  
  	// 24.3.2 JSON.stringify(value [, replacer [, space]])
  	$JSON && _export(_export.S + _export.F * (!USE_NATIVE || _fails(function () {
  	  var S = $Symbol();
  	  // MS Edge converts symbol values to JSON as {}
  	  // WebKit converts symbol values to JSON as null
  	  // V8 throws on boxed symbols
  	  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';
  	})), 'JSON', {
  	  stringify: function stringify(it) {
  	    var args = [it];
  	    var i = 1;
  	    var replacer, $replacer;
  	    while (arguments.length > i) args.push(arguments[i++]);
  	    $replacer = replacer = args[1];
  	    if (!_isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
  	    if (!_isArray(replacer)) replacer = function (key, value) {
  	      if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
  	      if (!isSymbol(value)) return value;
  	    };
  	    args[1] = replacer;
  	    return _stringify.apply($JSON, args);
  	  }
  	});
  
  	// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
  	$Symbol[PROTOTYPE$2][TO_PRIMITIVE] || _hide($Symbol[PROTOTYPE$2], TO_PRIMITIVE, $Symbol[PROTOTYPE$2].valueOf);
  	// 19.4.3.5 Symbol.prototype[@@toStringTag]
  	_setToStringTag($Symbol, 'Symbol');
  	// 20.2.1.9 Math[@@toStringTag]
  	_setToStringTag(Math, 'Math', true);
  	// 24.3.3 JSON[@@toStringTag]
  	_setToStringTag(_global.JSON, 'JSON', true);
  
  	// 22.1.3.31 Array.prototype[@@unscopables]
  	var UNSCOPABLES = _wks('unscopables');
  	var ArrayProto = Array.prototype;
  	if (ArrayProto[UNSCOPABLES] == undefined) _hide(ArrayProto, UNSCOPABLES, {});
  	var _addToUnscopables = function (key) {
  	  ArrayProto[UNSCOPABLES][key] = true;
  	};
  
  	var _iterStep = function (done, value) {
  	  return { value: value, done: !!done };
  	};
  
  	var _iterators = {};
  
  	var IteratorPrototype = {};
  
  	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
  	_hide(IteratorPrototype, _wks('iterator'), function () { return this; });
  
  	var _iterCreate = function (Constructor, NAME, next) {
  	  Constructor.prototype = _objectCreate(IteratorPrototype, { next: _propertyDesc(1, next) });
  	  _setToStringTag(Constructor, NAME + ' Iterator');
  	};
  
  	// 7.1.13 ToObject(argument)
  
  	var _toObject = function (it) {
  	  return Object(_defined(it));
  	};
  
  	// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
  
  
  	var IE_PROTO$2 = _sharedKey('IE_PROTO');
  	var ObjectProto$1 = Object.prototype;
  
  	var _objectGpo = Object.getPrototypeOf || function (O) {
  	  O = _toObject(O);
  	  if (_has(O, IE_PROTO$2)) return O[IE_PROTO$2];
  	  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
  	    return O.constructor.prototype;
  	  } return O instanceof Object ? ObjectProto$1 : 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 for some old engines
  	      if (!_library && typeof IteratorPrototype[ITERATOR] != 'function') _hide(IteratorPrototype, ITERATOR, returnThis);
  	    }
  	  }
  	  // 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 ((!_library || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
  	    _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 _export(_export.P + _export.F * (BUGGY || VALUES_BUG), NAME, methods);
  	  }
  	  return methods;
  	};
  
  	// 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 = _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;
  
  	_addToUnscopables('keys');
  	_addToUnscopables('values');
  	_addToUnscopables('entries');
  
  	var ITERATOR$1 = _wks('iterator');
  	var TO_STRING_TAG = _wks('toStringTag');
  	var ArrayValues = _iterators.Array;
  
  	var DOMIterables = {
  	  CSSRuleList: true, // TODO: Not spec compliant, should be false.
  	  CSSStyleDeclaration: false,
  	  CSSValueList: false,
  	  ClientRectList: false,
  	  DOMRectList: false,
  	  DOMStringList: false,
  	  DOMTokenList: true,
  	  DataTransferItemList: false,
  	  FileList: false,
  	  HTMLAllCollection: false,
  	  HTMLCollection: false,
  	  HTMLFormElement: false,
  	  HTMLSelectElement: false,
  	  MediaList: true, // TODO: Not spec compliant, should be false.
  	  MimeTypeArray: false,
  	  NamedNodeMap: false,
  	  NodeList: true,
  	  PaintRequestList: false,
  	  Plugin: false,
  	  PluginArray: false,
  	  SVGLengthList: false,
  	  SVGNumberList: false,
  	  SVGPathSegList: false,
  	  SVGPointList: false,
  	  SVGStringList: false,
  	  SVGTransformList: false,
  	  SourceBufferList: false,
  	  StyleSheetList: true, // TODO: Not spec compliant, should be false.
  	  TextTrackCueList: false,
  	  TextTrackList: false,
  	  TouchList: false
  	};
  
  	for (var collections = _objectKeys(DOMIterables), i = 0; i < collections.length; i++) {
  	  var NAME = collections[i];
  	  var explicit = DOMIterables[NAME];
  	  var Collection = _global[NAME];
  	  var proto = Collection && Collection.prototype;
  	  var key;
  	  if (proto) {
  	    if (!proto[ITERATOR$1]) _hide(proto, ITERATOR$1, ArrayValues);
  	    if (!proto[TO_STRING_TAG]) _hide(proto, TO_STRING_TAG, NAME);
  	    _iterators[NAME] = ArrayValues;
  	    if (explicit) for (key in es6_array_iterator) if (!proto[key]) _redefine(proto, key, es6_array_iterator[key], true);
  	  }
  	}
  
  	function _typeof(obj) {
  	  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
  	    _typeof = function (obj) {
  	      return typeof obj;
  	    };
  	  } else {
  	    _typeof = function (obj) {
  	      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  	    };
  	  }
  
  	  return _typeof(obj);
  	}
  
  	function _toConsumableArray(arr) {
  	  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
  	}
  
  	function _arrayWithoutHoles(arr) {
  	  if (Array.isArray(arr)) {
  	    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
  
  	    return arr2;
  	  }
  	}
  
  	function _iterableToArray(iter) {
  	  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
  	}
  
  	function _nonIterableSpread() {
  	  throw new TypeError("Invalid attempt to spread non-iterable instance");
  	}
  
  	var _redefineAll = function (target, src, safe) {
  	  for (var key in src) _redefine(target, key, src[key], safe);
  	  return target;
  	};
  
  	var _anInstance = function (it, Constructor, name, forbiddenField) {
  	  if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
  	    throw TypeError(name + ': incorrect invocation!');
  	  } return it;
  	};
  
  	// call something on iterator step with safe closing on error
  
  	var _iterCall = function (iterator, fn, value, entries) {
  	  try {
  	    return entries ? fn(_anObject(value)[0], value[1]) : fn(value);
  	  // 7.4.6 IteratorClose(iterator, completion)
  	  } catch (e) {
  	    var ret = iterator['return'];
  	    if (ret !== undefined) _anObject(ret.call(iterator));
  	    throw e;
  	  }
  	};
  
  	// check on default Array iterator
  
  	var ITERATOR$2 = _wks('iterator');
  	var ArrayProto$1 = Array.prototype;
  
  	var _isArrayIter = function (it) {
  	  return it !== undefined && (_iterators.Array === it || ArrayProto$1[ITERATOR$2] === it);
  	};
  
  	// getting tag from 19.1.3.6 Object.prototype.toString()
  
  	var TAG$1 = _wks('toStringTag');
  	// ES3 wrong here
  	var ARG = _cof(function () { return arguments; }()) == 'Arguments';
  
  	// fallback for IE11 Script Access Denied error
  	var tryGet = function (it, key) {
  	  try {
  	    return it[key];
  	  } catch (e) { /* empty */ }
  	};
  
  	var _classof = function (it) {
  	  var O, T, B;
  	  return it === undefined ? 'Undefined' : it === null ? 'Null'
  	    // @@toStringTag case
  	    : typeof (T = tryGet(O = Object(it), TAG$1)) == 'string' ? T
  	    // builtinTag case
  	    : ARG ? _cof(O)
  	    // ES3 arguments fallback
  	    : (B = _cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
  	};
  
  	var ITERATOR$3 = _wks('iterator');
  
  	var core_getIteratorMethod = _core.getIteratorMethod = function (it) {
  	  if (it != undefined) return it[ITERATOR$3]
  	    || it['@@iterator']
  	    || _iterators[_classof(it)];
  	};
  
  	var _forOf = createCommonjsModule(function (module) {
  	var BREAK = {};
  	var RETURN = {};
  	var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
  	  var iterFn = ITERATOR ? function () { return iterable; } : core_getIteratorMethod(iterable);
  	  var f = _ctx(fn, that, entries ? 2 : 1);
  	  var index = 0;
  	  var length, step, iterator, result;
  	  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
  	  // fast case for arrays with default iterator
  	  if (_isArrayIter(iterFn)) for (length = _toLength(iterable.length); length > index; index++) {
  	    result = entries ? f(_anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
  	    if (result === BREAK || result === RETURN) return result;
  	  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
  	    result = _iterCall(iterator, f, step.value, entries);
  	    if (result === BREAK || result === RETURN) return result;
  	  }
  	};
  	exports.BREAK = BREAK;
  	exports.RETURN = RETURN;
  	});
  
  	var SPECIES = _wks('species');
  
  	var _arraySpeciesConstructor = function (original) {
  	  var C;
  	  if (_isArray(original)) {
  	    C = original.constructor;
  	    // cross-realm fallback
  	    if (typeof C == 'function' && (C === Array || _isArray(C.prototype))) C = undefined;
  	    if (_isObject(C)) {
  	      C = C[SPECIES];
  	      if (C === null) C = undefined;
  	    }
  	  } return C === undefined ? Array : C;
  	};
  
  	// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
  
  
  	var _arraySpeciesCreate = function (original, length) {
  	  return new (_arraySpeciesConstructor(original))(length);
  	};
  
  	// 0 -> Array#forEach
  	// 1 -> Array#map
  	// 2 -> Array#filter
  	// 3 -> Array#some
  	// 4 -> Array#every
  	// 5 -> Array#find
  	// 6 -> Array#findIndex
  
  
  
  
  
  	var _arrayMethods = function (TYPE, $create) {
  	  var IS_MAP = TYPE == 1;
  	  var IS_FILTER = TYPE == 2;
  	  var IS_SOME = TYPE == 3;
  	  var IS_EVERY = TYPE == 4;
  	  var IS_FIND_INDEX = TYPE == 6;
  	  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
  	  var create = $create || _arraySpeciesCreate;
  	  return function ($this, callbackfn, that) {
  	    var O = _toObject($this);
  	    var self = _iobject(O);
  	    var f = _ctx(callbackfn, that, 3);
  	    var length = _toLength(self.length);
  	    var index = 0;
  	    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
  	    var val, res;
  	    for (;length > index; index++) if (NO_HOLES || index in self) {
  	      val = self[index];
  	      res = f(val, index, O);
  	      if (TYPE) {
  	        if (IS_MAP) result[index] = res;   // map
  	        else if (res) switch (TYPE) {
  	          case 3: return true;             // some
  	          case 5: return val;              // find
  	          case 6: return index;            // findIndex
  	          case 2: result.push(val);        // filter
  	        } else if (IS_EVERY) return false; // every
  	      }
  	    }
  	    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
  	  };
  	};
  
  	var _validateCollection = function (it, TYPE) {
  	  if (!_isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
  	  return it;
  	};
  
  	var getWeak = _meta.getWeak;
  
  
  
  
  
  
  
  	var arrayFind = _arrayMethods(5);
  	var arrayFindIndex = _arrayMethods(6);
  	var id$1 = 0;
  
  	// fallback for uncaught frozen keys
  	var uncaughtFrozenStore = function (that) {
  	  return that._l || (that._l = new UncaughtFrozenStore());
  	};
  	var UncaughtFrozenStore = function () {
  	  this.a = [];
  	};
  	var findUncaughtFrozen = function (store, key) {
  	  return arrayFind(store.a, function (it) {
  	    return it[0] === key;
  	  });
  	};
  	UncaughtFrozenStore.prototype = {
  	  get: function (key) {
  	    var entry = findUncaughtFrozen(this, key);
  	    if (entry) return entry[1];
  	  },
  	  has: function (key) {
  	    return !!findUncaughtFrozen(this, key);
  	  },
  	  set: function (key, value) {
  	    var entry = findUncaughtFrozen(this, key);
  	    if (entry) entry[1] = value;
  	    else this.a.push([key, value]);
  	  },
  	  'delete': function (key) {
  	    var index = arrayFindIndex(this.a, function (it) {
  	      return it[0] === key;
  	    });
  	    if (~index) this.a.splice(index, 1);
  	    return !!~index;
  	  }
  	};
  
  	var _collectionWeak = {
  	  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
  	    var C = wrapper(function (that, iterable) {
  	      _anInstance(that, C, NAME, '_i');
  	      that._t = NAME;      // collection type
  	      that._i = id$1++;      // collection id
  	      that._l = undefined; // leak store for uncaught frozen objects
  	      if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that);
  	    });
  	    _redefineAll(C.prototype, {
  	      // 23.3.3.2 WeakMap.prototype.delete(key)
  	      // 23.4.3.3 WeakSet.prototype.delete(value)
  	      'delete': function (key) {
  	        if (!_isObject(key)) return false;
  	        var data = getWeak(key);
  	        if (data === true) return uncaughtFrozenStore(_validateCollection(this, NAME))['delete'](key);
  	        return data && _has(data, this._i) && delete data[this._i];
  	      },
  	      // 23.3.3.4 WeakMap.prototype.has(key)
  	      // 23.4.3.4 WeakSet.prototype.has(value)
  	      has: function has(key) {
  	        if (!_isObject(key)) return false;
  	        var data = getWeak(key);
  	        if (data === true) return uncaughtFrozenStore(_validateCollection(this, NAME)).has(key);
  	        return data && _has(data, this._i);
  	      }
  	    });
  	    return C;
  	  },
  	  def: function (that, key, value) {
  	    var data = getWeak(_anObject(key), true);
  	    if (data === true) uncaughtFrozenStore(that).set(key, value);
  	    else data[that._i] = value;
  	    return that;
  	  },
  	  ufstore: uncaughtFrozenStore
  	};
  
  	var ITERATOR$4 = _wks('iterator');
  	var SAFE_CLOSING = false;
  
  	try {
  	  var riter = [7][ITERATOR$4]();
  	  riter['return'] = function () { SAFE_CLOSING = true; };
  	} 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$4]();
  	    iter.next = function () { return { done: safe = true }; };
  	    arr[ITERATOR$4] = function () { return iter; };
  	    exec(arr);
  	  } catch (e) { /* empty */ }
  	  return safe;
  	};
  
  	// Works with __proto__ only. Old v8 can't work with null proto objects.
  	/* eslint-disable no-proto */
  
  
  	var check = function (O, proto) {
  	  _anObject(O);
  	  if (!_isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
  	};
  	var _setProto = {
  	  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
  	    function (test, buggy, set) {
  	      try {
  	        set = _ctx(Function.call, _objectGopd.f(Object.prototype, '__proto__').set, 2);
  	        set(test, []);
  	        buggy = !(test instanceof Array);
  	      } catch (e) { buggy = true; }
  	      return function setPrototypeOf(O, proto) {
  	        check(O, proto);
  	        if (buggy) O.__proto__ = proto;
  	        else set(O, proto);
  	        return O;
  	      };
  	    }({}, false) : undefined),
  	  check: check
  	};
  
  	var setPrototypeOf = _setProto.set;
  	var _inheritIfRequired = function (that, target, C) {
  	  var S = target.constructor;
  	  var P;
  	  if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && _isObject(P) && setPrototypeOf) {
  	    setPrototypeOf(that, P);
  	  } return that;
  	};
  
  	var _collection = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
  	  var Base = _global[NAME];
  	  var C = Base;
  	  var ADDER = IS_MAP ? 'set' : 'add';
  	  var proto = C && C.prototype;
  	  var O = {};
  	  var fixMethod = function (KEY) {
  	    var fn = proto[KEY];
  	    _redefine(proto, KEY,
  	      KEY == 'delete' ? function (a) {
  	        return IS_WEAK && !_isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
  	      } : KEY == 'has' ? function has(a) {
  	        return IS_WEAK && !_isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
  	      } : KEY == 'get' ? function get(a) {
  	        return IS_WEAK && !_isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
  	      } : KEY == 'add' ? function add(a) { fn.call(this, a === 0 ? 0 : a); return this; }
  	        : function set(a, b) { fn.call(this, a === 0 ? 0 : a, b); return this; }
  	    );
  	  };
  	  if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !_fails(function () {
  	    new C().entries().next();
  	  }))) {
  	    // create collection constructor
  	    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
  	    _redefineAll(C.prototype, methods);
  	    _meta.NEED = true;
  	  } else {
  	    var instance = new C();
  	    // early implementations not supports chaining
  	    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
  	    // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false
  	    var THROWS_ON_PRIMITIVES = _fails(function () { instance.has(1); });
  	    // most early implementations doesn't supports iterables, most modern - not close it correctly
  	    var ACCEPT_ITERABLES = _iterDetect(function (iter) { new C(iter); }); // eslint-disable-line no-new
  	    // for early implementations -0 and +0 not the same
  	    var BUGGY_ZERO = !IS_WEAK && _fails(function () {
  	      // V8 ~ Chromium 42- fails only with 5+ elements
  	      var $instance = new C();
  	      var index = 5;
  	      while (index--) $instance[ADDER](index, index);
  	      return !$instance.has(-0);
  	    });
  	    if (!ACCEPT_ITERABLES) {
  	      C = wrapper(function (target, iterable) {
  	        _anInstance(target, C, NAME);
  	        var that = _inheritIfRequired(new Base(), target, C);
  	        if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that);
  	        return that;
  	      });
  	      C.prototype = proto;
  	      proto.constructor = C;
  	    }
  	    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
  	      fixMethod('delete');
  	      fixMethod('has');
  	      IS_MAP && fixMethod('get');
  	    }
  	    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
  	    // weak collections should not contains .clear method
  	    if (IS_WEAK && proto.clear) delete proto.clear;
  	  }
  
  	  _setToStringTag(C, NAME);
  
  	  O[NAME] = C;
  	  _export(_export.G + _export.W + _export.F * (C != Base), O);
  
  	  if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
  
  	  return C;
  	};
  
  	var WEAK_SET = 'WeakSet';
  
  	// 23.4 WeakSet Objects
  	_collection(WEAK_SET, function (get) {
  	  return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  	}, {
  	  // 23.4.3.1 WeakSet.prototype.add(value)
  	  add: function add(value) {
  	    return _collectionWeak.def(_validateCollection(this, WEAK_SET), value, true);
  	  }
  	}, _collectionWeak, false, true);
  
  	// 19.1.2.1 Object.assign(target, source, ...)
  
  
  
  
  
  	var $assign = Object.assign;
  
  	// should work with symbols and should have deterministic property order (V8 bug)
  	var _objectAssign = !$assign || _fails(function () {
  	  var A = {};
  	  var B = {};
  	  // eslint-disable-next-line no-undef
  	  var S = Symbol();
  	  var K = 'abcdefghijklmnopqrst';
  	  A[S] = 7;
  	  K.split('').forEach(function (k) { B[k] = k; });
  	  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
  	}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
  	  var T = _toObject(target);
  	  var aLen = arguments.length;
  	  var index = 1;
  	  var getSymbols = _objectGops.f;
  	  var isEnum = _objectPie.f;
  	  while (aLen > index) {
  	    var S = _iobject(arguments[index++]);
  	    var keys = getSymbols ? _objectKeys(S).concat(getSymbols(S)) : _objectKeys(S);
  	    var length = keys.length;
  	    var j = 0;
  	    var key;
  	    while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];
  	  } return T;
  	} : $assign;
  
  	var es6_weakMap = createCommonjsModule(function (module) {
  	var each = _arrayMethods(0);
  
  
  
  
  
  
  
  	var WEAK_MAP = 'WeakMap';
  	var getWeak = _meta.getWeak;
  	var isExtensible = Object.isExtensible;
  	var uncaughtFrozenStore = _collectionWeak.ufstore;
  	var tmp = {};
  	var InternalMap;
  
  	var wrapper = function (get) {
  	  return function WeakMap() {
  	    return get(this, arguments.length > 0 ? arguments[0] : undefined);
  	  };
  	};
  
  	var methods = {
  	  // 23.3.3.3 WeakMap.prototype.get(key)
  	  get: function get(key) {
  	    if (_isObject(key)) {
  	      var data = getWeak(key);
  	      if (data === true) return uncaughtFrozenStore(_validateCollection(this, WEAK_MAP)).get(key);
  	      return data ? data[this._i] : undefined;
  	    }
  	  },
  	  // 23.3.3.5 WeakMap.prototype.set(key, value)
  	  set: function set(key, value) {
  	    return _collectionWeak.def(_validateCollection(this, WEAK_MAP), key, value);
  	  }
  	};
  
  	// 23.3 WeakMap Objects
  	var $WeakMap = module.exports = _collection(WEAK_MAP, wrapper, methods, _collectionWeak, true, true);
  
  	// IE11 WeakMap frozen keys fix
  	if (_fails(function () { return new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7; })) {
  	  InternalMap = _collectionWeak.getConstructor(wrapper, WEAK_MAP);
  	  _objectAssign(InternalMap.prototype, methods);
  	  _meta.NEED = true;
  	  each(['delete', 'has', 'get', 'set'], function (key) {
  	    var proto = $WeakMap.prototype;
  	    var method = proto[key];
  	    _redefine(proto, key, function (a, b) {
  	      // store frozen objects on internal weakmap shim
  	      if (_isObject(a) && !isExtensible(a)) {
  	        if (!this._f) this._f = new InternalMap();
  	        var result = this._f[key](a, b);
  	        return key == 'set' ? this : result;
  	      // store all the rest on native weakmap
  	      } return method.call(this, a, b);
  	    });
  	  });
  	}
  	});
  
  	var SPECIES$1 = _wks('species');
  
  	var _setSpecies = function (KEY) {
  	  var C = _global[KEY];
  	  if (_descriptors && C && !C[SPECIES$1]) _objectDp.f(C, SPECIES$1, {
  	    configurable: true,
  	    get: function () { return this; }
  	  });
  	};
  
  	var dP$2 = _objectDp.f;
  
  
  
  
  
  
  
  
  
  	var fastKey = _meta.fastKey;
  
  	var SIZE = _descriptors ? '_s' : 'size';
  
  	var getEntry = function (that, key) {
  	  // fast case
  	  var index = fastKey(key);
  	  var entry;
  	  if (index !== 'F') return that._i[index];
  	  // frozen object case
  	  for (entry = that._f; entry; entry = entry.n) {
  	    if (entry.k == key) return entry;
  	  }
  	};
  
  	var _collectionStrong = {
  	  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
  	    var C = wrapper(function (that, iterable) {
  	      _anInstance(that, C, NAME, '_i');
  	      that._t = NAME;         // collection type
  	      that._i = _objectCreate(null); // index
  	      that._f = undefined;    // first entry
  	      that._l = undefined;    // last entry
  	      that[SIZE] = 0;         // size
  	      if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that);
  	    });
  	    _redefineAll(C.prototype, {
  	      // 23.1.3.1 Map.prototype.clear()
  	      // 23.2.3.2 Set.prototype.clear()
  	      clear: function clear() {
  	        for (var that = _validateCollection(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) {
  	          entry.r = true;
  	          if (entry.p) entry.p = entry.p.n = undefined;
  	          delete data[entry.i];
  	        }
  	        that._f = that._l = undefined;
  	        that[SIZE] = 0;
  	      },
  	      // 23.1.3.3 Map.prototype.delete(key)
  	      // 23.2.3.4 Set.prototype.delete(value)
  	      'delete': function (key) {
  	        var that = _validateCollection(this, NAME);
  	        var entry = getEntry(that, key);
  	        if (entry) {
  	          var next = entry.n;
  	          var prev = entry.p;
  	          delete that._i[entry.i];
  	          entry.r = true;
  	          if (prev) prev.n = next;
  	          if (next) next.p = prev;
  	          if (that._f == entry) that._f = next;
  	          if (that._l == entry) that._l = prev;
  	          that[SIZE]--;
  	        } return !!entry;
  	      },
  	      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
  	      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
  	      forEach: function forEach(callbackfn /* , that = undefined */) {
  	        _validateCollection(this, NAME);
  	        var f = _ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
  	        var entry;
  	        while (entry = entry ? entry.n : this._f) {
  	          f(entry.v, entry.k, this);
  	          // revert to the last existing entry
  	          while (entry && entry.r) entry = entry.p;
  	        }
  	      },
  	      // 23.1.3.7 Map.prototype.has(key)
  	      // 23.2.3.7 Set.prototype.has(value)
  	      has: function has(key) {
  	        return !!getEntry(_validateCollection(this, NAME), key);
  	      }
  	    });
  	    if (_descriptors) dP$2(C.prototype, 'size', {
  	      get: function () {
  	        return _validateCollection(this, NAME)[SIZE];
  	      }
  	    });
  	    return C;
  	  },
  	  def: function (that, key, value) {
  	    var entry = getEntry(that, key);
  	    var prev, index;
  	    // change existing entry
  	    if (entry) {
  	      entry.v = value;
  	    // create new entry
  	    } else {
  	      that._l = entry = {
  	        i: index = fastKey(key, true), // <- index
  	        k: key,                        // <- key
  	        v: value,                      // <- value
  	        p: prev = that._l,             // <- previous entry
  	        n: undefined,                  // <- next entry
  	        r: false                       // <- removed
  	      };
  	      if (!that._f) that._f = entry;
  	      if (prev) prev.n = entry;
  	      that[SIZE]++;
  	      // add to index
  	      if (index !== 'F') that._i[index] = entry;
  	    } return that;
  	  },
  	  getEntry: getEntry,
  	  setStrong: function (C, NAME, IS_MAP) {
  	    // add .keys, .values, .entries, [@@iterator]
  	    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
  	    _iterDefine(C, NAME, function (iterated, kind) {
  	      this._t = _validateCollection(iterated, NAME); // target
  	      this._k = kind;                     // kind
  	      this._l = undefined;                // previous
  	    }, function () {
  	      var that = this;
  	      var kind = that._k;
  	      var entry = that._l;
  	      // revert to the last existing entry
  	      while (entry && entry.r) entry = entry.p;
  	      // get next entry
  	      if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
  	        // or finish the iteration
  	        that._t = undefined;
  	        return _iterStep(1);
  	      }
  	      // return step by kind
  	      if (kind == 'keys') return _iterStep(0, entry.k);
  	      if (kind == 'values') return _iterStep(0, entry.v);
  	      return _iterStep(0, [entry.k, entry.v]);
  	    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
  
  	    // add [@@species], 23.1.2.2, 23.2.2.2
  	    _setSpecies(NAME);
  	  }
  	};
  
  	var SET = 'Set';
  
  	// 23.2 Set Objects
  	var es6_set = _collection(SET, function (get) {
  	  return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  	}, {
  	  // 23.2.3.1 Set.prototype.add(value)
  	  add: function add(value) {
  	    return _collectionStrong.def(_validateCollection(this, SET), value = value === 0 ? 0 : value, value);
  	  }
  	}, _collectionStrong);
  
  	var MAP = 'Map';
  
  	// 23.1 Map Objects
  	var es6_map = _collection(MAP, function (get) {
  	  return function Map() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  	}, {
  	  // 23.1.3.6 Map.prototype.get(key)
  	  get: function get(key) {
  	    var entry = _collectionStrong.getEntry(_validateCollection(this, MAP), key);
  	    return entry && entry.v;
  	  },
  	  // 23.1.3.9 Map.prototype.set(key, value)
  	  set: function set(key, value) {
  	    return _collectionStrong.def(_validateCollection(this, MAP), key === 0 ? 0 : key, value);
  	  }
  	}, _collectionStrong, true);
  
  	// 7.3.20 SpeciesConstructor(O, defaultConstructor)
  
  
  	var SPECIES$2 = _wks('species');
  	var _speciesConstructor = function (O, D) {
  	  var C = _anObject(O).constructor;
  	  var S;
  	  return C === undefined || (S = _anObject(C)[SPECIES$2]) == undefined ? D : _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 = _global.process;
  	var setTask = _global.setImmediate;
  	var clearTask = _global.clearImmediate;
  	var MessageChannel = _global.MessageChannel;
  	var Dispatch = _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 (_cof(process) == 'process') {
  	    defer = function (id) {
  	      process.nextTick(_ctx(run, id, 1));
  	    };
  	  // Sphere (JS game engine) Dispatch API
  	  } else if (Dispatch && Dispatch.now) {
  	    defer = function (id) {
  	      Dispatch.now(_ctx(run, id, 1));
  	    };
  	  // Browsers with MessageChannel, includes WebWorkers
  	  } else if (MessageChannel) {
  	    channel = new MessageChannel();
  	    port = channel.port2;
  	    channel.port1.onmessage = listener;
  	    defer = _ctx(port.postMessage, port, 1);
  	  // Browsers with postMessage, skip WebWorkers
  	  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
  	  } else if (_global.addEventListener && typeof postMessage == 'function' && !_global.importScripts) {
  	    defer = function (id) {
  	      _global.postMessage(id + '', '*');
  	    };
  	    _global.addEventListener('message', listener, false);
  	  // IE8-
  	  } else if (ONREADYSTATECHANGE in _domCreate('script')) {
  	    defer = function (id) {
  	      _html.appendChild(_domCreate('script'))[ONREADYSTATECHANGE] = function () {
  	        _html.removeChild(this);
  	        run.call(id);
  	      };
  	    };
  	  // Rest old browsers
  	  } else {
  	    defer = function (id) {
  	      setTimeout(_ctx(run, id, 1), 0);
  	    };
  	  }
  	}
  	var _task = {
  	  set: setTask,
  	  clear: clearTask
  	};
  
  	var macrotask = _task.set;
  	var Observer = _global.MutationObserver || _global.WebKitMutationObserver;
  	var process$1 = _global.process;
  	var Promise$1 = _global.Promise;
  	var isNode = _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 && !(_global.navigator && _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) {
  	    var promise = Promise$1.resolve();
  	    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(_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 = _aFunction(resolve);
  	  this.reject = _aFunction(reject);
  	}
  
  	var f$7 = function (C) {
  	  return new PromiseCapability(C);
  	};
  
  	var _newPromiseCapability = {
  		f: f$7
  	};
  
  	var _perform = function (exec) {
  	  try {
  	    return { e: false, v: exec() };
  	  } catch (e) {
  	    return { e: true, v: e };
  	  }
  	};
  
  	var _promiseResolve = 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;
  	};
  
  	var task = _task.set;
  	var microtask = _microtask();
  
  
  
  	var PROMISE = 'Promise';
  	var TypeError$1 = _global.TypeError;
  	var process$2 = _global.process;
  	var $Promise = _global[PROMISE];
  	var isNode$1 = _classof(process$2) == 'process';
  	var empty = function () { /* empty */ };
  	var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
  	var newPromiseCapability = newGenericPromiseCapability = _newPromiseCapability.f;
  
  	var USE_NATIVE$1 = !!function () {
  	  try {
  	    // correct subclassing with @@species support
  	    var promise = $Promise.resolve(1);
  	    var FakePromise = (promise.constructor = {})[_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;
  	  } catch (e) { /* empty */ }
  	}();
  
  	// helpers
  	var isThenable = function (it) {
  	  var then;
  	  return _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(_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 = _global.onunhandledrejection) {
  	          handler({ promise: promise, reason: value });
  	        } else if ((console = _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(_global, function () {
  	    var handler;
  	    if (isNode$1) {
  	      process$2.emit('rejectionHandled', promise);
  	    } else if (handler = _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, _ctx($resolve, wrapper, 1), _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$1) {
  	  // 25.4.3.1 Promise(executor)
  	  $Promise = function Promise(executor) {
  	    _anInstance(this, $Promise, PROMISE, '_h');
  	    _aFunction(executor);
  	    Internal.call(this);
  	    try {
  	      executor(_ctx($resolve, this, 1), _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 = _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 = _ctx($resolve, promise, 1);
  	    this.reject = _ctx($reject, promise, 1);
  	  };
  	  _newPromiseCapability.f = newPromiseCapability = function (C) {
  	    return C === $Promise || C === Wrapper
  	      ? new OwnPromiseCapability(C)
  	      : newGenericPromiseCapability(C);
  	  };
  	}
  
  	_export(_export.G + _export.W + _export.F * !USE_NATIVE$1, { Promise: $Promise });
  	_setToStringTag($Promise, PROMISE);
  	_setSpecies(PROMISE);
  	Wrapper = _core[PROMISE];
  
  	// statics
  	_export(_export.S + _export.F * !USE_NATIVE$1, 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;
  	  }
  	});
  	_export(_export.S + _export.F * (_library || !USE_NATIVE$1), PROMISE, {
  	  // 25.4.4.6 Promise.resolve(x)
  	  resolve: function resolve(x) {
  	    return _promiseResolve(_library && this === Wrapper ? $Promise : this, x);
  	  }
  	});
  	_export(_export.S + _export.F * !(USE_NATIVE$1 && _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;
  	      _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 () {
  	      _forOf(iterable, false, function (promise) {
  	        C.resolve(promise).then(capability.resolve, reject);
  	      });
  	    });
  	    if (result.e) reject(result.v);
  	    return capability.promise;
  	  }
  	});
  
  	var typeDetect = createCommonjsModule(function (module, exports) {
  	  (function (global, factory) {
  	    module.exports = factory();
  	  })(commonjsGlobal, function () {
  	    /* !
  	     * type-detect
  	     * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
  	     * MIT Licensed
  	     */
  
  	    var promiseExists = typeof Promise === 'function';
  	    /* eslint-disable no-undef */
  
  	    var globalObject = (typeof self === "undefined" ? "undefined" : _typeof(self)) === 'object' ? self : commonjsGlobal; // eslint-disable-line id-blacklist
  
  	    var symbolExists = typeof Symbol !== 'undefined';
  	    var mapExists = typeof Map !== 'undefined';
  	    var setExists = typeof Set !== 'undefined';
  	    var weakMapExists = typeof WeakMap !== 'undefined';
  	    var weakSetExists = typeof WeakSet !== 'undefined';
  	    var dataViewExists = typeof DataView !== 'undefined';
  	    var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== 'undefined';
  	    var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== 'undefined';
  	    var setEntriesExists = setExists && typeof Set.prototype.entries === 'function';
  	    var mapEntriesExists = mapExists && typeof Map.prototype.entries === 'function';
  	    var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf(new Set().entries());
  	    var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf(new Map().entries());
  	    var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === 'function';
  	    var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
  	    var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === 'function';
  	    var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(''[Symbol.iterator]());
  	    var toStringLeftSliceLength = 8;
  	    var toStringRightSliceLength = -1;
  	    /**
  	     * ### typeOf (obj)
  	     *
  	     * Uses `Object.prototype.toString` to determine the type of an object,
  	     * normalising behaviour across engine versions & well optimised.
  	     *
  	     * @param {Mixed} object
  	     * @return {String} object type
  	     * @api public
  	     */
  
  	    function typeDetect(obj) {
  	      /* ! Speed optimisation
  	       * Pre:
  	       *   string literal     x 3,039,035 ops/sec ±1.62% (78 runs sampled)
  	       *   boolean literal    x 1,424,138 ops/sec ±4.54% (75 runs sampled)
  	       *   number literal     x 1,653,153 ops/sec ±1.91% (82 runs sampled)
  	       *   undefined          x 9,978,660 ops/sec ±1.92% (75 runs sampled)
  	       *   function           x 2,556,769 ops/sec ±1.73% (77 runs sampled)
  	       * Post:
  	       *   string literal     x 38,564,796 ops/sec ±1.15% (79 runs sampled)
  	       *   boolean literal    x 31,148,940 ops/sec ±1.10% (79 runs sampled)
  	       *   number literal     x 32,679,330 ops/sec ±1.90% (78 runs sampled)
  	       *   undefined          x 32,363,368 ops/sec ±1.07% (82 runs sampled)
  	       *   function           x 31,296,870 ops/sec ±0.96% (83 runs sampled)
  	       */
  	      var typeofObj = _typeof(obj);
  
  	      if (typeofObj !== 'object') {
  	        return typeofObj;
  	      }
  	      /* ! Speed optimisation
  	       * Pre:
  	       *   null               x 28,645,765 ops/sec ±1.17% (82 runs sampled)
  	       * Post:
  	       *   null               x 36,428,962 ops/sec ±1.37% (84 runs sampled)
  	       */
  
  
  	      if (obj === null) {
  	        return 'null';
  	      }
  	      /* ! Spec Conformance
  	       * Test: `Object.prototype.toString.call(window)``
  	       *  - Node === "[object global]"
  	       *  - Chrome === "[object global]"
  	       *  - Firefox === "[object Window]"
  	       *  - PhantomJS === "[object Window]"
  	       *  - Safari === "[object Window]"
  	       *  - IE 11 === "[object Window]"
  	       *  - IE Edge === "[object Window]"
  	       * Test: `Object.prototype.toString.call(this)``
  	       *  - Chrome Worker === "[object global]"
  	       *  - Firefox Worker === "[object DedicatedWorkerGlobalScope]"
  	       *  - Safari Worker === "[object DedicatedWorkerGlobalScope]"
  	       *  - IE 11 Worker === "[object WorkerGlobalScope]"
  	       *  - IE Edge Worker === "[object WorkerGlobalScope]"
  	       */
  
  
  	      if (obj === globalObject) {
  	        return 'global';
  	      }
  	      /* ! Speed optimisation
  	       * Pre:
  	       *   array literal      x 2,888,352 ops/sec ±0.67% (82 runs sampled)
  	       * Post:
  	       *   array literal      x 22,479,650 ops/sec ±0.96% (81 runs sampled)
  	       */
  
  
  	      if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) {
  	        return 'Array';
  	      } // Not caching existence of `window` and related properties due to potential
  	      // for `window` to be unset before tests in quasi-browser environments.
  
  
  	      if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' && window !== null) {
  	        /* ! Spec Conformance
  	         * (https://html.spec.whatwg.org/multipage/browsers.html#location)
  	         * WhatWG HTML$7.7.3 - The `Location` interface
  	         * Test: `Object.prototype.toString.call(window.location)``
  	         *  - IE <=11 === "[object Object]"
  	         *  - IE Edge <=13 === "[object Object]"
  	         */
  	        if (_typeof(window.location) === 'object' && obj === window.location) {
  	          return 'Location';
  	        }
  	        /* ! Spec Conformance
  	         * (https://html.spec.whatwg.org/#document)
  	         * WhatWG HTML$3.1.1 - The `Document` object
  	         * Note: Most browsers currently adher to the W3C DOM Level 2 spec
  	         *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-26809268)
  	         *       which suggests that browsers should use HTMLTableCellElement for
  	         *       both TD and TH elements. WhatWG separates these.
  	         *       WhatWG HTML states:
  	         *         > For historical reasons, Window objects must also have a
  	         *         > writable, configurable, non-enumerable property named
  	         *         > HTMLDocument whose value is the Document interface object.
  	         * Test: `Object.prototype.toString.call(document)``
  	         *  - Chrome === "[object HTMLDocument]"
  	         *  - Firefox === "[object HTMLDocument]"
  	         *  - Safari === "[object HTMLDocument]"
  	         *  - IE <=10 === "[object Document]"
  	         *  - IE 11 === "[object HTMLDocument]"
  	         *  - IE Edge <=13 === "[object HTMLDocument]"
  	         */
  
  
  	        if (_typeof(window.document) === 'object' && obj === window.document) {
  	          return 'Document';
  	        }
  
  	        if (_typeof(window.navigator) === 'object') {
  	          /* ! Spec Conformance
  	           * (https://html.spec.whatwg.org/multipage/webappapis.html#mimetypearray)
  	           * WhatWG HTML$8.6.1.5 - Plugins - Interface MimeTypeArray
  	           * Test: `Object.prototype.toString.call(navigator.mimeTypes)``
  	           *  - IE <=10 === "[object MSMimeTypesCollection]"
  	           */
  	          if (_typeof(window.navigator.mimeTypes) === 'object' && obj === window.navigator.mimeTypes) {
  	            return 'MimeTypeArray';
  	          }
  	          /* ! Spec Conformance
  	           * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray)
  	           * WhatWG HTML$8.6.1.5 - Plugins - Interface PluginArray
  	           * Test: `Object.prototype.toString.call(navigator.plugins)``
  	           *  - IE <=10 === "[object MSPluginsCollection]"
  	           */
  
  
  	          if (_typeof(window.navigator.plugins) === 'object' && obj === window.navigator.plugins) {
  	            return 'PluginArray';
  	          }
  	        }
  
  	        if ((typeof window.HTMLElement === 'function' || _typeof(window.HTMLElement) === 'object') && obj instanceof window.HTMLElement) {
  	          /* ! Spec Conformance
  	          * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray)
  	          * WhatWG HTML$4.4.4 - The `blockquote` element - Interface `HTMLQuoteElement`
  	          * Test: `Object.prototype.toString.call(document.createElement('blockquote'))``
  	          *  - IE <=10 === "[object HTMLBlockElement]"
  	          */
  	          if (obj.tagName === 'BLOCKQUOTE') {
  	            return 'HTMLQuoteElement';
  	          }
  	          /* ! Spec Conformance
  	           * (https://html.spec.whatwg.org/#htmltabledatacellelement)
  	           * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableDataCellElement`
  	           * Note: Most browsers currently adher to the W3C DOM Level 2 spec
  	           *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075)
  	           *       which suggests that browsers should use HTMLTableCellElement for
  	           *       both TD and TH elements. WhatWG separates these.
  	           * Test: Object.prototype.toString.call(document.createElement('td'))
  	           *  - Chrome === "[object HTMLTableCellElement]"
  	           *  - Firefox === "[object HTMLTableCellElement]"
  	           *  - Safari === "[object HTMLTableCellElement]"
  	           */
  
  
  	          if (obj.tagName === 'TD') {
  	            return 'HTMLTableDataCellElement';
  	          }
  	          /* ! Spec Conformance
  	           * (https://html.spec.whatwg.org/#htmltableheadercellelement)
  	           * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableHeaderCellElement`
  	           * Note: Most browsers currently adher to the W3C DOM Level 2 spec
  	           *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075)
  	           *       which suggests that browsers should use HTMLTableCellElement for
  	           *       both TD and TH elements. WhatWG separates these.
  	           * Test: Object.prototype.toString.call(document.createElement('th'))
  	           *  - Chrome === "[object HTMLTableCellElement]"
  	           *  - Firefox === "[object HTMLTableCellElement]"
  	           *  - Safari === "[object HTMLTableCellElement]"
  	           */
  
  
  	          if (obj.tagName === 'TH') {
  	            return 'HTMLTableHeaderCellElement';
  	          }
  	        }
  	      }
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   Float64Array       x 625,644 ops/sec ±1.58% (80 runs sampled)
  	      *   Float32Array       x 1,279,852 ops/sec ±2.91% (77 runs sampled)
  	      *   Uint32Array        x 1,178,185 ops/sec ±1.95% (83 runs sampled)
  	      *   Uint16Array        x 1,008,380 ops/sec ±2.25% (80 runs sampled)
  	      *   Uint8Array         x 1,128,040 ops/sec ±2.11% (81 runs sampled)
  	      *   Int32Array         x 1,170,119 ops/sec ±2.88% (80 runs sampled)
  	      *   Int16Array         x 1,176,348 ops/sec ±5.79% (86 runs sampled)
  	      *   Int8Array          x 1,058,707 ops/sec ±4.94% (77 runs sampled)
  	      *   Uint8ClampedArray  x 1,110,633 ops/sec ±4.20% (80 runs sampled)
  	      * Post:
  	      *   Float64Array       x 7,105,671 ops/sec ±13.47% (64 runs sampled)
  	      *   Float32Array       x 5,887,912 ops/sec ±1.46% (82 runs sampled)
  	      *   Uint32Array        x 6,491,661 ops/sec ±1.76% (79 runs sampled)
  	      *   Uint16Array        x 6,559,795 ops/sec ±1.67% (82 runs sampled)
  	      *   Uint8Array         x 6,463,966 ops/sec ±1.43% (85 runs sampled)
  	      *   Int32Array         x 5,641,841 ops/sec ±3.49% (81 runs sampled)
  	      *   Int16Array         x 6,583,511 ops/sec ±1.98% (80 runs sampled)
  	      *   Int8Array          x 6,606,078 ops/sec ±1.74% (81 runs sampled)
  	      *   Uint8ClampedArray  x 6,602,224 ops/sec ±1.77% (83 runs sampled)
  	      */
  
  
  	      var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
  
  	      if (typeof stringTag === 'string') {
  	        return stringTag;
  	      }
  
  	      var objPrototype = Object.getPrototypeOf(obj);
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   regex literal      x 1,772,385 ops/sec ±1.85% (77 runs sampled)
  	      *   regex constructor  x 2,143,634 ops/sec ±2.46% (78 runs sampled)
  	      * Post:
  	      *   regex literal      x 3,928,009 ops/sec ±0.65% (78 runs sampled)
  	      *   regex constructor  x 3,931,108 ops/sec ±0.58% (84 runs sampled)
  	      */
  
  	      if (objPrototype === RegExp.prototype) {
  	        return 'RegExp';
  	      }
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   date               x 2,130,074 ops/sec ±4.42% (68 runs sampled)
  	      * Post:
  	      *   date               x 3,953,779 ops/sec ±1.35% (77 runs sampled)
  	      */
  
  
  	      if (objPrototype === Date.prototype) {
  	        return 'Date';
  	      }
  	      /* ! Spec Conformance
  	       * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-promise.prototype-@@tostringtag)
  	       * ES6$25.4.5.4 - Promise.prototype[@@toStringTag] should be "Promise":
  	       * Test: `Object.prototype.toString.call(Promise.resolve())``
  	       *  - Chrome <=47 === "[object Object]"
  	       *  - Edge <=20 === "[object Object]"
  	       *  - Firefox 29-Latest === "[object Promise]"
  	       *  - Safari 7.1-Latest === "[object Promise]"
  	       */
  
  
  	      if (promiseExists && objPrototype === Promise.prototype) {
  	        return 'Promise';
  	      }
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   set                x 2,222,186 ops/sec ±1.31% (82 runs sampled)
  	      * Post:
  	      *   set                x 4,545,879 ops/sec ±1.13% (83 runs sampled)
  	      */
  
  
  	      if (setExists && objPrototype === Set.prototype) {
  	        return 'Set';
  	      }
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   map                x 2,396,842 ops/sec ±1.59% (81 runs sampled)
  	      * Post:
  	      *   map                x 4,183,945 ops/sec ±6.59% (82 runs sampled)
  	      */
  
  
  	      if (mapExists && objPrototype === Map.prototype) {
  	        return 'Map';
  	      }
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   weakset            x 1,323,220 ops/sec ±2.17% (76 runs sampled)
  	      * Post:
  	      *   weakset            x 4,237,510 ops/sec ±2.01% (77 runs sampled)
  	      */
  
  
  	      if (weakSetExists && objPrototype === WeakSet.prototype) {
  	        return 'WeakSet';
  	      }
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   weakmap            x 1,500,260 ops/sec ±2.02% (78 runs sampled)
  	      * Post:
  	      *   weakmap            x 3,881,384 ops/sec ±1.45% (82 runs sampled)
  	      */
  
  
  	      if (weakMapExists && objPrototype === WeakMap.prototype) {
  	        return 'WeakMap';
  	      }
  	      /* ! Spec Conformance
  	       * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-dataview.prototype-@@tostringtag)
  	       * ES6$24.2.4.21 - DataView.prototype[@@toStringTag] should be "DataView":
  	       * Test: `Object.prototype.toString.call(new DataView(new ArrayBuffer(1)))``
  	       *  - Edge <=13 === "[object Object]"
  	       */
  
  
  	      if (dataViewExists && objPrototype === DataView.prototype) {
  	        return 'DataView';
  	      }
  	      /* ! Spec Conformance
  	       * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%mapiteratorprototype%-@@tostringtag)
  	       * ES6$23.1.5.2.2 - %MapIteratorPrototype%[@@toStringTag] should be "Map Iterator":
  	       * Test: `Object.prototype.toString.call(new Map().entries())``
  	       *  - Edge <=13 === "[object Object]"
  	       */
  
  
  	      if (mapExists && objPrototype === mapIteratorPrototype) {
  	        return 'Map Iterator';
  	      }
  	      /* ! Spec Conformance
  	       * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%setiteratorprototype%-@@tostringtag)
  	       * ES6$23.2.5.2.2 - %SetIteratorPrototype%[@@toStringTag] should be "Set Iterator":
  	       * Test: `Object.prototype.toString.call(new Set().entries())``
  	       *  - Edge <=13 === "[object Object]"
  	       */
  
  
  	      if (setExists && objPrototype === setIteratorPrototype) {
  	        return 'Set Iterator';
  	      }
  	      /* ! Spec Conformance
  	       * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%arrayiteratorprototype%-@@tostringtag)
  	       * ES6$22.1.5.2.2 - %ArrayIteratorPrototype%[@@toStringTag] should be "Array Iterator":
  	       * Test: `Object.prototype.toString.call([][Symbol.iterator]())``
  	       *  - Edge <=13 === "[object Object]"
  	       */
  
  
  	      if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {
  	        return 'Array Iterator';
  	      }
  	      /* ! Spec Conformance
  	       * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%stringiteratorprototype%-@@tostringtag)
  	       * ES6$21.1.5.2.2 - %StringIteratorPrototype%[@@toStringTag] should be "String Iterator":
  	       * Test: `Object.prototype.toString.call(''[Symbol.iterator]())``
  	       *  - Edge <=13 === "[object Object]"
  	       */
  
  
  	      if (stringIteratorExists && objPrototype === stringIteratorPrototype) {
  	        return 'String Iterator';
  	      }
  	      /* ! Speed optimisation
  	      * Pre:
  	      *   object from null   x 2,424,320 ops/sec ±1.67% (76 runs sampled)
  	      * Post:
  	      *   object from null   x 5,838,000 ops/sec ±0.99% (84 runs sampled)
  	      */
  
  
  	      if (objPrototype === null) {
  	        return 'Object';
  	      }
  
  	      return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
  	    }
  
  	    return typeDetect;
  	  });
  	});
  
  	var isBufferExists = typeof Buffer !== 'undefined';
  	var isBufferFromExists = isBufferExists && typeof Buffer.from !== 'undefined';
  	var isBuffer = isBufferExists ?
  	/**
  	 * is value is Buffer?
  	 *
  	 * @param {*} value
  	 * @return {boolean}
  	 */
  	function isBuffer(value) {
  	  return Buffer.isBuffer(value);
  	} :
  	/**
  	 * return false
  	 *
  	 * NOTE: for Buffer unsupported
  	 *
  	 * @return {boolean}
  	 */
  	function isBuffer() {
  	  return false;
  	};
  	var copy = isBufferFromExists ?
  	/**
  	 * copy Buffer
  	 *
  	 * @param {Buffer} value
  	 * @return {Buffer}
  	 */
  	function copy(value) {
  	  return Buffer.from(value);
  	} : isBufferExists ?
  	/**
  	 * copy Buffer
  	 *
  	 * NOTE: for old node.js
  	 *
  	 * @param {Buffer} value
  	 * @return {Buffer}
  	 */
  	function copy(value) {
  	  return new Buffer(value);
  	} :
  	/**
  	 * shallow copy
  	 *
  	 * NOTE: for Buffer unsupported
  	 *
  	 * @param {*}
  	 * @return {*}
  	 */
  	function copy(value) {
  	  return value;
  	};
  
  	/**
  	 * detect type of value
  	 *
  	 * @param {*} value
  	 * @return {string}
  	 */
  
  	function detectType(value) {
  	  // NOTE: isBuffer must execute before type-detect,
  	  // because type-detect returns 'Uint8Array'.
  	  if (isBuffer(value)) {
  	    return 'Buffer';
  	  }
  
  	  return typeDetect(value);
  	}
  
  	/**
  	 * collection types
  	 */
  
  	var collectionTypeSet = new Set(['Arguments', 'Array', 'Map', 'Object', 'Set']);
  	/**
  	 * get value from collection
  	 *
  	 * @param {Array|Object|Map|Set} collection
  	 * @param {string|number|symbol} key
  	 * @param {string} [type=null]
  	 * @return {*}
  	 */
  
  	function get(collection, key) {
  	  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  	  var valueType = type || detectType(collection);
  
  	  switch (valueType) {
  	    case 'Arguments':
  	    case 'Array':
  	    case 'Object':
  	      return collection[key];
  
  	    case 'Map':
  	      return collection.get(key);
  
  	    case 'Set':
  	      // NOTE: Set.prototype.keys is alias of Set.prototype.values
  	      // it means key is equals value
  	      return key;
  
  	    default:
  	  }
  	}
  	/**
  	 * check to type string is collection
  	 *
  	 * @param {string} type
  	 */
  
  	function isCollection(type) {
  	  return collectionTypeSet.has(type);
  	}
  	/**
  	 * set value to collection
  	 *
  	 * @param {Array|Object|Map|Set} collection
  	 * @param {string|number|symbol} key
  	 * @param {*} value
  	 * @param {string} [type=null]
  	 * @return {Array|Object|Map|Set}
  	 */
  
  	function set(collection, key, value) {
  	  var type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  	  var valueType = type || detectType(collection);
  
  	  switch (valueType) {
  	    case 'Arguments':
  	    case 'Array':
  	    case 'Object':
  	      collection[key] = value;
  	      break;
  
  	    case 'Map':
  	      collection.set(key, value);
  	      break;
  
  	    case 'Set':
  	      collection.add(value);
  	      break;
  
  	    default:
  	  }
  
  	  return collection;
  	}
  
  	// 21.2.5.3 get RegExp.prototype.flags
  
  	var _flags = function () {
  	  var that = _anObject(this);
  	  var result = '';
  	  if (that.global) result += 'g';
  	  if (that.ignoreCase) result += 'i';
  	  if (that.multiline) result += 'm';
  	  if (that.unicode) result += 'u';
  	  if (that.sticky) result += 'y';
  	  return result;
  	};
  
  	// 21.2.5.3 get RegExp.prototype.flags()
  	if (_descriptors && /./g.flags != 'g') _objectDp.f(RegExp.prototype, 'flags', {
  	  configurable: true,
  	  get: _flags
  	});
  
  	var globalObject = Function('return this')();
  	/**
  	 * copy ArrayBuffer
  	 *
  	 * @param {ArrayBuffer} value
  	 * @return {ArrayBuffer}
  	 */
  
  	function copyArrayBuffer(value) {
  	  return value.slice(0);
  	}
  	/**
  	 * copy Boolean
  	 *
  	 * @param {Boolean} value
  	 * @return {Boolean}
  	 */
  
  
  	function copyBoolean(value) {
  	  return new Boolean(value.valueOf());
  	}
  	/**
  	 * copy DataView
  	 *
  	 * @param {DataView} value
  	 * @return {DataView}
  	 */
  
  
  	function copyDataView(value) {
  	  // TODO: copy ArrayBuffer?
  	  return new DataView(value.buffer);
  	}
  	/**
  	 * copy Buffer
  	 *
  	 * @param {Buffer} value
  	 * @return {Buffer}
  	 */
  
  
  	function copyBuffer(value) {
  	  return copy(value);
  	}
  	/**
  	 * copy Date
  	 *
  	 * @param {Date} value
  	 * @return {Date}
  	 */
  
  
  	function copyDate(value) {
  	  return new Date(value.getTime());
  	}
  	/**
  	 * copy Number
  	 *
  	 * @param {Number} value
  	 * @return {Number}
  	 */
  
  
  	function copyNumber(value) {
  	  return new Number(value);
  	}
  	/**
  	 * copy RegExp
  	 *
  	 * @param {RegExp} value
  	 * @return {RegExp}
  	 */
  
  
  	function copyRegExp(value) {
  	  return new RegExp(value.source || '(?:)', value.flags);
  	}
  	/**
  	 * copy String
  	 *
  	 * @param {String} value
  	 * @return {String}
  	 */
  
  
  	function copyString(value) {
  	  return new String(value);
  	}
  	/**
  	 * copy TypedArray
  	 *
  	 * @param {*} value
  	 * @return {*}
  	 */
  
  
  	function copyTypedArray(value, type) {
  	  return globalObject[type].from(value);
  	}
  	/**
  	 * shallow copy
  	 *
  	 * @param {*} value
  	 * @return {*}
  	 */
  
  
  	function shallowCopy(value) {
  	  return value;
  	}
  	/**
  	 * get empty Array
  	 *
  	 * @return {Array}
  	 */
  
  
  	function getEmptyArray() {
  	  return [];
  	}
  	/**
  	 * get empty Map
  	 *
  	 * @return {Map}
  	 */
  
  
  	function getEmptyMap() {
  	  return new Map();
  	}
  	/**
  	 * get empty Object
  	 *
  	 * @return {Object}
  	 */
  
  
  	function getEmptyObject() {
  	  return {};
  	}
  	/**
  	 * get empty Set
  	 *
  	 * @return {Set}
  	 */
  
  
  	function getEmptySet() {
  	  return new Set();
  	}
  
  	var copyMap = new Map([// deep copy
  	['ArrayBuffer', copyArrayBuffer], ['Boolean', copyBoolean], ['Buffer', copyBuffer], ['DataView', copyDataView], ['Date', copyDate], ['Number', copyNumber], ['RegExp', copyRegExp], ['String', copyString], // typed arrays
  	// TODO: pass bound function
  	['Float32Array', copyTypedArray], ['Float64Array', copyTypedArray], ['Int16Array', copyTypedArray], ['Int32Array', copyTypedArray], ['Int8Array', copyTypedArray], ['Uint16Array', copyTypedArray], ['Uint32Array', copyTypedArray], ['Uint8Array', copyTypedArray], ['Uint8ClampedArray', copyTypedArray], // shallow copy
  	['Array Iterator', shallowCopy], ['Map Iterator', shallowCopy], ['Promise', shallowCopy], ['Set Iterator', shallowCopy], ['String Iterator', shallowCopy], ['function', shallowCopy], ['global', shallowCopy], // NOTE: WeakMap and WeakSet cannot get entries
  	['WeakMap', shallowCopy], ['WeakSet', shallowCopy], // primitives
  	['boolean', shallowCopy], ['null', shallowCopy], ['number', shallowCopy], ['string', shallowCopy], ['symbol', shallowCopy], ['undefined', shallowCopy], // collections
  	// NOTE: return empty value, because recursively copy later.
  	['Arguments', getEmptyArray], ['Array', getEmptyArray], ['Map', getEmptyMap], ['Object', getEmptyObject], ['Set', getEmptySet] // NOTE: type-detect returns following types
  	// 'Location'
  	// 'Document'
  	// 'MimeTypeArray'
  	// 'PluginArray'
  	// 'HTMLQuoteElement'
  	// 'HTMLTableDataCellElement'
  	// 'HTMLTableHeaderCellElement'
  	// TODO: is type-detect never return 'object'?
  	// 'object'
  	]);
  
  	/**
  	 * no operation
  	 */
  
  	function noop() {}
  	/**
  	 * copy value
  	 *
  	 * @param {*} value
  	 * @param {string} [type=null]
  	 * @param {Function} [customizer=noop]
  	 * @return {*}
  	 */
  
  
  	function copy$1(value) {
  	  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  	  var customizer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : noop;
  
  	  if (arguments.length === 2 && typeof type === 'function') {
  	    customizer = type;
  	    type = null;
  	  }
  
  	  var valueType = type || detectType(value);
  	  var copyFunction = copyMap.get(valueType);
  
  	  if (valueType === 'Object') {
  	    var result = customizer(value, valueType);
  
  	    if (result !== undefined) {
  	      return result;
  	    }
  	  } // NOTE: TypedArray needs pass type to argument
  
  
  	  return copyFunction ? copyFunction(value, valueType) : value;
  	}
  
  	/**
  	 * deepcopy function
  	 *
  	 * @param {*} value
  	 * @param {Object|Function} [options]
  	 * @return {*}
  	 */
  
  	function deepcopy(value) {
  	  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  	  if (typeof options === 'function') {
  	    options = {
  	      customizer: options
  	    };
  	  }
  
  	  var _options = options,
  	      customizer = _options.customizer;
  	  var valueType = detectType(value);
  
  	  if (!isCollection(valueType)) {
  	    return recursiveCopy(value, null, null, null, customizer);
  	  }
  
  	  var copiedValue = copy$1(value, valueType, customizer);
  	  var references = new WeakMap([[value, copiedValue]]);
  	  var visited = new WeakSet([value]);
  	  return recursiveCopy(value, copiedValue, references, visited, customizer);
  	}
  	/**
  	 * recursively copy
  	 *
  	 * @param {*} value target value
  	 * @param {*} clone clone of value
  	 * @param {WeakMap} references visited references of clone
  	 * @param {WeakSet} visited visited references of value
  	 * @param {Function} customizer user customize function
  	 * @return {*}
  	 */
  
  	function recursiveCopy(value, clone, references, visited, customizer) {
  	  var _keys;
  
  	  var type = detectType(value);
  	  var copiedValue = copy$1(value, type); // return if not a collection value
  
  	  if (!isCollection(type)) {
  	    return copiedValue;
  	  }
  
  	  var keys;
  
  	  switch (type) {
  	    case 'Arguments':
  	    case 'Array':
  	      keys = Object.keys(value);
  	      break;
  
  	    case 'Object':
  	      keys = Object.keys(value);
  
  	      (_keys = keys).push.apply(_keys, _toConsumableArray(Object.getOwnPropertySymbols(value)));
  
  	      break;
  
  	    case 'Map':
  	    case 'Set':
  	      keys = value.keys();
  	      break;
  
  	    default:
  	  } // walk within collection with iterator
  
  
  	  var _iteratorNormalCompletion = true;
  	  var _didIteratorError = false;
  	  var _iteratorError = undefined;
  
  	  try {
  	    for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
  	      var _collectionKey = _step.value;
  	      var collectionValue = get(value, _collectionKey, type);
  
  	      if (visited.has(collectionValue)) {
  	        // for [Circular]
  	        set(clone, _collectionKey, references.get(collectionValue), type);
  	      } else {
  	        var collectionValueType = detectType(collectionValue);
  	        var copiedCollectionValue = copy$1(collectionValue, collectionValueType); // save reference if value is collection
  
  	        if (isCollection(collectionValueType)) {
  	          references.set(collectionValue, copiedCollectionValue);
  	          visited.add(collectionValue);
  	        }
  
  	        set(clone, _collectionKey, recursiveCopy(collectionValue, copiedCollectionValue, references, visited, customizer), type);
  	      }
  	    } // TODO: isSealed/isFrozen/isExtensible
  
  	  } catch (err) {
  	    _didIteratorError = true;
  	    _iteratorError = err;
  	  } finally {
  	    try {
  	      if (!_iteratorNormalCompletion && _iterator.return != null) {
  	        _iterator.return();
  	      }
  	    } finally {
  	      if (_didIteratorError) {
  	        throw _iteratorError;
  	      }
  	    }
  	  }
  
  	  return clone;
  	}
  
  	return deepcopy;
  
  })));
  //# sourceMappingURL=deepcopy.legacy.js.map
  