Diff: STRATO-apps/wordpress_03/app/wp-includes/js/dist/vendor/wp-polyfill.js
Keine Baseline-Datei – Diff nur gegen leer.
1
-
1
+
/**
2
+
* core-js 3.39.0
3
+
* © 2014-2024 Denis Pushkarev (zloirock.ru)
4
+
* license: https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE
5
+
* source: https://github.com/zloirock/core-js
6
+
*/
7
+
!function (undefined) { 'use strict'; /******/ (function(modules) { // webpackBootstrap
8
+
/******/ // The module cache
9
+
/******/ var installedModules = {};
10
+
/******/
11
+
/******/ // The require function
12
+
/******/ var __webpack_require__ = function (moduleId) {
13
+
/******/
14
+
/******/ // Check if module is in cache
15
+
/******/ if(installedModules[moduleId]) {
16
+
/******/ return installedModules[moduleId].exports;
17
+
/******/ }
18
+
/******/ // Create a new module (and put it into the cache)
19
+
/******/ var module = installedModules[moduleId] = {
20
+
/******/ i: moduleId,
21
+
/******/ l: false,
22
+
/******/ exports: {}
23
+
/******/ };
24
+
/******/
25
+
/******/ // Execute the module function
26
+
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
27
+
/******/
28
+
/******/ // Flag the module as loaded
29
+
/******/ module.l = true;
30
+
/******/
31
+
/******/ // Return the exports of the module
32
+
/******/ return module.exports;
33
+
/******/ }
34
+
/******/
35
+
/******/
36
+
/******/ // expose the modules object (__webpack_modules__)
37
+
/******/ __webpack_require__.m = modules;
38
+
/******/
39
+
/******/ // expose the module cache
40
+
/******/ __webpack_require__.c = installedModules;
41
+
/******/
42
+
/******/ // define getter function for harmony exports
43
+
/******/ __webpack_require__.d = function(exports, name, getter) {
44
+
/******/ if(!__webpack_require__.o(exports, name)) {
45
+
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
46
+
/******/ }
47
+
/******/ };
48
+
/******/
49
+
/******/ // define __esModule on exports
50
+
/******/ __webpack_require__.r = function(exports) {
51
+
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
52
+
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
53
+
/******/ }
54
+
/******/ Object.defineProperty(exports, '__esModule', { value: true });
55
+
/******/ };
56
+
/******/
57
+
/******/ // create a fake namespace object
58
+
/******/ // mode & 1: value is a module id, require it
59
+
/******/ // mode & 2: merge all properties of value into the ns
60
+
/******/ // mode & 4: return value when already ns object
61
+
/******/ // mode & 8|1: behave like require
62
+
/******/ __webpack_require__.t = function(value, mode) {
63
+
/******/ if(mode & 1) value = __webpack_require__(value);
64
+
/******/ if(mode & 8) return value;
65
+
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
66
+
/******/ var ns = Object.create(null);
67
+
/******/ __webpack_require__.r(ns);
68
+
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
69
+
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
70
+
/******/ return ns;
71
+
/******/ };
72
+
/******/
73
+
/******/ // getDefaultExport function for compatibility with non-harmony modules
74
+
/******/ __webpack_require__.n = function(module) {
75
+
/******/ var getter = module && module.__esModule ?
76
+
/******/ function getDefault() { return module['default']; } :
77
+
/******/ function getModuleExports() { return module; };
78
+
/******/ __webpack_require__.d(getter, 'a', getter);
79
+
/******/ return getter;
80
+
/******/ };
81
+
/******/
82
+
/******/ // Object.prototype.hasOwnProperty.call
83
+
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
84
+
/******/
85
+
/******/ // __webpack_public_path__
86
+
/******/ __webpack_require__.p = "";
87
+
/******/
88
+
/******/
89
+
/******/ // Load entry module and return exports
90
+
/******/ return __webpack_require__(__webpack_require__.s = 0);
91
+
/******/ })
92
+
/************************************************************************/
93
+
/******/ ([
94
+
/* 0 */
95
+
/***/ (function(module, exports, __webpack_require__) {
96
+
97
+
__webpack_require__(1);
98
+
__webpack_require__(53);
99
+
__webpack_require__(81);
100
+
__webpack_require__(82);
101
+
__webpack_require__(93);
102
+
__webpack_require__(94);
103
+
__webpack_require__(99);
104
+
__webpack_require__(100);
105
+
__webpack_require__(110);
106
+
__webpack_require__(120);
107
+
__webpack_require__(122);
108
+
__webpack_require__(123);
109
+
__webpack_require__(124);
110
+
module.exports = __webpack_require__(125);
111
+
112
+
113
+
/***/ }),
114
+
/* 1 */
115
+
/***/ (function(module, exports, __webpack_require__) {
116
+
117
+
"use strict";
118
+
119
+
var DESCRIPTORS = __webpack_require__(2);
120
+
var defineBuiltInAccessor = __webpack_require__(4);
121
+
var isDetached = __webpack_require__(48);
122
+
123
+
var ArrayBufferPrototype = ArrayBuffer.prototype;
124
+
125
+
// `ArrayBuffer.prototype.detached` getter
126
+
// https://tc39.es/ecma262/#sec-get-arraybuffer.prototype.detached
127
+
if (DESCRIPTORS && !('detached' in ArrayBufferPrototype)) {
128
+
defineBuiltInAccessor(ArrayBufferPrototype, 'detached', {
129
+
configurable: true,
130
+
get: function detached() {
131
+
return isDetached(this);
132
+
}
133
+
});
134
+
}
135
+
136
+
137
+
/***/ }),
138
+
/* 2 */
139
+
/***/ (function(module, exports, __webpack_require__) {
140
+
141
+
"use strict";
142
+
143
+
var fails = __webpack_require__(3);
144
+
145
+
// Detect IE8's incomplete defineProperty implementation
146
+
module.exports = !fails(function () {
147
+
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
148
+
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
149
+
});
150
+
151
+
152
+
/***/ }),
153
+
/* 3 */
154
+
/***/ (function(module, exports, __webpack_require__) {
155
+
156
+
"use strict";
157
+
158
+
module.exports = function (exec) {
159
+
try {
160
+
return !!exec();
161
+
} catch (error) {
162
+
return true;
163
+
}
164
+
};
165
+
166
+
167
+
/***/ }),
168
+
/* 4 */
169
+
/***/ (function(module, exports, __webpack_require__) {
170
+
171
+
"use strict";
172
+
173
+
var makeBuiltIn = __webpack_require__(5);
174
+
var defineProperty = __webpack_require__(23);
175
+
176
+
module.exports = function (target, name, descriptor) {
177
+
if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
178
+
if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
179
+
return defineProperty.f(target, name, descriptor);
180
+
};
181
+
182
+
183
+
/***/ }),
184
+
/* 5 */
185
+
/***/ (function(module, exports, __webpack_require__) {
186
+
187
+
"use strict";
188
+
189
+
var uncurryThis = __webpack_require__(6);
190
+
var fails = __webpack_require__(3);
191
+
var isCallable = __webpack_require__(8);
192
+
var hasOwn = __webpack_require__(9);
193
+
var DESCRIPTORS = __webpack_require__(2);
194
+
var CONFIGURABLE_FUNCTION_NAME = __webpack_require__(13).CONFIGURABLE;
195
+
var inspectSource = __webpack_require__(14);
196
+
var InternalStateModule = __webpack_require__(19);
197
+
198
+
var enforceInternalState = InternalStateModule.enforce;
199
+
var getInternalState = InternalStateModule.get;
200
+
var $String = String;
201
+
// eslint-disable-next-line es/no-object-defineproperty -- safe
202
+
var defineProperty = Object.defineProperty;
203
+
var stringSlice = uncurryThis(''.slice);
204
+
var replace = uncurryThis(''.replace);
205
+
var join = uncurryThis([].join);
206
+
207
+
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
208
+
return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
209
+
});
210
+
211
+
var TEMPLATE = String(String).split('String');
212
+
213
+
var makeBuiltIn = module.exports = function (value, name, options) {
214
+
if (stringSlice($String(name), 0, 7) === 'Symbol(') {
215
+
name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
216
+
}
217
+
if (options && options.getter) name = 'get ' + name;
218
+
if (options && options.setter) name = 'set ' + name;
219
+
if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
220
+
if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
221
+
else value.name = name;
222
+
}
223
+
if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
224
+
defineProperty(value, 'length', { value: options.arity });
225
+
}
226
+
try {
227
+
if (options && hasOwn(options, 'constructor') && options.constructor) {
228
+
if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
229
+
// in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
230
+
} else if (value.prototype) value.prototype = undefined;
231
+
} catch (error) { /* empty */ }
232
+
var state = enforceInternalState(value);
233
+
if (!hasOwn(state, 'source')) {
234
+
state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
235
+
} return value;
236
+
};
237
+
238
+
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
239
+
// eslint-disable-next-line no-extend-native -- required
240
+
Function.prototype.toString = makeBuiltIn(function toString() {
241
+
return isCallable(this) && getInternalState(this).source || inspectSource(this);
242
+
}, 'toString');
243
+
244
+
245
+
/***/ }),
246
+
/* 6 */
247
+
/***/ (function(module, exports, __webpack_require__) {
248
+
249
+
"use strict";
250
+
251
+
var NATIVE_BIND = __webpack_require__(7);
252
+
253
+
var FunctionPrototype = Function.prototype;
254
+
var call = FunctionPrototype.call;
255
+
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
256
+
257
+
module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
258
+
return function () {
259
+
return call.apply(fn, arguments);
260
+
};
261
+
};
262
+
263
+
264
+
/***/ }),
265
+
/* 7 */
266
+
/***/ (function(module, exports, __webpack_require__) {
267
+
268
+
"use strict";
269
+
270
+
var fails = __webpack_require__(3);
271
+
272
+
module.exports = !fails(function () {
273
+
// eslint-disable-next-line es/no-function-prototype-bind -- safe
274
+
var test = (function () { /* empty */ }).bind();
275
+
// eslint-disable-next-line no-prototype-builtins -- safe
276
+
return typeof test != 'function' || test.hasOwnProperty('prototype');
277
+
});
278
+
279
+
280
+
/***/ }),
281
+
/* 8 */
282
+
/***/ (function(module, exports, __webpack_require__) {
283
+
284
+
"use strict";
285
+
286
+
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
287
+
var documentAll = typeof document == 'object' && document.all;
288
+
289
+
// `IsCallable` abstract operation
290
+
// https://tc39.es/ecma262/#sec-iscallable
291
+
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
292
+
module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
293
+
return typeof argument == 'function' || argument === documentAll;
294
+
} : function (argument) {
295
+
return typeof argument == 'function';
296
+
};
297
+
298
+
299
+
/***/ }),
300
+
/* 9 */
301
+
/***/ (function(module, exports, __webpack_require__) {
302
+
303
+
"use strict";
304
+
305
+
var uncurryThis = __webpack_require__(6);
306
+
var toObject = __webpack_require__(10);
307
+
308
+
var hasOwnProperty = uncurryThis({}.hasOwnProperty);
309
+
310
+
// `HasOwnProperty` abstract operation
311
+
// https://tc39.es/ecma262/#sec-hasownproperty
312
+
// eslint-disable-next-line es/no-object-hasown -- safe
313
+
module.exports = Object.hasOwn || function hasOwn(it, key) {
314
+
return hasOwnProperty(toObject(it), key);
315
+
};
316
+
317
+
318
+
/***/ }),
319
+
/* 10 */
320
+
/***/ (function(module, exports, __webpack_require__) {
321
+
322
+
"use strict";
323
+
324
+
var requireObjectCoercible = __webpack_require__(11);
325
+
326
+
var $Object = Object;
327
+
328
+
// `ToObject` abstract operation
329
+
// https://tc39.es/ecma262/#sec-toobject
330
+
module.exports = function (argument) {
331
+
return $Object(requireObjectCoercible(argument));
332
+
};
333
+
334
+
335
+
/***/ }),
336
+
/* 11 */
337
+
/***/ (function(module, exports, __webpack_require__) {
338
+
339
+
"use strict";
340
+
341
+
var isNullOrUndefined = __webpack_require__(12);
342
+
343
+
var $TypeError = TypeError;
344
+
345
+
// `RequireObjectCoercible` abstract operation
346
+
// https://tc39.es/ecma262/#sec-requireobjectcoercible
347
+
module.exports = function (it) {
348
+
if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
349
+
return it;
350
+
};
351
+
352
+
353
+
/***/ }),
354
+
/* 12 */
355
+
/***/ (function(module, exports, __webpack_require__) {
356
+
357
+
"use strict";
358
+
359
+
// we can't use just `it == null` since of `document.all` special case
360
+
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
361
+
module.exports = function (it) {
362
+
return it === null || it === undefined;
363
+
};
364
+
365
+
366
+
/***/ }),
367
+
/* 13 */
368
+
/***/ (function(module, exports, __webpack_require__) {
369
+
370
+
"use strict";
371
+
372
+
var DESCRIPTORS = __webpack_require__(2);
373
+
var hasOwn = __webpack_require__(9);
374
+
375
+
var FunctionPrototype = Function.prototype;
376
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
377
+
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
378
+
379
+
var EXISTS = hasOwn(FunctionPrototype, 'name');
380
+
// additional protection from minified / mangled / dropped function names
381
+
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
382
+
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
383
+
384
+
module.exports = {
385
+
EXISTS: EXISTS,
386
+
PROPER: PROPER,
387
+
CONFIGURABLE: CONFIGURABLE
388
+
};
389
+
390
+
391
+
/***/ }),
392
+
/* 14 */
393
+
/***/ (function(module, exports, __webpack_require__) {
394
+
395
+
"use strict";
396
+
397
+
var uncurryThis = __webpack_require__(6);
398
+
var isCallable = __webpack_require__(8);
399
+
var store = __webpack_require__(15);
400
+
401
+
var functionToString = uncurryThis(Function.toString);
402
+
403
+
// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
404
+
if (!isCallable(store.inspectSource)) {
405
+
store.inspectSource = function (it) {
406
+
return functionToString(it);
407
+
};
408
+
}
409
+
410
+
module.exports = store.inspectSource;
411
+
412
+
413
+
/***/ }),
414
+
/* 15 */
415
+
/***/ (function(module, exports, __webpack_require__) {
416
+
417
+
"use strict";
418
+
419
+
var IS_PURE = __webpack_require__(16);
420
+
var globalThis = __webpack_require__(17);
421
+
var defineGlobalProperty = __webpack_require__(18);
422
+
423
+
var SHARED = '__core-js_shared__';
424
+
var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
425
+
426
+
(store.versions || (store.versions = [])).push({
427
+
version: '3.39.0',
428
+
mode: IS_PURE ? 'pure' : 'global',
429
+
copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
430
+
license: 'https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE',
431
+
source: 'https://github.com/zloirock/core-js'
432
+
});
433
+
434
+
435
+
/***/ }),
436
+
/* 16 */
437
+
/***/ (function(module, exports, __webpack_require__) {
438
+
439
+
"use strict";
440
+
441
+
module.exports = false;
442
+
443
+
444
+
/***/ }),
445
+
/* 17 */
446
+
/***/ (function(module, exports, __webpack_require__) {
447
+
448
+
"use strict";
449
+
450
+
var check = function (it) {
451
+
return it && it.Math === Math && it;
452
+
};
453
+
454
+
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
455
+
module.exports =
456
+
// eslint-disable-next-line es/no-global-this -- safe
457
+
check(typeof globalThis == 'object' && globalThis) ||
458
+
check(typeof window == 'object' && window) ||
459
+
// eslint-disable-next-line no-restricted-globals -- safe
460
+
check(typeof self == 'object' && self) ||
461
+
check(typeof global == 'object' && global) ||
462
+
check(typeof this == 'object' && this) ||
463
+
// eslint-disable-next-line no-new-func -- fallback
464
+
(function () { return this; })() || Function('return this')();
465
+
466
+
467
+
/***/ }),
468
+
/* 18 */
469
+
/***/ (function(module, exports, __webpack_require__) {
470
+
471
+
"use strict";
472
+
473
+
var globalThis = __webpack_require__(17);
474
+
475
+
// eslint-disable-next-line es/no-object-defineproperty -- safe
476
+
var defineProperty = Object.defineProperty;
477
+
478
+
module.exports = function (key, value) {
479
+
try {
480
+
defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
481
+
} catch (error) {
482
+
globalThis[key] = value;
483
+
} return value;
484
+
};
485
+
486
+
487
+
/***/ }),
488
+
/* 19 */
489
+
/***/ (function(module, exports, __webpack_require__) {
490
+
491
+
"use strict";
492
+
493
+
var NATIVE_WEAK_MAP = __webpack_require__(20);
494
+
var globalThis = __webpack_require__(17);
495
+
var isObject = __webpack_require__(21);
496
+
var createNonEnumerableProperty = __webpack_require__(22);
497
+
var hasOwn = __webpack_require__(9);
498
+
var shared = __webpack_require__(15);
499
+
var sharedKey = __webpack_require__(46);
500
+
var hiddenKeys = __webpack_require__(47);
501
+
502
+
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
503
+
var TypeError = globalThis.TypeError;
504
+
var WeakMap = globalThis.WeakMap;
505
+
var set, get, has;
506
+
507
+
var enforce = function (it) {
508
+
return has(it) ? get(it) : set(it, {});
509
+
};
510
+
511
+
var getterFor = function (TYPE) {
512
+
return function (it) {
513
+
var state;
514
+
if (!isObject(it) || (state = get(it)).type !== TYPE) {
515
+
throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
516
+
} return state;
517
+
};
518
+
};
519
+
520
+
if (NATIVE_WEAK_MAP || shared.state) {
521
+
var store = shared.state || (shared.state = new WeakMap());
522
+
/* eslint-disable no-self-assign -- prototype methods protection */
523
+
store.get = store.get;
524
+
store.has = store.has;
525
+
store.set = store.set;
526
+
/* eslint-enable no-self-assign -- prototype methods protection */
527
+
set = function (it, metadata) {
528
+
if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
529
+
metadata.facade = it;
530
+
store.set(it, metadata);
531
+
return metadata;
532
+
};
533
+
get = function (it) {
534
+
return store.get(it) || {};
535
+
};
536
+
has = function (it) {
537
+
return store.has(it);
538
+
};
539
+
} else {
540
+
var STATE = sharedKey('state');
541
+
hiddenKeys[STATE] = true;
542
+
set = function (it, metadata) {
543
+
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
544
+
metadata.facade = it;
545
+
createNonEnumerableProperty(it, STATE, metadata);
546
+
return metadata;
547
+
};
548
+
get = function (it) {
549
+
return hasOwn(it, STATE) ? it[STATE] : {};
550
+
};
551
+
has = function (it) {
552
+
return hasOwn(it, STATE);
553
+
};
554
+
}
555
+
556
+
module.exports = {
557
+
set: set,
558
+
get: get,
559
+
has: has,
560
+
enforce: enforce,
561
+
getterFor: getterFor
562
+
};
563
+
564
+
565
+
/***/ }),
566
+
/* 20 */
567
+
/***/ (function(module, exports, __webpack_require__) {
568
+
569
+
"use strict";
570
+
571
+
var globalThis = __webpack_require__(17);
572
+
var isCallable = __webpack_require__(8);
573
+
574
+
var WeakMap = globalThis.WeakMap;
575
+
576
+
module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
577
+
578
+
579
+
/***/ }),
580
+
/* 21 */
581
+
/***/ (function(module, exports, __webpack_require__) {
582
+
583
+
"use strict";
584
+
585
+
var isCallable = __webpack_require__(8);
586
+
587
+
module.exports = function (it) {
588
+
return typeof it == 'object' ? it !== null : isCallable(it);
589
+
};
590
+
591
+
592
+
/***/ }),
593
+
/* 22 */
594
+
/***/ (function(module, exports, __webpack_require__) {
595
+
596
+
"use strict";
597
+
598
+
var DESCRIPTORS = __webpack_require__(2);
599
+
var definePropertyModule = __webpack_require__(23);
600
+
var createPropertyDescriptor = __webpack_require__(45);
601
+
602
+
module.exports = DESCRIPTORS ? function (object, key, value) {
603
+
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
604
+
} : function (object, key, value) {
605
+
object[key] = value;
606
+
return object;
607
+
};
608
+
609
+
610
+
/***/ }),
611
+
/* 23 */
612
+
/***/ (function(module, exports, __webpack_require__) {
613
+
614
+
"use strict";
615
+
616
+
var DESCRIPTORS = __webpack_require__(2);
617
+
var IE8_DOM_DEFINE = __webpack_require__(24);
618
+
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(26);
619
+
var anObject = __webpack_require__(27);
620
+
var toPropertyKey = __webpack_require__(28);
621
+
622
+
var $TypeError = TypeError;
623
+
// eslint-disable-next-line es/no-object-defineproperty -- safe
624
+
var $defineProperty = Object.defineProperty;
625
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
626
+
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
627
+
var ENUMERABLE = 'enumerable';
628
+
var CONFIGURABLE = 'configurable';
629
+
var WRITABLE = 'writable';
630
+
631
+
// `Object.defineProperty` method
632
+
// https://tc39.es/ecma262/#sec-object.defineproperty
633
+
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
634
+
anObject(O);
635
+
P = toPropertyKey(P);
636
+
anObject(Attributes);
637
+
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
638
+
var current = $getOwnPropertyDescriptor(O, P);
639
+
if (current && current[WRITABLE]) {
640
+
O[P] = Attributes.value;
641
+
Attributes = {
642
+
configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
643
+
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
644
+
writable: false
645
+
};
646
+
}
647
+
} return $defineProperty(O, P, Attributes);
648
+
} : $defineProperty : function defineProperty(O, P, Attributes) {
649
+
anObject(O);
650
+
P = toPropertyKey(P);
651
+
anObject(Attributes);
652
+
if (IE8_DOM_DEFINE) try {
653
+
return $defineProperty(O, P, Attributes);
654
+
} catch (error) { /* empty */ }
655
+
if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
656
+
if ('value' in Attributes) O[P] = Attributes.value;
657
+
return O;
658
+
};
659
+
660
+
661
+
/***/ }),
662
+
/* 24 */
663
+
/***/ (function(module, exports, __webpack_require__) {
664
+
665
+
"use strict";
666
+
667
+
var DESCRIPTORS = __webpack_require__(2);
668
+
var fails = __webpack_require__(3);
669
+
var createElement = __webpack_require__(25);
670
+
671
+
// Thanks to IE8 for its funny defineProperty
672
+
module.exports = !DESCRIPTORS && !fails(function () {
673
+
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
674
+
return Object.defineProperty(createElement('div'), 'a', {
675
+
get: function () { return 7; }
676
+
}).a !== 7;
677
+
});
678
+
679
+
680
+
/***/ }),
681
+
/* 25 */
682
+
/***/ (function(module, exports, __webpack_require__) {
683
+
684
+
"use strict";
685
+
686
+
var globalThis = __webpack_require__(17);
687
+
var isObject = __webpack_require__(21);
688
+
689
+
var document = globalThis.document;
690
+
// typeof document.createElement is 'object' in old IE
691
+
var EXISTS = isObject(document) && isObject(document.createElement);
692
+
693
+
module.exports = function (it) {
694
+
return EXISTS ? document.createElement(it) : {};
695
+
};
696
+
697
+
698
+
/***/ }),
699
+
/* 26 */
700
+
/***/ (function(module, exports, __webpack_require__) {
701
+
702
+
"use strict";
703
+
704
+
var DESCRIPTORS = __webpack_require__(2);
705
+
var fails = __webpack_require__(3);
706
+
707
+
// V8 ~ Chrome 36-
708
+
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
709
+
module.exports = DESCRIPTORS && fails(function () {
710
+
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
711
+
return Object.defineProperty(function () { /* empty */ }, 'prototype', {
712
+
value: 42,
713
+
writable: false
714
+
}).prototype !== 42;
715
+
});
716
+
717
+
718
+
/***/ }),
719
+
/* 27 */
720
+
/***/ (function(module, exports, __webpack_require__) {
721
+
722
+
"use strict";
723
+
724
+
var isObject = __webpack_require__(21);
725
+
726
+
var $String = String;
727
+
var $TypeError = TypeError;
728
+
729
+
// `Assert: Type(argument) is Object`
730
+
module.exports = function (argument) {
731
+
if (isObject(argument)) return argument;
732
+
throw new $TypeError($String(argument) + ' is not an object');
733
+
};
734
+
735
+
736
+
/***/ }),
737
+
/* 28 */
738
+
/***/ (function(module, exports, __webpack_require__) {
739
+
740
+
"use strict";
741
+
742
+
var toPrimitive = __webpack_require__(29);
743
+
var isSymbol = __webpack_require__(31);
744
+
745
+
// `ToPropertyKey` abstract operation
746
+
// https://tc39.es/ecma262/#sec-topropertykey
747
+
module.exports = function (argument) {
748
+
var key = toPrimitive(argument, 'string');
749
+
return isSymbol(key) ? key : key + '';
750
+
};
751
+
752
+
753
+
/***/ }),
754
+
/* 29 */
755
+
/***/ (function(module, exports, __webpack_require__) {
756
+
757
+
"use strict";
758
+
759
+
var call = __webpack_require__(30);
760
+
var isObject = __webpack_require__(21);
761
+
var isSymbol = __webpack_require__(31);
762
+
var getMethod = __webpack_require__(38);
763
+
var ordinaryToPrimitive = __webpack_require__(41);
764
+
var wellKnownSymbol = __webpack_require__(42);
765
+
766
+
var $TypeError = TypeError;
767
+
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
768
+
769
+
// `ToPrimitive` abstract operation
770
+
// https://tc39.es/ecma262/#sec-toprimitive
771
+
module.exports = function (input, pref) {
772
+
if (!isObject(input) || isSymbol(input)) return input;
773
+
var exoticToPrim = getMethod(input, TO_PRIMITIVE);
774
+
var result;
775
+
if (exoticToPrim) {
776
+
if (pref === undefined) pref = 'default';
777
+
result = call(exoticToPrim, input, pref);
778
+
if (!isObject(result) || isSymbol(result)) return result;
779
+
throw new $TypeError("Can't convert object to primitive value");
780
+
}
781
+
if (pref === undefined) pref = 'number';
782
+
return ordinaryToPrimitive(input, pref);
783
+
};
784
+
785
+
786
+
/***/ }),
787
+
/* 30 */
788
+
/***/ (function(module, exports, __webpack_require__) {
789
+
790
+
"use strict";
791
+
792
+
var NATIVE_BIND = __webpack_require__(7);
793
+
794
+
var call = Function.prototype.call;
795
+
796
+
module.exports = NATIVE_BIND ? call.bind(call) : function () {
797
+
return call.apply(call, arguments);
798
+
};
799
+
800
+
801
+
/***/ }),
802
+
/* 31 */
803
+
/***/ (function(module, exports, __webpack_require__) {
804
+
805
+
"use strict";
806
+
807
+
var getBuiltIn = __webpack_require__(32);
808
+
var isCallable = __webpack_require__(8);
809
+
var isPrototypeOf = __webpack_require__(33);
810
+
var USE_SYMBOL_AS_UID = __webpack_require__(34);
811
+
812
+
var $Object = Object;
813
+
814
+
module.exports = USE_SYMBOL_AS_UID ? function (it) {
815
+
return typeof it == 'symbol';
816
+
} : function (it) {
817
+
var $Symbol = getBuiltIn('Symbol');
818
+
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
819
+
};
820
+
821
+
822
+
/***/ }),
823
+
/* 32 */
824
+
/***/ (function(module, exports, __webpack_require__) {
825
+
826
+
"use strict";
827
+
828
+
var globalThis = __webpack_require__(17);
829
+
var isCallable = __webpack_require__(8);
830
+
831
+
var aFunction = function (argument) {
832
+
return isCallable(argument) ? argument : undefined;
833
+
};
834
+
835
+
module.exports = function (namespace, method) {
836
+
return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
837
+
};
838
+
839
+
840
+
/***/ }),
841
+
/* 33 */
842
+
/***/ (function(module, exports, __webpack_require__) {
843
+
844
+
"use strict";
845
+
846
+
var uncurryThis = __webpack_require__(6);
847
+
848
+
module.exports = uncurryThis({}.isPrototypeOf);
849
+
850
+
851
+
/***/ }),
852
+
/* 34 */
853
+
/***/ (function(module, exports, __webpack_require__) {
854
+
855
+
"use strict";
856
+
857
+
/* eslint-disable es/no-symbol -- required for testing */
858
+
var NATIVE_SYMBOL = __webpack_require__(35);
859
+
860
+
module.exports = NATIVE_SYMBOL &&
861
+
!Symbol.sham &&
862
+
typeof Symbol.iterator == 'symbol';
863
+
864
+
865
+
/***/ }),
866
+
/* 35 */
867
+
/***/ (function(module, exports, __webpack_require__) {
868
+
869
+
"use strict";
870
+
871
+
/* eslint-disable es/no-symbol -- required for testing */
872
+
var V8_VERSION = __webpack_require__(36);
873
+
var fails = __webpack_require__(3);
874
+
var globalThis = __webpack_require__(17);
875
+
876
+
var $String = globalThis.String;
877
+
878
+
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
879
+
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
880
+
var symbol = Symbol('symbol detection');
881
+
// Chrome 38 Symbol has incorrect toString conversion
882
+
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
883
+
// nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
884
+
// of course, fail.
885
+
return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
886
+
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
887
+
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
888
+
});
889
+
890
+
891
+
/***/ }),
892
+
/* 36 */
893
+
/***/ (function(module, exports, __webpack_require__) {
894
+
895
+
"use strict";
896
+
897
+
var globalThis = __webpack_require__(17);
898
+
var userAgent = __webpack_require__(37);
899
+
900
+
var process = globalThis.process;
901
+
var Deno = globalThis.Deno;
902
+
var versions = process && process.versions || Deno && Deno.version;
903
+
var v8 = versions && versions.v8;
904
+
var match, version;
905
+
906
+
if (v8) {
907
+
match = v8.split('.');
908
+
// in old Chrome, versions of V8 isn't V8 = Chrome / 10
909
+
// but their correct versions are not interesting for us
910
+
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
911
+
}
912
+
913
+
// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
914
+
// so check `userAgent` even if `.v8` exists, but 0
915
+
if (!version && userAgent) {
916
+
match = userAgent.match(/Edge\/(\d+)/);
917
+
if (!match || match[1] >= 74) {
918
+
match = userAgent.match(/Chrome\/(\d+)/);
919
+
if (match) version = +match[1];
920
+
}
921
+
}
922
+
923
+
module.exports = version;
924
+
925
+
926
+
/***/ }),
927
+
/* 37 */
928
+
/***/ (function(module, exports, __webpack_require__) {
929
+
930
+
"use strict";
931
+
932
+
var globalThis = __webpack_require__(17);
933
+
934
+
var navigator = globalThis.navigator;
935
+
var userAgent = navigator && navigator.userAgent;
936
+
937
+
module.exports = userAgent ? String(userAgent) : '';
938
+
939
+
940
+
/***/ }),
941
+
/* 38 */
942
+
/***/ (function(module, exports, __webpack_require__) {
943
+
944
+
"use strict";
945
+
946
+
var aCallable = __webpack_require__(39);
947
+
var isNullOrUndefined = __webpack_require__(12);
948
+
949
+
// `GetMethod` abstract operation
950
+
// https://tc39.es/ecma262/#sec-getmethod
951
+
module.exports = function (V, P) {
952
+
var func = V[P];
953
+
return isNullOrUndefined(func) ? undefined : aCallable(func);
954
+
};
955
+
956
+
957
+
/***/ }),
958
+
/* 39 */
959
+
/***/ (function(module, exports, __webpack_require__) {
960
+
961
+
"use strict";
962
+
963
+
var isCallable = __webpack_require__(8);
964
+
var tryToString = __webpack_require__(40);
965
+
966
+
var $TypeError = TypeError;
967
+
968
+
// `Assert: IsCallable(argument) is true`
969
+
module.exports = function (argument) {
970
+
if (isCallable(argument)) return argument;
971
+
throw new $TypeError(tryToString(argument) + ' is not a function');
972
+
};
973
+
974
+
975
+
/***/ }),
976
+
/* 40 */
977
+
/***/ (function(module, exports, __webpack_require__) {
978
+
979
+
"use strict";
980
+
981
+
var $String = String;
982
+
983
+
module.exports = function (argument) {
984
+
try {
985
+
return $String(argument);
986
+
} catch (error) {
987
+
return 'Object';
988
+
}
989
+
};
990
+
991
+
992
+
/***/ }),
993
+
/* 41 */
994
+
/***/ (function(module, exports, __webpack_require__) {
995
+
996
+
"use strict";
997
+
998
+
var call = __webpack_require__(30);
999
+
var isCallable = __webpack_require__(8);
1000
+
var isObject = __webpack_require__(21);
1001
+
1002
+
var $TypeError = TypeError;
1003
+
1004
+
// `OrdinaryToPrimitive` abstract operation
1005
+
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
1006
+
module.exports = function (input, pref) {
1007
+
var fn, val;
1008
+
if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
1009
+
if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
1010
+
if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
1011
+
throw new $TypeError("Can't convert object to primitive value");
1012
+
};
1013
+
1014
+
1015
+
/***/ }),
1016
+
/* 42 */
1017
+
/***/ (function(module, exports, __webpack_require__) {
1018
+
1019
+
"use strict";
1020
+
1021
+
var globalThis = __webpack_require__(17);
1022
+
var shared = __webpack_require__(43);
1023
+
var hasOwn = __webpack_require__(9);
1024
+
var uid = __webpack_require__(44);
1025
+
var NATIVE_SYMBOL = __webpack_require__(35);
1026
+
var USE_SYMBOL_AS_UID = __webpack_require__(34);
1027
+
1028
+
var Symbol = globalThis.Symbol;
1029
+
var WellKnownSymbolsStore = shared('wks');
1030
+
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
1031
+
1032
+
module.exports = function (name) {
1033
+
if (!hasOwn(WellKnownSymbolsStore, name)) {
1034
+
WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
1035
+
? Symbol[name]
1036
+
: createWellKnownSymbol('Symbol.' + name);
1037
+
} return WellKnownSymbolsStore[name];
1038
+
};
1039
+
1040
+
1041
+
/***/ }),
1042
+
/* 43 */
1043
+
/***/ (function(module, exports, __webpack_require__) {
1044
+
1045
+
"use strict";
1046
+
1047
+
var store = __webpack_require__(15);
1048
+
1049
+
module.exports = function (key, value) {
1050
+
return store[key] || (store[key] = value || {});
1051
+
};
1052
+
1053
+
1054
+
/***/ }),
1055
+
/* 44 */
1056
+
/***/ (function(module, exports, __webpack_require__) {
1057
+
1058
+
"use strict";
1059
+
1060
+
var uncurryThis = __webpack_require__(6);
1061
+
1062
+
var id = 0;
1063
+
var postfix = Math.random();
1064
+
var toString = uncurryThis(1.0.toString);
1065
+
1066
+
module.exports = function (key) {
1067
+
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
1068
+
};
1069
+
1070
+
1071
+
/***/ }),
1072
+
/* 45 */
1073
+
/***/ (function(module, exports, __webpack_require__) {
1074
+
1075
+
"use strict";
1076
+
1077
+
module.exports = function (bitmap, value) {
1078
+
return {
1079
+
enumerable: !(bitmap & 1),
1080
+
configurable: !(bitmap & 2),
1081
+
writable: !(bitmap & 4),
1082
+
value: value
1083
+
};
1084
+
};
1085
+
1086
+
1087
+
/***/ }),
1088
+
/* 46 */
1089
+
/***/ (function(module, exports, __webpack_require__) {
1090
+
1091
+
"use strict";
1092
+
1093
+
var shared = __webpack_require__(43);
1094
+
var uid = __webpack_require__(44);
1095
+
1096
+
var keys = shared('keys');
1097
+
1098
+
module.exports = function (key) {
1099
+
return keys[key] || (keys[key] = uid(key));
1100
+
};
1101
+
1102
+
1103
+
/***/ }),
1104
+
/* 47 */
1105
+
/***/ (function(module, exports, __webpack_require__) {
1106
+
1107
+
"use strict";
1108
+
1109
+
module.exports = {};
1110
+
1111
+
1112
+
/***/ }),
1113
+
/* 48 */
1114
+
/***/ (function(module, exports, __webpack_require__) {
1115
+
1116
+
"use strict";
1117
+
1118
+
var globalThis = __webpack_require__(17);
1119
+
var uncurryThis = __webpack_require__(49);
1120
+
var arrayBufferByteLength = __webpack_require__(51);
1121
+
1122
+
var ArrayBuffer = globalThis.ArrayBuffer;
1123
+
var ArrayBufferPrototype = ArrayBuffer && ArrayBuffer.prototype;
1124
+
var slice = ArrayBufferPrototype && uncurryThis(ArrayBufferPrototype.slice);
1125
+
1126
+
module.exports = function (O) {
1127
+
if (arrayBufferByteLength(O) !== 0) return false;
1128
+
if (!slice) return false;
1129
+
try {
1130
+
slice(O, 0, 0);
1131
+
return false;
1132
+
} catch (error) {
1133
+
return true;
1134
+
}
1135
+
};
1136
+
1137
+
1138
+
/***/ }),
1139
+
/* 49 */
1140
+
/***/ (function(module, exports, __webpack_require__) {
1141
+
1142
+
"use strict";
1143
+
1144
+
var classofRaw = __webpack_require__(50);
1145
+
var uncurryThis = __webpack_require__(6);
1146
+
1147
+
module.exports = function (fn) {
1148
+
// Nashorn bug:
1149
+
// https://github.com/zloirock/core-js/issues/1128
1150
+
// https://github.com/zloirock/core-js/issues/1130
1151
+
if (classofRaw(fn) === 'Function') return uncurryThis(fn);
1152
+
};
1153
+
1154
+
1155
+
/***/ }),
1156
+
/* 50 */
1157
+
/***/ (function(module, exports, __webpack_require__) {
1158
+
1159
+
"use strict";
1160
+
1161
+
var uncurryThis = __webpack_require__(6);
1162
+
1163
+
var toString = uncurryThis({}.toString);
1164
+
var stringSlice = uncurryThis(''.slice);
1165
+
1166
+
module.exports = function (it) {
1167
+
return stringSlice(toString(it), 8, -1);
1168
+
};
1169
+
1170
+
1171
+
/***/ }),
1172
+
/* 51 */
1173
+
/***/ (function(module, exports, __webpack_require__) {
1174
+
1175
+
"use strict";
1176
+
1177
+
var globalThis = __webpack_require__(17);
1178
+
var uncurryThisAccessor = __webpack_require__(52);
1179
+
var classof = __webpack_require__(50);
1180
+
1181
+
var ArrayBuffer = globalThis.ArrayBuffer;
1182
+
var TypeError = globalThis.TypeError;
1183
+
1184
+
// Includes
1185
+
// - Perform ? RequireInternalSlot(O, [[ArrayBufferData]]).
1186
+
// - If IsSharedArrayBuffer(O) is true, throw a TypeError exception.
1187
+
module.exports = ArrayBuffer && uncurryThisAccessor(ArrayBuffer.prototype, 'byteLength', 'get') || function (O) {
1188
+
if (classof(O) !== 'ArrayBuffer') throw new TypeError('ArrayBuffer expected');
1189
+
return O.byteLength;
1190
+
};
1191
+
1192
+
1193
+
/***/ }),
1194
+
/* 52 */
1195
+
/***/ (function(module, exports, __webpack_require__) {
1196
+
1197
+
"use strict";
1198
+
1199
+
var uncurryThis = __webpack_require__(6);
1200
+
var aCallable = __webpack_require__(39);
1201
+
1202
+
module.exports = function (object, key, method) {
1203
+
try {
1204
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1205
+
return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
1206
+
} catch (error) { /* empty */ }
1207
+
};
1208
+
1209
+
1210
+
/***/ }),
1211
+
/* 53 */
1212
+
/***/ (function(module, exports, __webpack_require__) {
1213
+
1214
+
"use strict";
1215
+
1216
+
var $ = __webpack_require__(54);
1217
+
var $transfer = __webpack_require__(73);
1218
+
1219
+
// `ArrayBuffer.prototype.transfer` method
1220
+
// https://tc39.es/proposal-arraybuffer-transfer/#sec-arraybuffer.prototype.transfer
1221
+
if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
1222
+
transfer: function transfer() {
1223
+
return $transfer(this, arguments.length ? arguments[0] : undefined, true);
1224
+
}
1225
+
});
1226
+
1227
+
1228
+
/***/ }),
1229
+
/* 54 */
1230
+
/***/ (function(module, exports, __webpack_require__) {
1231
+
1232
+
"use strict";
1233
+
1234
+
var globalThis = __webpack_require__(17);
1235
+
var getOwnPropertyDescriptor = __webpack_require__(55).f;
1236
+
var createNonEnumerableProperty = __webpack_require__(22);
1237
+
var defineBuiltIn = __webpack_require__(59);
1238
+
var defineGlobalProperty = __webpack_require__(18);
1239
+
var copyConstructorProperties = __webpack_require__(60);
1240
+
var isForced = __webpack_require__(72);
1241
+
1242
+
/*
1243
+
options.target - name of the target object
1244
+
options.global - target is the global object
1245
+
options.stat - export as static methods of target
1246
+
options.proto - export as prototype methods of target
1247
+
options.real - real prototype method for the `pure` version
1248
+
options.forced - export even if the native feature is available
1249
+
options.bind - bind methods to the target, required for the `pure` version
1250
+
options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
1251
+
options.unsafe - use the simple assignment of property instead of delete + defineProperty
1252
+
options.sham - add a flag to not completely full polyfills
1253
+
options.enumerable - export as enumerable property
1254
+
options.dontCallGetSet - prevent calling a getter on target
1255
+
options.name - the .name of the function if it does not match the key
1256
+
*/
1257
+
module.exports = function (options, source) {
1258
+
var TARGET = options.target;
1259
+
var GLOBAL = options.global;
1260
+
var STATIC = options.stat;
1261
+
var FORCED, target, key, targetProperty, sourceProperty, descriptor;
1262
+
if (GLOBAL) {
1263
+
target = globalThis;
1264
+
} else if (STATIC) {
1265
+
target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
1266
+
} else {
1267
+
target = globalThis[TARGET] && globalThis[TARGET].prototype;
1268
+
}
1269
+
if (target) for (key in source) {
1270
+
sourceProperty = source[key];
1271
+
if (options.dontCallGetSet) {
1272
+
descriptor = getOwnPropertyDescriptor(target, key);
1273
+
targetProperty = descriptor && descriptor.value;
1274
+
} else targetProperty = target[key];
1275
+
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
1276
+
// contained in target
1277
+
if (!FORCED && targetProperty !== undefined) {
1278
+
if (typeof sourceProperty == typeof targetProperty) continue;
1279
+
copyConstructorProperties(sourceProperty, targetProperty);
1280
+
}
1281
+
// add a flag to not completely full polyfills
1282
+
if (options.sham || (targetProperty && targetProperty.sham)) {
1283
+
createNonEnumerableProperty(sourceProperty, 'sham', true);
1284
+
}
1285
+
defineBuiltIn(target, key, sourceProperty, options);
1286
+
}
1287
+
};
1288
+
1289
+
1290
+
/***/ }),
1291
+
/* 55 */
1292
+
/***/ (function(module, exports, __webpack_require__) {
1293
+
1294
+
"use strict";
1295
+
1296
+
var DESCRIPTORS = __webpack_require__(2);
1297
+
var call = __webpack_require__(30);
1298
+
var propertyIsEnumerableModule = __webpack_require__(56);
1299
+
var createPropertyDescriptor = __webpack_require__(45);
1300
+
var toIndexedObject = __webpack_require__(57);
1301
+
var toPropertyKey = __webpack_require__(28);
1302
+
var hasOwn = __webpack_require__(9);
1303
+
var IE8_DOM_DEFINE = __webpack_require__(24);
1304
+
1305
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1306
+
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
1307
+
1308
+
// `Object.getOwnPropertyDescriptor` method
1309
+
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
1310
+
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
1311
+
O = toIndexedObject(O);
1312
+
P = toPropertyKey(P);
1313
+
if (IE8_DOM_DEFINE) try {
1314
+
return $getOwnPropertyDescriptor(O, P);
1315
+
} catch (error) { /* empty */ }
1316
+
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
1317
+
};
1318
+
1319
+
1320
+
/***/ }),
1321
+
/* 56 */
1322
+
/***/ (function(module, exports, __webpack_require__) {
1323
+
1324
+
"use strict";
1325
+
1326
+
var $propertyIsEnumerable = {}.propertyIsEnumerable;
1327
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1328
+
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
1329
+
1330
+
// Nashorn ~ JDK8 bug
1331
+
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
1332
+
1333
+
// `Object.prototype.propertyIsEnumerable` method implementation
1334
+
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
1335
+
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
1336
+
var descriptor = getOwnPropertyDescriptor(this, V);
1337
+
return !!descriptor && descriptor.enumerable;
1338
+
} : $propertyIsEnumerable;
1339
+
1340
+
1341
+
/***/ }),
1342
+
/* 57 */
1343
+
/***/ (function(module, exports, __webpack_require__) {
1344
+
1345
+
"use strict";
1346
+
1347
+
// toObject with fallback for non-array-like ES3 strings
1348
+
var IndexedObject = __webpack_require__(58);
1349
+
var requireObjectCoercible = __webpack_require__(11);
1350
+
1351
+
module.exports = function (it) {
1352
+
return IndexedObject(requireObjectCoercible(it));
1353
+
};
1354
+
1355
+
1356
+
/***/ }),
1357
+
/* 58 */
1358
+
/***/ (function(module, exports, __webpack_require__) {
1359
+
1360
+
"use strict";
1361
+
1362
+
var uncurryThis = __webpack_require__(6);
1363
+
var fails = __webpack_require__(3);
1364
+
var classof = __webpack_require__(50);
1365
+
1366
+
var $Object = Object;
1367
+
var split = uncurryThis(''.split);
1368
+
1369
+
// fallback for non-array-like ES3 and non-enumerable old V8 strings
1370
+
module.exports = fails(function () {
1371
+
// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
1372
+
// eslint-disable-next-line no-prototype-builtins -- safe
1373
+
return !$Object('z').propertyIsEnumerable(0);
1374
+
}) ? function (it) {
1375
+
return classof(it) === 'String' ? split(it, '') : $Object(it);
1376
+
} : $Object;
1377
+
1378
+
1379
+
/***/ }),
1380
+
/* 59 */
1381
+
/***/ (function(module, exports, __webpack_require__) {
1382
+
1383
+
"use strict";
1384
+
1385
+
var isCallable = __webpack_require__(8);
1386
+
var definePropertyModule = __webpack_require__(23);
1387
+
var makeBuiltIn = __webpack_require__(5);
1388
+
var defineGlobalProperty = __webpack_require__(18);
1389
+
1390
+
module.exports = function (O, key, value, options) {
1391
+
if (!options) options = {};
1392
+
var simple = options.enumerable;
1393
+
var name = options.name !== undefined ? options.name : key;
1394
+
if (isCallable(value)) makeBuiltIn(value, name, options);
1395
+
if (options.global) {
1396
+
if (simple) O[key] = value;
1397
+
else defineGlobalProperty(key, value);
1398
+
} else {
1399
+
try {
1400
+
if (!options.unsafe) delete O[key];
1401
+
else if (O[key]) simple = true;
1402
+
} catch (error) { /* empty */ }
1403
+
if (simple) O[key] = value;
1404
+
else definePropertyModule.f(O, key, {
1405
+
value: value,
1406
+
enumerable: false,
1407
+
configurable: !options.nonConfigurable,
1408
+
writable: !options.nonWritable
1409
+
});
1410
+
} return O;
1411
+
};
1412
+
1413
+
1414
+
/***/ }),
1415
+
/* 60 */
1416
+
/***/ (function(module, exports, __webpack_require__) {
1417
+
1418
+
"use strict";
1419
+
1420
+
var hasOwn = __webpack_require__(9);
1421
+
var ownKeys = __webpack_require__(61);
1422
+
var getOwnPropertyDescriptorModule = __webpack_require__(55);
1423
+
var definePropertyModule = __webpack_require__(23);
1424
+
1425
+
module.exports = function (target, source, exceptions) {
1426
+
var keys = ownKeys(source);
1427
+
var defineProperty = definePropertyModule.f;
1428
+
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
1429
+
for (var i = 0; i < keys.length; i++) {
1430
+
var key = keys[i];
1431
+
if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
1432
+
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
1433
+
}
1434
+
}
1435
+
};
1436
+
1437
+
1438
+
/***/ }),
1439
+
/* 61 */
1440
+
/***/ (function(module, exports, __webpack_require__) {
1441
+
1442
+
"use strict";
1443
+
1444
+
var getBuiltIn = __webpack_require__(32);
1445
+
var uncurryThis = __webpack_require__(6);
1446
+
var getOwnPropertyNamesModule = __webpack_require__(62);
1447
+
var getOwnPropertySymbolsModule = __webpack_require__(71);
1448
+
var anObject = __webpack_require__(27);
1449
+
1450
+
var concat = uncurryThis([].concat);
1451
+
1452
+
// all object keys, includes non-enumerable and symbols
1453
+
module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
1454
+
var keys = getOwnPropertyNamesModule.f(anObject(it));
1455
+
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1456
+
return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
1457
+
};
1458
+
1459
+
1460
+
/***/ }),
1461
+
/* 62 */
1462
+
/***/ (function(module, exports, __webpack_require__) {
1463
+
1464
+
"use strict";
1465
+
1466
+
var internalObjectKeys = __webpack_require__(63);
1467
+
var enumBugKeys = __webpack_require__(70);
1468
+
1469
+
var hiddenKeys = enumBugKeys.concat('length', 'prototype');
1470
+
1471
+
// `Object.getOwnPropertyNames` method
1472
+
// https://tc39.es/ecma262/#sec-object.getownpropertynames
1473
+
// eslint-disable-next-line es/no-object-getownpropertynames -- safe
1474
+
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
1475
+
return internalObjectKeys(O, hiddenKeys);
1476
+
};
1477
+
1478
+
1479
+
/***/ }),
1480
+
/* 63 */
1481
+
/***/ (function(module, exports, __webpack_require__) {
1482
+
1483
+
"use strict";
1484
+
1485
+
var uncurryThis = __webpack_require__(6);
1486
+
var hasOwn = __webpack_require__(9);
1487
+
var toIndexedObject = __webpack_require__(57);
1488
+
var indexOf = __webpack_require__(64).indexOf;
1489
+
var hiddenKeys = __webpack_require__(47);
1490
+
1491
+
var push = uncurryThis([].push);
1492
+
1493
+
module.exports = function (object, names) {
1494
+
var O = toIndexedObject(object);
1495
+
var i = 0;
1496
+
var result = [];
1497
+
var key;
1498
+
for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
1499
+
// Don't enum bug & hidden keys
1500
+
while (names.length > i) if (hasOwn(O, key = names[i++])) {
1501
+
~indexOf(result, key) || push(result, key);
1502
+
}
1503
+
return result;
1504
+
};
1505
+
1506
+
1507
+
/***/ }),
1508
+
/* 64 */
1509
+
/***/ (function(module, exports, __webpack_require__) {
1510
+
1511
+
"use strict";
1512
+
1513
+
var toIndexedObject = __webpack_require__(57);
1514
+
var toAbsoluteIndex = __webpack_require__(65);
1515
+
var lengthOfArrayLike = __webpack_require__(68);
1516
+
1517
+
// `Array.prototype.{ indexOf, includes }` methods implementation
1518
+
var createMethod = function (IS_INCLUDES) {
1519
+
return function ($this, el, fromIndex) {
1520
+
var O = toIndexedObject($this);
1521
+
var length = lengthOfArrayLike(O);
1522
+
if (length === 0) return !IS_INCLUDES && -1;
1523
+
var index = toAbsoluteIndex(fromIndex, length);
1524
+
var value;
1525
+
// Array#includes uses SameValueZero equality algorithm
1526
+
// eslint-disable-next-line no-self-compare -- NaN check
1527
+
if (IS_INCLUDES && el !== el) while (length > index) {
1528
+
value = O[index++];
1529
+
// eslint-disable-next-line no-self-compare -- NaN check
1530
+
if (value !== value) return true;
1531
+
// Array#indexOf ignores holes, Array#includes - not
1532
+
} else for (;length > index; index++) {
1533
+
if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
1534
+
} return !IS_INCLUDES && -1;
1535
+
};
1536
+
};
1537
+
1538
+
module.exports = {
1539
+
// `Array.prototype.includes` method
1540
+
// https://tc39.es/ecma262/#sec-array.prototype.includes
1541
+
includes: createMethod(true),
1542
+
// `Array.prototype.indexOf` method
1543
+
// https://tc39.es/ecma262/#sec-array.prototype.indexof
1544
+
indexOf: createMethod(false)
1545
+
};
1546
+
1547
+
1548
+
/***/ }),
1549
+
/* 65 */
1550
+
/***/ (function(module, exports, __webpack_require__) {
1551
+
1552
+
"use strict";
1553
+
1554
+
var toIntegerOrInfinity = __webpack_require__(66);
1555
+
1556
+
var max = Math.max;
1557
+
var min = Math.min;
1558
+
1559
+
// Helper for a popular repeating case of the spec:
1560
+
// Let integer be ? ToInteger(index).
1561
+
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
1562
+
module.exports = function (index, length) {
1563
+
var integer = toIntegerOrInfinity(index);
1564
+
return integer < 0 ? max(integer + length, 0) : min(integer, length);
1565
+
};
1566
+
1567
+
1568
+
/***/ }),
1569
+
/* 66 */
1570
+
/***/ (function(module, exports, __webpack_require__) {
1571
+
1572
+
"use strict";
1573
+
1574
+
var trunc = __webpack_require__(67);
1575
+
1576
+
// `ToIntegerOrInfinity` abstract operation
1577
+
// https://tc39.es/ecma262/#sec-tointegerorinfinity
1578
+
module.exports = function (argument) {
1579
+
var number = +argument;
1580
+
// eslint-disable-next-line no-self-compare -- NaN check
1581
+
return number !== number || number === 0 ? 0 : trunc(number);
1582
+
};
1583
+
1584
+
1585
+
/***/ }),
1586
+
/* 67 */
1587
+
/***/ (function(module, exports, __webpack_require__) {
1588
+
1589
+
"use strict";
1590
+
1591
+
var ceil = Math.ceil;
1592
+
var floor = Math.floor;
1593
+
1594
+
// `Math.trunc` method
1595
+
// https://tc39.es/ecma262/#sec-math.trunc
1596
+
// eslint-disable-next-line es/no-math-trunc -- safe
1597
+
module.exports = Math.trunc || function trunc(x) {
1598
+
var n = +x;
1599
+
return (n > 0 ? floor : ceil)(n);
1600
+
};
1601
+
1602
+
1603
+
/***/ }),
1604
+
/* 68 */
1605
+
/***/ (function(module, exports, __webpack_require__) {
1606
+
1607
+
"use strict";
1608
+
1609
+
var toLength = __webpack_require__(69);
1610
+
1611
+
// `LengthOfArrayLike` abstract operation
1612
+
// https://tc39.es/ecma262/#sec-lengthofarraylike
1613
+
module.exports = function (obj) {
1614
+
return toLength(obj.length);
1615
+
};
1616
+
1617
+
1618
+
/***/ }),
1619
+
/* 69 */
1620
+
/***/ (function(module, exports, __webpack_require__) {
1621
+
1622
+
"use strict";
1623
+
1624
+
var toIntegerOrInfinity = __webpack_require__(66);
1625
+
1626
+
var min = Math.min;
1627
+
1628
+
// `ToLength` abstract operation
1629
+
// https://tc39.es/ecma262/#sec-tolength
1630
+
module.exports = function (argument) {
1631
+
var len = toIntegerOrInfinity(argument);
1632
+
return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1633
+
};
1634
+
1635
+
1636
+
/***/ }),
1637
+
/* 70 */
1638
+
/***/ (function(module, exports, __webpack_require__) {
1639
+
1640
+
"use strict";
1641
+
1642
+
// IE8- don't enum bug keys
1643
+
module.exports = [
1644
+
'constructor',
1645
+
'hasOwnProperty',
1646
+
'isPrototypeOf',
1647
+
'propertyIsEnumerable',
1648
+
'toLocaleString',
1649
+
'toString',
1650
+
'valueOf'
1651
+
];
1652
+
1653
+
1654
+
/***/ }),
1655
+
/* 71 */
1656
+
/***/ (function(module, exports, __webpack_require__) {
1657
+
1658
+
"use strict";
1659
+
1660
+
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
1661
+
exports.f = Object.getOwnPropertySymbols;
1662
+
1663
+
1664
+
/***/ }),
1665
+
/* 72 */
1666
+
/***/ (function(module, exports, __webpack_require__) {
1667
+
1668
+
"use strict";
1669
+
1670
+
var fails = __webpack_require__(3);
1671
+
var isCallable = __webpack_require__(8);
1672
+
1673
+
var replacement = /#|\.prototype\./;
1674
+
1675
+
var isForced = function (feature, detection) {
1676
+
var value = data[normalize(feature)];
1677
+
return value === POLYFILL ? true
1678
+
: value === NATIVE ? false
1679
+
: isCallable(detection) ? fails(detection)
1680
+
: !!detection;
1681
+
};
1682
+
1683
+
var normalize = isForced.normalize = function (string) {
1684
+
return String(string).replace(replacement, '.').toLowerCase();
1685
+
};
1686
+
1687
+
var data = isForced.data = {};
1688
+
var NATIVE = isForced.NATIVE = 'N';
1689
+
var POLYFILL = isForced.POLYFILL = 'P';
1690
+
1691
+
module.exports = isForced;
1692
+
1693
+
1694
+
/***/ }),
1695
+
/* 73 */
1696
+
/***/ (function(module, exports, __webpack_require__) {
1697
+
1698
+
"use strict";
1699
+
1700
+
var globalThis = __webpack_require__(17);
1701
+
var uncurryThis = __webpack_require__(6);
1702
+
var uncurryThisAccessor = __webpack_require__(52);
1703
+
var toIndex = __webpack_require__(74);
1704
+
var notDetached = __webpack_require__(75);
1705
+
var arrayBufferByteLength = __webpack_require__(51);
1706
+
var detachTransferable = __webpack_require__(76);
1707
+
var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(80);
1708
+
1709
+
var structuredClone = globalThis.structuredClone;
1710
+
var ArrayBuffer = globalThis.ArrayBuffer;
1711
+
var DataView = globalThis.DataView;
1712
+
var min = Math.min;
1713
+
var ArrayBufferPrototype = ArrayBuffer.prototype;
1714
+
var DataViewPrototype = DataView.prototype;
1715
+
var slice = uncurryThis(ArrayBufferPrototype.slice);
1716
+
var isResizable = uncurryThisAccessor(ArrayBufferPrototype, 'resizable', 'get');
1717
+
var maxByteLength = uncurryThisAccessor(ArrayBufferPrototype, 'maxByteLength', 'get');
1718
+
var getInt8 = uncurryThis(DataViewPrototype.getInt8);
1719
+
var setInt8 = uncurryThis(DataViewPrototype.setInt8);
1720
+
1721
+
module.exports = (PROPER_STRUCTURED_CLONE_TRANSFER || detachTransferable) && function (arrayBuffer, newLength, preserveResizability) {
1722
+
var byteLength = arrayBufferByteLength(arrayBuffer);
1723
+
var newByteLength = newLength === undefined ? byteLength : toIndex(newLength);
1724
+
var fixedLength = !isResizable || !isResizable(arrayBuffer);
1725
+
var newBuffer;
1726
+
notDetached(arrayBuffer);
1727
+
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
1728
+
arrayBuffer = structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
1729
+
if (byteLength === newByteLength && (preserveResizability || fixedLength)) return arrayBuffer;
1730
+
}
1731
+
if (byteLength >= newByteLength && (!preserveResizability || fixedLength)) {
1732
+
newBuffer = slice(arrayBuffer, 0, newByteLength);
1733
+
} else {
1734
+
var options = preserveResizability && !fixedLength && maxByteLength ? { maxByteLength: maxByteLength(arrayBuffer) } : undefined;
1735
+
newBuffer = new ArrayBuffer(newByteLength, options);
1736
+
var a = new DataView(arrayBuffer);
1737
+
var b = new DataView(newBuffer);
1738
+
var copyLength = min(newByteLength, byteLength);
1739
+
for (var i = 0; i < copyLength; i++) setInt8(b, i, getInt8(a, i));
1740
+
}
1741
+
if (!PROPER_STRUCTURED_CLONE_TRANSFER) detachTransferable(arrayBuffer);
1742
+
return newBuffer;
1743
+
};
1744
+
1745
+
1746
+
/***/ }),
1747
+
/* 74 */
1748
+
/***/ (function(module, exports, __webpack_require__) {
1749
+
1750
+
"use strict";
1751
+
1752
+
var toIntegerOrInfinity = __webpack_require__(66);
1753
+
var toLength = __webpack_require__(69);
1754
+
1755
+
var $RangeError = RangeError;
1756
+
1757
+
// `ToIndex` abstract operation
1758
+
// https://tc39.es/ecma262/#sec-toindex
1759
+
module.exports = function (it) {
1760
+
if (it === undefined) return 0;
1761
+
var number = toIntegerOrInfinity(it);
1762
+
var length = toLength(number);
1763
+
if (number !== length) throw new $RangeError('Wrong length or index');
1764
+
return length;
1765
+
};
1766
+
1767
+
1768
+
/***/ }),
1769
+
/* 75 */
1770
+
/***/ (function(module, exports, __webpack_require__) {
1771
+
1772
+
"use strict";
1773
+
1774
+
var isDetached = __webpack_require__(48);
1775
+
1776
+
var $TypeError = TypeError;
1777
+
1778
+
module.exports = function (it) {
1779
+
if (isDetached(it)) throw new $TypeError('ArrayBuffer is detached');
1780
+
return it;
1781
+
};
1782
+
1783
+
1784
+
/***/ }),
1785
+
/* 76 */
1786
+
/***/ (function(module, exports, __webpack_require__) {
1787
+
1788
+
"use strict";
1789
+
1790
+
var globalThis = __webpack_require__(17);
1791
+
var getBuiltInNodeModule = __webpack_require__(77);
1792
+
var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(80);
1793
+
1794
+
var structuredClone = globalThis.structuredClone;
1795
+
var $ArrayBuffer = globalThis.ArrayBuffer;
1796
+
var $MessageChannel = globalThis.MessageChannel;
1797
+
var detach = false;
1798
+
var WorkerThreads, channel, buffer, $detach;
1799
+
1800
+
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
1801
+
detach = function (transferable) {
1802
+
structuredClone(transferable, { transfer: [transferable] });
1803
+
};
1804
+
} else if ($ArrayBuffer) try {
1805
+
if (!$MessageChannel) {
1806
+
WorkerThreads = getBuiltInNodeModule('worker_threads');
1807
+
if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel;
1808
+
}
1809
+
1810
+
if ($MessageChannel) {
1811
+
channel = new $MessageChannel();
1812
+
buffer = new $ArrayBuffer(2);
1813
+
1814
+
$detach = function (transferable) {
1815
+
channel.port1.postMessage(null, [transferable]);
1816
+
};
1817
+
1818
+
if (buffer.byteLength === 2) {
1819
+
$detach(buffer);
1820
+
if (buffer.byteLength === 0) detach = $detach;
1821
+
}
1822
+
}
1823
+
} catch (error) { /* empty */ }
1824
+
1825
+
module.exports = detach;
1826
+
1827
+
1828
+
/***/ }),
1829
+
/* 77 */
1830
+
/***/ (function(module, exports, __webpack_require__) {
1831
+
1832
+
"use strict";
1833
+
1834
+
var globalThis = __webpack_require__(17);
1835
+
var IS_NODE = __webpack_require__(78);
1836
+
1837
+
module.exports = function (name) {
1838
+
if (IS_NODE) {
1839
+
try {
1840
+
return globalThis.process.getBuiltinModule(name);
1841
+
} catch (error) { /* empty */ }
1842
+
try {
1843
+
// eslint-disable-next-line no-new-func -- safe
1844
+
return Function('return require("' + name + '")')();
1845
+
} catch (error) { /* empty */ }
1846
+
}
1847
+
};
1848
+
1849
+
1850
+
/***/ }),
1851
+
/* 78 */
1852
+
/***/ (function(module, exports, __webpack_require__) {
1853
+
1854
+
"use strict";
1855
+
1856
+
var ENVIRONMENT = __webpack_require__(79);
1857
+
1858
+
module.exports = ENVIRONMENT === 'NODE';
1859
+
1860
+
1861
+
/***/ }),
1862
+
/* 79 */
1863
+
/***/ (function(module, exports, __webpack_require__) {
1864
+
1865
+
"use strict";
1866
+
1867
+
/* global Bun, Deno -- detection */
1868
+
var globalThis = __webpack_require__(17);
1869
+
var userAgent = __webpack_require__(37);
1870
+
var classof = __webpack_require__(50);
1871
+
1872
+
var userAgentStartsWith = function (string) {
1873
+
return userAgent.slice(0, string.length) === string;
1874
+
};
1875
+
1876
+
module.exports = (function () {
1877
+
if (userAgentStartsWith('Bun/')) return 'BUN';
1878
+
if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE';
1879
+
if (userAgentStartsWith('Deno/')) return 'DENO';
1880
+
if (userAgentStartsWith('Node.js/')) return 'NODE';
1881
+
if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN';
1882
+
if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO';
1883
+
if (classof(globalThis.process) === 'process') return 'NODE';
1884
+
if (globalThis.window && globalThis.document) return 'BROWSER';
1885
+
return 'REST';
1886
+
})();
1887
+
1888
+
1889
+
/***/ }),
1890
+
/* 80 */
1891
+
/***/ (function(module, exports, __webpack_require__) {
1892
+
1893
+
"use strict";
1894
+
1895
+
var globalThis = __webpack_require__(17);
1896
+
var fails = __webpack_require__(3);
1897
+
var V8 = __webpack_require__(36);
1898
+
var ENVIRONMENT = __webpack_require__(79);
1899
+
1900
+
var structuredClone = globalThis.structuredClone;
1901
+
1902
+
module.exports = !!structuredClone && !fails(function () {
1903
+
// prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation
1904
+
// https://github.com/zloirock/core-js/issues/679
1905
+
if ((ENVIRONMENT === 'DENO' && V8 > 92) || (ENVIRONMENT === 'NODE' && V8 > 94) || (ENVIRONMENT === 'BROWSER' && V8 > 97)) return false;
1906
+
var buffer = new ArrayBuffer(8);
1907
+
var clone = structuredClone(buffer, { transfer: [buffer] });
1908
+
return buffer.byteLength !== 0 || clone.byteLength !== 8;
1909
+
});
1910
+
1911
+
1912
+
/***/ }),
1913
+
/* 81 */
1914
+
/***/ (function(module, exports, __webpack_require__) {
1915
+
1916
+
"use strict";
1917
+
1918
+
var $ = __webpack_require__(54);
1919
+
var $transfer = __webpack_require__(73);
1920
+
1921
+
// `ArrayBuffer.prototype.transferToFixedLength` method
1922
+
// https://tc39.es/proposal-arraybuffer-transfer/#sec-arraybuffer.prototype.transfertofixedlength
1923
+
if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
1924
+
transferToFixedLength: function transferToFixedLength() {
1925
+
return $transfer(this, arguments.length ? arguments[0] : undefined, false);
1926
+
}
1927
+
});
1928
+
1929
+
1930
+
/***/ }),
1931
+
/* 82 */
1932
+
/***/ (function(module, exports, __webpack_require__) {
1933
+
1934
+
"use strict";
1935
+
1936
+
var $ = __webpack_require__(54);
1937
+
var uncurryThis = __webpack_require__(6);
1938
+
var aCallable = __webpack_require__(39);
1939
+
var requireObjectCoercible = __webpack_require__(11);
1940
+
var iterate = __webpack_require__(83);
1941
+
var MapHelpers = __webpack_require__(92);
1942
+
var IS_PURE = __webpack_require__(16);
1943
+
var fails = __webpack_require__(3);
1944
+
1945
+
var Map = MapHelpers.Map;
1946
+
var has = MapHelpers.has;
1947
+
var get = MapHelpers.get;
1948
+
var set = MapHelpers.set;
1949
+
var push = uncurryThis([].push);
1950
+
1951
+
var DOES_NOT_WORK_WITH_PRIMITIVES = IS_PURE || fails(function () {
1952
+
return Map.groupBy('ab', function (it) {
1953
+
return it;
1954
+
}).get('a').length !== 1;
1955
+
});
1956
+
1957
+
// `Map.groupBy` method
1958
+
// https://tc39.es/ecma262/#sec-map.groupby
1959
+
$({ target: 'Map', stat: true, forced: IS_PURE || DOES_NOT_WORK_WITH_PRIMITIVES }, {
1960
+
groupBy: function groupBy(items, callbackfn) {
1961
+
requireObjectCoercible(items);
1962
+
aCallable(callbackfn);
1963
+
var map = new Map();
1964
+
var k = 0;
1965
+
iterate(items, function (value) {
1966
+
var key = callbackfn(value, k++);
1967
+
if (!has(map, key)) set(map, key, [value]);
1968
+
else push(get(map, key), value);
1969
+
});
1970
+
return map;
1971
+
}
1972
+
});
1973
+
1974
+
1975
+
/***/ }),
1976
+
/* 83 */
1977
+
/***/ (function(module, exports, __webpack_require__) {
1978
+
1979
+
"use strict";
1980
+
1981
+
var bind = __webpack_require__(84);
1982
+
var call = __webpack_require__(30);
1983
+
var anObject = __webpack_require__(27);
1984
+
var tryToString = __webpack_require__(40);
1985
+
var isArrayIteratorMethod = __webpack_require__(85);
1986
+
var lengthOfArrayLike = __webpack_require__(68);
1987
+
var isPrototypeOf = __webpack_require__(33);
1988
+
var getIterator = __webpack_require__(87);
1989
+
var getIteratorMethod = __webpack_require__(88);
1990
+
var iteratorClose = __webpack_require__(91);
1991
+
1992
+
var $TypeError = TypeError;
1993
+
1994
+
var Result = function (stopped, result) {
1995
+
this.stopped = stopped;
1996
+
this.result = result;
1997
+
};
1998
+
1999
+
var ResultPrototype = Result.prototype;
2000
+
2001
+
module.exports = function (iterable, unboundFunction, options) {
2002
+
var that = options && options.that;
2003
+
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
2004
+
var IS_RECORD = !!(options && options.IS_RECORD);
2005
+
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
2006
+
var INTERRUPTED = !!(options && options.INTERRUPTED);
2007
+
var fn = bind(unboundFunction, that);
2008
+
var iterator, iterFn, index, length, result, next, step;
2009
+
2010
+
var stop = function (condition) {
2011
+
if (iterator) iteratorClose(iterator, 'normal', condition);
2012
+
return new Result(true, condition);
2013
+
};
2014
+
2015
+
var callFn = function (value) {
2016
+
if (AS_ENTRIES) {
2017
+
anObject(value);
2018
+
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
2019
+
} return INTERRUPTED ? fn(value, stop) : fn(value);
2020
+
};
2021
+
2022
+
if (IS_RECORD) {
2023
+
iterator = iterable.iterator;
2024
+
} else if (IS_ITERATOR) {
2025
+
iterator = iterable;
2026
+
} else {
2027
+
iterFn = getIteratorMethod(iterable);
2028
+
if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
2029
+
// optimisation for array iterators
2030
+
if (isArrayIteratorMethod(iterFn)) {
2031
+
for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
2032
+
result = callFn(iterable[index]);
2033
+
if (result && isPrototypeOf(ResultPrototype, result)) return result;
2034
+
} return new Result(false);
2035
+
}
2036
+
iterator = getIterator(iterable, iterFn);
2037
+
}
2038
+
2039
+
next = IS_RECORD ? iterable.next : iterator.next;
2040
+
while (!(step = call(next, iterator)).done) {
2041
+
try {
2042
+
result = callFn(step.value);
2043
+
} catch (error) {
2044
+
iteratorClose(iterator, 'throw', error);
2045
+
}
2046
+
if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
2047
+
} return new Result(false);
2048
+
};
2049
+
2050
+
2051
+
/***/ }),
2052
+
/* 84 */
2053
+
/***/ (function(module, exports, __webpack_require__) {
2054
+
2055
+
"use strict";
2056
+
2057
+
var uncurryThis = __webpack_require__(49);
2058
+
var aCallable = __webpack_require__(39);
2059
+
var NATIVE_BIND = __webpack_require__(7);
2060
+
2061
+
var bind = uncurryThis(uncurryThis.bind);
2062
+
2063
+
// optional / simple context binding
2064
+
module.exports = function (fn, that) {
2065
+
aCallable(fn);
2066
+
return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
2067
+
return fn.apply(that, arguments);
2068
+
};
2069
+
};
2070
+
2071
+
2072
+
/***/ }),
2073
+
/* 85 */
2074
+
/***/ (function(module, exports, __webpack_require__) {
2075
+
2076
+
"use strict";
2077
+
2078
+
var wellKnownSymbol = __webpack_require__(42);
2079
+
var Iterators = __webpack_require__(86);
2080
+
2081
+
var ITERATOR = wellKnownSymbol('iterator');
2082
+
var ArrayPrototype = Array.prototype;
2083
+
2084
+
// check on default Array iterator
2085
+
module.exports = function (it) {
2086
+
return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
2087
+
};
2088
+
2089
+
2090
+
/***/ }),
2091
+
/* 86 */
2092
+
/***/ (function(module, exports, __webpack_require__) {
2093
+
2094
+
"use strict";
2095
+
2096
+
module.exports = {};
2097
+
2098
+
2099
+
/***/ }),
2100
+
/* 87 */
2101
+
/***/ (function(module, exports, __webpack_require__) {
2102
+
2103
+
"use strict";
2104
+
2105
+
var call = __webpack_require__(30);
2106
+
var aCallable = __webpack_require__(39);
2107
+
var anObject = __webpack_require__(27);
2108
+
var tryToString = __webpack_require__(40);
2109
+
var getIteratorMethod = __webpack_require__(88);
2110
+
2111
+
var $TypeError = TypeError;
2112
+
2113
+
module.exports = function (argument, usingIterator) {
2114
+
var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
2115
+
if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
2116
+
throw new $TypeError(tryToString(argument) + ' is not iterable');
2117
+
};
2118
+
2119
+
2120
+
/***/ }),
2121
+
/* 88 */
2122
+
/***/ (function(module, exports, __webpack_require__) {
2123
+
2124
+
"use strict";
2125
+
2126
+
var classof = __webpack_require__(89);
2127
+
var getMethod = __webpack_require__(38);
2128
+
var isNullOrUndefined = __webpack_require__(12);
2129
+
var Iterators = __webpack_require__(86);
2130
+
var wellKnownSymbol = __webpack_require__(42);
2131
+
2132
+
var ITERATOR = wellKnownSymbol('iterator');
2133
+
2134
+
module.exports = function (it) {
2135
+
if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
2136
+
|| getMethod(it, '@@iterator')
2137
+
|| Iterators[classof(it)];
2138
+
};
2139
+
2140
+
2141
+
/***/ }),
2142
+
/* 89 */
2143
+
/***/ (function(module, exports, __webpack_require__) {
2144
+
2145
+
"use strict";
2146
+
2147
+
var TO_STRING_TAG_SUPPORT = __webpack_require__(90);
2148
+
var isCallable = __webpack_require__(8);
2149
+
var classofRaw = __webpack_require__(50);
2150
+
var wellKnownSymbol = __webpack_require__(42);
2151
+
2152
+
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
2153
+
var $Object = Object;
2154
+
2155
+
// ES3 wrong here
2156
+
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
2157
+
2158
+
// fallback for IE11 Script Access Denied error
2159
+
var tryGet = function (it, key) {
2160
+
try {
2161
+
return it[key];
2162
+
} catch (error) { /* empty */ }
2163
+
};
2164
+
2165
+
// getting tag from ES6+ `Object.prototype.toString`
2166
+
module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
2167
+
var O, tag, result;
2168
+
return it === undefined ? 'Undefined' : it === null ? 'Null'
2169
+
// @@toStringTag case
2170
+
: typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
2171
+
// builtinTag case
2172
+
: CORRECT_ARGUMENTS ? classofRaw(O)
2173
+
// ES3 arguments fallback
2174
+
: (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
2175
+
};
2176
+
2177
+
2178
+
/***/ }),
2179
+
/* 90 */
2180
+
/***/ (function(module, exports, __webpack_require__) {
2181
+
2182
+
"use strict";
2183
+
2184
+
var wellKnownSymbol = __webpack_require__(42);
2185
+
2186
+
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
2187
+
var test = {};
2188
+
2189
+
test[TO_STRING_TAG] = 'z';
2190
+
2191
+
module.exports = String(test) === '[object z]';
2192
+
2193
+
2194
+
/***/ }),
2195
+
/* 91 */
2196
+
/***/ (function(module, exports, __webpack_require__) {
2197
+
2198
+
"use strict";
2199
+
2200
+
var call = __webpack_require__(30);
2201
+
var anObject = __webpack_require__(27);
2202
+
var getMethod = __webpack_require__(38);
2203
+
2204
+
module.exports = function (iterator, kind, value) {
2205
+
var innerResult, innerError;
2206
+
anObject(iterator);
2207
+
try {
2208
+
innerResult = getMethod(iterator, 'return');
2209
+
if (!innerResult) {
2210
+
if (kind === 'throw') throw value;
2211
+
return value;
2212
+
}
2213
+
innerResult = call(innerResult, iterator);
2214
+
} catch (error) {
2215
+
innerError = true;
2216
+
innerResult = error;
2217
+
}
2218
+
if (kind === 'throw') throw value;
2219
+
if (innerError) throw innerResult;
2220
+
anObject(innerResult);
2221
+
return value;
2222
+
};
2223
+
2224
+
2225
+
/***/ }),
2226
+
/* 92 */
2227
+
/***/ (function(module, exports, __webpack_require__) {
2228
+
2229
+
"use strict";
2230
+
2231
+
var uncurryThis = __webpack_require__(6);
2232
+
2233
+
// eslint-disable-next-line es/no-map -- safe
2234
+
var MapPrototype = Map.prototype;
2235
+
2236
+
module.exports = {
2237
+
// eslint-disable-next-line es/no-map -- safe
2238
+
Map: Map,
2239
+
set: uncurryThis(MapPrototype.set),
2240
+
get: uncurryThis(MapPrototype.get),
2241
+
has: uncurryThis(MapPrototype.has),
2242
+
remove: uncurryThis(MapPrototype['delete']),
2243
+
proto: MapPrototype
2244
+
};
2245
+
2246
+
2247
+
/***/ }),
2248
+
/* 93 */
2249
+
/***/ (function(module, exports, __webpack_require__) {
2250
+
2251
+
"use strict";
2252
+
2253
+
var $ = __webpack_require__(54);
2254
+
var getBuiltIn = __webpack_require__(32);
2255
+
var uncurryThis = __webpack_require__(6);
2256
+
var aCallable = __webpack_require__(39);
2257
+
var requireObjectCoercible = __webpack_require__(11);
2258
+
var toPropertyKey = __webpack_require__(28);
2259
+
var iterate = __webpack_require__(83);
2260
+
var fails = __webpack_require__(3);
2261
+
2262
+
// eslint-disable-next-line es/no-object-groupby -- testing
2263
+
var nativeGroupBy = Object.groupBy;
2264
+
var create = getBuiltIn('Object', 'create');
2265
+
var push = uncurryThis([].push);
2266
+
2267
+
var DOES_NOT_WORK_WITH_PRIMITIVES = !nativeGroupBy || fails(function () {
2268
+
return nativeGroupBy('ab', function (it) {
2269
+
return it;
2270
+
}).a.length !== 1;
2271
+
});
2272
+
2273
+
// `Object.groupBy` method
2274
+
// https://tc39.es/ecma262/#sec-object.groupby
2275
+
$({ target: 'Object', stat: true, forced: DOES_NOT_WORK_WITH_PRIMITIVES }, {
2276
+
groupBy: function groupBy(items, callbackfn) {
2277
+
requireObjectCoercible(items);
2278
+
aCallable(callbackfn);
2279
+
var obj = create(null);
2280
+
var k = 0;
2281
+
iterate(items, function (value) {
2282
+
var key = toPropertyKey(callbackfn(value, k++));
2283
+
// in some IE versions, `hasOwnProperty` returns incorrect result on integer keys
2284
+
// but since it's a `null` prototype object, we can safely use `in`
2285
+
if (key in obj) push(obj[key], value);
2286
+
else obj[key] = [value];
2287
+
});
2288
+
return obj;
2289
+
}
2290
+
});
2291
+
2292
+
2293
+
/***/ }),
2294
+
/* 94 */
2295
+
/***/ (function(module, exports, __webpack_require__) {
2296
+
2297
+
"use strict";
2298
+
2299
+
var $ = __webpack_require__(54);
2300
+
var globalThis = __webpack_require__(17);
2301
+
var apply = __webpack_require__(95);
2302
+
var slice = __webpack_require__(96);
2303
+
var newPromiseCapabilityModule = __webpack_require__(97);
2304
+
var aCallable = __webpack_require__(39);
2305
+
var perform = __webpack_require__(98);
2306
+
2307
+
var Promise = globalThis.Promise;
2308
+
2309
+
var ACCEPT_ARGUMENTS = false;
2310
+
// Avoiding the use of polyfills of the previous iteration of this proposal
2311
+
// that does not accept arguments of the callback
2312
+
var FORCED = !Promise || !Promise['try'] || perform(function () {
2313
+
Promise['try'](function (argument) {
2314
+
ACCEPT_ARGUMENTS = argument === 8;
2315
+
}, 8);
2316
+
}).error || !ACCEPT_ARGUMENTS;
2317
+
2318
+
// `Promise.try` method
2319
+
// https://tc39.es/ecma262/#sec-promise.try
2320
+
$({ target: 'Promise', stat: true, forced: FORCED }, {
2321
+
'try': function (callbackfn /* , ...args */) {
2322
+
var args = arguments.length > 1 ? slice(arguments, 1) : [];
2323
+
var promiseCapability = newPromiseCapabilityModule.f(this);
2324
+
var result = perform(function () {
2325
+
return apply(aCallable(callbackfn), undefined, args);
2326
+
});
2327
+
(result.error ? promiseCapability.reject : promiseCapability.resolve)(result.value);
2328
+
return promiseCapability.promise;
2329
+
}
2330
+
});
2331
+
2332
+
2333
+
/***/ }),
2334
+
/* 95 */
2335
+
/***/ (function(module, exports, __webpack_require__) {
2336
+
2337
+
"use strict";
2338
+
2339
+
var NATIVE_BIND = __webpack_require__(7);
2340
+
2341
+
var FunctionPrototype = Function.prototype;
2342
+
var apply = FunctionPrototype.apply;
2343
+
var call = FunctionPrototype.call;
2344
+
2345
+
// eslint-disable-next-line es/no-reflect -- safe
2346
+
module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
2347
+
return call.apply(apply, arguments);
2348
+
});
2349
+
2350
+
2351
+
/***/ }),
2352
+
/* 96 */
2353
+
/***/ (function(module, exports, __webpack_require__) {
2354
+
2355
+
"use strict";
2356
+
2357
+
var uncurryThis = __webpack_require__(6);
2358
+
2359
+
module.exports = uncurryThis([].slice);
2360
+
2361
+
2362
+
/***/ }),
2363
+
/* 97 */
2364
+
/***/ (function(module, exports, __webpack_require__) {
2365
+
2366
+
"use strict";
2367
+
2368
+
var aCallable = __webpack_require__(39);
2369
+
2370
+
var $TypeError = TypeError;
2371
+
2372
+
var PromiseCapability = function (C) {
2373
+
var resolve, reject;
2374
+
this.promise = new C(function ($$resolve, $$reject) {
2375
+
if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');
2376
+
resolve = $$resolve;
2377
+
reject = $$reject;
2378
+
});
2379
+
this.resolve = aCallable(resolve);
2380
+
this.reject = aCallable(reject);
2381
+
};
2382
+
2383
+
// `NewPromiseCapability` abstract operation
2384
+
// https://tc39.es/ecma262/#sec-newpromisecapability
2385
+
module.exports.f = function (C) {
2386
+
return new PromiseCapability(C);
2387
+
};
2388
+
2389
+
2390
+
/***/ }),
2391
+
/* 98 */
2392
+
/***/ (function(module, exports, __webpack_require__) {
2393
+
2394
+
"use strict";
2395
+
2396
+
module.exports = function (exec) {
2397
+
try {
2398
+
return { error: false, value: exec() };
2399
+
} catch (error) {
2400
+
return { error: true, value: error };
2401
+
}
2402
+
};
2403
+
2404
+
2405
+
/***/ }),
2406
+
/* 99 */
2407
+
/***/ (function(module, exports, __webpack_require__) {
2408
+
2409
+
"use strict";
2410
+
2411
+
var $ = __webpack_require__(54);
2412
+
var newPromiseCapabilityModule = __webpack_require__(97);
2413
+
2414
+
// `Promise.withResolvers` method
2415
+
// https://tc39.es/ecma262/#sec-promise.withResolvers
2416
+
$({ target: 'Promise', stat: true }, {
2417
+
withResolvers: function withResolvers() {
2418
+
var promiseCapability = newPromiseCapabilityModule.f(this);
2419
+
return {
2420
+
promise: promiseCapability.promise,
2421
+
resolve: promiseCapability.resolve,
2422
+
reject: promiseCapability.reject
2423
+
};
2424
+
}
2425
+
});
2426
+
2427
+
2428
+
/***/ }),
2429
+
/* 100 */
2430
+
/***/ (function(module, exports, __webpack_require__) {
2431
+
2432
+
"use strict";
2433
+
2434
+
var $ = __webpack_require__(54);
2435
+
var globalThis = __webpack_require__(17);
2436
+
var getBuiltIn = __webpack_require__(32);
2437
+
var createPropertyDescriptor = __webpack_require__(45);
2438
+
var defineProperty = __webpack_require__(23).f;
2439
+
var hasOwn = __webpack_require__(9);
2440
+
var anInstance = __webpack_require__(101);
2441
+
var inheritIfRequired = __webpack_require__(102);
2442
+
var normalizeStringArgument = __webpack_require__(106);
2443
+
var DOMExceptionConstants = __webpack_require__(108);
2444
+
var clearErrorStack = __webpack_require__(109);
2445
+
var DESCRIPTORS = __webpack_require__(2);
2446
+
var IS_PURE = __webpack_require__(16);
2447
+
2448
+
var DOM_EXCEPTION = 'DOMException';
2449
+
var Error = getBuiltIn('Error');
2450
+
var NativeDOMException = getBuiltIn(DOM_EXCEPTION);
2451
+
2452
+
var $DOMException = function DOMException() {
2453
+
anInstance(this, DOMExceptionPrototype);
2454
+
var argumentsLength = arguments.length;
2455
+
var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);
2456
+
var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');
2457
+
var that = new NativeDOMException(message, name);
2458
+
var error = new Error(message);
2459
+
error.name = DOM_EXCEPTION;
2460
+
defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));
2461
+
inheritIfRequired(that, this, $DOMException);
2462
+
return that;
2463
+
};
2464
+
2465
+
var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype;
2466
+
2467
+
var ERROR_HAS_STACK = 'stack' in new Error(DOM_EXCEPTION);
2468
+
var DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2);
2469
+
2470
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2471
+
var descriptor = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(globalThis, DOM_EXCEPTION);
2472
+
2473
+
// Bun ~ 0.1.1 DOMException have incorrect descriptor and we can't redefine it
2474
+
// https://github.com/Jarred-Sumner/bun/issues/399
2475
+
var BUGGY_DESCRIPTOR = !!descriptor && !(descriptor.writable && descriptor.configurable);
2476
+
2477
+
var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK;
2478
+
2479
+
// `DOMException` constructor patch for `.stack` where it's required
2480
+
// https://webidl.spec.whatwg.org/#es-DOMException-specialness
2481
+
$({ global: true, constructor: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic
2482
+
DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException
2483
+
});
2484
+
2485
+
var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);
2486
+
var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;
2487
+
2488
+
if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) {
2489
+
if (!IS_PURE) {
2490
+
defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException));
2491
+
}
2492
+
2493
+
for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {
2494
+
var constant = DOMExceptionConstants[key];
2495
+
var constantName = constant.s;
2496
+
if (!hasOwn(PolyfilledDOMException, constantName)) {
2497
+
defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c));
2498
+
}
2499
+
}
2500
+
}
2501
+
2502
+
2503
+
/***/ }),
2504
+
/* 101 */
2505
+
/***/ (function(module, exports, __webpack_require__) {
2506
+
2507
+
"use strict";
2508
+
2509
+
var isPrototypeOf = __webpack_require__(33);
2510
+
2511
+
var $TypeError = TypeError;
2512
+
2513
+
module.exports = function (it, Prototype) {
2514
+
if (isPrototypeOf(Prototype, it)) return it;
2515
+
throw new $TypeError('Incorrect invocation');
2516
+
};
2517
+
2518
+
2519
+
/***/ }),
2520
+
/* 102 */
2521
+
/***/ (function(module, exports, __webpack_require__) {
2522
+
2523
+
"use strict";
2524
+
2525
+
var isCallable = __webpack_require__(8);
2526
+
var isObject = __webpack_require__(21);
2527
+
var setPrototypeOf = __webpack_require__(103);
2528
+
2529
+
// makes subclassing work correct for wrapped built-ins
2530
+
module.exports = function ($this, dummy, Wrapper) {
2531
+
var NewTarget, NewTargetPrototype;
2532
+
if (
2533
+
// it can work only with native `setPrototypeOf`
2534
+
setPrototypeOf &&
2535
+
// we haven't completely correct pre-ES6 way for getting `new.target`, so use this
2536
+
isCallable(NewTarget = dummy.constructor) &&
2537
+
NewTarget !== Wrapper &&
2538
+
isObject(NewTargetPrototype = NewTarget.prototype) &&
2539
+
NewTargetPrototype !== Wrapper.prototype
2540
+
) setPrototypeOf($this, NewTargetPrototype);
2541
+
return $this;
2542
+
};
2543
+
2544
+
2545
+
/***/ }),
2546
+
/* 103 */
2547
+
/***/ (function(module, exports, __webpack_require__) {
2548
+
2549
+
"use strict";
2550
+
2551
+
/* eslint-disable no-proto -- safe */
2552
+
var uncurryThisAccessor = __webpack_require__(52);
2553
+
var isObject = __webpack_require__(21);
2554
+
var requireObjectCoercible = __webpack_require__(11);
2555
+
var aPossiblePrototype = __webpack_require__(104);
2556
+
2557
+
// `Object.setPrototypeOf` method
2558
+
// https://tc39.es/ecma262/#sec-object.setprototypeof
2559
+
// Works with __proto__ only. Old v8 can't work with null proto objects.
2560
+
// eslint-disable-next-line es/no-object-setprototypeof -- safe
2561
+
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
2562
+
var CORRECT_SETTER = false;
2563
+
var test = {};
2564
+
var setter;
2565
+
try {
2566
+
setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
2567
+
setter(test, []);
2568
+
CORRECT_SETTER = test instanceof Array;
2569
+
} catch (error) { /* empty */ }
2570
+
return function setPrototypeOf(O, proto) {
2571
+
requireObjectCoercible(O);
2572
+
aPossiblePrototype(proto);
2573
+
if (!isObject(O)) return O;
2574
+
if (CORRECT_SETTER) setter(O, proto);
2575
+
else O.__proto__ = proto;
2576
+
return O;
2577
+
};
2578
+
}() : undefined);
2579
+
2580
+
2581
+
/***/ }),
2582
+
/* 104 */
2583
+
/***/ (function(module, exports, __webpack_require__) {
2584
+
2585
+
"use strict";
2586
+
2587
+
var isPossiblePrototype = __webpack_require__(105);
2588
+
2589
+
var $String = String;
2590
+
var $TypeError = TypeError;
2591
+
2592
+
module.exports = function (argument) {
2593
+
if (isPossiblePrototype(argument)) return argument;
2594
+
throw new $TypeError("Can't set " + $String(argument) + ' as a prototype');
2595
+
};
2596
+
2597
+
2598
+
/***/ }),
2599
+
/* 105 */
2600
+
/***/ (function(module, exports, __webpack_require__) {
2601
+
2602
+
"use strict";
2603
+
2604
+
var isObject = __webpack_require__(21);
2605
+
2606
+
module.exports = function (argument) {
2607
+
return isObject(argument) || argument === null;
2608
+
};
2609
+
2610
+
2611
+
/***/ }),
2612
+
/* 106 */
2613
+
/***/ (function(module, exports, __webpack_require__) {
2614
+
2615
+
"use strict";
2616
+
2617
+
var toString = __webpack_require__(107);
2618
+
2619
+
module.exports = function (argument, $default) {
2620
+
return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
2621
+
};
2622
+
2623
+
2624
+
/***/ }),
2625
+
/* 107 */
2626
+
/***/ (function(module, exports, __webpack_require__) {
2627
+
2628
+
"use strict";
2629
+
2630
+
var classof = __webpack_require__(89);
2631
+
2632
+
var $String = String;
2633
+
2634
+
module.exports = function (argument) {
2635
+
if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
2636
+
return $String(argument);
2637
+
};
2638
+
2639
+
2640
+
/***/ }),
2641
+
/* 108 */
2642
+
/***/ (function(module, exports, __webpack_require__) {
2643
+
2644
+
"use strict";
2645
+
2646
+
module.exports = {
2647
+
IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },
2648
+
DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },
2649
+
HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },
2650
+
WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 },
2651
+
InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 },
2652
+
NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 },
2653
+
NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 },
2654
+
NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 },
2655
+
NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 },
2656
+
InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 },
2657
+
InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 },
2658
+
SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 },
2659
+
InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 },
2660
+
NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 },
2661
+
InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 },
2662
+
ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 },
2663
+
TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 },
2664
+
SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 },
2665
+
NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 },
2666
+
AbortError: { s: 'ABORT_ERR', c: 20, m: 1 },
2667
+
URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 },
2668
+
QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 },
2669
+
TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 },
2670
+
InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 },
2671
+
DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 }
2672
+
};
2673
+
2674
+
2675
+
/***/ }),
2676
+
/* 109 */
2677
+
/***/ (function(module, exports, __webpack_require__) {
2678
+
2679
+
"use strict";
2680
+
2681
+
var uncurryThis = __webpack_require__(6);
2682
+
2683
+
var $Error = Error;
2684
+
var replace = uncurryThis(''.replace);
2685
+
2686
+
var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
2687
+
// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe
2688
+
var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
2689
+
var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
2690
+
2691
+
module.exports = function (stack, dropEntries) {
2692
+
if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
2693
+
while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
2694
+
} return stack;
2695
+
};
2696
+
2697
+
2698
+
/***/ }),
2699
+
/* 110 */
2700
+
/***/ (function(module, exports, __webpack_require__) {
2701
+
2702
+
"use strict";
2703
+
2704
+
var IS_PURE = __webpack_require__(16);
2705
+
var $ = __webpack_require__(54);
2706
+
var globalThis = __webpack_require__(17);
2707
+
var getBuiltIn = __webpack_require__(32);
2708
+
var uncurryThis = __webpack_require__(6);
2709
+
var fails = __webpack_require__(3);
2710
+
var uid = __webpack_require__(44);
2711
+
var isCallable = __webpack_require__(8);
2712
+
var isConstructor = __webpack_require__(111);
2713
+
var isNullOrUndefined = __webpack_require__(12);
2714
+
var isObject = __webpack_require__(21);
2715
+
var isSymbol = __webpack_require__(31);
2716
+
var iterate = __webpack_require__(83);
2717
+
var anObject = __webpack_require__(27);
2718
+
var classof = __webpack_require__(89);
2719
+
var hasOwn = __webpack_require__(9);
2720
+
var createProperty = __webpack_require__(112);
2721
+
var createNonEnumerableProperty = __webpack_require__(22);
2722
+
var lengthOfArrayLike = __webpack_require__(68);
2723
+
var validateArgumentsLength = __webpack_require__(113);
2724
+
var getRegExpFlags = __webpack_require__(114);
2725
+
var MapHelpers = __webpack_require__(92);
2726
+
var SetHelpers = __webpack_require__(116);
2727
+
var setIterate = __webpack_require__(117);
2728
+
var detachTransferable = __webpack_require__(76);
2729
+
var ERROR_STACK_INSTALLABLE = __webpack_require__(119);
2730
+
var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(80);
2731
+
2732
+
var Object = globalThis.Object;
2733
+
var Array = globalThis.Array;
2734
+
var Date = globalThis.Date;
2735
+
var Error = globalThis.Error;
2736
+
var TypeError = globalThis.TypeError;
2737
+
var PerformanceMark = globalThis.PerformanceMark;
2738
+
var DOMException = getBuiltIn('DOMException');
2739
+
var Map = MapHelpers.Map;
2740
+
var mapHas = MapHelpers.has;
2741
+
var mapGet = MapHelpers.get;
2742
+
var mapSet = MapHelpers.set;
2743
+
var Set = SetHelpers.Set;
2744
+
var setAdd = SetHelpers.add;
2745
+
var setHas = SetHelpers.has;
2746
+
var objectKeys = getBuiltIn('Object', 'keys');
2747
+
var push = uncurryThis([].push);
2748
+
var thisBooleanValue = uncurryThis(true.valueOf);
2749
+
var thisNumberValue = uncurryThis(1.0.valueOf);
2750
+
var thisStringValue = uncurryThis(''.valueOf);
2751
+
var thisTimeValue = uncurryThis(Date.prototype.getTime);
2752
+
var PERFORMANCE_MARK = uid('structuredClone');
2753
+
var DATA_CLONE_ERROR = 'DataCloneError';
2754
+
var TRANSFERRING = 'Transferring';
2755
+
2756
+
var checkBasicSemantic = function (structuredCloneImplementation) {
2757
+
return !fails(function () {
2758
+
var set1 = new globalThis.Set([7]);
2759
+
var set2 = structuredCloneImplementation(set1);
2760
+
var number = structuredCloneImplementation(Object(7));
2761
+
return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7;
2762
+
}) && structuredCloneImplementation;
2763
+
};
2764
+
2765
+
var checkErrorsCloning = function (structuredCloneImplementation, $Error) {
2766
+
return !fails(function () {
2767
+
var error = new $Error();
2768
+
var test = structuredCloneImplementation({ a: error, b: error });
2769
+
return !(test && test.a === test.b && test.a instanceof $Error && test.a.stack === error.stack);
2770
+
});
2771
+
};
2772
+
2773
+
// https://github.com/whatwg/html/pull/5749
2774
+
var checkNewErrorsCloningSemantic = function (structuredCloneImplementation) {
2775
+
return !fails(function () {
2776
+
var test = structuredCloneImplementation(new globalThis.AggregateError([1], PERFORMANCE_MARK, { cause: 3 }));
2777
+
return test.name !== 'AggregateError' || test.errors[0] !== 1 || test.message !== PERFORMANCE_MARK || test.cause !== 3;
2778
+
});
2779
+
};
2780
+
2781
+
// FF94+, Safari 15.4+, Chrome 98+, NodeJS 17.0+, Deno 1.13+
2782
+
// FF<103 and Safari implementations can't clone errors
2783
+
// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604
2784
+
// FF103 can clone errors, but `.stack` of clone is an empty string
2785
+
// https://bugzilla.mozilla.org/show_bug.cgi?id=1778762
2786
+
// FF104+ fixed it on usual errors, but not on DOMExceptions
2787
+
// https://bugzilla.mozilla.org/show_bug.cgi?id=1777321
2788
+
// Chrome <102 returns `null` if cloned object contains multiple references to one error
2789
+
// https://bugs.chromium.org/p/v8/issues/detail?id=12542
2790
+
// NodeJS implementation can't clone DOMExceptions
2791
+
// https://github.com/nodejs/node/issues/41038
2792
+
// only FF103+ supports new (html/5749) error cloning semantic
2793
+
var nativeStructuredClone = globalThis.structuredClone;
2794
+
2795
+
var FORCED_REPLACEMENT = IS_PURE
2796
+
|| !checkErrorsCloning(nativeStructuredClone, Error)
2797
+
|| !checkErrorsCloning(nativeStructuredClone, DOMException)
2798
+
|| !checkNewErrorsCloningSemantic(nativeStructuredClone);
2799
+
2800
+
// Chrome 82+, Safari 14.1+, Deno 1.11+
2801
+
// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException`
2802
+
// Chrome returns `null` if cloned object contains multiple references to one error
2803
+
// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround
2804
+
// Safari implementation can't clone errors
2805
+
// Deno 1.2-1.10 implementations too naive
2806
+
// NodeJS 16.0+ does not have `PerformanceMark` constructor
2807
+
// NodeJS <17.2 structured cloning implementation from `performance.mark` is too naive
2808
+
// and can't clone, for example, `RegExp` or some boxed primitives
2809
+
// https://github.com/nodejs/node/issues/40840
2810
+
// no one of those implementations supports new (html/5749) error cloning semantic
2811
+
var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) {
2812
+
return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail;
2813
+
});
2814
+
2815
+
var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark;
2816
+
2817
+
var throwUncloneable = function (type) {
2818
+
throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR);
2819
+
};
2820
+
2821
+
var throwUnpolyfillable = function (type, action) {
2822
+
throw new DOMException((action || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR);
2823
+
};
2824
+
2825
+
var tryNativeRestrictedStructuredClone = function (value, type) {
2826
+
if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type);
2827
+
return nativeRestrictedStructuredClone(value);
2828
+
};
2829
+
2830
+
var createDataTransfer = function () {
2831
+
var dataTransfer;
2832
+
try {
2833
+
dataTransfer = new globalThis.DataTransfer();
2834
+
} catch (error) {
2835
+
try {
2836
+
dataTransfer = new globalThis.ClipboardEvent('').clipboardData;
2837
+
} catch (error2) { /* empty */ }
2838
+
}
2839
+
return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null;
2840
+
};
2841
+
2842
+
var cloneBuffer = function (value, map, $type) {
2843
+
if (mapHas(map, value)) return mapGet(map, value);
2844
+
2845
+
var type = $type || classof(value);
2846
+
var clone, length, options, source, target, i;
2847
+
2848
+
if (type === 'SharedArrayBuffer') {
2849
+
if (nativeRestrictedStructuredClone) clone = nativeRestrictedStructuredClone(value);
2850
+
// SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original
2851
+
else clone = value;
2852
+
} else {
2853
+
var DataView = globalThis.DataView;
2854
+
2855
+
// `ArrayBuffer#slice` is not available in IE10
2856
+
// `ArrayBuffer#slice` and `DataView` are not available in old FF
2857
+
if (!DataView && !isCallable(value.slice)) throwUnpolyfillable('ArrayBuffer');
2858
+
// detached buffers throws in `DataView` and `.slice`
2859
+
try {
2860
+
if (isCallable(value.slice) && !value.resizable) {
2861
+
clone = value.slice(0);
2862
+
} else {
2863
+
length = value.byteLength;
2864
+
options = 'maxByteLength' in value ? { maxByteLength: value.maxByteLength } : undefined;
2865
+
// eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe
2866
+
clone = new ArrayBuffer(length, options);
2867
+
source = new DataView(value);
2868
+
target = new DataView(clone);
2869
+
for (i = 0; i < length; i++) {
2870
+
target.setUint8(i, source.getUint8(i));
2871
+
}
2872
+
}
2873
+
} catch (error) {
2874
+
throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR);
2875
+
}
2876
+
}
2877
+
2878
+
mapSet(map, value, clone);
2879
+
2880
+
return clone;
2881
+
};
2882
+
2883
+
var cloneView = function (value, type, offset, length, map) {
2884
+
var C = globalThis[type];
2885
+
// in some old engines like Safari 9, typeof C is 'object'
2886
+
// on Uint8ClampedArray or some other constructors
2887
+
if (!isObject(C)) throwUnpolyfillable(type);
2888
+
return new C(cloneBuffer(value.buffer, map), offset, length);
2889
+
};
2890
+
2891
+
var structuredCloneInternal = function (value, map) {
2892
+
if (isSymbol(value)) throwUncloneable('Symbol');
2893
+
if (!isObject(value)) return value;
2894
+
// effectively preserves circular references
2895
+
if (map) {
2896
+
if (mapHas(map, value)) return mapGet(map, value);
2897
+
} else map = new Map();
2898
+
2899
+
var type = classof(value);
2900
+
var C, name, cloned, dataTransfer, i, length, keys, key;
2901
+
2902
+
switch (type) {
2903
+
case 'Array':
2904
+
cloned = Array(lengthOfArrayLike(value));
2905
+
break;
2906
+
case 'Object':
2907
+
cloned = {};
2908
+
break;
2909
+
case 'Map':
2910
+
cloned = new Map();
2911
+
break;
2912
+
case 'Set':
2913
+
cloned = new Set();
2914
+
break;
2915
+
case 'RegExp':
2916
+
// in this block because of a Safari 14.1 bug
2917
+
// old FF does not clone regexes passed to the constructor, so get the source and flags directly
2918
+
cloned = new RegExp(value.source, getRegExpFlags(value));
2919
+
break;
2920
+
case 'Error':
2921
+
name = value.name;
2922
+
switch (name) {
2923
+
case 'AggregateError':
2924
+
cloned = new (getBuiltIn(name))([]);
2925
+
break;
2926
+
case 'EvalError':
2927
+
case 'RangeError':
2928
+
case 'ReferenceError':
2929
+
case 'SuppressedError':
2930
+
case 'SyntaxError':
2931
+
case 'TypeError':
2932
+
case 'URIError':
2933
+
cloned = new (getBuiltIn(name))();
2934
+
break;
2935
+
case 'CompileError':
2936
+
case 'LinkError':
2937
+
case 'RuntimeError':
2938
+
cloned = new (getBuiltIn('WebAssembly', name))();
2939
+
break;
2940
+
default:
2941
+
cloned = new Error();
2942
+
}
2943
+
break;
2944
+
case 'DOMException':
2945
+
cloned = new DOMException(value.message, value.name);
2946
+
break;
2947
+
case 'ArrayBuffer':
2948
+
case 'SharedArrayBuffer':
2949
+
cloned = cloneBuffer(value, map, type);
2950
+
break;
2951
+
case 'DataView':
2952
+
case 'Int8Array':
2953
+
case 'Uint8Array':
2954
+
case 'Uint8ClampedArray':
2955
+
case 'Int16Array':
2956
+
case 'Uint16Array':
2957
+
case 'Int32Array':
2958
+
case 'Uint32Array':
2959
+
case 'Float16Array':
2960
+
case 'Float32Array':
2961
+
case 'Float64Array':
2962
+
case 'BigInt64Array':
2963
+
case 'BigUint64Array':
2964
+
length = type === 'DataView' ? value.byteLength : value.length;
2965
+
cloned = cloneView(value, type, value.byteOffset, length, map);
2966
+
break;
2967
+
case 'DOMQuad':
2968
+
try {
2969
+
cloned = new DOMQuad(
2970
+
structuredCloneInternal(value.p1, map),
2971
+
structuredCloneInternal(value.p2, map),
2972
+
structuredCloneInternal(value.p3, map),
2973
+
structuredCloneInternal(value.p4, map)
2974
+
);
2975
+
} catch (error) {
2976
+
cloned = tryNativeRestrictedStructuredClone(value, type);
2977
+
}
2978
+
break;
2979
+
case 'File':
2980
+
if (nativeRestrictedStructuredClone) try {
2981
+
cloned = nativeRestrictedStructuredClone(value);
2982
+
// NodeJS 20.0.0 bug, https://github.com/nodejs/node/issues/47612
2983
+
if (classof(cloned) !== type) cloned = undefined;
2984
+
} catch (error) { /* empty */ }
2985
+
if (!cloned) try {
2986
+
cloned = new File([value], value.name, value);
2987
+
} catch (error) { /* empty */ }
2988
+
if (!cloned) throwUnpolyfillable(type);
2989
+
break;
2990
+
case 'FileList':
2991
+
dataTransfer = createDataTransfer();
2992
+
if (dataTransfer) {
2993
+
for (i = 0, length = lengthOfArrayLike(value); i < length; i++) {
2994
+
dataTransfer.items.add(structuredCloneInternal(value[i], map));
2995
+
}
2996
+
cloned = dataTransfer.files;
2997
+
} else cloned = tryNativeRestrictedStructuredClone(value, type);
2998
+
break;
2999
+
case 'ImageData':
3000
+
// Safari 9 ImageData is a constructor, but typeof ImageData is 'object'
3001
+
try {
3002
+
cloned = new ImageData(
3003
+
structuredCloneInternal(value.data, map),
3004
+
value.width,
3005
+
value.height,
3006
+
{ colorSpace: value.colorSpace }
3007
+
);
3008
+
} catch (error) {
3009
+
cloned = tryNativeRestrictedStructuredClone(value, type);
3010
+
} break;
3011
+
default:
3012
+
if (nativeRestrictedStructuredClone) {
3013
+
cloned = nativeRestrictedStructuredClone(value);
3014
+
} else switch (type) {
3015
+
case 'BigInt':
3016
+
// can be a 3rd party polyfill
3017
+
cloned = Object(value.valueOf());
3018
+
break;
3019
+
case 'Boolean':
3020
+
cloned = Object(thisBooleanValue(value));
3021
+
break;
3022
+
case 'Number':
3023
+
cloned = Object(thisNumberValue(value));
3024
+
break;
3025
+
case 'String':
3026
+
cloned = Object(thisStringValue(value));
3027
+
break;
3028
+
case 'Date':
3029
+
cloned = new Date(thisTimeValue(value));
3030
+
break;
3031
+
case 'Blob':
3032
+
try {
3033
+
cloned = value.slice(0, value.size, value.type);
3034
+
} catch (error) {
3035
+
throwUnpolyfillable(type);
3036
+
} break;
3037
+
case 'DOMPoint':
3038
+
case 'DOMPointReadOnly':
3039
+
C = globalThis[type];
3040
+
try {
3041
+
cloned = C.fromPoint
3042
+
? C.fromPoint(value)
3043
+
: new C(value.x, value.y, value.z, value.w);
3044
+
} catch (error) {
3045
+
throwUnpolyfillable(type);
3046
+
} break;
3047
+
case 'DOMRect':
3048
+
case 'DOMRectReadOnly':
3049
+
C = globalThis[type];
3050
+
try {
3051
+
cloned = C.fromRect
3052
+
? C.fromRect(value)
3053
+
: new C(value.x, value.y, value.width, value.height);
3054
+
} catch (error) {
3055
+
throwUnpolyfillable(type);
3056
+
} break;
3057
+
case 'DOMMatrix':
3058
+
case 'DOMMatrixReadOnly':
3059
+
C = globalThis[type];
3060
+
try {
3061
+
cloned = C.fromMatrix
3062
+
? C.fromMatrix(value)
3063
+
: new C(value);
3064
+
} catch (error) {
3065
+
throwUnpolyfillable(type);
3066
+
} break;
3067
+
case 'AudioData':
3068
+
case 'VideoFrame':
3069
+
if (!isCallable(value.clone)) throwUnpolyfillable(type);
3070
+
try {
3071
+
cloned = value.clone();
3072
+
} catch (error) {
3073
+
throwUncloneable(type);
3074
+
} break;
3075
+
case 'CropTarget':
3076
+
case 'CryptoKey':
3077
+
case 'FileSystemDirectoryHandle':
3078
+
case 'FileSystemFileHandle':
3079
+
case 'FileSystemHandle':
3080
+
case 'GPUCompilationInfo':
3081
+
case 'GPUCompilationMessage':
3082
+
case 'ImageBitmap':
3083
+
case 'RTCCertificate':
3084
+
case 'WebAssembly.Module':
3085
+
throwUnpolyfillable(type);
3086
+
// break omitted
3087
+
default:
3088
+
throwUncloneable(type);
3089
+
}
3090
+
}
3091
+
3092
+
mapSet(map, value, cloned);
3093
+
3094
+
switch (type) {
3095
+
case 'Array':
3096
+
case 'Object':
3097
+
keys = objectKeys(value);
3098
+
for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) {
3099
+
key = keys[i];
3100
+
createProperty(cloned, key, structuredCloneInternal(value[key], map));
3101
+
} break;
3102
+
case 'Map':
3103
+
value.forEach(function (v, k) {
3104
+
mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map));
3105
+
});
3106
+
break;
3107
+
case 'Set':
3108
+
value.forEach(function (v) {
3109
+
setAdd(cloned, structuredCloneInternal(v, map));
3110
+
});
3111
+
break;
3112
+
case 'Error':
3113
+
createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map));
3114
+
if (hasOwn(value, 'cause')) {
3115
+
createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map));
3116
+
}
3117
+
if (name === 'AggregateError') {
3118
+
cloned.errors = structuredCloneInternal(value.errors, map);
3119
+
} else if (name === 'SuppressedError') {
3120
+
cloned.error = structuredCloneInternal(value.error, map);
3121
+
cloned.suppressed = structuredCloneInternal(value.suppressed, map);
3122
+
} // break omitted
3123
+
case 'DOMException':
3124
+
if (ERROR_STACK_INSTALLABLE) {
3125
+
createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map));
3126
+
}
3127
+
}
3128
+
3129
+
return cloned;
3130
+
};
3131
+
3132
+
var tryToTransfer = function (rawTransfer, map) {
3133
+
if (!isObject(rawTransfer)) throw new TypeError('Transfer option cannot be converted to a sequence');
3134
+
3135
+
var transfer = [];
3136
+
3137
+
iterate(rawTransfer, function (value) {
3138
+
push(transfer, anObject(value));
3139
+
});
3140
+
3141
+
var i = 0;
3142
+
var length = lengthOfArrayLike(transfer);
3143
+
var buffers = new Set();
3144
+
var value, type, C, transferred, canvas, context;
3145
+
3146
+
while (i < length) {
3147
+
value = transfer[i++];
3148
+
3149
+
type = classof(value);
3150
+
3151
+
if (type === 'ArrayBuffer' ? setHas(buffers, value) : mapHas(map, value)) {
3152
+
throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR);
3153
+
}
3154
+
3155
+
if (type === 'ArrayBuffer') {
3156
+
setAdd(buffers, value);
3157
+
continue;
3158
+
}
3159
+
3160
+
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
3161
+
transferred = nativeStructuredClone(value, { transfer: [value] });
3162
+
} else switch (type) {
3163
+
case 'ImageBitmap':
3164
+
C = globalThis.OffscreenCanvas;
3165
+
if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING);
3166
+
try {
3167
+
canvas = new C(value.width, value.height);
3168
+
context = canvas.getContext('bitmaprenderer');
3169
+
context.transferFromImageBitmap(value);
3170
+
transferred = canvas.transferToImageBitmap();
3171
+
} catch (error) { /* empty */ }
3172
+
break;
3173
+
case 'AudioData':
3174
+
case 'VideoFrame':
3175
+
if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING);
3176
+
try {
3177
+
transferred = value.clone();
3178
+
value.close();
3179
+
} catch (error) { /* empty */ }
3180
+
break;
3181
+
case 'MediaSourceHandle':
3182
+
case 'MessagePort':
3183
+
case 'MIDIAccess':
3184
+
case 'OffscreenCanvas':
3185
+
case 'ReadableStream':
3186
+
case 'RTCDataChannel':
3187
+
case 'TransformStream':
3188
+
case 'WebTransportReceiveStream':
3189
+
case 'WebTransportSendStream':
3190
+
case 'WritableStream':
3191
+
throwUnpolyfillable(type, TRANSFERRING);
3192
+
}
3193
+
3194
+
if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR);
3195
+
3196
+
mapSet(map, value, transferred);
3197
+
}
3198
+
3199
+
return buffers;
3200
+
};
3201
+
3202
+
var detachBuffers = function (buffers) {
3203
+
setIterate(buffers, function (buffer) {
3204
+
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
3205
+
nativeRestrictedStructuredClone(buffer, { transfer: [buffer] });
3206
+
} else if (isCallable(buffer.transfer)) {
3207
+
buffer.transfer();
3208
+
} else if (detachTransferable) {
3209
+
detachTransferable(buffer);
3210
+
} else {
3211
+
throwUnpolyfillable('ArrayBuffer', TRANSFERRING);
3212
+
}
3213
+
});
3214
+
};
3215
+
3216
+
// `structuredClone` method
3217
+
// https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone
3218
+
$({ global: true, enumerable: true, sham: !PROPER_STRUCTURED_CLONE_TRANSFER, forced: FORCED_REPLACEMENT }, {
3219
+
structuredClone: function structuredClone(value /* , { transfer } */) {
3220
+
var options = validateArgumentsLength(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject(arguments[1]) : undefined;
3221
+
var transfer = options ? options.transfer : undefined;
3222
+
var map, buffers;
3223
+
3224
+
if (transfer !== undefined) {
3225
+
map = new Map();
3226
+
buffers = tryToTransfer(transfer, map);
3227
+
}
3228
+
3229
+
var clone = structuredCloneInternal(value, map);
3230
+
3231
+
// since of an issue with cloning views of transferred buffers, we a forced to detach them later
3232
+
// https://github.com/zloirock/core-js/issues/1265
3233
+
if (buffers) detachBuffers(buffers);
3234
+
3235
+
return clone;
3236
+
}
3237
+
});
3238
+
3239
+
3240
+
/***/ }),
3241
+
/* 111 */
3242
+
/***/ (function(module, exports, __webpack_require__) {
3243
+
3244
+
"use strict";
3245
+
3246
+
var uncurryThis = __webpack_require__(6);
3247
+
var fails = __webpack_require__(3);
3248
+
var isCallable = __webpack_require__(8);
3249
+
var classof = __webpack_require__(89);
3250
+
var getBuiltIn = __webpack_require__(32);
3251
+
var inspectSource = __webpack_require__(14);
3252
+
3253
+
var noop = function () { /* empty */ };
3254
+
var construct = getBuiltIn('Reflect', 'construct');
3255
+
var constructorRegExp = /^\s*(?:class|function)\b/;
3256
+
var exec = uncurryThis(constructorRegExp.exec);
3257
+
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
3258
+
3259
+
var isConstructorModern = function isConstructor(argument) {
3260
+
if (!isCallable(argument)) return false;
3261
+
try {
3262
+
construct(noop, [], argument);
3263
+
return true;
3264
+
} catch (error) {
3265
+
return false;
3266
+
}
3267
+
};
3268
+
3269
+
var isConstructorLegacy = function isConstructor(argument) {
3270
+
if (!isCallable(argument)) return false;
3271
+
switch (classof(argument)) {
3272
+
case 'AsyncFunction':
3273
+
case 'GeneratorFunction':
3274
+
case 'AsyncGeneratorFunction': return false;
3275
+
}
3276
+
try {
3277
+
// we can't check .prototype since constructors produced by .bind haven't it
3278
+
// `Function#toString` throws on some built-it function in some legacy engines
3279
+
// (for example, `DOMQuad` and similar in FF41-)
3280
+
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
3281
+
} catch (error) {
3282
+
return true;
3283
+
}
3284
+
};
3285
+
3286
+
isConstructorLegacy.sham = true;
3287
+
3288
+
// `IsConstructor` abstract operation
3289
+
// https://tc39.es/ecma262/#sec-isconstructor
3290
+
module.exports = !construct || fails(function () {
3291
+
var called;
3292
+
return isConstructorModern(isConstructorModern.call)
3293
+
|| !isConstructorModern(Object)
3294
+
|| !isConstructorModern(function () { called = true; })
3295
+
|| called;
3296
+
}) ? isConstructorLegacy : isConstructorModern;
3297
+
3298
+
3299
+
/***/ }),
3300
+
/* 112 */
3301
+
/***/ (function(module, exports, __webpack_require__) {
3302
+
3303
+
"use strict";
3304
+
3305
+
var DESCRIPTORS = __webpack_require__(2);
3306
+
var definePropertyModule = __webpack_require__(23);
3307
+
var createPropertyDescriptor = __webpack_require__(45);
3308
+
3309
+
module.exports = function (object, key, value) {
3310
+
if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
3311
+
else object[key] = value;
3312
+
};
3313
+
3314
+
3315
+
/***/ }),
3316
+
/* 113 */
3317
+
/***/ (function(module, exports, __webpack_require__) {
3318
+
3319
+
"use strict";
3320
+
3321
+
var $TypeError = TypeError;
3322
+
3323
+
module.exports = function (passed, required) {
3324
+
if (passed < required) throw new $TypeError('Not enough arguments');
3325
+
return passed;
3326
+
};
3327
+
3328
+
3329
+
/***/ }),
3330
+
/* 114 */
3331
+
/***/ (function(module, exports, __webpack_require__) {
3332
+
3333
+
"use strict";
3334
+
3335
+
var call = __webpack_require__(30);
3336
+
var hasOwn = __webpack_require__(9);
3337
+
var isPrototypeOf = __webpack_require__(33);
3338
+
var regExpFlags = __webpack_require__(115);
3339
+
3340
+
var RegExpPrototype = RegExp.prototype;
3341
+
3342
+
module.exports = function (R) {
3343
+
var flags = R.flags;
3344
+
return flags === undefined && !('flags' in RegExpPrototype) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype, R)
3345
+
? call(regExpFlags, R) : flags;
3346
+
};
3347
+
3348
+
3349
+
/***/ }),
3350
+
/* 115 */
3351
+
/***/ (function(module, exports, __webpack_require__) {
3352
+
3353
+
"use strict";
3354
+
3355
+
var anObject = __webpack_require__(27);
3356
+
3357
+
// `RegExp.prototype.flags` getter implementation
3358
+
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
3359
+
module.exports = function () {
3360
+
var that = anObject(this);
3361
+
var result = '';
3362
+
if (that.hasIndices) result += 'd';
3363
+
if (that.global) result += 'g';
3364
+
if (that.ignoreCase) result += 'i';
3365
+
if (that.multiline) result += 'm';
3366
+
if (that.dotAll) result += 's';
3367
+
if (that.unicode) result += 'u';
3368
+
if (that.unicodeSets) result += 'v';
3369
+
if (that.sticky) result += 'y';
3370
+
return result;
3371
+
};
3372
+
3373
+
3374
+
/***/ }),
3375
+
/* 116 */
3376
+
/***/ (function(module, exports, __webpack_require__) {
3377
+
3378
+
"use strict";
3379
+
3380
+
var uncurryThis = __webpack_require__(6);
3381
+
3382
+
// eslint-disable-next-line es/no-set -- safe
3383
+
var SetPrototype = Set.prototype;
3384
+
3385
+
module.exports = {
3386
+
// eslint-disable-next-line es/no-set -- safe
3387
+
Set: Set,
3388
+
add: uncurryThis(SetPrototype.add),
3389
+
has: uncurryThis(SetPrototype.has),
3390
+
remove: uncurryThis(SetPrototype['delete']),
3391
+
proto: SetPrototype
3392
+
};
3393
+
3394
+
3395
+
/***/ }),
3396
+
/* 117 */
3397
+
/***/ (function(module, exports, __webpack_require__) {
3398
+
3399
+
"use strict";
3400
+
3401
+
var uncurryThis = __webpack_require__(6);
3402
+
var iterateSimple = __webpack_require__(118);
3403
+
var SetHelpers = __webpack_require__(116);
3404
+
3405
+
var Set = SetHelpers.Set;
3406
+
var SetPrototype = SetHelpers.proto;
3407
+
var forEach = uncurryThis(SetPrototype.forEach);
3408
+
var keys = uncurryThis(SetPrototype.keys);
3409
+
var next = keys(new Set()).next;
3410
+
3411
+
module.exports = function (set, fn, interruptible) {
3412
+
return interruptible ? iterateSimple({ iterator: keys(set), next: next }, fn) : forEach(set, fn);
3413
+
};
3414
+
3415
+
3416
+
/***/ }),
3417
+
/* 118 */
3418
+
/***/ (function(module, exports, __webpack_require__) {
3419
+
3420
+
"use strict";
3421
+
3422
+
var call = __webpack_require__(30);
3423
+
3424
+
module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
3425
+
var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
3426
+
var next = record.next;
3427
+
var step, result;
3428
+
while (!(step = call(next, iterator)).done) {
3429
+
result = fn(step.value);
3430
+
if (result !== undefined) return result;
3431
+
}
3432
+
};
3433
+
3434
+
3435
+
/***/ }),
3436
+
/* 119 */
3437
+
/***/ (function(module, exports, __webpack_require__) {
3438
+
3439
+
"use strict";
3440
+
3441
+
var fails = __webpack_require__(3);
3442
+
var createPropertyDescriptor = __webpack_require__(45);
3443
+
3444
+
module.exports = !fails(function () {
3445
+
var error = new Error('a');
3446
+
if (!('stack' in error)) return true;
3447
+
// eslint-disable-next-line es/no-object-defineproperty -- safe
3448
+
Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
3449
+
return error.stack !== 7;
3450
+
});
3451
+
3452
+
3453
+
/***/ }),
3454
+
/* 120 */
3455
+
/***/ (function(module, exports, __webpack_require__) {
3456
+
3457
+
"use strict";
3458
+
3459
+
var $ = __webpack_require__(54);
3460
+
var getBuiltIn = __webpack_require__(32);
3461
+
var fails = __webpack_require__(3);
3462
+
var validateArgumentsLength = __webpack_require__(113);
3463
+
var toString = __webpack_require__(107);
3464
+
var USE_NATIVE_URL = __webpack_require__(121);
3465
+
3466
+
var URL = getBuiltIn('URL');
3467
+
3468
+
// https://github.com/nodejs/node/issues/47505
3469
+
// https://github.com/denoland/deno/issues/18893
3470
+
var THROWS_WITHOUT_ARGUMENTS = USE_NATIVE_URL && fails(function () {
3471
+
URL.canParse();
3472
+
});
3473
+
3474
+
// Bun ~ 1.0.30 bug
3475
+
// https://github.com/oven-sh/bun/issues/9250
3476
+
var WRONG_ARITY = fails(function () {
3477
+
return URL.canParse.length !== 1;
3478
+
});
3479
+
3480
+
// `URL.canParse` method
3481
+
// https://url.spec.whatwg.org/#dom-url-canparse
3482
+
$({ target: 'URL', stat: true, forced: !THROWS_WITHOUT_ARGUMENTS || WRONG_ARITY }, {
3483
+
canParse: function canParse(url) {
3484
+
var length = validateArgumentsLength(arguments.length, 1);
3485
+
var urlString = toString(url);
3486
+
var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]);
3487
+
try {
3488
+
return !!new URL(urlString, base);
3489
+
} catch (error) {
3490
+
return false;
3491
+
}
3492
+
}
3493
+
});
3494
+
3495
+
3496
+
/***/ }),
3497
+
/* 121 */
3498
+
/***/ (function(module, exports, __webpack_require__) {
3499
+
3500
+
"use strict";
3501
+
3502
+
var fails = __webpack_require__(3);
3503
+
var wellKnownSymbol = __webpack_require__(42);
3504
+
var DESCRIPTORS = __webpack_require__(2);
3505
+
var IS_PURE = __webpack_require__(16);
3506
+
3507
+
var ITERATOR = wellKnownSymbol('iterator');
3508
+
3509
+
module.exports = !fails(function () {
3510
+
// eslint-disable-next-line unicorn/relative-url-style -- required for testing
3511
+
var url = new URL('b?a=1&b=2&c=3', 'https://a');
3512
+
var params = url.searchParams;
3513
+
var params2 = new URLSearchParams('a=1&a=2&b=3');
3514
+
var result = '';
3515
+
url.pathname = 'c%20d';
3516
+
params.forEach(function (value, key) {
3517
+
params['delete']('b');
3518
+
result += key + value;
3519
+
});
3520
+
params2['delete']('a', 2);
3521
+
// `undefined` case is a Chromium 117 bug
3522
+
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
3523
+
params2['delete']('b', undefined);
3524
+
return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b')))
3525
+
|| (!params.size && (IS_PURE || !DESCRIPTORS))
3526
+
|| !params.sort
3527
+
|| url.href !== 'https://a/c%20d?a=1&c=3'
3528
+
|| params.get('c') !== '3'
3529
+
|| String(new URLSearchParams('?a=1')) !== 'a=1'
3530
+
|| !params[ITERATOR]
3531
+
// throws in Edge
3532
+
|| new URL('https://a@b').username !== 'a'
3533
+
|| new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
3534
+
// not punycoded in Edge
3535
+
|| new URL('https://тест').host !== 'xn--e1aybc'
3536
+
// not escaped in Chrome 62-
3537
+
|| new URL('https://a#б').hash !== '#%D0%B1'
3538
+
// fails in Chrome 66-
3539
+
|| result !== 'a1c3'
3540
+
// throws in Safari
3541
+
|| new URL('https://x', undefined).host !== 'x';
3542
+
});
3543
+
3544
+
3545
+
/***/ }),
3546
+
/* 122 */
3547
+
/***/ (function(module, exports, __webpack_require__) {
3548
+
3549
+
"use strict";
3550
+
3551
+
var $ = __webpack_require__(54);
3552
+
var getBuiltIn = __webpack_require__(32);
3553
+
var validateArgumentsLength = __webpack_require__(113);
3554
+
var toString = __webpack_require__(107);
3555
+
var USE_NATIVE_URL = __webpack_require__(121);
3556
+
3557
+
var URL = getBuiltIn('URL');
3558
+
3559
+
// `URL.parse` method
3560
+
// https://url.spec.whatwg.org/#dom-url-canparse
3561
+
$({ target: 'URL', stat: true, forced: !USE_NATIVE_URL }, {
3562
+
parse: function parse(url) {
3563
+
var length = validateArgumentsLength(arguments.length, 1);
3564
+
var urlString = toString(url);
3565
+
var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]);
3566
+
try {
3567
+
return new URL(urlString, base);
3568
+
} catch (error) {
3569
+
return null;
3570
+
}
3571
+
}
3572
+
});
3573
+
3574
+
3575
+
/***/ }),
3576
+
/* 123 */
3577
+
/***/ (function(module, exports, __webpack_require__) {
3578
+
3579
+
"use strict";
3580
+
3581
+
var defineBuiltIn = __webpack_require__(59);
3582
+
var uncurryThis = __webpack_require__(6);
3583
+
var toString = __webpack_require__(107);
3584
+
var validateArgumentsLength = __webpack_require__(113);
3585
+
3586
+
var $URLSearchParams = URLSearchParams;
3587
+
var URLSearchParamsPrototype = $URLSearchParams.prototype;
3588
+
var append = uncurryThis(URLSearchParamsPrototype.append);
3589
+
var $delete = uncurryThis(URLSearchParamsPrototype['delete']);
3590
+
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
3591
+
var push = uncurryThis([].push);
3592
+
var params = new $URLSearchParams('a=1&a=2&b=3');
3593
+
3594
+
params['delete']('a', 1);
3595
+
// `undefined` case is a Chromium 117 bug
3596
+
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
3597
+
params['delete']('b', undefined);
3598
+
3599
+
if (params + '' !== 'a=2') {
3600
+
defineBuiltIn(URLSearchParamsPrototype, 'delete', function (name /* , value */) {
3601
+
var length = arguments.length;
3602
+
var $value = length < 2 ? undefined : arguments[1];
3603
+
if (length && $value === undefined) return $delete(this, name);
3604
+
var entries = [];
3605
+
forEach(this, function (v, k) { // also validates `this`
3606
+
push(entries, { key: k, value: v });
3607
+
});
3608
+
validateArgumentsLength(length, 1);
3609
+
var key = toString(name);
3610
+
var value = toString($value);
3611
+
var index = 0;
3612
+
var dindex = 0;
3613
+
var found = false;
3614
+
var entriesLength = entries.length;
3615
+
var entry;
3616
+
while (index < entriesLength) {
3617
+
entry = entries[index++];
3618
+
if (found || entry.key === key) {
3619
+
found = true;
3620
+
$delete(this, entry.key);
3621
+
} else dindex++;
3622
+
}
3623
+
while (dindex < entriesLength) {
3624
+
entry = entries[dindex++];
3625
+
if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value);
3626
+
}
3627
+
}, { enumerable: true, unsafe: true });
3628
+
}
3629
+
3630
+
3631
+
/***/ }),
3632
+
/* 124 */
3633
+
/***/ (function(module, exports, __webpack_require__) {
3634
+
3635
+
"use strict";
3636
+
3637
+
var defineBuiltIn = __webpack_require__(59);
3638
+
var uncurryThis = __webpack_require__(6);
3639
+
var toString = __webpack_require__(107);
3640
+
var validateArgumentsLength = __webpack_require__(113);
3641
+
3642
+
var $URLSearchParams = URLSearchParams;
3643
+
var URLSearchParamsPrototype = $URLSearchParams.prototype;
3644
+
var getAll = uncurryThis(URLSearchParamsPrototype.getAll);
3645
+
var $has = uncurryThis(URLSearchParamsPrototype.has);
3646
+
var params = new $URLSearchParams('a=1');
3647
+
3648
+
// `undefined` case is a Chromium 117 bug
3649
+
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
3650
+
if (params.has('a', 2) || !params.has('a', undefined)) {
3651
+
defineBuiltIn(URLSearchParamsPrototype, 'has', function has(name /* , value */) {
3652
+
var length = arguments.length;
3653
+
var $value = length < 2 ? undefined : arguments[1];
3654
+
if (length && $value === undefined) return $has(this, name);
3655
+
var values = getAll(this, name); // also validates `this`
3656
+
validateArgumentsLength(length, 1);
3657
+
var value = toString($value);
3658
+
var index = 0;
3659
+
while (index < values.length) {
3660
+
if (values[index++] === value) return true;
3661
+
} return false;
3662
+
}, { enumerable: true, unsafe: true });
3663
+
}
3664
+
3665
+
3666
+
/***/ }),
3667
+
/* 125 */
3668
+
/***/ (function(module, exports, __webpack_require__) {
3669
+
3670
+
"use strict";
3671
+
3672
+
var DESCRIPTORS = __webpack_require__(2);
3673
+
var uncurryThis = __webpack_require__(6);
3674
+
var defineBuiltInAccessor = __webpack_require__(4);
3675
+
3676
+
var URLSearchParamsPrototype = URLSearchParams.prototype;
3677
+
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
3678
+
3679
+
// `URLSearchParams.prototype.size` getter
3680
+
// https://github.com/whatwg/url/pull/734
3681
+
if (DESCRIPTORS && !('size' in URLSearchParamsPrototype)) {
3682
+
defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
3683
+
get: function size() {
3684
+
var count = 0;
3685
+
forEach(this, function () { count++; });
3686
+
return count;
3687
+
},
3688
+
configurable: true,
3689
+
enumerable: true
3690
+
});
3691
+
}
3692
+
3693
+
3694
+
/***/ })
3695
+
/******/ ]); }();
3696
+