@aleen42/idea/dist/idea.all.js

The IDEA cypher implementation in JavaScript

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else {
		var a = factory();
		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
	}
})(typeof window !== 'undefined' ? window : this, function() {
return /******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 5241:
/***/ (function(module) {

/*
 * Copyright (c) 1999-2003 AppGate Network Security AB. All Rights Reserved.
 *
 * This file contains Original Code and/or Modifications of Original Code as
 * defined in and that are subject to the MindTerm Public Source License,
 * Version 2.0, (the 'License'). You may not use this file except in compliance
 * with the License.
 *
 * You should have received a copy of the MindTerm Public Source License
 * along with this software; see the file LICENSE.  If not, write to
 * AppGate Network Security AB, Stora Badhusgatan 18-20, 41121 Goteborg, SWEDEN
 *
 *****************************************************************************/

/*
 * Author's comment: The contents of this file is heavily based upon Bruce
 * Schneier's c-code found in his book: Bruce Schneier: Applied Cryptography 2nd
 * ed., John Wiley & Sons, 1996
 *
 * The IDEA mathematical formula may be covered by one or more of the following
 * patents: PCT/CH91/00117, EP 0 482 154 B1, US Pat. 5,214,703.
 * Hence it might be subject to licensing for commercial use.
 */
var DEFAULT_XOR_KEY = 197; // default xor key using by ENC3

var BLOCK_SIZE = 8; // bytes in a data-block

/**
 * @param {Int8Array} key
 * @param {number}    xorKey
 * @returns {exports}
 */

module.exports = function IDEA(key, xorKey) {
  if (xorKey === void 0) {
    xorKey = DEFAULT_XOR_KEY;
  }

  this.encryptor = new Engine();
  this.decryptor = new Engine();

  function Engine() {
    var _this = this;

    this.keySchedule = [];

    this.getBlockSize = function () {
      return BLOCK_SIZE;
    };

    this.processBlock = function (src, inOff, out, outOff) {
      ideaCipher(src, inOff, out, outOff, _this.keySchedule);
      return BLOCK_SIZE;
    };
  }
  /**
   * @param {Int8Array} key
   * @param {number} xorKey
   */


  this.setKey = function (key, xorKey) {
    ideaExpandKey(key, this.encryptor.keySchedule);
    ideaInvertKey(this.encryptor.keySchedule, this.decryptor.keySchedule);
    xorKey && (this.xorKey = xorKey);
  };
  /**
   * the method to encrypt
   * @param {Int8Array | Uint8Array} src
   * @returns {Int8Array}
   */


  this.encrypt = function (src) {
    var len = src.length,
        out = new Int8Array(len),
        srcOff = 0,
        outOff = 0;

    if (this.xorKey === -1) {
      Padding.noPaddingFinal(this.encryptor, src, srcOff, out, outOff, len);
    } else {
      Padding.xorPaddingFinal(this.encryptor, this.xorKey, src, srcOff, out, outOff, len);
    }

    return out;
  };
  /**
   * the method to decrypt
   * @param {Int8Array | Uint8Array} src
   * @returns {Int8Array}
   */


  this.decrypt = function (src) {
    var len = src.length,
        out = new Int8Array(len),
        srcOff = 0,
        outOff = 0;

    if (this.xorKey === -1) {
      Padding.noPaddingFinal(this.decryptor, src, srcOff, out, outOff, len);
    } else {
      Padding.xorPaddingFinal(this.decryptor, this.xorKey, src, srcOff, out, outOff, len);
    }

    return out;
  };
  /**
   * @param {Int8Array} key
   * @param {int[]}     keySchedule
   */


  function ideaExpandKey(key, keySchedule) {
    var i,
        ki = 0,
        j;

    for (i = 0; i < 8; i++) {
      keySchedule[i] = (key[2 * i] & 0xff) << 8 | key[2 * i + 1] & 0xff;
    }

    for (i = 8, j = 0; i < 52; i++) {
      j++;
      keySchedule[ki + j + 7] = (keySchedule[ki + (j & 7)] << 9 | keySchedule[ki + (j + 1 & 7)] >>> 7) & 0xffff;
      ki += j & 8;
      j &= 7;
    }
  }
  /**
   * @param {int[]} key
   * @param {int[]} keySchedule
   */


  function ideaInvertKey(key, keySchedule) {
    var i, j, k, t1, t2, t3;
    j = 0;
    k = 51;
    t1 = mulInv(key[j++]);
    t2 = -key[j++] & 0xffff;
    t3 = -key[j++] & 0xffff;
    keySchedule[k--] = mulInv(key[j++]);
    keySchedule[k--] = t3;
    keySchedule[k--] = t2;
    keySchedule[k--] = t1;

    for (i = 1; i < 8; i++) {
      t1 = key[j++];
      keySchedule[k--] = key[j++];
      keySchedule[k--] = t1;
      t1 = mulInv(key[j++]);
      t2 = -key[j++] & 0xffff;
      t3 = -key[j++] & 0xffff;
      keySchedule[k--] = mulInv(key[j++]);
      keySchedule[k--] = t2;
      keySchedule[k--] = t3;
      keySchedule[k--] = t1;
    }

    t1 = key[j++];
    keySchedule[k--] = key[j++];
    keySchedule[k--] = t1;
    t1 = mulInv(key[j++]);
    t2 = -key[j++] & 0xffff;
    t3 = -key[j++] & 0xffff; // noinspection UnusedAssignment

    keySchedule[k--] = mulInv(key[j++]);
    keySchedule[k--] = t3;
    keySchedule[k--] = t2; // noinspection UnusedAssignment

    keySchedule[k--] = t1;
  }

  function ideaCipher(src, srcOffset, out, outOffset, keySchedule) {
    var t1 = 0,
        t2,
        x1,
        x2,
        x3,
        x4,
        ki = 0;
    var l = getIntMSBO(src, srcOffset);
    var r = getIntMSBO(src, srcOffset + 4);
    x1 = l >>> 16;
    x2 = l & 0xffff;
    x3 = r >>> 16;
    x4 = r & 0xffff;

    for (var round = 0; round < 8; round++) {
      x1 = mul(x1 & 0xffff, keySchedule[ki++]);
      x2 = x2 + keySchedule[ki++];
      x3 = x3 + keySchedule[ki++];
      x4 = mul(x4 & 0xffff, keySchedule[ki++]);
      t1 = x1 ^ x3;
      t2 = x2 ^ x4;
      t1 = mul(t1 & 0xffff, keySchedule[ki++]);
      t2 = t1 + t2;
      t2 = mul(t2 & 0xffff, keySchedule[ki++]);
      t1 = t1 + t2;
      x1 = x1 ^ t2;
      x4 = x4 ^ t1;
      t1 = t1 ^ x2;
      x2 = t2 ^ x3;
      x3 = t1;
    }

    t2 = x2;
    x1 = mul(x1 & 0xffff, keySchedule[ki++]);
    x2 = t1 + keySchedule[ki++];
    x3 = t2 + keySchedule[ki++] & 0xffff;
    x4 = mul(x4 & 0xffff, keySchedule[ki]);
    putIntMSBO(x1 << 16 | x2 & 0xffff, out, outOffset);
    putIntMSBO(x3 << 16 | x4 & 0xffff, out, outOffset + 4);
  }

  function mul(a, b) {
    var ab = a * b;

    if (ab !== 0) {
      var lo = ab & 0xffff;
      var hi = ab >>> 16 & 0xffff;
      return lo - hi + (lo < hi ? 1 : 0);
    }

    if (a === 0) {
      return 1 - b;
    }

    return 1 - a;
  }

  function mulInv(x) {
    var t0, t1, q, y;

    if (x <= 1) {
      return x;
    }

    t1 = Math.floor(0x10001 / x);
    y = 0x10001 % x;

    if (y === 1) {
      return 1 - t1 & 0xffff;
    }

    t0 = 1;

    do {
      q = Math.floor(x / y);
      x = x % y;
      t0 += q * t1;

      if (x === 1) {
        return t0;
      }

      q = Math.floor(y / x);
      y = y % x;
      t1 += q * t0;
    } while (y !== 1);

    return 1 - t1 & 0xffff;
  }

  function getIntMSBO(src, srcOffset) {
    return (src[srcOffset] & 0xff) << 24 | (src[srcOffset + 1] & 0xff) << 16 | (src[srcOffset + 2] & 0xff) << 8 | src[srcOffset + 3] & 0xff;
  }

  function putIntMSBO(val, dest, destOffset) {
    dest[destOffset] = val >>> 24 & 0xff;
    dest[destOffset + 1] = val >>> 16 & 0xff;
    dest[destOffset + 2] = val >>> 8 & 0xff;
    dest[destOffset + 3] = val & 0xff;
  }

  this.setKey(key, xorKey);
  return this;
};
/**
 * @see org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher#engineSetPadding
 * BaseBlockCipher.engineSetPadding("NOPADDING")
 */


var Padding = {
  noPaddingFinal: function (cipher, src, inOff, out, outOff, len) {
    doFinal(cipher, false, 0, src, inOff, out, outOff, len);
  },
  xorPaddingFinal: function (cipher, xorKey, src, inOff, out, outOff, len) {
    doFinal(cipher, true, xorKey, src, inOff, out, outOff, len);
  }
};

function doFinal(cipher, xorPadding, xorKey, src, inOff, out, outOff, len) {
  var blockSize = cipher.getBlockSize(); // assert Integer.bitCount(blockSize) == 1;

  var nBlocks = Math.floor(len / blockSize); // use the cipher algorithm for parts divided by the block size.

  for (var i = 0; i < nBlocks; i++) {
    cipher.processBlock(src, inOff, out, outOff);
    inOff += blockSize;
    outOff += blockSize;
    len -= blockSize;
  }

  if (!xorPadding && len > 0) {
    throw new Error('no padding, expecting more inputs');
  } // use xor encryption for remain parts


  for (var _i = 0; _i < len; _i++) {
    out[outOff + _i] = src[inOff + _i] ^ xorKey;
  }
}

/***/ }),

/***/ 9697:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {

__webpack_require__(2409);

/***/ }),

/***/ 2409:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

__webpack_require__(6830);

__webpack_require__(6014);

__webpack_require__(7200);

__webpack_require__(7607);

__webpack_require__(4225);

__webpack_require__(1829);

__webpack_require__(3863);

__webpack_require__(7280);

__webpack_require__(9747);

__webpack_require__(8655);

module.exports = __webpack_require__(6121);

/***/ }),

/***/ 8655:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {

__webpack_require__(8465);

__webpack_require__(6307);

__webpack_require__(6562);

__webpack_require__(5167);

__webpack_require__(7984);

__webpack_require__(4062);

__webpack_require__(2980);

__webpack_require__(6991);

__webpack_require__(7629);

__webpack_require__(1708);

__webpack_require__(7529);

__webpack_require__(6444);

__webpack_require__(6897);

__webpack_require__(3196);

__webpack_require__(3811);

__webpack_require__(1274);

__webpack_require__(1010);

__webpack_require__(9313);

__webpack_require__(485);

__webpack_require__(8491);

__webpack_require__(4230);

__webpack_require__(2826);

__webpack_require__(70);

__webpack_require__(2376);

__webpack_require__(1095);

__webpack_require__(3888);

__webpack_require__(8509);

__webpack_require__(9491);

/***/ }),

/***/ 9257:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var isCallable = __webpack_require__(5222);

var tryToString = __webpack_require__(3120);

var TypeError = global.TypeError; // `Assert: IsCallable(argument) is true`

module.exports = function (argument) {
  if (isCallable(argument)) return argument;
  throw TypeError(tryToString(argument) + ' is not a function');
};

/***/ }),

/***/ 3834:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var isConstructor = __webpack_require__(3722);

var tryToString = __webpack_require__(3120);

var TypeError = global.TypeError; // `Assert: IsConstructor(argument) is true`

module.exports = function (argument) {
  if (isConstructor(argument)) return argument;
  throw TypeError(tryToString(argument) + ' is not a constructor');
};

/***/ }),

/***/ 2193:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var isCallable = __webpack_require__(5222);

var String = global.String;
var TypeError = global.TypeError;

module.exports = function (argument) {
  if (typeof argument == 'object' || isCallable(argument)) return argument;
  throw TypeError("Can't set " + String(argument) + ' as a prototype');
};

/***/ }),

/***/ 9690:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var wellKnownSymbol = __webpack_require__(1386);

var create = __webpack_require__(3571);

var definePropertyModule = __webpack_require__(7455);

var UNSCOPABLES = wellKnownSymbol('unscopables');
var ArrayPrototype = Array.prototype; // Array.prototype[@@unscopables]
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables

if (ArrayPrototype[UNSCOPABLES] == undefined) {
  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
    configurable: true,
    value: create(null)
  });
} // add a key to Array.prototype[@@unscopables]


module.exports = function (key) {
  ArrayPrototype[UNSCOPABLES][key] = true;
};

/***/ }),

/***/ 680:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var isPrototypeOf = __webpack_require__(8449);

var TypeError = global.TypeError;

module.exports = function (it, Prototype) {
  if (isPrototypeOf(Prototype, it)) return it;
  throw TypeError('Incorrect invocation');
};

/***/ }),

/***/ 6956:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var isObject = __webpack_require__(2521);

var String = global.String;
var TypeError = global.TypeError; // `Assert: Type(argument) is Object`

module.exports = function (argument) {
  if (isObject(argument)) return argument;
  throw TypeError(String(argument) + ' is not an object');
};

/***/ }),

/***/ 251:
/***/ (function(module) {

// eslint-disable-next-line es/no-typed-arrays -- safe
module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';

/***/ }),

/***/ 4162:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var NATIVE_ARRAY_BUFFER = __webpack_require__(251);

var DESCRIPTORS = __webpack_require__(7703);

var global = __webpack_require__(6121);

var isCallable = __webpack_require__(5222);

var isObject = __webpack_require__(2521);

var hasOwn = __webpack_require__(9146);

var classof = __webpack_require__(9538);

var tryToString = __webpack_require__(3120);

var createNonEnumerableProperty = __webpack_require__(1471);

var redefine = __webpack_require__(2327);

var defineProperty = (__webpack_require__(7455).f);

var isPrototypeOf = __webpack_require__(8449);

var getPrototypeOf = __webpack_require__(9366);

var setPrototypeOf = __webpack_require__(6594);

var wellKnownSymbol = __webpack_require__(1386);

var uid = __webpack_require__(1735);

var Int8Array = global.Int8Array;
var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
var Uint8ClampedArray = global.Uint8ClampedArray;
var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
var TypedArray = Int8Array && getPrototypeOf(Int8Array);
var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
var ObjectPrototype = Object.prototype;
var TypeError = global.TypeError;
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
var TYPED_ARRAY_CONSTRUCTOR = uid('TYPED_ARRAY_CONSTRUCTOR'); // Fixing native typed arrays in Opera Presto crashes the browser, see #595

var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';
var TYPED_ARRAY_TAG_REQUIRED = false;
var NAME, Constructor, Prototype;
var TypedArrayConstructorsList = {
  Int8Array: 1,
  Uint8Array: 1,
  Uint8ClampedArray: 1,
  Int16Array: 2,
  Uint16Array: 2,
  Int32Array: 4,
  Uint32Array: 4,
  Float32Array: 4,
  Float64Array: 8
};
var BigIntArrayConstructorsList = {
  BigInt64Array: 8,
  BigUint64Array: 8
};

var isView = function isView(it) {
  if (!isObject(it)) return false;
  var klass = classof(it);
  return klass === 'DataView' || hasOwn(TypedArrayConstructorsList, klass) || hasOwn(BigIntArrayConstructorsList, klass);
};

var isTypedArray = function (it) {
  if (!isObject(it)) return false;
  var klass = classof(it);
  return hasOwn(TypedArrayConstructorsList, klass) || hasOwn(BigIntArrayConstructorsList, klass);
};

var aTypedArray = function (it) {
  if (isTypedArray(it)) return it;
  throw TypeError('Target is not a typed array');
};

var aTypedArrayConstructor = function (C) {
  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
  throw TypeError(tryToString(C) + ' is not a typed array constructor');
};

var exportTypedArrayMethod = function (KEY, property, forced, options) {
  if (!DESCRIPTORS) return;
  if (forced) for (var ARRAY in TypedArrayConstructorsList) {
    var TypedArrayConstructor = global[ARRAY];
    if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
      delete TypedArrayConstructor.prototype[KEY];
    } catch (error) {
      /* empty */
    }
  }

  if (!TypedArrayPrototype[KEY] || forced) {
    redefine(TypedArrayPrototype, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
  }
};

var exportTypedArrayStaticMethod = function (KEY, property, forced) {
  var ARRAY, TypedArrayConstructor;
  if (!DESCRIPTORS) return;

  if (setPrototypeOf) {
    if (forced) for (ARRAY in TypedArrayConstructorsList) {
      TypedArrayConstructor = global[ARRAY];
      if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
        delete TypedArrayConstructor[KEY];
      } catch (error) {
        /* empty */
      }
    }

    if (!TypedArray[KEY] || forced) {
      // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
      try {
        return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
      } catch (error) {
        /* empty */
      }
    } else return;
  }

  for (ARRAY in TypedArrayConstructorsList) {
    TypedArrayConstructor = global[ARRAY];

    if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
      redefine(TypedArrayConstructor, KEY, property);
    }
  }
};

for (NAME in TypedArrayConstructorsList) {
  Constructor = global[NAME];
  Prototype = Constructor && Constructor.prototype;
  if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);else NATIVE_ARRAY_BUFFER_VIEWS = false;
}

for (NAME in BigIntArrayConstructorsList) {
  Constructor = global[NAME];
  Prototype = Constructor && Constructor.prototype;
  if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);
} // WebKit bug - typed arrays constructors prototype is Object.prototype


if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
  // eslint-disable-next-line no-shadow -- safe
  TypedArray = function TypedArray() {
    throw TypeError('Incorrect invocation');
  };

  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
    if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);
  }
}

if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
  TypedArrayPrototype = TypedArray.prototype;
  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
    if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);
  }
} // WebKit bug - one more object in Uint8ClampedArray prototype chain


if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
  setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
}

if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
  TYPED_ARRAY_TAG_REQUIRED = true;
  defineProperty(TypedArrayPrototype, TO_STRING_TAG, {
    get: function () {
      return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
    }
  });

  for (NAME in TypedArrayConstructorsList) {
    if (global[NAME]) {
      createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);
    }
  }
}

module.exports = {
  NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
  TYPED_ARRAY_CONSTRUCTOR: TYPED_ARRAY_CONSTRUCTOR,
  TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
  aTypedArray: aTypedArray,
  aTypedArrayConstructor: aTypedArrayConstructor,
  exportTypedArrayMethod: exportTypedArrayMethod,
  exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
  isView: isView,
  isTypedArray: isTypedArray,
  TypedArray: TypedArray,
  TypedArrayPrototype: TypedArrayPrototype
};

/***/ }),

/***/ 5117:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var global = __webpack_require__(6121);

var uncurryThis = __webpack_require__(7585);

var DESCRIPTORS = __webpack_require__(7703);

var NATIVE_ARRAY_BUFFER = __webpack_require__(251);

var FunctionName = __webpack_require__(3343);

var createNonEnumerableProperty = __webpack_require__(1471);

var redefineAll = __webpack_require__(9757);

var fails = __webpack_require__(2763);

var anInstance = __webpack_require__(680);

var toIntegerOrInfinity = __webpack_require__(4725);

var toLength = __webpack_require__(8331);

var toIndex = __webpack_require__(5639);

var IEEE754 = __webpack_require__(6601);

var getPrototypeOf = __webpack_require__(9366);

var setPrototypeOf = __webpack_require__(6594);

var getOwnPropertyNames = (__webpack_require__(2042).f);

var defineProperty = (__webpack_require__(7455).f);

var arrayFill = __webpack_require__(6922);

var arraySlice = __webpack_require__(1280);

var setToStringTag = __webpack_require__(4849);

var InternalStateModule = __webpack_require__(2995);

var PROPER_FUNCTION_NAME = FunctionName.PROPER;
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
var getInternalState = InternalStateModule.get;
var setInternalState = InternalStateModule.set;
var ARRAY_BUFFER = 'ArrayBuffer';
var DATA_VIEW = 'DataView';
var PROTOTYPE = 'prototype';
var WRONG_LENGTH = 'Wrong length';
var WRONG_INDEX = 'Wrong index';
var NativeArrayBuffer = global[ARRAY_BUFFER];
var $ArrayBuffer = NativeArrayBuffer;
var ArrayBufferPrototype = $ArrayBuffer && $ArrayBuffer[PROTOTYPE];
var $DataView = global[DATA_VIEW];
var DataViewPrototype = $DataView && $DataView[PROTOTYPE];
var ObjectPrototype = Object.prototype;
var Array = global.Array;
var RangeError = global.RangeError;
var fill = uncurryThis(arrayFill);
var reverse = uncurryThis([].reverse);
var packIEEE754 = IEEE754.pack;
var unpackIEEE754 = IEEE754.unpack;

var packInt8 = function (number) {
  return [number & 0xFF];
};

var packInt16 = function (number) {
  return [number & 0xFF, number >> 8 & 0xFF];
};

var packInt32 = function (number) {
  return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF];
};

var unpackInt32 = function (buffer) {
  return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0];
};

var packFloat32 = function (number) {
  return packIEEE754(number, 23, 4);
};

var packFloat64 = function (number) {
  return packIEEE754(number, 52, 8);
};

var addGetter = function (Constructor, key) {
  defineProperty(Constructor[PROTOTYPE], key, {
    get: function () {
      return getInternalState(this)[key];
    }
  });
};

var get = function (view, count, index, isLittleEndian) {
  var intIndex = toIndex(index);
  var store = getInternalState(view);
  if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX);
  var bytes = getInternalState(store.buffer).bytes;
  var start = intIndex + store.byteOffset;
  var pack = arraySlice(bytes, start, start + count);
  return isLittleEndian ? pack : reverse(pack);
};

var set = function (view, count, index, conversion, value, isLittleEndian) {
  var intIndex = toIndex(index);
  var store = getInternalState(view);
  if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX);
  var bytes = getInternalState(store.buffer).bytes;
  var start = intIndex + store.byteOffset;
  var pack = conversion(+value);

  for (var i = 0; i < count; i++) {
    bytes[start + i] = pack[isLittleEndian ? i : count - i - 1];
  }
};

if (!NATIVE_ARRAY_BUFFER) {
  $ArrayBuffer = function ArrayBuffer(length) {
    anInstance(this, ArrayBufferPrototype);
    var byteLength = toIndex(length);
    setInternalState(this, {
      bytes: fill(Array(byteLength), 0),
      byteLength: byteLength
    });
    if (!DESCRIPTORS) this.byteLength = byteLength;
  };

  ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE];

  $DataView = function DataView(buffer, byteOffset, byteLength) {
    anInstance(this, DataViewPrototype);
    anInstance(buffer, ArrayBufferPrototype);
    var bufferLength = getInternalState(buffer).byteLength;
    var offset = toIntegerOrInfinity(byteOffset);
    if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset');
    byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);
    if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);
    setInternalState(this, {
      buffer: buffer,
      byteLength: byteLength,
      byteOffset: offset
    });

    if (!DESCRIPTORS) {
      this.buffer = buffer;
      this.byteLength = byteLength;
      this.byteOffset = offset;
    }
  };

  DataViewPrototype = $DataView[PROTOTYPE];

  if (DESCRIPTORS) {
    addGetter($ArrayBuffer, 'byteLength');
    addGetter($DataView, 'buffer');
    addGetter($DataView, 'byteLength');
    addGetter($DataView, 'byteOffset');
  }

  redefineAll(DataViewPrototype, {
    getInt8: function getInt8(byteOffset) {
      return get(this, 1, byteOffset)[0] << 24 >> 24;
    },
    getUint8: function getUint8(byteOffset) {
      return get(this, 1, byteOffset)[0];
    },
    getInt16: function getInt16(byteOffset
    /* , littleEndian */
    ) {
      var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined);
      return (bytes[1] << 8 | bytes[0]) << 16 >> 16;
    },
    getUint16: function getUint16(byteOffset
    /* , littleEndian */
    ) {
      var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined);
      return bytes[1] << 8 | bytes[0];
    },
    getInt32: function getInt32(byteOffset
    /* , littleEndian */
    ) {
      return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined));
    },
    getUint32: function getUint32(byteOffset
    /* , littleEndian */
    ) {
      return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined)) >>> 0;
    },
    getFloat32: function getFloat32(byteOffset
    /* , littleEndian */
    ) {
      return unpackIEEE754(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 23);
    },
    getFloat64: function getFloat64(byteOffset
    /* , littleEndian */
    ) {
      return unpackIEEE754(get(this, 8, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 52);
    },
    setInt8: function setInt8(byteOffset, value) {
      set(this, 1, byteOffset, packInt8, value);
    },
    setUint8: function setUint8(byteOffset, value) {
      set(this, 1, byteOffset, packInt8, value);
    },
    setInt16: function setInt16(byteOffset, value
    /* , littleEndian */
    ) {
      set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined);
    },
    setUint16: function setUint16(byteOffset, value
    /* , littleEndian */
    ) {
      set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined);
    },
    setInt32: function setInt32(byteOffset, value
    /* , littleEndian */
    ) {
      set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined);
    },
    setUint32: function setUint32(byteOffset, value
    /* , littleEndian */
    ) {
      set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined);
    },
    setFloat32: function setFloat32(byteOffset, value
    /* , littleEndian */
    ) {
      set(this, 4, byteOffset, packFloat32, value, arguments.length > 2 ? arguments[2] : undefined);
    },
    setFloat64: function setFloat64(byteOffset, value
    /* , littleEndian */
    ) {
      set(this, 8, byteOffset, packFloat64, value, arguments.length > 2 ? arguments[2] : undefined);
    }
  });
} else {
  var INCORRECT_ARRAY_BUFFER_NAME = PROPER_FUNCTION_NAME && NativeArrayBuffer.name !== ARRAY_BUFFER;
  /* eslint-disable no-new -- required for testing */

  if (!fails(function () {
    NativeArrayBuffer(1);
  }) || !fails(function () {
    new NativeArrayBuffer(-1);
  }) || fails(function () {
    new NativeArrayBuffer();
    new NativeArrayBuffer(1.5);
    new NativeArrayBuffer(NaN);
    return INCORRECT_ARRAY_BUFFER_NAME && !CONFIGURABLE_FUNCTION_NAME;
  })) {
    /* eslint-enable no-new -- required for testing */
    $ArrayBuffer = function ArrayBuffer(length) {
      anInstance(this, ArrayBufferPrototype);
      return new NativeArrayBuffer(toIndex(length));
    };

    $ArrayBuffer[PROTOTYPE] = ArrayBufferPrototype;

    for (var keys = getOwnPropertyNames(NativeArrayBuffer), j = 0, key; keys.length > j;) {
      if (!((key = keys[j++]) in $ArrayBuffer)) {
        createNonEnumerableProperty($ArrayBuffer, key, NativeArrayBuffer[key]);
      }
    }

    ArrayBufferPrototype.constructor = $ArrayBuffer;
  } else if (INCORRECT_ARRAY_BUFFER_NAME && CONFIGURABLE_FUNCTION_NAME) {
    createNonEnumerableProperty(NativeArrayBuffer, 'name', ARRAY_BUFFER);
  } // WebKit bug - the same parent prototype for typed arrays and data view


  if (setPrototypeOf && getPrototypeOf(DataViewPrototype) !== ObjectPrototype) {
    setPrototypeOf(DataViewPrototype, ObjectPrototype);
  } // iOS Safari 7.x bug


  var testView = new $DataView(new $ArrayBuffer(2));
  var $setInt8 = uncurryThis(DataViewPrototype.setInt8);
  testView.setInt8(0, 2147483648);
  testView.setInt8(1, 2147483649);
  if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll(DataViewPrototype, {
    setInt8: function setInt8(byteOffset, value) {
      $setInt8(this, byteOffset, value << 24 >> 24);
    },
    setUint8: function setUint8(byteOffset, value) {
      $setInt8(this, byteOffset, value << 24 >> 24);
    }
  }, {
    unsafe: true
  });
}

setToStringTag($ArrayBuffer, ARRAY_BUFFER);
setToStringTag($DataView, DATA_VIEW);
module.exports = {
  ArrayBuffer: $ArrayBuffer,
  DataView: $DataView
};

/***/ }),

/***/ 4579:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var toObject = __webpack_require__(4766);

var toAbsoluteIndex = __webpack_require__(1588);

var lengthOfArrayLike = __webpack_require__(5902);

var min = Math.min; // `Array.prototype.copyWithin` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.copywithin
// eslint-disable-next-line es/no-array-prototype-copywithin -- safe

module.exports = [].copyWithin || function copyWithin(target
/* = 0 */
, start
/* = 0, end = @length */
) {
  var O = toObject(this);
  var len = lengthOfArrayLike(O);
  var to = toAbsoluteIndex(target, len);
  var from = toAbsoluteIndex(start, len);
  var end = arguments.length > 2 ? arguments[2] : undefined;
  var count = min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);
  var inc = 1;

  if (from < to && to < from + count) {
    inc = -1;
    from += count - 1;
    to += count - 1;
  }

  while (count-- > 0) {
    if (from in O) O[to] = O[from];else delete O[to];
    to += inc;
    from += inc;
  }

  return O;
};

/***/ }),

/***/ 6922:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var toObject = __webpack_require__(4766);

var toAbsoluteIndex = __webpack_require__(1588);

var lengthOfArrayLike = __webpack_require__(5902); // `Array.prototype.fill` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.fill


module.exports = function fill(value
/* , start = 0, end = @length */
) {
  var O = toObject(this);
  var length = lengthOfArrayLike(O);
  var argumentsLength = arguments.length;
  var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);
  var end = argumentsLength > 2 ? arguments[2] : undefined;
  var endPos = end === undefined ? length : toAbsoluteIndex(end, length);

  while (endPos > index) {
    O[index++] = value;
  }

  return O;
};

/***/ }),

/***/ 5078:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var lengthOfArrayLike = __webpack_require__(5902);

module.exports = function (Constructor, list) {
  var index = 0;
  var length = lengthOfArrayLike(list);
  var result = new Constructor(length);

  while (length > index) {
    result[index] = list[index++];
  }

  return result;
};

/***/ }),

/***/ 9729:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var toIndexedObject = __webpack_require__(9969);

var toAbsoluteIndex = __webpack_require__(1588);

var lengthOfArrayLike = __webpack_require__(5902); // `Array.prototype.{ indexOf, includes }` methods implementation


var createMethod = function (IS_INCLUDES) {
  return function ($this, el, fromIndex) {
    var O = toIndexedObject($this);
    var length = lengthOfArrayLike(O);
    var index = toAbsoluteIndex(fromIndex, length);
    var value; // Array#includes uses SameValueZero equality algorithm
    // eslint-disable-next-line no-self-compare -- NaN check

    if (IS_INCLUDES && el != el) while (length > index) {
      value = O[index++]; // eslint-disable-next-line no-self-compare -- NaN check

      if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not
    } else for (; length > index; index++) {
      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
    }
    return !IS_INCLUDES && -1;
  };
};

module.exports = {
  // `Array.prototype.includes` method
  // https://tc39.es/ecma262/#sec-array.prototype.includes
  includes: createMethod(true),
  // `Array.prototype.indexOf` method
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
  indexOf: createMethod(false)
};

/***/ }),

/***/ 5097:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var bind = __webpack_require__(3322);

var uncurryThis = __webpack_require__(7585);

var IndexedObject = __webpack_require__(3169);

var toObject = __webpack_require__(4766);

var lengthOfArrayLike = __webpack_require__(5902);

var arraySpeciesCreate = __webpack_require__(8347);

var push = uncurryThis([].push); // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation

var createMethod = function (TYPE) {
  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 IS_FILTER_REJECT = TYPE == 7;
  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
  return function ($this, callbackfn, that, specificCreate) {
    var O = toObject($this);
    var self = IndexedObject(O);
    var boundFunction = bind(callbackfn, that);
    var length = lengthOfArrayLike(self);
    var index = 0;
    var create = specificCreate || arraySpeciesCreate;
    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
    var value, result;

    for (; length > index; index++) {
      if (NO_HOLES || index in self) {
        value = self[index];
        result = boundFunction(value, index, O);

        if (TYPE) {
          if (IS_MAP) target[index] = result; // map
          else if (result) switch (TYPE) {
            case 3:
              return true;
            // some

            case 5:
              return value;
            // find

            case 6:
              return index;
            // findIndex

            case 2:
              push(target, value);
            // filter
          } else switch (TYPE) {
            case 4:
              return false;
            // every

            case 7:
              push(target, value);
            // filterReject
          }
        }
      }
    }

    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
  };
};

module.exports = {
  // `Array.prototype.forEach` method
  // https://tc39.es/ecma262/#sec-array.prototype.foreach
  forEach: createMethod(0),
  // `Array.prototype.map` method
  // https://tc39.es/ecma262/#sec-array.prototype.map
  map: createMethod(1),
  // `Array.prototype.filter` method
  // https://tc39.es/ecma262/#sec-array.prototype.filter
  filter: createMethod(2),
  // `Array.prototype.some` method
  // https://tc39.es/ecma262/#sec-array.prototype.some
  some: createMethod(3),
  // `Array.prototype.every` method
  // https://tc39.es/ecma262/#sec-array.prototype.every
  every: createMethod(4),
  // `Array.prototype.find` method
  // https://tc39.es/ecma262/#sec-array.prototype.find
  find: createMethod(5),
  // `Array.prototype.findIndex` method
  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
  findIndex: createMethod(6),
  // `Array.prototype.filterReject` method
  // https://github.com/tc39/proposal-array-filtering
  filterReject: createMethod(7)
};

/***/ }),

/***/ 8139:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {



/* eslint-disable es/no-array-prototype-lastindexof -- safe */

var apply = __webpack_require__(9102);

var toIndexedObject = __webpack_require__(9969);

var toIntegerOrInfinity = __webpack_require__(4725);

var lengthOfArrayLike = __webpack_require__(5902);

var arrayMethodIsStrict = __webpack_require__(9719);

var min = Math.min;
var $lastIndexOf = [].lastIndexOf;
var NEGATIVE_ZERO = !!$lastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0;
var STRICT_METHOD = arrayMethodIsStrict('lastIndexOf');
var FORCED = NEGATIVE_ZERO || !STRICT_METHOD; // `Array.prototype.lastIndexOf` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.lastindexof

module.exports = FORCED ? function lastIndexOf(searchElement
/* , fromIndex = @[*-1] */
) {
  // convert -0 to +0
  if (NEGATIVE_ZERO) return apply($lastIndexOf, this, arguments) || 0;
  var O = toIndexedObject(this);
  var length = lengthOfArrayLike(O);
  var index = length - 1;
  if (arguments.length > 1) index = min(index, toIntegerOrInfinity(arguments[1]));
  if (index < 0) index = length + index;

  for (; index >= 0; index--) {
    if (index in O && O[index] === searchElement) return index || 0;
  }

  return -1;
} : $lastIndexOf;

/***/ }),

/***/ 9719:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var fails = __webpack_require__(2763);

module.exports = function (METHOD_NAME, argument) {
  var method = [][METHOD_NAME];
  return !!method && fails(function () {
    // eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing
    method.call(null, argument || function () {
      throw 1;
    }, 1);
  });
};

/***/ }),

/***/ 9856:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var aCallable = __webpack_require__(9257);

var toObject = __webpack_require__(4766);

var IndexedObject = __webpack_require__(3169);

var lengthOfArrayLike = __webpack_require__(5902);

var TypeError = global.TypeError; // `Array.prototype.{ reduce, reduceRight }` methods implementation

var createMethod = function (IS_RIGHT) {
  return function (that, callbackfn, argumentsLength, memo) {
    aCallable(callbackfn);
    var O = toObject(that);
    var self = IndexedObject(O);
    var length = lengthOfArrayLike(O);
    var index = IS_RIGHT ? length - 1 : 0;
    var i = IS_RIGHT ? -1 : 1;
    if (argumentsLength < 2) while (true) {
      if (index in self) {
        memo = self[index];
        index += i;
        break;
      }

      index += i;

      if (IS_RIGHT ? index < 0 : length <= index) {
        throw TypeError('Reduce of empty array with no initial value');
      }
    }

    for (; IS_RIGHT ? index >= 0 : length > index; index += i) {
      if (index in self) {
        memo = callbackfn(memo, self[index], index, O);
      }
    }

    return memo;
  };
};

module.exports = {
  // `Array.prototype.reduce` method
  // https://tc39.es/ecma262/#sec-array.prototype.reduce
  left: createMethod(false),
  // `Array.prototype.reduceRight` method
  // https://tc39.es/ecma262/#sec-array.prototype.reduceright
  right: createMethod(true)
};

/***/ }),

/***/ 1280:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var toAbsoluteIndex = __webpack_require__(1588);

var lengthOfArrayLike = __webpack_require__(5902);

var createProperty = __webpack_require__(2385);

var Array = global.Array;
var max = Math.max;

module.exports = function (O, start, end) {
  var length = lengthOfArrayLike(O);
  var k = toAbsoluteIndex(start, length);
  var fin = toAbsoluteIndex(end === undefined ? length : end, length);
  var result = Array(max(fin - k, 0));

  for (var n = 0; k < fin; k++, n++) {
    createProperty(result, n, O[k]);
  }

  result.length = n;
  return result;
};

/***/ }),

/***/ 1939:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var uncurryThis = __webpack_require__(7585);

module.exports = uncurryThis([].slice);

/***/ }),

/***/ 3407:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arraySlice = __webpack_require__(1280);

var floor = Math.floor;

var mergeSort = function (array, comparefn) {
  var length = array.length;
  var middle = floor(length / 2);
  return length < 8 ? insertionSort(array, comparefn) : merge(array, mergeSort(arraySlice(array, 0, middle), comparefn), mergeSort(arraySlice(array, middle), comparefn), comparefn);
};

var insertionSort = function (array, comparefn) {
  var length = array.length;
  var i = 1;
  var element, j;

  while (i < length) {
    j = i;
    element = array[i];

    while (j && comparefn(array[j - 1], element) > 0) {
      array[j] = array[--j];
    }

    if (j !== i++) array[j] = element;
  }

  return array;
};

var merge = function (array, left, right, comparefn) {
  var llength = left.length;
  var rlength = right.length;
  var lindex = 0;
  var rindex = 0;

  while (lindex < llength || rindex < rlength) {
    array[lindex + rindex] = lindex < llength && rindex < rlength ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] : lindex < llength ? left[lindex++] : right[rindex++];
  }

  return array;
};

module.exports = mergeSort;

/***/ }),

/***/ 2021:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var isArray = __webpack_require__(3964);

var isConstructor = __webpack_require__(3722);

var isObject = __webpack_require__(2521);

var wellKnownSymbol = __webpack_require__(1386);

var SPECIES = wellKnownSymbol('species');
var Array = global.Array; // a part of `ArraySpeciesCreate` abstract operation
// https://tc39.es/ecma262/#sec-arrayspeciescreate

module.exports = function (originalArray) {
  var C;

  if (isArray(originalArray)) {
    C = originalArray.constructor; // cross-realm fallback

    if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;else if (isObject(C)) {
      C = C[SPECIES];
      if (C === null) C = undefined;
    }
  }

  return C === undefined ? Array : C;
};

/***/ }),

/***/ 8347:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arraySpeciesConstructor = __webpack_require__(2021); // `ArraySpeciesCreate` abstract operation
// https://tc39.es/ecma262/#sec-arrayspeciescreate


module.exports = function (originalArray, length) {
  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
};

/***/ }),

/***/ 4684:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var wellKnownSymbol = __webpack_require__(1386);

var ITERATOR = wellKnownSymbol('iterator');
var SAFE_CLOSING = false;

try {
  var called = 0;
  var iteratorWithReturn = {
    next: function () {
      return {
        done: !!called++
      };
    },
    'return': function () {
      SAFE_CLOSING = true;
    }
  };

  iteratorWithReturn[ITERATOR] = function () {
    return this;
  }; // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing


  Array.from(iteratorWithReturn, function () {
    throw 2;
  });
} catch (error) {
  /* empty */
}

module.exports = function (exec, SKIP_CLOSING) {
  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
  var ITERATION_SUPPORT = false;

  try {
    var object = {};

    object[ITERATOR] = function () {
      return {
        next: function () {
          return {
            done: ITERATION_SUPPORT = true
          };
        }
      };
    };

    exec(object);
  } catch (error) {
    /* empty */
  }

  return ITERATION_SUPPORT;
};

/***/ }),

/***/ 2849:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var uncurryThis = __webpack_require__(7585);

var toString = uncurryThis({}.toString);
var stringSlice = uncurryThis(''.slice);

module.exports = function (it) {
  return stringSlice(toString(it), 8, -1);
};

/***/ }),

/***/ 9538:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var global = __webpack_require__(6121);

var TO_STRING_TAG_SUPPORT = __webpack_require__(6395);

var isCallable = __webpack_require__(5222);

var classofRaw = __webpack_require__(2849);

var wellKnownSymbol = __webpack_require__(1386);

var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var Object = global.Object; // ES3 wrong here

var CORRECT_ARGUMENTS = classofRaw(function () {
  return arguments;
}()) == 'Arguments'; // fallback for IE11 Script Access Denied error

var tryGet = function (it, key) {
  try {
    return it[key];
  } catch (error) {
    /* empty */
  }
}; // getting tag from ES6+ `Object.prototype.toString`


module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
  var O, tag, result;
  return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case
  : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag // builtinTag case
  : CORRECT_ARGUMENTS ? classofRaw(O) // ES3 arguments fallback
  : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
};

/***/ }),

/***/ 4488:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var hasOwn = __webpack_require__(9146);

var ownKeys = __webpack_require__(9593);

var getOwnPropertyDescriptorModule = __webpack_require__(8769);

var definePropertyModule = __webpack_require__(7455);

module.exports = function (target, source, exceptions) {
  var keys = ownKeys(source);
  var defineProperty = definePropertyModule.f;
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;

  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];

    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
    }
  }
};

/***/ }),

/***/ 4264:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var fails = __webpack_require__(2763);

module.exports = !fails(function () {
  function F() {
    /* empty */
  }

  F.prototype.constructor = null; // eslint-disable-next-line es/no-object-getprototypeof -- required for testing

  return Object.getPrototypeOf(new F()) !== F.prototype;
});

/***/ }),

/***/ 4427:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var IteratorPrototype = (__webpack_require__(4109).IteratorPrototype);

var create = __webpack_require__(3571);

var createPropertyDescriptor = __webpack_require__(5938);

var setToStringTag = __webpack_require__(4849);

var Iterators = __webpack_require__(3403);

var returnThis = function () {
  return this;
};

module.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
  var TO_STRING_TAG = NAME + ' Iterator';
  IteratorConstructor.prototype = create(IteratorPrototype, {
    next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next)
  });
  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
  Iterators[TO_STRING_TAG] = returnThis;
  return IteratorConstructor;
};

/***/ }),

/***/ 1471:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var DESCRIPTORS = __webpack_require__(7703);

var definePropertyModule = __webpack_require__(7455);

var createPropertyDescriptor = __webpack_require__(5938);

module.exports = DESCRIPTORS ? function (object, key, value) {
  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
} : function (object, key, value) {
  object[key] = value;
  return object;
};

/***/ }),

/***/ 5938:
/***/ (function(module) {

module.exports = function (bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value: value
  };
};

/***/ }),

/***/ 2385:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var toPropertyKey = __webpack_require__(5224);

var definePropertyModule = __webpack_require__(7455);

var createPropertyDescriptor = __webpack_require__(5938);

module.exports = function (object, key, value) {
  var propertyKey = toPropertyKey(key);
  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));else object[propertyKey] = value;
};

/***/ }),

/***/ 4247:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {




var $ = __webpack_require__(7309);

var call = __webpack_require__(7702);

var IS_PURE = __webpack_require__(8451);

var FunctionName = __webpack_require__(3343);

var isCallable = __webpack_require__(5222);

var createIteratorConstructor = __webpack_require__(4427);

var getPrototypeOf = __webpack_require__(9366);

var setPrototypeOf = __webpack_require__(6594);

var setToStringTag = __webpack_require__(4849);

var createNonEnumerableProperty = __webpack_require__(1471);

var redefine = __webpack_require__(2327);

var wellKnownSymbol = __webpack_require__(1386);

var Iterators = __webpack_require__(3403);

var IteratorsCore = __webpack_require__(4109);

var PROPER_FUNCTION_NAME = FunctionName.PROPER;
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
var IteratorPrototype = IteratorsCore.IteratorPrototype;
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
var ITERATOR = wellKnownSymbol('iterator');
var KEYS = 'keys';
var VALUES = 'values';
var ENTRIES = 'entries';

var returnThis = function () {
  return this;
};

module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
  createIteratorConstructor(IteratorConstructor, NAME, next);

  var getIterationMethod = function (KIND) {
    if (KIND === DEFAULT && defaultIterator) return defaultIterato