https://www.revistalopinio.cat/wp-content/plugins/pdfjs-viewer-shortcode/pdfjs/web/viewer.js?v=3.1.1

220  try {
221    // eslint-disable-next-line no-new -- thrower
222    new DataView(O);
223    return false;
224  } catch (error) {
225    return true;
226  }
227};
228
229
230/***/ },
231
232/***/ 5169
233(module, __unused_webpack_exports, __webpack_require__) {
234
235
236var isDetached = __webpack_require__(3238);
237
238var $TypeError = TypeError;
239
240module.exports = function (it) {
241  if (isDetached(it)) throw new $TypeError('ArrayBuffer is detached');
242  return it;
243};
244
245
246/***/ },
247
248/***/ 5636
249(module, __unused_webpack_exports, __webpack_require__) {
250
251
252var globalThis = __webpack_require__(4576);
253var uncurryThis = __webpack_require__(9504);
254var uncurryThisAccessor = __webpack_require__(6706);
255var toIndex = __webpack_require__(7696);
256var notDetached = __webpack_require__(5169);
257var arrayBufferByteLength = __webpack_require__(7394);
258var detachTransferable = __webpack_require__(4483);
259var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(1548);
260
261var structuredClone = globalThis.structuredClone;
262var ArrayBuffer = globalThis.ArrayBuffer;
263var DataView = globalThis.DataView;
264var min = Math.min;
265var ArrayBufferPrototype = ArrayBuffer.prototype;
266var DataViewPrototype = DataView.prototype;
267var slice = uncurryThis(ArrayBufferPrototype.slice);
268var isResizable = uncurryThisAccessor(ArrayBufferPrototype, 'resizable', 'get');
269var maxByteLength = uncurryThisAccessor(ArrayBufferPrototype, 'maxByteLength', 'get');
270var getInt8 = uncurryThis(DataViewPrototype.getInt8);
271var setInt8 = uncurryThis(DataViewPrototype.setInt8);
272
273module.exports = (PROPER_STRUCTURED_CLONE_TRANSFER || detachTransferable) && function (arrayBuffer, newLength, preserveResizability) {
274  var byteLength = arrayBufferByteLength(arrayBuffer);
275  var newByteLength = newLength === undefined ? byteLength : toIndex(newLength);
276  var fixedLength = !isResizable || !isResizable(arrayBuffer);
277  var newBuffer;
278  notDetached(arrayBuffer);
279  if (PROPER_STRUCTURED_CLONE_TRANSFER) {
280    arrayBuffer = structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
281    if (byteLength === newByteLength && (preserveResizability || fixedLength)) return arrayBuffer;
282  }
283  if (byteLength >= newByteLength && (!preserveResizability || fixedLength)) {
284    newBuffer = slice(arrayBuffer, 0, newByteLength);
285  } else {
286    var options = preserveResizability && !fixedLength && maxByteLength ? { maxByteLength: maxByteLength(arrayBuffer) } : undefined;
287    newBuffer = new ArrayBuffer(newByteLength, options);
288    var a = new DataView(arrayBuffer);
289    var b = new DataView(newBuffer);
290    var copyLength = min(newByteLength, byteLength);
291    for (var i = 0; i < copyLength; i++) setInt8(b, i, getInt8(a, i));
292  }
293  if (!PROPER_STRUCTURED_CLONE_TRANSFER) detachTransferable(arrayBuffer);
294  return newBuffer;
295};
296
297
298/***/ },
299
300/***/ 4644
301(module, __unused_webpack_exports, __webpack_require__) {
302
303
304var NATIVE_ARRAY_BUFFER = __webpack_require__(7811);
305var DESCRIPTORS = __webpack_require__(3724);
306var globalThis = __webpack_require__(4576);
307var isCallable = __webpack_require__(4901);
308var isObject = __webpack_require__(34);
309var hasOwn = __webpack_require__(9297);
310var classof = __webpack_require__(6955);
311var tryToString = __webpack_require__(6823);
312var createNonEnumerableProperty = __webpack_require__(6699);
313var defineBuiltIn = __webpack_require__(6840);
314var defineBuiltInAccessor = __webpack_require__(2106);
315var isPrototypeOf = __webpack_require__(1625);
316var getPrototypeOf = __webpack_require__(2787);
317var setPrototypeOf = __webpack_require__(2967);
318var wellKnownSymbol = __webpack_require__(8227);
319var uid = __webpack_require__(3392);
320var InternalStateModule = __webpack_require__(1181);
321
322var enforceInternalState = InternalStateModule.enforce;
323var getInternalState = InternalStateModule.get;
324var Int8Array = globalThis.Int8Array;
325var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
326var Uint8ClampedArray = globalThis.Uint8ClampedArray;
327var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
328var TypedArray = Int8Array && getPrototypeOf(Int8Array);
329var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
330var ObjectPrototype = Object.prototype;
331var TypeError = globalThis.TypeError;
332
333var TO_STRING_TAG = wellKnownSymbol('toStringTag');
334var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
335var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';

336// Fixing native typed arrays in Opera Presto crashes the browser, see #595
337var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(globalThis.opera) !== 'Opera';
338var TYPED_ARRAY_TAG_REQUIRED = false;
339var NAME, Constructor, Prototype;
340
341var TypedArrayConstructorsList = {
342  Int8Array: 1,
343  Uint8Array: 1,
344  Uint8ClampedArray: 1,
345  Int16Array: 2,
346  Uint16Array: 2,
347  Int32Array: 4,
348  Uint32Array: 4,
349  Float32Array: 4,
350  Float64Array: 8
351};
352
353var BigIntArrayConstructorsList = {
354  BigInt64Array: 8,
355  BigUint64Array: 8
356};
357
358var isView = function isView(it) {
359  if (!isObject(it)) return false;
360  var klass = classof(it);
361  return klass === 'DataView'
362    || hasOwn(TypedArrayConstructorsList, klass)
363    || hasOwn(BigIntArrayConstructorsList, klass);
364};
365
366var getTypedArrayConstructor = function (it) {
367  var proto = getPrototypeOf(it);
368  if (!isObject(proto)) return;
369  var state = getInternalState(proto);
370  return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);
371};
372
373var isTypedArray = function (it) {
374  if (!isObject(it)) return false;
375  var klass = classof(it);
376  return hasOwn(TypedArrayConstructorsList, klass)
377    || hasOwn(BigIntArrayConstructorsList, klass);
378};
379
380var aTypedArray = function (it) {
381  if (isTypedArray(it)) return it;
382  throw new TypeError('Target is not a typed array');
383};
384
385var aTypedArrayConstructor = function (C) {
386  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
387  throw new TypeError(tryToString(C) + ' is not a typed array constructor');
388};
389
390var exportTypedArrayMethod = function (KEY, property, forced, options) {
391  if (!DESCRIPTORS) return;
392  if (forced) for (var ARRAY in TypedArrayConstructorsList) {
393    var TypedArrayConstructor = globalThis[ARRAY];
394    if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
395      delete TypedArrayConstructor.prototype[KEY];
396    } catch (error) {
397      // old WebKit bug - some methods are non-configurable
398      try {
399        TypedArrayConstructor.prototype[KEY] = property;
400      } catch (error2) { /* empty */ }
401    }
402  }
403  if (!TypedArrayPrototype[KEY] || forced) {
404    defineBuiltIn(TypedArrayPrototype, KEY, forced ? property
405      : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
406  }
407};
408
409var exportTypedArrayStaticMethod = function (KEY, property, forced) {
410  var ARRAY, TypedArrayConstructor;
411  if (!DESCRIPTORS) return;
412  if (setPrototypeOf) {
413    if (forced) for (ARRAY in TypedArrayConstructorsList) {
414      TypedArrayConstructor = globalThis[ARRAY];
415      if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
416        delete TypedArrayConstructor[KEY];
417      } catch (error) { /* empty */ }
418    }
419    if (!TypedArray[KEY] || forced) {
420      // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
421      try {
422        return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
423      } catch (error) { /* empty */ }
424    } else return;
425  }
426  for (ARRAY in TypedArrayConstructorsList) {
427    TypedArrayConstructor = globalThis[ARRAY];
428    if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
429      defineBuiltIn(TypedArrayConstructor, KEY, property);
430    }
431  }
432};
433
434for (NAME in TypedArrayConstructorsList) {
435  Constructor = globalThis[NAME];
436  Prototype = Constructor && Constructor.prototype;
437  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
438  else NATIVE_ARRAY_BUFFER_VIEWS = false;
439}
440
441for (NAME in BigIntArrayConstructorsList) {
442  Constructor = globalThis[NAME];
443  Prototype = Constructor && Constructor.prototype;
444  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
445}
446
447// WebKit bug - typed arrays constructors prototype is Object.prototype
448if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
449  // eslint-disable-next-line no-shadow -- safe
450  TypedArray = function TypedArray() {
451    throw new TypeError('Incorrect invocation');
452  };
453  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
454    if (globalThis[NAME]) setPrototypeOf(globalThis[NAME], TypedArray);
455  }
456}
457
458if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
459  TypedArrayPrototype = TypedArray.prototype;
460  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
461    if (globalThis[NAME]) setPrototypeOf(globalThis[NAME].prototype, TypedArrayPrototype);
462  }
463}
464
465// WebKit bug - one more object in Uint8ClampedArray prototype chain
466if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
467  setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
468}
469
470if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
471  TYPED_ARRAY_TAG_REQUIRED = true;
472  defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, {
473    configurable: true,
474    get: function () {
475      return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
476    }
477  });
478  for (NAME in TypedArrayConstructorsList) if (globalThis[NAME]) {
479    createNonEnumerableProperty(globalThis[NAME], TYPED_ARRAY_TAG, NAME);
480  }
481}
482
483module.exports = {
484  NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
485  TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
486  aTypedArray: aTypedArray,
487  aTypedArrayConstructor: aTypedArrayConstructor,
488  exportTypedArrayMethod: exportTypedArrayMethod,
489  exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
490  getTypedArrayConstructor: getTypedArrayConstructor,
491  isView: isView,
492  isTypedArray: isTypedArray,
493  TypedArray: TypedArray,
494  TypedArrayPrototype: TypedArrayPrototype
495};
496
497
498/***/ },
499
500/***/ 9617
501(module, __unused_webpack_exports, __webpack_require__) {
502
503
504var toIndexedObject = __webpack_require__(5397);
505var toAbsoluteIndex = __webpack_require__(5610);
506var lengthOfArrayLike = __webpack_require__(6198);
507
508// `Array.prototype.{ indexOf, includes }` methods implementation
509var createMethod = function (IS_INCLUDES) {
510  return function ($this, el, fromIndex) {
511    var O = toIndexedObject($this);
512    var length = lengthOfArrayLike(O);
513    if (length === 0) return !IS_INCLUDES && -1;
514    var index = toAbsoluteIndex(fromIndex, length);
515    var value;
516    // Array#includes uses SameValueZero equality algorithm
517    // eslint-disable-next-line no-self-compare -- NaN check
518    if (IS_INCLUDES && el !== el) while (length > index) {
519      value = O[index++];
520      // eslint-disable-next-line no-self-compare -- NaN check
521      if (value !== value) return true;
522    // Array#indexOf ignores holes, Array#includes - not
523    } else for (;length > index; index++) {

524      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
525    } return !IS_INCLUDES && -1;
526  };
527};
528
529module.exports = {
530  // `Array.prototype.includes` method
531  // https://tc39.es/ecma262/#sec-array.prototype.includes
532  includes: createMethod(true),
533  // `Array.prototype.indexOf` method
534  // https://tc39.es/ecma262/#sec-array.prototype.indexof
535  indexOf: createMethod(false)
536};
537
538
539/***/ },
540
541/***/ 4527
542(module, __unused_webpack_exports, __webpack_require__) {
543
544
545var DESCRIPTORS = __webpack_require__(3724);
546var isArray = __webpack_require__(4376);
547
548var $TypeError = TypeError;
549// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
550var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
551
552// Safari < 13 does not throw an error in this case
553var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
554  // makes no sense without proper strict mode support
555  if (this !== undefined) return true;
556  try {
557    // eslint-disable-next-line es/no-object-defineproperty -- safe
558    Object.defineProperty([], 'length', { writable: false }).length = 1;
559  } catch (error) {
560    return error instanceof TypeError;
561  }
562}();
563
564module.exports = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
565  if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
566    throw new $TypeError('Cannot set read only .length');
567  } return O.length = length;
568} : function (O, length) {
569  return O.length = length;
570};
571
572
573/***/ },
574
575/***/ 7680
576(module, __unused_webpack_exports, __webpack_require__) {
577
578
579var uncurryThis = __webpack_require__(9504);
580
581module.exports = uncurryThis([].slice);
582
583
584/***/ },
585
586/***/ 6319
587(module, __unused_webpack_exports, __webpack_require__) {
588
589
590var anObject = __webpack_require__(8551);
591var iteratorClose = __webpack_require__(9539);
592
593// call something on iterator step with safe closing on error
594module.exports = function (iterator, fn, value, ENTRIES) {
595  try {
596    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
597  } catch (error) {
598    iteratorClose(iterator, 'throw', error);
599  }
600};
601
602
603/***/ },
604
605/***/ 2195
606(module, __unused_webpack_exports, __webpack_require__) {
607
608
609var uncurryThis = __webpack_require__(9504);
610
611var toString = uncurryThis({}.toString);
612var stringSlice = uncurryThis(''.slice);
613
614module.exports = function (it) {
615  return stringSlice(toString(it), 8, -1);
616};
617
618
619/***/ },
620
621/***/ 6955
622(module, __unused_webpack_exports, __webpack_require__) {
623
624
625var TO_STRING_TAG_SUPPORT = __webpack_require__(2140);
626var isCallable = __webpack_require__(4901);
627var classofRaw = __webpack_require__(2195);
628var wellKnownSymbol = __webpack_require__(8227);
629
630var TO_STRING_TAG = wellKnownSymbol('toStringTag');
631var $Object = Object;
632
633// ES3 wrong here
634var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
635
636// fallback for IE11 Script Access Denied error
637var tryGet = function (it, key) {
638  try {
639    return it[key];
640  } catch (error) { /* empty */ }
641};
642
643// getting tag from ES6+ `Object.prototype.toString`
644module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
645  var O, tag, result;
646  return it === undefined ? 'Undefined' : it === null ? 'Null'
647    // @@toStringTag case
648    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
649    // builtinTag case
650    : CORRECT_ARGUMENTS ? classofRaw(O)
651    // ES3 arguments fallback
652    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
653};
654
655
656/***/ },
657
658/***/ 7740
659(module, __unused_webpack_exports, __webpack_require__) {
660
661
662var hasOwn = __webpack_require__(9297);
663var ownKeys = __webpack_require__(5031);
664var getOwnPropertyDescriptorModule = __webpack_require__(7347);
665var definePropertyModule = __webpack_require__(4913);
666
667module.exports = function (target, source, exceptions) {
668  var keys = ownKeys(source);
669  var defineProperty = definePropertyModule.f;
670  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
671  for (var i = 0; i < keys.length; i++) {
672    var key = keys[i];
673    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
674      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
675    }
676  }
677};
678
679
680/***/ },
681
682/***/ 2211
683(module, __unused_webpack_exports, __webpack_require__) {
684
685
686var fails = __webpack_require__(9039);
687
688module.exports = !fails(function () {
689  function F() { /* empty */ }
690  F.prototype.constructor = null;
691  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
692  return Object.getPrototypeOf(new F()) !== F.prototype;
693});
694
695
696/***/ },
697
698/***/ 2529
699(module) {
700
701
702// `CreateIterResultObject` abstract operation
703// https://tc39.es/ecma262/#sec-createiterresultobject
704module.exports = function (value, done) {
705  return { value: value, done: done };
706};
707
708
709/***/ },
710
711/***/ 6699
712(module, __unused_webpack_exports, __webpack_require__) {
713
714
715var DESCRIPTORS = __webpack_require__(3724);
716var definePropertyModule = __webpack_require__(4913);
717var createPropertyDescriptor = __webpack_require__(6980);
718
719module.exports = DESCRIPTORS ? function (object, key, value) {
720  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
721} : function (object, key, value) {
722  object[key] = value;
723  return object;
724};
725
726
727/***/ },
728
729/***/ 6980
730(module) {
731
732
733module.exports = function (bitmap, value) {
734  return {
735    enumerable: !(bitmap & 1),
736    configurable: !(bitmap & 2),
737    writable: !(bitmap & 4),
738    value: value
739  };
740};
741
742
743/***/ },
744
745/***/ 4659
746(module, __unused_webpack_exports, __webpack_require__) {
747
748
749var DESCRIPTORS = __webpack_require__(3724);
750var definePropertyModule = __webpack_require__(4913);
751var createPropertyDescriptor = __webpack_require__(6980);
752
753module.exports = function (object, key, value) {
754  if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
755  else object[key] = value;
756};
757
758
759/***/ },
760
761/***/ 2106
762(module, __unused_webpack_exports, __webpack_require__) {
763
764
765var makeBuiltIn = __webpack_require__(283);
766var defineProperty = __webpack_require__(4913);
767
768module.exports = function (target, name, descriptor) {
769  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
770  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
771  return defineProperty.f(target, name, descriptor);
772};
773
774
775/***/ },
776
777/***/ 6840
778(module, __unused_webpack_exports, __webpack_require__) {
779
780
781var isCallable = __webpack_require__(4901);
782var definePropertyModule = __webpack_require__(4913);
783var makeBuiltIn = __webpack_require__(283);
784var defineGlobalProperty = __webpack_require__(9433);
785
786module.exports = function (O, key, value, options) {
787  if (!options) options = {};
788  var simple = options.enumerable;
789  var name = options.name !== undefined ? options.name : key;
790  if (isCallable(value)) makeBuiltIn(value, name, options);
791  if (options.global) {
792    if (simple) O[key] = value;
793    else defineGlobalProperty(key, value);
794  } else {
795    try {
796      if (!options.unsafe) delete O[key];
797      else if (O[key]) simple = true;
798    } catch (error) { /* empty */ }
799    if (simple) O[key] = value;
800    else definePropertyModule.f(O, key, {
801      value: value,
802      enumerable: false,
803      configurable: !options.nonConfigurable,
804      writable: !options.nonWritable
805    });
806  } return O;
807};
808
809
810/***/ },
811
812/***/ 6279
813(module, __unused_webpack_exports, __webpack_require__) {
814
815
816var defineBuiltIn = __webpack_require__(6840);
817
818module.exports = function (target, src, options) {
819  for (var key in src) defineBuiltIn(target, key, src[key], options);
820  return target;
821};
822
823
824/***/ },
825
826/***/ 9433
827(module, __unused_webpack_exports, __webpack_require__) {
828
829
830var globalThis = __webpack_require__(4576);
831
832// eslint-disable-next-line es/no-object-defineproperty -- safe
833var defineProperty = Object.defineProperty;
834
835module.exports = function (key, value) {
836  try {
837    defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
838  } catch (error) {
839    globalThis[key] = value;
840  } return value;
841};
842
843
844/***/ },
845
846/***/ 3724
847(module, __unused_webpack_exports, __webpack_require__) {
848
849
850var fails = __webpack_require__(9039);
851
852// Detect IE8's incomplete defineProperty implementation
853module.exports = !fails(function () {
854  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
855  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
856});
857
858
859/***/ },
860
861/***/ 4483
862(module, __unused_webpack_exports, __webpack_require__) {
863
864
865var globalThis = __webpack_require__(4576);
866var getBuiltInNodeModule = __webpack_require__(9429);
867var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(1548);
868
869var structuredClone = globalThis.structuredClone;
870var $ArrayBuffer = globalThis.ArrayBuffer;
871var $MessageChannel = globalThis.MessageChannel;
872var detach = false;

873var WorkerThreads, channel, buffer, $detach;
874
875if (PROPER_STRUCTURED_CLONE_TRANSFER) {
876  detach = function (transferable) {
877    structuredClone(transferable, { transfer: [transferable] });
878  };
879} else if ($ArrayBuffer) try {
880  if (!$MessageChannel) {
881    WorkerThreads = getBuiltInNodeModule('worker_threads');
882    if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel;
883  }
884
885  if ($MessageChannel) {
886    channel = new $MessageChannel();
887    buffer = new $ArrayBuffer(2);
888
889    $detach = function (transferable) {
890      channel.port1.postMessage(null, [transferable]);
891    };
892
893    if (buffer.byteLength === 2) {
894      $detach(buffer);
895      if (buffer.byteLength === 0) detach = $detach;
896    }
897  }
898} catch (error) { /* empty */ }
899
900module.exports = detach;
901
902
903/***/ },
904
905/***/ 4055
906(module, __unused_webpack_exports, __webpack_require__) {
907
908
909var globalThis = __webpack_require__(4576);
910var isObject = __webpack_require__(34);
911
912var document = globalThis.document;
913// typeof document.createElement is 'object' in old IE
914var EXISTS = isObject(document) && isObject(document.createElement);
915
916module.exports = function (it) {
917  return EXISTS ? document.createElement(it) : {};
918};
919
920
921/***/ },
922
923/***/ 6837
924(module) {
925
926
927var $TypeError = TypeError;
928var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
929
930module.exports = function (it) {
931  if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
932  return it;
933};
934
935
936/***/ },
937
938/***/ 8727
939(module) {
940
941
942// IE8- don't enum bug keys
943module.exports = [
944  'constructor',
945  'hasOwnProperty',
946  'isPrototypeOf',
947  'propertyIsEnumerable',
948  'toLocaleString',
949  'toString',
950  'valueOf'
951];
952
953
954/***/ },
955
956/***/ 6193
957(module, __unused_webpack_exports, __webpack_require__) {
958
959
960var ENVIRONMENT = __webpack_require__(4215);
961
962module.exports = ENVIRONMENT === 'NODE';
963
964
965/***/ },
966
967/***/ 2839
968(module, __unused_webpack_exports, __webpack_require__) {
969
970
971var globalThis = __webpack_require__(4576);
972
973var navigator = globalThis.navigator;
974var userAgent = navigator && navigator.userAgent;
975
976module.exports = userAgent ? String(userAgent) : '';
977
978
979/***/ },
980
981/***/ 9519
982(module, __unused_webpack_exports, __webpack_require__) {
983
984
985var globalThis = __webpack_require__(4576);
986var userAgent = __webpack_require__(2839);
987
988var process = globalThis.process;
989var Deno = globalThis.Deno;
990var versions = process && process.versions || Deno && Deno.version;
991var v8 = versions && versions.v8;
992var match, version;
993
994if (v8) {
995  match = v8.split('.');
996  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
997  // but their correct versions are not interesting for us
998  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
999}
1000
1001// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
1002// so check `userAgent` even if `.v8` exists, but 0
1003if (!version && userAgent) {
1004  match = userAgent.match(/Edge\/(\d+)/);
1005  if (!match || match[1] >= 74) {
1006    match = userAgent.match(/Chrome\/(\d+)/);
1007    if (match) version = +match[1];
1008  }
1009}
1010
1011module.exports = version;
1012
1013
1014/***/ },
1015
1016/***/ 4215
1017(module, __unused_webpack_exports, __webpack_require__) {
1018
1019
1020/* global Bun, Deno -- detection */
1021var globalThis = __webpack_require__(4576);
1022var userAgent = __webpack_require__(2839);
1023var classof = __webpack_require__(2195);
1024
1025var userAgentStartsWith = function (string) {
1026  return userAgent.slice(0, string.length) === string;
1027};
1028
1029module.exports = (function () {
1030  if (userAgentStartsWith('Bun/')) return 'BUN';
1031  if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE';
1032  if (userAgentStartsWith('Deno/')) return 'DENO';
1033  if (userAgentStartsWith('Node.js/')) return 'NODE';
1034  if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN';
1035  if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO';
1036  if (classof(globalThis.process) === 'process') return 'NODE';
1037  if (globalThis.window && globalThis.document) return 'BROWSER';
1038  return 'REST';
1039})();
1040
1041
1042/***/ },
1043
1044/***/ 6518
1045(module, __unused_webpack_exports, __webpack_require__) {
1046
1047
1048var globalThis = __webpack_require__(4576);
1049var getOwnPropertyDescriptor = (__webpack_require__(7347).f);
1050var createNonEnumerableProperty = __webpack_require__(6699);
1051var defineBuiltIn = __webpack_require__(6840);
1052var defineGlobalProperty = __webpack_require__(9433);
1053var copyConstructorProperties = __webpack_require__(7740);
1054var isForced = __webpack_require__(2796);
1055
1056/*
1057  options.target         - name of the target object
1058  options.global         - target is the global object
1059  options.stat           - export as static methods of target
1060  options.proto          - export as prototype methods of target
1061  options.real           - real prototype method for the `pure` version
1062  options.forced         - export even if the native feature is available

1063  options.bind           - bind methods to the target, required for the `pure` version
1064  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
1065  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
1066  options.sham           - add a flag to not completely full polyfills
1067  options.enumerable     - export as enumerable property
1068  options.dontCallGetSet - prevent calling a getter on target
1069  options.name           - the .name of the function if it does not match the key
1070*/
1071module.exports = function (options, source) {
1072  var TARGET = options.target;
1073  var GLOBAL = options.global;
1074  var STATIC = options.stat;
1075  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
1076  if (GLOBAL) {
1077    target = globalThis;
1078  } else if (STATIC) {
1079    target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
1080  } else {
1081    target = globalThis[TARGET] && globalThis[TARGET].prototype;
1082  }
1083  if (target) for (key in source) {
1084    sourceProperty = source[key];
1085    if (options.dontCallGetSet) {
1086      descriptor = getOwnPropertyDescriptor(target, key);
1087      targetProperty = descriptor && descriptor.value;
1088    } else targetProperty = target[key];
1089    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
1090    // contained in target
1091    if (!FORCED && targetProperty !== undefined) {
1092      if (typeof sourceProperty == typeof targetProperty) continue;
1093      copyConstructorProperties(sourceProperty, targetProperty);
1094    }
1095    // add a flag to not completely full polyfills
1096    if (options.sham || (targetProperty && targetProperty.sham)) {
1097      createNonEnumerableProperty(sourceProperty, 'sham', true);
1098    }
1099    defineBuiltIn(target, key, sourceProperty, options);
1100  }
1101};
1102
1103
1104/***/ },
1105
1106/***/ 9039
1107(module) {
1108
1109
1110module.exports = function (exec) {
1111  try {
1112    return !!exec();
1113  } catch (error) {
1114    return true;
1115  }
1116};
1117
1118
1119/***/ },
1120
1121/***/ 8745
1122(module, __unused_webpack_exports, __webpack_require__) {
1123
1124
1125var NATIVE_BIND = __webpack_require__(616);
1126
1127var FunctionPrototype = Function.prototype;
1128var apply = FunctionPrototype.apply;
1129var call = FunctionPrototype.call;
1130
1131// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
1132module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
1133  return call.apply(apply, arguments);
1134});
1135
1136
1137/***/ },
1138
1139/***/ 6080
1140(module, __unused_webpack_exports, __webpack_require__) {
1141
1142
1143var uncurryThis = __webpack_require__(7476);
1144var aCallable = __webpack_require__(9306);
1145var NATIVE_BIND = __webpack_require__(616);
1146
1147var bind = uncurryThis(uncurryThis.bind);
1148
1149// optional / simple context binding
1150module.exports = function (fn, that) {
1151  aCallable(fn);
1152  return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
1153    return fn.apply(that, arguments);
1154  };
1155};
1156
1157
1158/***/ },
1159
1160/***/ 616
1161(module, __unused_webpack_exports, __webpack_require__) {
1162
1163
1164var fails = __webpack_require__(9039);
1165
1166module.exports = !fails(function () {
1167  // eslint-disable-next-line es/no-function-prototype-bind -- safe
1168  var test = (function () { /* empty */ }).bind();
1169  // eslint-disable-next-line no-prototype-builtins -- safe
1170  return typeof test != 'function' || test.hasOwnProperty('prototype');
1171});
1172
1173
1174/***/ },
1175
1176/***/ 9565
1177(module, __unused_webpack_exports, __webpack_require__) {
1178
1179
1180var NATIVE_BIND = __webpack_require__(616);
1181
1182var call = Function.prototype.call;
1183// eslint-disable-next-line es/no-function-prototype-bind -- safe
1184module.exports = NATIVE_BIND ? call.bind(call) : function () {
1185  return call.apply(call, arguments);
1186};
1187
1188
1189/***/ },
1190
1191/***/ 350
1192(module, __unused_webpack_exports, __webpack_require__) {
1193
1194
1195var DESCRIPTORS = __webpack_require__(3724);
1196var hasOwn = __webpack_require__(9297);
1197
1198var FunctionPrototype = Function.prototype;
1199// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1200var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
1201
1202var EXISTS = hasOwn(FunctionPrototype, 'name');
1203// additional protection from minified / mangled / dropped function names
1204var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
1205var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
1206
1207module.exports = {
1208  EXISTS: EXISTS,
1209  PROPER: PROPER,
1210  CONFIGURABLE: CONFIGURABLE
1211};
1212
1213
1214/***/ },
1215
1216/***/ 6706
1217(module, __unused_webpack_exports, __webpack_require__) {
1218
1219
1220var uncurryThis = __webpack_require__(9504);
1221var aCallable = __webpack_require__(9306);
1222
1223module.exports = function (object, key, method) {
1224  try {
1225    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1226    return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
1227  } catch (error) { /* empty */ }
1228};
1229
1230
1231/***/ },
1232
1233/***/ 7476
1234(module, __unused_webpack_exports, __webpack_require__) {
1235
1236
1237var classofRaw = __webpack_require__(2195);
1238var uncurryThis = __webpack_require__(9504);
1239
1240module.exports = function (fn) {
1241  // Nashorn bug:
1242  //   https://github.com/zloirock/core-js/issues/1128
1243  //   https://github.com/zloirock/core-js/issues/1130
1244  if (classofRaw(fn) === 'Function') return uncurryThis(fn);
1245};
1246
1247
1248/***/ },
1249
1250/***/ 9504
1251(module, __unused_webpack_exports, __webpack_require__) {
1252
1253
1254var NATIVE_BIND = __webpack_require__(616);
1255
1256var FunctionPrototype = Function.prototype;
1257var call = FunctionPrototype.call;
1258// eslint-disable-next-line es/no-function-prototype-bind -- safe
1259var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
1260
1261module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
1262  return function () {
1263    return call.apply(fn, arguments);
1264  };
1265};
1266
1267
1268/***/ },
1269
1270/***/ 9429
1271(module, __unused_webpack_exports, __webpack_require__) {
1272
1273
1274var globalThis = __webpack_require__(4576);
1275var IS_NODE = __webpack_require__(6193);
1276
1277module.exports = function (name) {
1278  if (IS_NODE) {
1279    try {
1280      return globalThis.process.getBuiltinModule(name);
1281    } catch (error) { /* empty */ }
1282    try {
1283      // eslint-disable-next-line no-new-func -- safe
1284      return Function('return require("' + name + '")')();
1285    } catch (error) { /* empty */ }
1286  }
1287};
1288
1289
1290/***/ },
1291
1292/***/ 7751
1293(module, __unused_webpack_exports, __webpack_require__) {
1294
1295
1296var globalThis = __webpack_require__(4576);
1297var isCallable = __webpack_require__(4901);
1298
1299var aFunction = function (argument) {
1300  return isCallable(argument) ? argument : undefined;
1301};
1302
1303module.exports = function (namespace, method) {
1304  return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
1305};
1306
1307
1308/***/ },
1309
1310/***/ 1767
1311(module) {
1312
1313
1314// `GetIteratorDirect(obj)` abstract operation
1315// https://tc39.es/ecma262/#sec-getiteratordirect
1316module.exports = function (obj) {
1317  return {
1318    iterator: obj,
1319    next: obj.next,
1320    done: false
1321  };
1322};
1323
1324
1325/***/ },
1326
1327/***/ 851
1328(module, __unused_webpack_exports, __webpack_require__) {
1329
1330
1331var classof = __webpack_require__(6955);
1332var getMethod = __webpack_require__(5966);
1333var isNullOrUndefined = __webpack_require__(4117);
1334var Iterators = __webpack_require__(6269);
1335var wellKnownSymbol = __webpack_require__(8227);
1336
1337var ITERATOR = wellKnownSymbol('iterator');
1338
1339module.exports = function (it) {
1340  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
1341    || getMethod(it, '@@iterator')
1342    || Iterators[classof(it)];
1343};
1344
1345
1346/***/ },
1347
1348/***/ 81
1349(module, __unused_webpack_exports, __webpack_require__) {
1350
1351
1352var call = __webpack_require__(9565);
1353var aCallable = __webpack_require__(9306);
1354var anObject = __webpack_require__(8551);
1355var tryToString = __webpack_require__(6823);
1356var getIteratorMethod = __webpack_require__(851);
1357
1358var $TypeError = TypeError;
1359
1360module.exports = function (argument, usingIterator) {
1361  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
1362  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
1363  throw new $TypeError(tryToString(argument) + ' is not iterable');
1364};
1365
1366
1367/***/ },
1368
1369/***/ 5966
1370(module, __unused_webpack_exports, __webpack_require__) {
1371
1372
1373var aCallable = __webpack_require__(9306);
1374var isNullOrUndefined = __webpack_require__(4117);
1375
1376// `GetMethod` abstract operation
1377// https://tc39.es/ecma262/#sec-getmethod
1378module.exports = function (V, P) {
1379  var func = V[P];
1380  return isNullOrUndefined(func) ? undefined : aCallable(func);
1381};
1382
1383
1384/***/ },
1385
1386/***/ 3789
1387(module, __unused_webpack_exports, __webpack_require__) {
1388
1389
1390var aCallable = __webpack_require__(9306);
1391var anObject = __webpack_require__(8551);
1392var call = __webpack_require__(9565);
1393var toIntegerOrInfinity = __webpack_require__(1291);
1394var getIteratorDirect = __webpack_require__(1767);
1395
1396var INVALID_SIZE = 'Invalid size';
1397var $RangeError = RangeError;
1398var $TypeError = TypeError;
1399var max = Math.max;
1400
1401var SetRecord = function (set, intSize) {
1402  this.set = set;
1403  this.size = max(intSize, 0);
1404  this.has = aCallable(set.has);
1405  this.keys = aCallable(set.keys);
1406};
1407
1408SetRecord.prototype = {
1409  getIterator: function () {
1410    return getIteratorDirect(anObject(call(this.keys, this.set)));
1411  },
1412  includes: function (it) {
1413    return call(this.has, this.set, it);
1414  }
1415};
1416
1417// `GetSetRecord` abstract operation
1418// https://tc39.es/proposal-set-methods/#sec-getsetrecord
1419module.exports = function (obj) {
1420  anObject(obj);
1421  var numSize = +obj.size;
1422  // NOTE: If size is undefined, then numSize will be NaN
1423  // eslint-disable-next-line no-self-compare -- NaN check
1424  if (numSize !== numSize) throw new $TypeError(INVALID_SIZE);
1425  var intSize = toIntegerOrInfinity(numSize);
1426  if (intSize < 0) throw new $RangeError(INVALID_SIZE);
1427  return new SetRecord(obj, intSize);
1428};
1429
1430
1431/***/ },
1432
1433/***/ 4576
1434(module) {
1435
1436
1437var check = function (it) {
1438  return it && it.Math === Math && it;
1439};
1440
1441// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
1442module.exports =
1443  // eslint-disable-next-line es/no-global-this -- safe
1444  check(typeof globalThis == 'object' && globalThis) ||
1445  check(typeof window == 'object' && window) ||
1446  // eslint-disable-next-line no-restricted-globals -- safe
1447  check(typeof self == 'object' && self) ||
1448  check(typeof global == 'object' && global) ||
1449  check(typeof this == 'object' && this) ||
1450  // eslint-disable-next-line no-new-func -- fallback
1451  (function () { return this; })() || Function('return this')();
1452
1453
1454/***/ },
1455
1456/***/ 9297
1457(module, __unused_webpack_exports, __webpack_require__) {
1458
1459
1460var uncurryThis = __webpack_require__(9504);
1461var toObject = __webpack_require__(8981);
1462
1463var hasOwnProperty = uncurryThis({}.hasOwnProperty);
1464
1465// `HasOwnProperty` abstract operation
1466// https://tc39.es/ecma262/#sec-hasownproperty
1467// eslint-disable-next-line es/no-object-hasown -- safe
1468module.exports = Object.hasOwn || function hasOwn(it, key) {
1469  return hasOwnProperty(toObject(it), key);
1470};
1471
1472
1473/***/ },
1474
1475/***/ 421
1476(module) {
1477
1478
1479module.exports = {};
1480
1481
1482/***/ },
1483
1484/***/ 397
1485(module, __unused_webpack_exports, __webpack_require__) {
1486
1487
1488var getBuiltIn = __webpack_require__(7751);
1489
1490module.exports = getBuiltIn('document', 'documentElement');
1491
1492
1493/***/ },
1494
1495/***/ 5917
1496(module, __unused_webpack_exports, __webpack_require__) {
1497
1498
1499var DESCRIPTORS = __webpack_require__(3724);
1500var fails = __webpack_require__(9039);
1501var createElement = __webpack_require__(4055);
1502
1503// Thanks to IE8 for its funny defineProperty
1504module.exports = !DESCRIPTORS && !fails(function () {
1505  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
1506  return Object.defineProperty(createElement('div'), 'a', {
1507    get: function () { return 7; }
1508  }).a !== 7;
1509});
1510
1511
1512/***/ },
1513
1514/***/ 7055
1515(module, __unused_webpack_exports, __webpack_require__) {
1516
1517
1518var uncurryThis = __webpack_require__(9504);
1519var fails = __webpack_require__(9039);
1520var classof = __webpack_require__(2195);
1521
1522var $Object = Object;
1523var split = uncurryThis(''.split);
1524
1525// fallback for non-array-like ES3 and non-enumerable old V8 strings
1526module.exports = fails(function () {
1527  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
1528  // eslint-disable-next-line no-prototype-builtins -- safe
1529  return !$Object('z').propertyIsEnumerable(0);
1530}) ? function (it) {
1531  return classof(it) === 'String' ? split(it, '') : $Object(it);
1532} : $Object;
1533
1534
1535/***/ },
1536
1537/***/ 3706
1538(module, __unused_webpack_exports, __webpack_require__) {
1539
1540
1541var uncurryThis = __webpack_require__(9504);
1542var isCallable = __webpack_require__(4901);
1543var store = __webpack_require__(7629);
1544
1545var functionToString = uncurryThis(Function.toString);
1546
1547// this helper broken in `[email protected]`, so we can't use `shared` helper
1548if (!isCallable(store.inspectSource)) {
1549  store.inspectSource = function (it) {
1550    return functionToString(it);
1551  };
1552}
1553
1554module.exports = store.inspectSource;
1555
1556
1557/***/ },
1558
1559/***/ 1181
1560(module, __unused_webpack_exports, __webpack_require__) {
1561
1562
1563var NATIVE_WEAK_MAP = __webpack_require__(8622);
1564var globalThis = __webpack_require__(4576);
1565var isObject = __webpack_require__(34);
1566var createNonEnumerableProperty = __webpack_require__(6699);
1567var hasOwn = __webpack_require__(9297);
1568var shared = __webpack_require__(7629);
1569var sharedKey = __webpack_require__(6119);
1570var hiddenKeys = __webpack_require__(421);
1571
1572var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
1573var TypeError = globalThis.TypeError;
1574var WeakMap = globalThis.WeakMap;
1575var set, get, has;
1576
1577var enforce = function (it) {
1578  return has(it) ? get(it) : set(it, {});
1579};
1580
1581var getterFor = function (TYPE) {
1582  return function (it) {
1583    var state;
1584    if (!isObject(it) || (state = get(it)).type !== TYPE) {
1585      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
1586    } return state;
1587  };
1588};
1589
1590if (NATIVE_WEAK_MAP || shared.state) {
1591  var store = shared.state || (shared.state = new WeakMap());
1592  /* eslint-disable no-self-assign -- prototype methods protection */
1593  store.get = store.get;
1594  store.has = store.has;
1595  store.set = store.set;
1596  /* eslint-enable no-self-assign -- prototype methods protection */
1597  set = function (it, metadata) {
1598    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
1599    metadata.facade = it;
1600    store.set(it, metadata);
1601    return metadata;
1602  };
1603  get = function (it) {
1604    return store.get(it) || {};
1605  };
1606  has = function (it) {
1607    return store.has(it);
1608  };
1609} else {
1610  var STATE = sharedKey('state');
1611  hiddenKeys[STATE] = true;
1612  set = function (it, metadata) {
1613    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
1614    metadata.facade = it;
1615    createNonEnumerableProperty(it, STATE, metadata);
1616    return metadata;
1617  };
1618  get = function (it) {
1619    return hasOwn(it, STATE) ? it[STATE] : {};
1620  };
1621  has = function (it) {
1622    return hasOwn(it, STATE);
1623  };
1624}
1625
1626module.exports = {
1627  set: set,
1628  get: get,
1629  has: has,
1630  enforce: enforce,
1631  getterFor: getterFor
1632};
1633
1634
1635/***/ },
1636
1637/***/ 4209
1638(module, __unused_webpack_exports, __webpack_require__) {
1639
1640
1641var wellKnownSymbol = __webpack_require__(8227);
1642var Iterators = __webpack_require__(6269);
1643
1644var ITERATOR = wellKnownSymbol('iterator');
1645var ArrayPrototype = Array.prototype;
1646
1647// check on default Array iterator
1648module.exports = function (it) {
1649  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
1650};
1651
1652
1653/***/ },
1654
1655/***/ 4376
1656(module, __unused_webpack_exports, __webpack_require__) {
1657
1658
1659var classof = __webpack_require__(2195);
1660
1661// `IsArray` abstract operation
1662// https://tc39.es/ecma262/#sec-isarray
1663// eslint-disable-next-line es/no-array-isarray -- safe
1664module.exports = Array.isArray || function isArray(argument) {
1665  return classof(argument) === 'Array';
1666};
1667
1668
1669/***/ },
1670
1671/***/ 1108
1672(module, __unused_webpack_exports, __webpack_require__) {
1673
1674
1675var classof = __webpack_require__(6955);
1676
1677module.exports = function (it) {
1678  var klass = classof(it);
1679  return klass === 'BigInt64Array' || klass === 'BigUint64Array';
1680};
1681
1682
1683/***/ },
1684
1685/***/ 4901
1686(module) {
1687
1688

1689// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
1690var documentAll = typeof document == 'object' && document.all;
1691
1692// `IsCallable` abstract operation
1693// https://tc39.es/ecma262/#sec-iscallable
1694// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
1695module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
1696  return typeof argument == 'function' || argument === documentAll;
1697} : function (argument) {
1698  return typeof argument == 'function';
1699};
1700
1701
1702/***/ },
1703
1704/***/ 2796
1705(module, __unused_webpack_exports, __webpack_require__) {
1706
1707
1708var fails = __webpack_require__(9039);
1709var isCallable = __webpack_require__(4901);
1710
1711var replacement = /#|\.prototype\./;
1712
1713var isForced = function (feature, detection) {
1714  var value = data[normalize(feature)];
1715  return value === POLYFILL ? true
1716    : value === NATIVE ? false
1717    : isCallable(detection) ? fails(detection)
1718    : !!detection;
1719};
1720
1721var normalize = isForced.normalize = function (string) {
1722  return String(string).replace(replacement, '.').toLowerCase();
1723};
1724
1725var data = isForced.data = {};
1726var NATIVE = isForced.NATIVE = 'N';
1727var POLYFILL = isForced.POLYFILL = 'P';
1728
1729module.exports = isForced;
1730
1731
1732/***/ },
1733
1734/***/ 4117
1735(module) {
1736
1737
1738// we can't use just `it == null` since of `document.all` special case
1739// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
1740module.exports = function (it) {
1741  return it === null || it === undefined;
1742};
1743
1744
1745/***/ },
1746
1747/***/ 34
1748(module, __unused_webpack_exports, __webpack_require__) {
1749
1750
1751var isCallable = __webpack_require__(4901);
1752
1753module.exports = function (it) {
1754  return typeof it == 'object' ? it !== null : isCallable(it);
1755};
1756
1757
1758/***/ },
1759
1760/***/ 3925
1761(module, __unused_webpack_exports, __webpack_require__) {
1762
1763
1764var isObject = __webpack_require__(34);
1765
1766module.exports = function (argument) {
1767  return isObject(argument) || argument === null;
1768};
1769
1770
1771/***/ },
1772
1773/***/ 6395
1774(module) {
1775
1776
1777module.exports = false;
1778
1779
1780/***/ },
1781
1782/***/ 5810
1783(module, __unused_webpack_exports, __webpack_require__) {
1784
1785
1786var isObject = __webpack_require__(34);
1787var getInternalState = (__webpack_require__(1181).get);
1788
1789module.exports = function isRawJSON(O) {
1790  if (!isObject(O)) return false;
1791  var state = getInternalState(O);
1792  return !!state && state.type === 'RawJSON';
1793};
1794
1795
1796/***/ },
1797
1798/***/ 757
1799(module, __unused_webpack_exports, __webpack_require__) {
1800
1801
1802var getBuiltIn = __webpack_require__(7751);
1803var isCallable = __webpack_require__(4901);
1804var isPrototypeOf = __webpack_require__(1625);
1805var USE_SYMBOL_AS_UID = __webpack_require__(7040);
1806
1807var $Object = Object;
1808
1809module.exports = USE_SYMBOL_AS_UID ? function (it) {
1810  return typeof it == 'symbol';
1811} : function (it) {
1812  var $Symbol = getBuiltIn('Symbol');
1813  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
1814};
1815
1816
1817/***/ },
1818
1819/***/ 507
1820(module, __unused_webpack_exports, __webpack_require__) {
1821
1822
1823var call = __webpack_require__(9565);
1824
1825module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
1826  var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
1827  var next = record.next;
1828  var step, result;
1829  while (!(step = call(next, iterator)).done) {
1830    result = fn(step.value);
1831    if (result !== undefined) return result;
1832  }
1833};
1834
1835
1836/***/ },
1837
1838/***/ 2652
1839(module, __unused_webpack_exports, __webpack_require__) {
1840
1841
1842var bind = __webpack_require__(6080);
1843var call = __webpack_require__(9565);
1844var anObject = __webpack_require__(8551);
1845var tryToString = __webpack_require__(6823);
1846var isArrayIteratorMethod = __webpack_require__(4209);
1847var lengthOfArrayLike = __webpack_require__(6198);
1848var isPrototypeOf = __webpack_require__(1625);
1849var getIterator = __webpack_require__(81);
1850var getIteratorMethod = __webpack_require__(851);
1851var iteratorClose = __webpack_require__(9539);
1852
1853var $TypeError = TypeError;
1854
1855var Result = function (stopped, result) {
1856  this.stopped = stopped;
1857  this.result = result;
1858};
1859
1860var ResultPrototype = Result.prototype;
1861
1862module.exports = function (iterable, unboundFunction, options) {
1863  var that = options && options.that;
1864  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
1865  var IS_RECORD = !!(options && options.IS_RECORD);
1866  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
1867  var INTERRUPTED = !!(options && options.INTERRUPTED);
1868  var fn = bind(unboundFunction, that);
1869  var iterator, iterFn, index, length, result, next, step;
1870
1871  var stop = function (condition) {
1872    if (iterator) iteratorClose(iterator, 'normal');
1873    return new Result(true, condition);
1874  };
1875
1876  var callFn = function (value) {
1877    if (AS_ENTRIES) {
1878      anObject(value);
1879      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
1880    }

1880 return INTERRUPTED ? fn(value, stop) : fn(value);
1881  };
1882
1883  if (IS_RECORD) {
1884    iterator = iterable.iterator;
1885  } else if (IS_ITERATOR) {
1886    iterator = iterable;
1887  } else {
1888    iterFn = getIteratorMethod(iterable);
1889    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
1890    // optimisation for array iterators
1891    if (isArrayIteratorMethod(iterFn)) {
1892      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
1893        result = callFn(iterable[index]);
1894        if (result && isPrototypeOf(ResultPrototype, result)) return result;
1895      } return new Result(false);
1896    }
1897    iterator = getIterator(iterable, iterFn);
1898  }
1899
1900  next = IS_RECORD ? iterable.next : iterator.next;
1901  while (!(step = call(next, iterator)).done) {
1902    try {
1903      result = callFn(step.value);
1904    } catch (error) {
1905      iteratorClose(iterator, 'throw', error);
1906    }
1907    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
1908  } return new Result(false);
1909};
1910
1911
1912/***/ },
1913
1914/***/ 1385
1915(module, __unused_webpack_exports, __webpack_require__) {
1916
1917
1918var iteratorClose = __webpack_require__(9539);
1919
1920module.exports = function (iters, kind, value) {
1921  for (var i = iters.length - 1; i >= 0; i--) {
1922    if (iters[i] === undefined) continue;
1923    try {
1924      value = iteratorClose(iters[i].iterator, kind, value);
1925    } catch (error) {
1926      kind = 'throw';
1927      value = error;
1928    }
1929  }
1930  if (kind === 'throw') throw value;
1931  return value;
1932};
1933
1934
1935/***/ },
1936
1937/***/ 9539
1938(module, __unused_webpack_exports, __webpack_require__) {
1939
1940
1941var call = __webpack_require__(9565);
1942var anObject = __webpack_require__(8551);
1943var getMethod = __webpack_require__(5966);
1944
1945module.exports = function (iterator, kind, value) {
1946  var innerResult, innerError;
1947  anObject(iterator);
1948  try {
1949    innerResult = getMethod(iterator, 'return');
1950    if (!innerResult) {
1951      if (kind === 'throw') throw value;
1952      return value;
1953    }
1954    innerResult = call(innerResult, iterator);
1955  } catch (error) {
1956    innerError = true;
1957    innerResult = error;
1958  }
1959  if (kind === 'throw') throw value;
1960  if (innerError) throw innerResult;
1961  anObject(innerResult);
1962  return value;
1963};
1964
1965
1966/***/ },
1967
1968/***/ 9462
1969(module, __unused_webpack_exports, __webpack_require__) {
1970
1971
1972var call = __webpack_require__(9565);
1973var create = __webpack_require__(2360);
1974var createNonEnumerableProperty = __webpack_require__(6699);
1975var defineBuiltIns = __webpack_require__(6279);
1976var wellKnownSymbol = __webpack_require__(8227);
1977var InternalStateModule = __webpack_require__(1181);
1978var getMethod = __webpack_require__(5966);
1979var IteratorPrototype = (__webpack_require__(7657).IteratorPrototype);
1980var createIterResultObject = __webpack_require__(2529);
1981var iteratorClose = __webpack_require__(9539);
1982var iteratorCloseAll = __webpack_require__(1385);
1983
1984var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1985var ITERATOR_HELPER = 'IteratorHelper';
1986var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
1987var NORMAL = 'normal';
1988var THROW = 'throw';
1989var setInternalState = InternalStateModule.set;
1990
1991var createIteratorProxyPrototype = function (IS_ITERATOR) {
1992  var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
1993
1994  return defineBuiltIns(create(IteratorPrototype), {
1995    next: function next() {
1996      var state = getInternalState(this);
1997      // for simplification:
1998      //   for `%WrapForValidIteratorPrototype%.next` or with `state.returnHandlerResult` our `nextHandler` returns `IterResultObject`
1999      //   for `%IteratorHelperPrototype%.next` - just a value
2000      if (IS_ITERATOR) return state.nextHandler();
2001      if (state.done) return createIterResultObject(undefined, true);

2002      try {
2003        var result = state.nextHandler();
2004        return state.returnHandlerResult ? result : createIterResultObject(result, state.done);
2005      } catch (error) {
2006        state.done = true;
2007        throw error;
2008      }
2009    },
2010    'return': function () {
2011      var state = getInternalState(this);
2012      var iterator = state.iterator;
2013      state.done = true;
2014      if (IS_ITERATOR) {
2015        var returnMethod = getMethod(iterator, 'return');
2016        return returnMethod ? call(returnMethod, iterator) : createIterResultObject(undefined, true);
2017      }
2018      if (state.inner) try {
2019        iteratorClose(state.inner.iterator, NORMAL);
2020      } catch (error) {
2021        return iteratorClose(iterator, THROW, error);
2022      }
2023      if (state.openIters) try {
2024        iteratorCloseAll(state.openIters, NORMAL);
2025      } catch (error) {
2026        return iteratorClose(iterator, THROW, error);
2027      }
2028      if (iterator) iteratorClose(iterator, NORMAL);
2029      return createIterResultObject(undefined, true);
2030    }
2031  });
2032};
2033
2034var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
2035var IteratorHelperPrototype = createIteratorProxyPrototype(false);
2036
2037createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');
2038
2039module.exports = function (nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) {
2040  var IteratorProxy = function Iterator(record, state) {
2041    if (state) {
2042      state.iterator = record.iterator;
2043      state.next = record.next;
2044    } else state = record;
2045    state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
2046    state.returnHandlerResult = !!RETURN_HANDLER_RESULT;
2047    state.nextHandler = nextHandler;
2048    state.counter = 0;
2049    state.done = false;
2050    setInternalState(this, state);
2051  };
2052
2053  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
2054
2055  return IteratorProxy;
2056};
2057
2058
2059/***/ },
2060
2061/***/ 684
2062(module) {
2063
2064
2065// Should throw an error on invalid iterator
2066// https://issues.chromium.org/issues/336839115
2067module.exports = function (methodName, argument) {
2068  // eslint-disable-next-line es/no-iterator -- required for testing
2069  var method = typeof Iterator == 'function' && Iterator.prototype[methodName];
2070  if (method) try {
2071    method.call({ next: null }, argument).next();
2072  } catch (error) {
2073    return true;
2074  }
2075};
2076
2077
2078/***/ },
2079
2080/***/ 4549
2081(module, __unused_webpack_exports, __webpack_require__) {
2082
2083
2084var globalThis = __webpack_require__(4576);
2085
2086// https://github.com/tc39/ecma262/pull/3467
2087module.exports = function (METHOD_NAME, ExpectedError) {
2088  var Iterator = globalThis.Iterator;
2089  var IteratorPrototype = Iterator && Iterator.prototype;
2090  var method = IteratorPrototype && IteratorPrototype[METHOD_NAME];
2091
2092  var CLOSED = false;
2093
2094  if (method) try {
2095    method.call({
2096      next: function () { return { done: true }; },
2097      'return': function () { CLOSED = true; }
2098    }, -1);
2099  } catch (error) {
2100    // https://bugs.webkit.org/show_bug.cgi?id=291195
2101    if (!(error instanceof ExpectedError)) CLOSED = false;
2102  }
2103
2104  if (!CLOSED) return method;
2105};
2106
2107
2108/***/ },
2109
2110/***/ 7657
2111(module, __unused_webpack_exports, __webpack_require__) {
2112
2113
2114var fails = __webpack_require__(9039);
2115var isCallable = __webpack_require__(4901);
2116var isObject = __webpack_require__(34);
2117var create = __webpack_require__(2360);
2118var getPrototypeOf = __webpack_require__(2787);
2119var defineBuiltIn = __webpack_require__(6840);
2120var wellKnownSymbol = __webpack_require__(8227);
2121var IS_PURE = __webpack_require__(6395);
2122
2123var ITERATOR = wellKnownSymbol('iterator');
2124var BUGGY_SAFARI_ITERATORS = false;
2125
2126// `%IteratorPrototype%` object
2127// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
2128var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
2129
2130/* eslint-disable es/no-array-prototype-keys -- safe */
2131if ([].keys) {
2132  arrayIterator = [].keys();
2133  // Safari 8 has buggy iterators w/o `next`
2134  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
2135  else {
2136    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
2137    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
2138  }
2139}
2140
2141var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {
2142  var test = {};
2143  // FF44- legacy iterators case
2144  return IteratorPrototype[ITERATOR].call(test) !== test;
2145});
2146
2147if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
2148else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
2149
2150// `%IteratorPrototype%[@@iterator]()` method
2151// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
2152if (!isCallable(IteratorPrototype[ITERATOR])) {
2153  defineBuiltIn(IteratorPrototype, ITERATOR, function () {
2154    return this;
2155  });
2156}
2157
2158module.exports = {
2159  IteratorPrototype: IteratorPrototype,
2160  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
2161};
2162
2163
2164/***/ },
2165
2166/***/ 6269
2167(module) {
2168
2169
2170module.exports = {};
2171
2172
2173/***/ },
2174
2175/***/ 6198
2176(module, __unused_webpack_exports, __webpack_require__) {
2177
2178

2179var toLength = __webpack_require__(8014);
2180
2181// `LengthOfArrayLike` abstract operation
2182// https://tc39.es/ecma262/#sec-lengthofarraylike
2183module.exports = function (obj) {
2184  return toLength(obj.length);
2185};
2186
2187
2188/***/ },
2189
2190/***/ 283
2191(module, __unused_webpack_exports, __webpack_require__) {
2192
2193
2194var uncurryThis = __webpack_require__(9504);
2195var fails = __webpack_require__(9039);
2196var isCallable = __webpack_require__(4901);
2197var hasOwn = __webpack_require__(9297);
2198var DESCRIPTORS = __webpack_require__(3724);
2199var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(350).CONFIGURABLE);
2200var inspectSource = __webpack_require__(3706);
2201var InternalStateModule = __webpack_require__(1181);
2202
2203var enforceInternalState = InternalStateModule.enforce;
2204var getInternalState = InternalStateModule.get;
2205var $String = String;
2206// eslint-disable-next-line es/no-object-defineproperty -- safe
2207var defineProperty = Object.defineProperty;
2208var stringSlice = uncurryThis(''.slice);
2209var replace = uncurryThis(''.replace);
2210var join = uncurryThis([].join);
2211
2212var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
2213  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
2214});
2215
2216var TEMPLATE = String(String).split('String');
2217
2218var makeBuiltIn = module.exports = function (value, name, options) {
2219  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
2220    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
2221  }
2222  if (options && options.getter) name = 'get ' + name;
2223  if (options && options.setter) name = 'set ' + name;
2224  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
2225    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
2226    else value.name = name;
2227  }
2228  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
2229    defineProperty(value, 'length', { value: options.arity });
2230  }
2231  try {
2232    if (options && hasOwn(options, 'constructor') && options.constructor) {
2233      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
2234    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
2235    } else if (value.prototype) value.prototype = undefined;
2236  } catch (error) { /* empty */ }
2237  var state = enforceInternalState(value);
2238  if (!hasOwn(state, 'source')) {
2239    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
2240  } return value;
2241};
2242
2243// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
2244// eslint-disable-next-line no-extend-native -- required
2245Function.prototype.toString = makeBuiltIn(function toString() {
2246  return isCallable(this) && getInternalState(this).source || inspectSource(this);
2247}, 'toString');
2248
2249
2250/***/ },
2251
2252/***/ 2248
2253(module, __unused_webpack_exports, __webpack_require__) {
2254
2255
2256var uncurryThis = __webpack_require__(9504);
2257
2258// eslint-disable-next-line es/no-map -- safe
2259var MapPrototype = Map.prototype;
2260
2261module.exports = {
2262  // eslint-disable-next-line es/no-map -- safe
2263  Map: Map,
2264  set: uncurryThis(MapPrototype.set),
2265  get: uncurryThis(MapPrototype.get),
2266  has: uncurryThis(MapPrototype.has),
2267  remove: uncurryThis(MapPrototype['delete']),
2268  proto: MapPrototype
2269};
2270
2271
2272/***/ },
2273
2274/***/ 741
2275(module) {
2276
2277
2278var ceil = Math.ceil;
2279var floor = Math.floor;
2280
2281// `Math.trunc` method
2282// https://tc39.es/ecma262/#sec-math.trunc
2283// eslint-disable-next-line es/no-math-trunc -- safe
2284module.exports = Math.trunc || function trunc(x) {
2285  var n = +x;
2286  return (n > 0 ? floor : ceil)(n);
2287};
2288
2289
2290/***/ },
2291
2292/***/ 7819
2293(module, __unused_webpack_exports, __webpack_require__) {
2294
2295
2296/* eslint-disable es/no-json -- safe */
2297var fails = __webpack_require__(9039);
2298
2299module.exports = !fails(function () {
2300  var unsafeInt = '9007199254740993';
2301  // eslint-disable-next-line es/no-json-rawjson -- feature detection
2302  var raw = JSON.rawJSON(unsafeInt);
2303  // eslint-disable-next-line es/no-json-israwjson -- feature detection
2304  return !JSON.isRawJSON(raw) || JSON.stringify(raw) !== unsafeInt;
2305});
2306
2307
2308/***/ },
2309
2310/***/ 6043
2311(module, __unused_webpack_exports, __webpack_require__) {
2312
2313
2314var aCallable = __webpack_require__(9306);
2315
2316var $TypeError = TypeError;
2317
2318var PromiseCapability = function (C) {
2319  var resolve, reject;
2320  this.promise = new C(function ($$resolve, $$reject) {
2321    if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');
2322    resolve = $$resolve;
2323    reject = $$reject;
2324  });
2325  this.resolve = aCallable(resolve);
2326  this.reject = aCallable(reject);
2327};
2328
2329// `NewPromiseCapability` abstract operation
2330// https://tc39.es/ecma262/#sec-newpromisecapability
2331module.exports.f = function (C) {
2332  return new PromiseCapability(C

2332);
2333};
2334
2335
2336/***/ },
2337
2338/***/ 2360
2339(module, __unused_webpack_exports, __webpack_require__) {
2340
2341
2342/* global ActiveXObject -- old IE, WSH */
2343var anObject = __webpack_require__(8551);
2344var definePropertiesModule = __webpack_require__(6801);
2345var enumBugKeys = __webpack_require__(8727);
2346var hiddenKeys = __webpack_require__(421);
2347var html = __webpack_require__(397);
2348var documentCreateElement = __webpack_require__(4055);
2349var sharedKey = __webpack_require__(6119);
2350
2351var GT = '>';
2352var LT = '<';
2353var PROTOTYPE = 'prototype';
2354var SCRIPT = 'script';
2355var IE_PROTO = sharedKey('IE_PROTO');
2356
2357var EmptyConstructor = function () { /* empty */ };
2358
2359var scriptTag = function (content) {
2360  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
2361};
2362
2363// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
2364var NullProtoObjectViaActiveX = function (activeXDocument) {
2365  activeXDocument.write(scriptTag(''));
2366  activeXDocument.close();
2367  var temp = activeXDocument.parentWindow.Object;
2368  // eslint-disable-next-line no-useless-assignment -- avoid memory leak
2369  activeXDocument = null;
2370  return temp;
2371};
2372
2373// Create object with fake `null` prototype: use iframe Object with cleared prototype
2374var NullProtoObjectViaIFrame = function () {
2375  // Thrash, waste and sodomy: IE GC bug
2376  var iframe = documentCreateElement('iframe');
2377  var JS = 'java' + SCRIPT + ':';
2378  var iframeDocument;
2379  iframe.style.display = 'none';
2380  html.appendChild(iframe);
2381  // https://github.com/zloirock/core-js/issues/475
2382  iframe.src = String(JS);
2383  iframeDocument = iframe.contentWindow.document;
2384  iframeDocument.open();
2385  iframeDocument.write(scriptTag('document.F=Object'));
2386  iframeDocument.close();
2387  return iframeDocument.F;
2388};
2389
2390// Check for document.domain and active x support
2391// No need to use active x approach when document.domain is not set
2392// see https://github.com/es-shims/es5-shim/issues/150
2393// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
2394// avoid IE GC bug
2395var activeXDocument;
2396var NullProtoObject = function () {
2397  try {
2398    activeXDocument = new ActiveXObject('htmlfile');
2399  } catch (error) { /* ignore */ }
2400  NullProtoObject = typeof document != 'undefined'
2401    ? document.domain && activeXDocument
2402      ? NullProtoObjectViaActiveX(activeXDocument) // old IE
2403      : NullProtoObjectViaIFrame()
2404    : NullProtoObjectViaActiveX(activeXDocument); // WSH
2405  var length = enumBugKeys.length;
2406  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
2407  return NullProtoObject();
2408};
2409
2410hiddenKeys[IE_PROTO] = true;
2411
2412// `Object.create` method
2413// https://tc39.es/ecma262/#sec-object.create
2414// eslint-disable-next-line es/no-object-create -- safe
2415module.exports = Object.create || function create(O, Properties) {
2416  var result;
2417  if (O !== null) {
2418    EmptyConstructor[PROTOTYPE] = anObject(O);
2419    result = new EmptyConstructor();
2420    EmptyConstructor[PROTOTYPE] = null;
2421    // add "__proto__" for Object.getPrototypeOf polyfill
2422    result[IE_PROTO] = O;
2423  } else result = NullProtoObject();
2424  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
2425};
2426
2427
2428/***/ },
2429
2430/***/ 6801
2431(__unused_webpack_module, exports, __webpack_require__) {
2432
2433
2434var DESCRIPTORS = __webpack_require__(3724);
2435var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(8686);
2436var definePropertyModule = __webpack_require__(4913);
2437var anObject = __webpack_require__(8551);
2438var toIndexedObject = __webpack_require__(5397);
2439var objectKeys = __webpack_require__(1072);
2440
2441// `Object.defineProperties` method
2442// https://tc39.es/ecma262/#sec-object.defineproperties
2443// eslint-disable-next-line es/no-object-defineproperties -- safe
2444exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
2445  anObject(O);
2446  var props = toIndexedObject(Properties);
2447  var keys = objectKeys(Properties);
2448  var length = keys.length;
2449  var index = 0;
2450  var key;
2451  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
2452  return O;
2453};
2454
2455
2456/***/ },
2457
2458/***/ 4913
2459(__unused_webpack_module, exports, __webpack_require__) {
2460
2461
2462var DESCRIPTORS = __webpack_require__(3724);
2463var IE8_DOM_DEFINE = __webpack_require__(5917);
2464var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(8686);
2465var anObject = __webpack_require__(8551);
2466var toPropertyKey = __webpack_require__(6969);
2467
2468var $TypeError = TypeError;
2469// eslint-disable-next-line es/no-object-defineproperty -- safe
2470var $defineProperty = Object.defineProperty;
2471// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2472var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2473var ENUMERABLE = 'enumerable';
2474var CONFIGURABLE = 'configurable';
2475var WRITABLE = 'writable';
2476
2477// `Object.defineProperty` method
2478// https://tc39.es/ecma262/#sec-object.defineproperty
2479exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
2480  anObject(O);
2481  P = toPropertyKey(P);
2482  anObject(Attributes);
2483  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
2484    var current = $getOwnPropertyDescriptor(O, P);
2485    if (current && current[WRITABLE]) {
2486      O[P] = Attributes.value;
2487      Attributes = {
2488        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
2489        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
2490        writable: false
2491      };
2492    }
2493  } return $defineProperty(O, P, Attributes);
2494} : $defineProperty : function defineProperty(O, P, Attributes) {
2495  anObject(O);
2496  P = toPropertyKey(P);
2497  anObject(Attributes);
2498  if (IE8_DOM_DEFINE) try {
2499    return $defineProperty(O, P, Attributes);
2500  } catch (error) { /* empty */ }
2501  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
2502  if ('value' in Attributes) O[P] = Attributes.value;
2503  return O;
2504};
2505
2506
2507/***/ },
2508
2509/***/ 7347
2510(__unused_webpack_module, exports, __webpack_require__) {
2511
2512
2513var DESCRIPTORS = __webpack_require__(3724);
2514var call = __webpack_require__(9565);
2515var propertyIsEnumerableModule = __webpack_require__(8773);
2516var createPropertyDescriptor = __webpack_require__(6980);
2517var toIndexedObject = __webpack_require__(5397);
2518var toPropertyKey = __webpack_require__(6969);
2519var hasOwn = __webpack_require__(9297);
2520var IE8_DOM_DEFINE = __webpack_require__(5917);
2521
2522// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2523var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2524
2525// `Object.getOwnPropertyDescriptor` method
2526// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
2527exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
2528  O = toIndexedObject(O);
2529  P = toPropertyKey(P);
2530  if (IE8_DOM_DEFINE) try {
2531    return $getOwnPropertyDescriptor(O, P);
2532  } catch (error) { /* empty */ }
2533  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
2534};
2535
2536
2537/***/ },
2538
2539/***/ 8480
2540(__unused_webpack_module, exports, __webpack_require__) {
2541
2542
2543var internalObjectKeys = __webpack_require__(1828);
2544var enumBugKeys = __webpack_require__(8727);
2545
2546var hiddenKeys = enumBugKeys.concat('length', 'prototype');
2547
2548// `Object.getOwnPropertyNames` method
2549// https://tc39.es/ecma262/#sec-object.getownpropertynames
2550// eslint-disable-next-line es/no-object-getownpropertynames -- safe
2551exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
2552  return internalObjectKeys(O, hiddenKeys);
2553};
2554
2555
2556/***/ },
2557
2558/***/ 3717
2559(__unused_webpack_module, exports) {
2560
2561
2562// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
2563exports.f = Object.getOwnPropertySymbols;
2564
2565
2566/***/ },
2567
2568/***/ 2787
2569(module, __unused_webpack_exports, __webpack_require__) {
2570
2571
2572var hasOwn = __webpack_require__(9297);
2573var isCallable = __webpack_require__(4901);
2574var toObject = __webpack_require__(8981);
2575var sharedKey = __webpack_require__(6119);
2576var CORRECT_PROTOTYPE_GETTER = __webpack_require__(2211);
2577
2578var IE_PROTO = sharedKey('IE_PROTO');
2579var $Object = Object;
2580var ObjectPrototype = $Object.prototype;
2581
2582// `Object.getPrototypeOf` method
2583// https://tc39.es/ecma262/#sec-object.getprototypeof
2584// eslint-disable-next-line es/no-object-getprototypeof -- safe
2585module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
2586  var object = toObject(O);
2587  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
2588  var constructor = object.constructor;
2589  if (isCallable(constructor) && object instanceof constructor) {
2590    return constructor.prototype;
2591  } return object instanceof $Object ? ObjectPrototype : null;
2592};
2593
2594
2595/***/ },
2596
2597/***/ 1625
2598(module, __unused_webpack_exports, __webpack_require__) {
2599
2600
2601var uncurryThis = __webpack_require__(9504);
2602
2603module.exports = uncurryThis({}.isPrototypeOf);
2604
2605
2606/***/ },
2607
2608/***/ 1828
2609(module, __unused_webpack_exports, __webpack_require__) {
2610
2611
2612var uncurryThis = __webpack_require__(9504);
2613var hasOwn = __webpack_require__(9297);
2614var toIndexedObject = __webpack_require__(5397);
2615var indexOf = (__webpack_require__(9617).indexOf);
2616var hiddenKeys = __webpack_require__(421);
2617
2618var push = uncurryThis([].push);
2619
2620module.exports = function (object, names) {
2621  var O = toIndexedObject(object);
2622  var i = 0;
2623  var result = [];
2624  var key;
2625  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
2626  // Don't enum bug & hidden keys
2627  while (names.length > i) if (hasOwn(O, key = names[i++])) {
2628    ~indexOf(result, key) || push(result, key);
2629  }
2630  return result;
2631};
2632
2633
2634/***/ },
2635
2636/***/ 1072
2637(module, __unused_webpack_exports, __webpack_require__) {
2638
2639
2640var internalObjectKeys = __webpack_require__(1828);
2641var enumBugKeys = __webpack_require__(8727);
2642
2643// `Object.keys` method
2644// https://tc39.es/ecma262/#sec-object.keys
2645// eslint-disable-next-line es/no-object-keys -- safe
2646module.exports = Object.keys || function keys(O) {
2647  return internalObjectKeys(O, enumBugKeys);
2648};
2649
2650
2651/***/ },
2652
2653/***/ 8773
2654(__unused_webpack_module, exports) {
2655
2656
2657var $propertyIsEnumerable = {}.propertyIsEnumerable;
2658// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2659var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2660
2661// Nashorn ~ JDK8 bug
2662var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
2663
2664// `Object.prototype.propertyIsEnumerable` method implementation
2665// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
2666exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
2667  var descriptor = getOwnPropertyDescriptor(this, V);
2668  return !!descriptor && descriptor.enumerable;
2669} : $propertyIsEnumerable;
2670
2671
2672/***/ },
2673
2674/***/ 2967
2675(module, __unused_webpack_exports, __webpack_require__) {
2676
2677
2678/* eslint-disable no-proto -- safe */
2679var uncurryThisAccessor = __webpack_require__(6706);
2680var isObject = __webpack_require__(34);
2681var requireObjectCoercible = __webpack_require__(7750);
2682var aPossiblePrototype = __webpack_require__(3506);
2683
2684// `Object.setPrototypeOf` method
2685// https://tc39.es/ecma262/#sec-object.setprototypeof
2686// Works with __proto__ only. Old v8 can't work with null proto objects.
2687// eslint-disable-next-line es/no-object-setprototypeof -- safe
2688module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
2689  var CORRECT_SETTER = false;
2690  var test = {};
2691  var setter;
2692  try {
2693    setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
2694    setter(test, []);
2695    CORRECT_SETTER = test instanceof Array;
2696  } catch (error) { /* empty */ }
2697  return function setPrototypeOf(O, proto) {
2698    requireObjectCoercible(O);
2699    aPossiblePrototype(proto);
2700    if (!isObject(O)) return O;
2701    if (CORRECT_SETTER) setter(O, proto);
2702    else O.__proto__ = proto;
2703    return O;
2704  };
2705}() : undefined);
2706
2707
2708/***/ },
2709
2710/***/