cross-spawn-cb 1.5.1 → 1.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,10 +1,8 @@
1
1
  'use strict';
2
2
 
3
- var require$$0 = require('buffer');
4
- var require$$0$2 = require('path');
5
- var require$$0$3 = require('child_process');
6
- var require$$6 = require('function-exec-sync');
7
- var require$$0$1 = require('fs');
3
+ var require$$0$1 = require('path');
4
+ var require$$0$2 = require('child_process');
5
+ var require$$0 = require('fs');
8
6
 
9
7
  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
10
8
  function getDefaultExportFromCjs(x) {
@@ -15,2136 +13,6 @@ var src$1 = {
15
13
  exports: {}
16
14
  };
17
15
 
18
- var es_object_assign = {};
19
-
20
- function _type_of$6(obj) {
21
- "@swc/helpers - typeof";
22
- return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
23
- }
24
- var globalThis_1;
25
- var hasRequiredGlobalThis;
26
- function requireGlobalThis() {
27
- if (hasRequiredGlobalThis) return globalThis_1;
28
- hasRequiredGlobalThis = 1;
29
- var check = function check(it) {
30
- return it && it.Math === Math && it;
31
- };
32
- // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
33
- globalThis_1 = // eslint-disable-next-line es/no-global-this -- safe
34
- check((typeof globalThis === "undefined" ? "undefined" : _type_of$6(globalThis)) == 'object' && globalThis) || check((typeof window === "undefined" ? "undefined" : _type_of$6(window)) == 'object' && window) || // eslint-disable-next-line no-restricted-globals -- safe
35
- check((typeof self === "undefined" ? "undefined" : _type_of$6(self)) == 'object' && self) || check(_type_of$6(commonjsGlobal) == 'object' && commonjsGlobal) || check((typeof globalThis_1 === "undefined" ? "undefined" : _type_of$6(globalThis_1)) == 'object' && globalThis_1) || // eslint-disable-next-line no-new-func -- fallback
36
- function() {
37
- return this;
38
- }() || Function('return this')();
39
- return globalThis_1;
40
- }
41
-
42
- var objectGetOwnPropertyDescriptor = {};
43
-
44
- var fails;
45
- var hasRequiredFails;
46
- function requireFails() {
47
- if (hasRequiredFails) return fails;
48
- hasRequiredFails = 1;
49
- fails = function fails(exec) {
50
- try {
51
- return !!exec();
52
- } catch (error) {
53
- return true;
54
- }
55
- };
56
- return fails;
57
- }
58
-
59
- var descriptors;
60
- var hasRequiredDescriptors;
61
- function requireDescriptors() {
62
- if (hasRequiredDescriptors) return descriptors;
63
- hasRequiredDescriptors = 1;
64
- var fails = requireFails();
65
- // Detect IE8's incomplete defineProperty implementation
66
- descriptors = !fails(function() {
67
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
68
- return Object.defineProperty({}, 1, {
69
- get: function get() {
70
- return 7;
71
- }
72
- })[1] !== 7;
73
- });
74
- return descriptors;
75
- }
76
-
77
- var functionBindNative;
78
- var hasRequiredFunctionBindNative;
79
- function requireFunctionBindNative() {
80
- if (hasRequiredFunctionBindNative) return functionBindNative;
81
- hasRequiredFunctionBindNative = 1;
82
- var fails = requireFails();
83
- functionBindNative = !fails(function() {
84
- // eslint-disable-next-line es/no-function-prototype-bind -- safe
85
- var test = (function() {}).bind();
86
- // eslint-disable-next-line no-prototype-builtins -- safe
87
- return typeof test != 'function' || test.hasOwnProperty('prototype');
88
- });
89
- return functionBindNative;
90
- }
91
-
92
- var functionCall;
93
- var hasRequiredFunctionCall;
94
- function requireFunctionCall() {
95
- if (hasRequiredFunctionCall) return functionCall;
96
- hasRequiredFunctionCall = 1;
97
- var NATIVE_BIND = requireFunctionBindNative();
98
- var call = Function.prototype.call;
99
- functionCall = NATIVE_BIND ? call.bind(call) : function functionCall() {
100
- return call.apply(call, arguments);
101
- };
102
- return functionCall;
103
- }
104
-
105
- var objectPropertyIsEnumerable = {};
106
-
107
- var hasRequiredObjectPropertyIsEnumerable;
108
- function requireObjectPropertyIsEnumerable() {
109
- if (hasRequiredObjectPropertyIsEnumerable) return objectPropertyIsEnumerable;
110
- hasRequiredObjectPropertyIsEnumerable = 1;
111
- var $propertyIsEnumerable = {}.propertyIsEnumerable;
112
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
113
- var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
114
- // Nashorn ~ JDK8 bug
115
- var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({
116
- 1: 2
117
- }, 1);
118
- // `Object.prototype.propertyIsEnumerable` method implementation
119
- // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
120
- objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
121
- var descriptor = getOwnPropertyDescriptor(this, V);
122
- return !!descriptor && descriptor.enumerable;
123
- } : $propertyIsEnumerable;
124
- return objectPropertyIsEnumerable;
125
- }
126
-
127
- var createPropertyDescriptor;
128
- var hasRequiredCreatePropertyDescriptor;
129
- function requireCreatePropertyDescriptor() {
130
- if (hasRequiredCreatePropertyDescriptor) return createPropertyDescriptor;
131
- hasRequiredCreatePropertyDescriptor = 1;
132
- createPropertyDescriptor = function createPropertyDescriptor(bitmap, value) {
133
- return {
134
- enumerable: !(bitmap & 1),
135
- configurable: !(bitmap & 2),
136
- writable: !(bitmap & 4),
137
- value: value
138
- };
139
- };
140
- return createPropertyDescriptor;
141
- }
142
-
143
- var functionUncurryThis;
144
- var hasRequiredFunctionUncurryThis;
145
- function requireFunctionUncurryThis() {
146
- if (hasRequiredFunctionUncurryThis) return functionUncurryThis;
147
- hasRequiredFunctionUncurryThis = 1;
148
- var NATIVE_BIND = requireFunctionBindNative();
149
- var FunctionPrototype = Function.prototype;
150
- var call = FunctionPrototype.call;
151
- var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
152
- functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function functionUncurryThis(fn) {
153
- return function() {
154
- return call.apply(fn, arguments);
155
- };
156
- };
157
- return functionUncurryThis;
158
- }
159
-
160
- var classofRaw;
161
- var hasRequiredClassofRaw;
162
- function requireClassofRaw() {
163
- if (hasRequiredClassofRaw) return classofRaw;
164
- hasRequiredClassofRaw = 1;
165
- var uncurryThis = requireFunctionUncurryThis();
166
- var toString = uncurryThis({}.toString);
167
- var stringSlice = uncurryThis(''.slice);
168
- classofRaw = function classofRaw(it) {
169
- return stringSlice(toString(it), 8, -1);
170
- };
171
- return classofRaw;
172
- }
173
-
174
- var indexedObject;
175
- var hasRequiredIndexedObject;
176
- function requireIndexedObject() {
177
- if (hasRequiredIndexedObject) return indexedObject;
178
- hasRequiredIndexedObject = 1;
179
- var uncurryThis = requireFunctionUncurryThis();
180
- var fails = requireFails();
181
- var classof = requireClassofRaw();
182
- var $Object = Object;
183
- var split = uncurryThis(''.split);
184
- // fallback for non-array-like ES3 and non-enumerable old V8 strings
185
- indexedObject = fails(function() {
186
- // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
187
- // eslint-disable-next-line no-prototype-builtins -- safe
188
- return !$Object('z').propertyIsEnumerable(0);
189
- }) ? function indexedObject(it) {
190
- return classof(it) === 'String' ? split(it, '') : $Object(it);
191
- } : $Object;
192
- return indexedObject;
193
- }
194
-
195
- var isNullOrUndefined;
196
- var hasRequiredIsNullOrUndefined;
197
- function requireIsNullOrUndefined() {
198
- if (hasRequiredIsNullOrUndefined) return isNullOrUndefined;
199
- hasRequiredIsNullOrUndefined = 1;
200
- // we can't use just `it == null` since of `document.all` special case
201
- // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
202
- isNullOrUndefined = function isNullOrUndefined(it) {
203
- return it === null || it === undefined;
204
- };
205
- return isNullOrUndefined;
206
- }
207
-
208
- var requireObjectCoercible;
209
- var hasRequiredRequireObjectCoercible;
210
- function requireRequireObjectCoercible() {
211
- if (hasRequiredRequireObjectCoercible) return requireObjectCoercible;
212
- hasRequiredRequireObjectCoercible = 1;
213
- var isNullOrUndefined = requireIsNullOrUndefined();
214
- var $TypeError = TypeError;
215
- // `RequireObjectCoercible` abstract operation
216
- // https://tc39.es/ecma262/#sec-requireobjectcoercible
217
- requireObjectCoercible = function requireObjectCoercible(it) {
218
- if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
219
- return it;
220
- };
221
- return requireObjectCoercible;
222
- }
223
-
224
- var toIndexedObject;
225
- var hasRequiredToIndexedObject;
226
- function requireToIndexedObject() {
227
- if (hasRequiredToIndexedObject) return toIndexedObject;
228
- hasRequiredToIndexedObject = 1;
229
- // toObject with fallback for non-array-like ES3 strings
230
- var IndexedObject = requireIndexedObject();
231
- var requireObjectCoercible = requireRequireObjectCoercible();
232
- toIndexedObject = function toIndexedObject(it) {
233
- return IndexedObject(requireObjectCoercible(it));
234
- };
235
- return toIndexedObject;
236
- }
237
-
238
- function _type_of$5(obj) {
239
- "@swc/helpers - typeof";
240
- return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
241
- }
242
- var isCallable;
243
- var hasRequiredIsCallable;
244
- function requireIsCallable() {
245
- if (hasRequiredIsCallable) return isCallable;
246
- hasRequiredIsCallable = 1;
247
- // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
248
- var documentAll = (typeof document === "undefined" ? "undefined" : _type_of$5(document)) == 'object' && document.all;
249
- // `IsCallable` abstract operation
250
- // https://tc39.es/ecma262/#sec-iscallable
251
- // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
252
- isCallable = typeof documentAll == 'undefined' && documentAll !== undefined ? function isCallable(argument) {
253
- return typeof argument == 'function' || argument === documentAll;
254
- } : function(argument) {
255
- return typeof argument == 'function';
256
- };
257
- return isCallable;
258
- }
259
-
260
- function _type_of$4(obj) {
261
- "@swc/helpers - typeof";
262
- return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
263
- }
264
- var isObject;
265
- var hasRequiredIsObject;
266
- function requireIsObject() {
267
- if (hasRequiredIsObject) return isObject;
268
- hasRequiredIsObject = 1;
269
- var isCallable = requireIsCallable();
270
- isObject = function isObject(it) {
271
- return (typeof it === "undefined" ? "undefined" : _type_of$4(it)) == 'object' ? it !== null : isCallable(it);
272
- };
273
- return isObject;
274
- }
275
-
276
- var getBuiltIn;
277
- var hasRequiredGetBuiltIn;
278
- function requireGetBuiltIn() {
279
- if (hasRequiredGetBuiltIn) return getBuiltIn;
280
- hasRequiredGetBuiltIn = 1;
281
- var globalThis = requireGlobalThis();
282
- var isCallable = requireIsCallable();
283
- var aFunction = function aFunction(argument) {
284
- return isCallable(argument) ? argument : undefined;
285
- };
286
- getBuiltIn = function getBuiltIn(namespace, method) {
287
- return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
288
- };
289
- return getBuiltIn;
290
- }
291
-
292
- var objectIsPrototypeOf;
293
- var hasRequiredObjectIsPrototypeOf;
294
- function requireObjectIsPrototypeOf() {
295
- if (hasRequiredObjectIsPrototypeOf) return objectIsPrototypeOf;
296
- hasRequiredObjectIsPrototypeOf = 1;
297
- var uncurryThis = requireFunctionUncurryThis();
298
- objectIsPrototypeOf = uncurryThis({}.isPrototypeOf);
299
- return objectIsPrototypeOf;
300
- }
301
-
302
- var environmentUserAgent;
303
- var hasRequiredEnvironmentUserAgent;
304
- function requireEnvironmentUserAgent() {
305
- if (hasRequiredEnvironmentUserAgent) return environmentUserAgent;
306
- hasRequiredEnvironmentUserAgent = 1;
307
- var globalThis = requireGlobalThis();
308
- var navigator = globalThis.navigator;
309
- var userAgent = navigator && navigator.userAgent;
310
- environmentUserAgent = userAgent ? String(userAgent) : '';
311
- return environmentUserAgent;
312
- }
313
-
314
- var environmentV8Version;
315
- var hasRequiredEnvironmentV8Version;
316
- function requireEnvironmentV8Version() {
317
- if (hasRequiredEnvironmentV8Version) return environmentV8Version;
318
- hasRequiredEnvironmentV8Version = 1;
319
- var globalThis = requireGlobalThis();
320
- var userAgent = requireEnvironmentUserAgent();
321
- var process = globalThis.process;
322
- var Deno = globalThis.Deno;
323
- var versions = process && process.versions || Deno && Deno.version;
324
- var v8 = versions && versions.v8;
325
- var match, version;
326
- if (v8) {
327
- match = v8.split('.');
328
- // in old Chrome, versions of V8 isn't V8 = Chrome / 10
329
- // but their correct versions are not interesting for us
330
- version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
331
- }
332
- // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
333
- // so check `userAgent` even if `.v8` exists, but 0
334
- if (!version && userAgent) {
335
- match = userAgent.match(/Edge\/(\d+)/);
336
- if (!match || match[1] >= 74) {
337
- match = userAgent.match(/Chrome\/(\d+)/);
338
- if (match) version = +match[1];
339
- }
340
- }
341
- environmentV8Version = version;
342
- return environmentV8Version;
343
- }
344
-
345
- function _instanceof$1(left, right) {
346
- if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
347
- return !!right[Symbol.hasInstance](left);
348
- } else {
349
- return left instanceof right;
350
- }
351
- }
352
- var symbolConstructorDetection;
353
- var hasRequiredSymbolConstructorDetection;
354
- function requireSymbolConstructorDetection() {
355
- if (hasRequiredSymbolConstructorDetection) return symbolConstructorDetection;
356
- hasRequiredSymbolConstructorDetection = 1;
357
- /* eslint-disable es/no-symbol -- required for testing */ var V8_VERSION = requireEnvironmentV8Version();
358
- var fails = requireFails();
359
- var globalThis = requireGlobalThis();
360
- var $String = globalThis.String;
361
- // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
362
- symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails(function() {
363
- var symbol = Symbol('symbol detection');
364
- // Chrome 38 Symbol has incorrect toString conversion
365
- // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
366
- // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
367
- // of course, fail.
368
- return !$String(symbol) || !_instanceof$1(Object(symbol), Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
369
- !Symbol.sham && V8_VERSION && V8_VERSION < 41;
370
- });
371
- return symbolConstructorDetection;
372
- }
373
-
374
- function _type_of$3(obj) {
375
- "@swc/helpers - typeof";
376
- return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
377
- }
378
- var useSymbolAsUid;
379
- var hasRequiredUseSymbolAsUid;
380
- function requireUseSymbolAsUid() {
381
- if (hasRequiredUseSymbolAsUid) return useSymbolAsUid;
382
- hasRequiredUseSymbolAsUid = 1;
383
- /* eslint-disable es/no-symbol -- required for testing */ var NATIVE_SYMBOL = requireSymbolConstructorDetection();
384
- useSymbolAsUid = NATIVE_SYMBOL && !Symbol.sham && _type_of$3(Symbol.iterator) == 'symbol';
385
- return useSymbolAsUid;
386
- }
387
-
388
- function _type_of$2(obj) {
389
- "@swc/helpers - typeof";
390
- return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
391
- }
392
- var isSymbol;
393
- var hasRequiredIsSymbol;
394
- function requireIsSymbol() {
395
- if (hasRequiredIsSymbol) return isSymbol;
396
- hasRequiredIsSymbol = 1;
397
- var getBuiltIn = requireGetBuiltIn();
398
- var isCallable = requireIsCallable();
399
- var isPrototypeOf = requireObjectIsPrototypeOf();
400
- var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
401
- var $Object = Object;
402
- isSymbol = USE_SYMBOL_AS_UID ? function isSymbol(it) {
403
- return (typeof it === "undefined" ? "undefined" : _type_of$2(it)) == 'symbol';
404
- } : function(it) {
405
- var $Symbol = getBuiltIn('Symbol');
406
- return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
407
- };
408
- return isSymbol;
409
- }
410
-
411
- var tryToString;
412
- var hasRequiredTryToString;
413
- function requireTryToString() {
414
- if (hasRequiredTryToString) return tryToString;
415
- hasRequiredTryToString = 1;
416
- var $String = String;
417
- tryToString = function tryToString(argument) {
418
- try {
419
- return $String(argument);
420
- } catch (error) {
421
- return 'Object';
422
- }
423
- };
424
- return tryToString;
425
- }
426
-
427
- var aCallable;
428
- var hasRequiredACallable;
429
- function requireACallable() {
430
- if (hasRequiredACallable) return aCallable;
431
- hasRequiredACallable = 1;
432
- var isCallable = requireIsCallable();
433
- var tryToString = requireTryToString();
434
- var $TypeError = TypeError;
435
- // `Assert: IsCallable(argument) is true`
436
- aCallable = function aCallable(argument) {
437
- if (isCallable(argument)) return argument;
438
- throw new $TypeError(tryToString(argument) + ' is not a function');
439
- };
440
- return aCallable;
441
- }
442
-
443
- var getMethod;
444
- var hasRequiredGetMethod;
445
- function requireGetMethod() {
446
- if (hasRequiredGetMethod) return getMethod;
447
- hasRequiredGetMethod = 1;
448
- var aCallable = requireACallable();
449
- var isNullOrUndefined = requireIsNullOrUndefined();
450
- // `GetMethod` abstract operation
451
- // https://tc39.es/ecma262/#sec-getmethod
452
- getMethod = function getMethod(V, P) {
453
- var func = V[P];
454
- return isNullOrUndefined(func) ? undefined : aCallable(func);
455
- };
456
- return getMethod;
457
- }
458
-
459
- var ordinaryToPrimitive;
460
- var hasRequiredOrdinaryToPrimitive;
461
- function requireOrdinaryToPrimitive() {
462
- if (hasRequiredOrdinaryToPrimitive) return ordinaryToPrimitive;
463
- hasRequiredOrdinaryToPrimitive = 1;
464
- var call = requireFunctionCall();
465
- var isCallable = requireIsCallable();
466
- var isObject = requireIsObject();
467
- var $TypeError = TypeError;
468
- // `OrdinaryToPrimitive` abstract operation
469
- // https://tc39.es/ecma262/#sec-ordinarytoprimitive
470
- ordinaryToPrimitive = function ordinaryToPrimitive(input, pref) {
471
- var fn, val;
472
- if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
473
- if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
474
- if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
475
- throw new $TypeError("Can't convert object to primitive value");
476
- };
477
- return ordinaryToPrimitive;
478
- }
479
-
480
- var sharedStore = {
481
- exports: {}
482
- };
483
-
484
- var isPure;
485
- var hasRequiredIsPure;
486
- function requireIsPure() {
487
- if (hasRequiredIsPure) return isPure;
488
- hasRequiredIsPure = 1;
489
- isPure = false;
490
- return isPure;
491
- }
492
-
493
- var defineGlobalProperty;
494
- var hasRequiredDefineGlobalProperty;
495
- function requireDefineGlobalProperty() {
496
- if (hasRequiredDefineGlobalProperty) return defineGlobalProperty;
497
- hasRequiredDefineGlobalProperty = 1;
498
- var globalThis = requireGlobalThis();
499
- // eslint-disable-next-line es/no-object-defineproperty -- safe
500
- var defineProperty = Object.defineProperty;
501
- defineGlobalProperty = function defineGlobalProperty(key, value) {
502
- try {
503
- defineProperty(globalThis, key, {
504
- value: value,
505
- configurable: true,
506
- writable: true
507
- });
508
- } catch (error) {
509
- globalThis[key] = value;
510
- }
511
- return value;
512
- };
513
- return defineGlobalProperty;
514
- }
515
-
516
- var hasRequiredSharedStore;
517
- function requireSharedStore() {
518
- if (hasRequiredSharedStore) return sharedStore.exports;
519
- hasRequiredSharedStore = 1;
520
- var IS_PURE = requireIsPure();
521
- var globalThis = requireGlobalThis();
522
- var defineGlobalProperty = requireDefineGlobalProperty();
523
- var SHARED = '__core-js_shared__';
524
- var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
525
- (store.versions || (store.versions = [])).push({
526
- version: '3.39.0',
527
- mode: IS_PURE ? 'pure' : 'global',
528
- copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
529
- license: 'https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE',
530
- source: 'https://github.com/zloirock/core-js'
531
- });
532
- return sharedStore.exports;
533
- }
534
-
535
- var shared;
536
- var hasRequiredShared;
537
- function requireShared() {
538
- if (hasRequiredShared) return shared;
539
- hasRequiredShared = 1;
540
- var store = requireSharedStore();
541
- shared = function shared(key, value) {
542
- return store[key] || (store[key] = value || {});
543
- };
544
- return shared;
545
- }
546
-
547
- var toObject;
548
- var hasRequiredToObject;
549
- function requireToObject() {
550
- if (hasRequiredToObject) return toObject;
551
- hasRequiredToObject = 1;
552
- var requireObjectCoercible = requireRequireObjectCoercible();
553
- var $Object = Object;
554
- // `ToObject` abstract operation
555
- // https://tc39.es/ecma262/#sec-toobject
556
- toObject = function toObject(argument) {
557
- return $Object(requireObjectCoercible(argument));
558
- };
559
- return toObject;
560
- }
561
-
562
- var hasOwnProperty_1;
563
- var hasRequiredHasOwnProperty;
564
- function requireHasOwnProperty() {
565
- if (hasRequiredHasOwnProperty) return hasOwnProperty_1;
566
- hasRequiredHasOwnProperty = 1;
567
- var uncurryThis = requireFunctionUncurryThis();
568
- var toObject = requireToObject();
569
- var hasOwnProperty = uncurryThis({}.hasOwnProperty);
570
- // `HasOwnProperty` abstract operation
571
- // https://tc39.es/ecma262/#sec-hasownproperty
572
- // eslint-disable-next-line es/no-object-hasown -- safe
573
- hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
574
- return hasOwnProperty(toObject(it), key);
575
- };
576
- return hasOwnProperty_1;
577
- }
578
-
579
- var uid;
580
- var hasRequiredUid;
581
- function requireUid() {
582
- if (hasRequiredUid) return uid;
583
- hasRequiredUid = 1;
584
- var uncurryThis = requireFunctionUncurryThis();
585
- var id = 0;
586
- var postfix = Math.random();
587
- var toString = uncurryThis(1.0.toString);
588
- uid = function uid(key) {
589
- return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
590
- };
591
- return uid;
592
- }
593
-
594
- var wellKnownSymbol;
595
- var hasRequiredWellKnownSymbol;
596
- function requireWellKnownSymbol() {
597
- if (hasRequiredWellKnownSymbol) return wellKnownSymbol;
598
- hasRequiredWellKnownSymbol = 1;
599
- var globalThis = requireGlobalThis();
600
- var shared = requireShared();
601
- var hasOwn = requireHasOwnProperty();
602
- var uid = requireUid();
603
- var NATIVE_SYMBOL = requireSymbolConstructorDetection();
604
- var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
605
- var Symbol = globalThis.Symbol;
606
- var WellKnownSymbolsStore = shared('wks');
607
- var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
608
- wellKnownSymbol = function wellKnownSymbol(name) {
609
- if (!hasOwn(WellKnownSymbolsStore, name)) {
610
- WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name) ? Symbol[name] : createWellKnownSymbol('Symbol.' + name);
611
- }
612
- return WellKnownSymbolsStore[name];
613
- };
614
- return wellKnownSymbol;
615
- }
616
-
617
- var toPrimitive;
618
- var hasRequiredToPrimitive;
619
- function requireToPrimitive() {
620
- if (hasRequiredToPrimitive) return toPrimitive;
621
- hasRequiredToPrimitive = 1;
622
- var call = requireFunctionCall();
623
- var isObject = requireIsObject();
624
- var isSymbol = requireIsSymbol();
625
- var getMethod = requireGetMethod();
626
- var ordinaryToPrimitive = requireOrdinaryToPrimitive();
627
- var wellKnownSymbol = requireWellKnownSymbol();
628
- var $TypeError = TypeError;
629
- var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
630
- // `ToPrimitive` abstract operation
631
- // https://tc39.es/ecma262/#sec-toprimitive
632
- toPrimitive = function toPrimitive(input, pref) {
633
- if (!isObject(input) || isSymbol(input)) return input;
634
- var exoticToPrim = getMethod(input, TO_PRIMITIVE);
635
- var result;
636
- if (exoticToPrim) {
637
- if (pref === undefined) pref = 'default';
638
- result = call(exoticToPrim, input, pref);
639
- if (!isObject(result) || isSymbol(result)) return result;
640
- throw new $TypeError("Can't convert object to primitive value");
641
- }
642
- if (pref === undefined) pref = 'number';
643
- return ordinaryToPrimitive(input, pref);
644
- };
645
- return toPrimitive;
646
- }
647
-
648
- var toPropertyKey;
649
- var hasRequiredToPropertyKey;
650
- function requireToPropertyKey() {
651
- if (hasRequiredToPropertyKey) return toPropertyKey;
652
- hasRequiredToPropertyKey = 1;
653
- var toPrimitive = requireToPrimitive();
654
- var isSymbol = requireIsSymbol();
655
- // `ToPropertyKey` abstract operation
656
- // https://tc39.es/ecma262/#sec-topropertykey
657
- toPropertyKey = function toPropertyKey(argument) {
658
- var key = toPrimitive(argument, 'string');
659
- return isSymbol(key) ? key : key + '';
660
- };
661
- return toPropertyKey;
662
- }
663
-
664
- var documentCreateElement;
665
- var hasRequiredDocumentCreateElement;
666
- function requireDocumentCreateElement() {
667
- if (hasRequiredDocumentCreateElement) return documentCreateElement;
668
- hasRequiredDocumentCreateElement = 1;
669
- var globalThis = requireGlobalThis();
670
- var isObject = requireIsObject();
671
- var document = globalThis.document;
672
- // typeof document.createElement is 'object' in old IE
673
- var EXISTS = isObject(document) && isObject(document.createElement);
674
- documentCreateElement = function documentCreateElement(it) {
675
- return EXISTS ? document.createElement(it) : {};
676
- };
677
- return documentCreateElement;
678
- }
679
-
680
- var ie8DomDefine;
681
- var hasRequiredIe8DomDefine;
682
- function requireIe8DomDefine() {
683
- if (hasRequiredIe8DomDefine) return ie8DomDefine;
684
- hasRequiredIe8DomDefine = 1;
685
- var DESCRIPTORS = requireDescriptors();
686
- var fails = requireFails();
687
- var createElement = requireDocumentCreateElement();
688
- // Thanks to IE8 for its funny defineProperty
689
- ie8DomDefine = !DESCRIPTORS && !fails(function() {
690
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
691
- return Object.defineProperty(createElement('div'), 'a', {
692
- get: function get() {
693
- return 7;
694
- }
695
- }).a !== 7;
696
- });
697
- return ie8DomDefine;
698
- }
699
-
700
- var hasRequiredObjectGetOwnPropertyDescriptor;
701
- function requireObjectGetOwnPropertyDescriptor() {
702
- if (hasRequiredObjectGetOwnPropertyDescriptor) return objectGetOwnPropertyDescriptor;
703
- hasRequiredObjectGetOwnPropertyDescriptor = 1;
704
- var DESCRIPTORS = requireDescriptors();
705
- var call = requireFunctionCall();
706
- var propertyIsEnumerableModule = requireObjectPropertyIsEnumerable();
707
- var createPropertyDescriptor = requireCreatePropertyDescriptor();
708
- var toIndexedObject = requireToIndexedObject();
709
- var toPropertyKey = requireToPropertyKey();
710
- var hasOwn = requireHasOwnProperty();
711
- var IE8_DOM_DEFINE = requireIe8DomDefine();
712
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
713
- var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
714
- // `Object.getOwnPropertyDescriptor` method
715
- // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
716
- objectGetOwnPropertyDescriptor.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
717
- O = toIndexedObject(O);
718
- P = toPropertyKey(P);
719
- if (IE8_DOM_DEFINE) try {
720
- return $getOwnPropertyDescriptor(O, P);
721
- } catch (error) {}
722
- if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
723
- };
724
- return objectGetOwnPropertyDescriptor;
725
- }
726
-
727
- var objectDefineProperty = {};
728
-
729
- var v8PrototypeDefineBug;
730
- var hasRequiredV8PrototypeDefineBug;
731
- function requireV8PrototypeDefineBug() {
732
- if (hasRequiredV8PrototypeDefineBug) return v8PrototypeDefineBug;
733
- hasRequiredV8PrototypeDefineBug = 1;
734
- var DESCRIPTORS = requireDescriptors();
735
- var fails = requireFails();
736
- // V8 ~ Chrome 36-
737
- // https://bugs.chromium.org/p/v8/issues/detail?id=3334
738
- v8PrototypeDefineBug = DESCRIPTORS && fails(function() {
739
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
740
- return Object.defineProperty(function() {}, 'prototype', {
741
- value: 42,
742
- writable: false
743
- }).prototype !== 42;
744
- });
745
- return v8PrototypeDefineBug;
746
- }
747
-
748
- var anObject;
749
- var hasRequiredAnObject;
750
- function requireAnObject() {
751
- if (hasRequiredAnObject) return anObject;
752
- hasRequiredAnObject = 1;
753
- var isObject = requireIsObject();
754
- var $String = String;
755
- var $TypeError = TypeError;
756
- // `Assert: Type(argument) is Object`
757
- anObject = function anObject(argument) {
758
- if (isObject(argument)) return argument;
759
- throw new $TypeError($String(argument) + ' is not an object');
760
- };
761
- return anObject;
762
- }
763
-
764
- var hasRequiredObjectDefineProperty;
765
- function requireObjectDefineProperty() {
766
- if (hasRequiredObjectDefineProperty) return objectDefineProperty;
767
- hasRequiredObjectDefineProperty = 1;
768
- var DESCRIPTORS = requireDescriptors();
769
- var IE8_DOM_DEFINE = requireIe8DomDefine();
770
- var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
771
- var anObject = requireAnObject();
772
- var toPropertyKey = requireToPropertyKey();
773
- var $TypeError = TypeError;
774
- // eslint-disable-next-line es/no-object-defineproperty -- safe
775
- var $defineProperty = Object.defineProperty;
776
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
777
- var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
778
- var ENUMERABLE = 'enumerable';
779
- var CONFIGURABLE = 'configurable';
780
- var WRITABLE = 'writable';
781
- // `Object.defineProperty` method
782
- // https://tc39.es/ecma262/#sec-object.defineproperty
783
- objectDefineProperty.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
784
- anObject(O);
785
- P = toPropertyKey(P);
786
- anObject(Attributes);
787
- if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
788
- var current = $getOwnPropertyDescriptor(O, P);
789
- if (current && current[WRITABLE]) {
790
- O[P] = Attributes.value;
791
- Attributes = {
792
- configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
793
- enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
794
- writable: false
795
- };
796
- }
797
- }
798
- return $defineProperty(O, P, Attributes);
799
- } : $defineProperty : function defineProperty(O, P, Attributes) {
800
- anObject(O);
801
- P = toPropertyKey(P);
802
- anObject(Attributes);
803
- if (IE8_DOM_DEFINE) try {
804
- return $defineProperty(O, P, Attributes);
805
- } catch (error) {}
806
- if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
807
- if ('value' in Attributes) O[P] = Attributes.value;
808
- return O;
809
- };
810
- return objectDefineProperty;
811
- }
812
-
813
- var createNonEnumerableProperty;
814
- var hasRequiredCreateNonEnumerableProperty;
815
- function requireCreateNonEnumerableProperty() {
816
- if (hasRequiredCreateNonEnumerableProperty) return createNonEnumerableProperty;
817
- hasRequiredCreateNonEnumerableProperty = 1;
818
- var DESCRIPTORS = requireDescriptors();
819
- var definePropertyModule = requireObjectDefineProperty();
820
- var createPropertyDescriptor = requireCreatePropertyDescriptor();
821
- createNonEnumerableProperty = DESCRIPTORS ? function createNonEnumerableProperty(object, key, value) {
822
- return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
823
- } : function(object, key, value) {
824
- object[key] = value;
825
- return object;
826
- };
827
- return createNonEnumerableProperty;
828
- }
829
-
830
- var makeBuiltIn = {
831
- exports: {}
832
- };
833
-
834
- var functionName;
835
- var hasRequiredFunctionName;
836
- function requireFunctionName() {
837
- if (hasRequiredFunctionName) return functionName;
838
- hasRequiredFunctionName = 1;
839
- var DESCRIPTORS = requireDescriptors();
840
- var hasOwn = requireHasOwnProperty();
841
- var FunctionPrototype = Function.prototype;
842
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
843
- var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
844
- var EXISTS = hasOwn(FunctionPrototype, 'name');
845
- // additional protection from minified / mangled / dropped function names
846
- var PROPER = EXISTS && (function something() {}).name === 'something';
847
- var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable);
848
- functionName = {
849
- EXISTS: EXISTS,
850
- PROPER: PROPER,
851
- CONFIGURABLE: CONFIGURABLE
852
- };
853
- return functionName;
854
- }
855
-
856
- var inspectSource;
857
- var hasRequiredInspectSource;
858
- function requireInspectSource() {
859
- if (hasRequiredInspectSource) return inspectSource;
860
- hasRequiredInspectSource = 1;
861
- var uncurryThis = requireFunctionUncurryThis();
862
- var isCallable = requireIsCallable();
863
- var store = requireSharedStore();
864
- var functionToString = uncurryThis(Function.toString);
865
- // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
866
- if (!isCallable(store.inspectSource)) {
867
- store.inspectSource = function(it) {
868
- return functionToString(it);
869
- };
870
- }
871
- inspectSource = store.inspectSource;
872
- return inspectSource;
873
- }
874
-
875
- var weakMapBasicDetection;
876
- var hasRequiredWeakMapBasicDetection;
877
- function requireWeakMapBasicDetection() {
878
- if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
879
- hasRequiredWeakMapBasicDetection = 1;
880
- var globalThis = requireGlobalThis();
881
- var isCallable = requireIsCallable();
882
- var WeakMap = globalThis.WeakMap;
883
- weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
884
- return weakMapBasicDetection;
885
- }
886
-
887
- var sharedKey;
888
- var hasRequiredSharedKey;
889
- function requireSharedKey() {
890
- if (hasRequiredSharedKey) return sharedKey;
891
- hasRequiredSharedKey = 1;
892
- var shared = requireShared();
893
- var uid = requireUid();
894
- var keys = shared('keys');
895
- sharedKey = function sharedKey(key) {
896
- return keys[key] || (keys[key] = uid(key));
897
- };
898
- return sharedKey;
899
- }
900
-
901
- var hiddenKeys;
902
- var hasRequiredHiddenKeys;
903
- function requireHiddenKeys() {
904
- if (hasRequiredHiddenKeys) return hiddenKeys;
905
- hasRequiredHiddenKeys = 1;
906
- hiddenKeys = {};
907
- return hiddenKeys;
908
- }
909
-
910
- var internalState;
911
- var hasRequiredInternalState;
912
- function requireInternalState() {
913
- if (hasRequiredInternalState) return internalState;
914
- hasRequiredInternalState = 1;
915
- var NATIVE_WEAK_MAP = requireWeakMapBasicDetection();
916
- var globalThis = requireGlobalThis();
917
- var isObject = requireIsObject();
918
- var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
919
- var hasOwn = requireHasOwnProperty();
920
- var shared = requireSharedStore();
921
- var sharedKey = requireSharedKey();
922
- var hiddenKeys = requireHiddenKeys();
923
- var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
924
- var TypeError = globalThis.TypeError;
925
- var WeakMap = globalThis.WeakMap;
926
- var set, get, has;
927
- var enforce = function enforce(it) {
928
- return has(it) ? get(it) : set(it, {});
929
- };
930
- var getterFor = function getterFor(TYPE) {
931
- return function(it) {
932
- var state;
933
- if (!isObject(it) || (state = get(it)).type !== TYPE) {
934
- throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
935
- }
936
- return state;
937
- };
938
- };
939
- if (NATIVE_WEAK_MAP || shared.state) {
940
- var store = shared.state || (shared.state = new WeakMap());
941
- /* eslint-disable no-self-assign -- prototype methods protection */ store.get = store.get;
942
- store.has = store.has;
943
- store.set = store.set;
944
- /* eslint-enable no-self-assign -- prototype methods protection */ set = function set(it, metadata) {
945
- if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
946
- metadata.facade = it;
947
- store.set(it, metadata);
948
- return metadata;
949
- };
950
- get = function get(it) {
951
- return store.get(it) || {};
952
- };
953
- has = function has(it) {
954
- return store.has(it);
955
- };
956
- } else {
957
- var STATE = sharedKey('state');
958
- hiddenKeys[STATE] = true;
959
- set = function set(it, metadata) {
960
- if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
961
- metadata.facade = it;
962
- createNonEnumerableProperty(it, STATE, metadata);
963
- return metadata;
964
- };
965
- get = function get(it) {
966
- return hasOwn(it, STATE) ? it[STATE] : {};
967
- };
968
- has = function has(it) {
969
- return hasOwn(it, STATE);
970
- };
971
- }
972
- internalState = {
973
- set: set,
974
- get: get,
975
- has: has,
976
- enforce: enforce,
977
- getterFor: getterFor
978
- };
979
- return internalState;
980
- }
981
-
982
- var hasRequiredMakeBuiltIn;
983
- function requireMakeBuiltIn() {
984
- if (hasRequiredMakeBuiltIn) return makeBuiltIn.exports;
985
- hasRequiredMakeBuiltIn = 1;
986
- var uncurryThis = requireFunctionUncurryThis();
987
- var fails = requireFails();
988
- var isCallable = requireIsCallable();
989
- var hasOwn = requireHasOwnProperty();
990
- var DESCRIPTORS = requireDescriptors();
991
- var CONFIGURABLE_FUNCTION_NAME = requireFunctionName().CONFIGURABLE;
992
- var inspectSource = requireInspectSource();
993
- var InternalStateModule = requireInternalState();
994
- var enforceInternalState = InternalStateModule.enforce;
995
- var getInternalState = InternalStateModule.get;
996
- var $String = String;
997
- // eslint-disable-next-line es/no-object-defineproperty -- safe
998
- var defineProperty = Object.defineProperty;
999
- var stringSlice = uncurryThis(''.slice);
1000
- var replace = uncurryThis(''.replace);
1001
- var join = uncurryThis([].join);
1002
- var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() {
1003
- return defineProperty(function() {}, 'length', {
1004
- value: 8
1005
- }).length !== 8;
1006
- });
1007
- var TEMPLATE = String(String).split('String');
1008
- var makeBuiltIn$1 = makeBuiltIn.exports = function makeBuiltIn(value, name, options) {
1009
- if (stringSlice($String(name), 0, 7) === 'Symbol(') {
1010
- name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
1011
- }
1012
- if (options && options.getter) name = 'get ' + name;
1013
- if (options && options.setter) name = 'set ' + name;
1014
- if (!hasOwn(value, 'name') || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
1015
- if (DESCRIPTORS) defineProperty(value, 'name', {
1016
- value: name,
1017
- configurable: true
1018
- });
1019
- else value.name = name;
1020
- }
1021
- if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
1022
- defineProperty(value, 'length', {
1023
- value: options.arity
1024
- });
1025
- }
1026
- try {
1027
- if (options && hasOwn(options, 'constructor') && options.constructor) {
1028
- if (DESCRIPTORS) defineProperty(value, 'prototype', {
1029
- writable: false
1030
- });
1031
- // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
1032
- } else if (value.prototype) value.prototype = undefined;
1033
- } catch (error) {}
1034
- var state = enforceInternalState(value);
1035
- if (!hasOwn(state, 'source')) {
1036
- state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
1037
- }
1038
- return value;
1039
- };
1040
- // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
1041
- // eslint-disable-next-line no-extend-native -- required
1042
- Function.prototype.toString = makeBuiltIn$1(function toString() {
1043
- return isCallable(this) && getInternalState(this).source || inspectSource(this);
1044
- }, 'toString');
1045
- return makeBuiltIn.exports;
1046
- }
1047
-
1048
- var defineBuiltIn;
1049
- var hasRequiredDefineBuiltIn;
1050
- function requireDefineBuiltIn() {
1051
- if (hasRequiredDefineBuiltIn) return defineBuiltIn;
1052
- hasRequiredDefineBuiltIn = 1;
1053
- var isCallable = requireIsCallable();
1054
- var definePropertyModule = requireObjectDefineProperty();
1055
- var makeBuiltIn = requireMakeBuiltIn();
1056
- var defineGlobalProperty = requireDefineGlobalProperty();
1057
- defineBuiltIn = function defineBuiltIn(O, key, value, options) {
1058
- if (!options) options = {};
1059
- var simple = options.enumerable;
1060
- var name = options.name !== undefined ? options.name : key;
1061
- if (isCallable(value)) makeBuiltIn(value, name, options);
1062
- if (options.global) {
1063
- if (simple) O[key] = value;
1064
- else defineGlobalProperty(key, value);
1065
- } else {
1066
- try {
1067
- if (!options.unsafe) delete O[key];
1068
- else if (O[key]) simple = true;
1069
- } catch (error) {}
1070
- if (simple) O[key] = value;
1071
- else definePropertyModule.f(O, key, {
1072
- value: value,
1073
- enumerable: false,
1074
- configurable: !options.nonConfigurable,
1075
- writable: !options.nonWritable
1076
- });
1077
- }
1078
- return O;
1079
- };
1080
- return defineBuiltIn;
1081
- }
1082
-
1083
- var objectGetOwnPropertyNames = {};
1084
-
1085
- var mathTrunc;
1086
- var hasRequiredMathTrunc;
1087
- function requireMathTrunc() {
1088
- if (hasRequiredMathTrunc) return mathTrunc;
1089
- hasRequiredMathTrunc = 1;
1090
- var ceil = Math.ceil;
1091
- var floor = Math.floor;
1092
- // `Math.trunc` method
1093
- // https://tc39.es/ecma262/#sec-math.trunc
1094
- // eslint-disable-next-line es/no-math-trunc -- safe
1095
- mathTrunc = Math.trunc || function trunc(x) {
1096
- var n = +x;
1097
- return (n > 0 ? floor : ceil)(n);
1098
- };
1099
- return mathTrunc;
1100
- }
1101
-
1102
- var toIntegerOrInfinity;
1103
- var hasRequiredToIntegerOrInfinity;
1104
- function requireToIntegerOrInfinity() {
1105
- if (hasRequiredToIntegerOrInfinity) return toIntegerOrInfinity;
1106
- hasRequiredToIntegerOrInfinity = 1;
1107
- var trunc = requireMathTrunc();
1108
- // `ToIntegerOrInfinity` abstract operation
1109
- // https://tc39.es/ecma262/#sec-tointegerorinfinity
1110
- toIntegerOrInfinity = function toIntegerOrInfinity(argument) {
1111
- var number = +argument;
1112
- // eslint-disable-next-line no-self-compare -- NaN check
1113
- return number !== number || number === 0 ? 0 : trunc(number);
1114
- };
1115
- return toIntegerOrInfinity;
1116
- }
1117
-
1118
- var toAbsoluteIndex;
1119
- var hasRequiredToAbsoluteIndex;
1120
- function requireToAbsoluteIndex() {
1121
- if (hasRequiredToAbsoluteIndex) return toAbsoluteIndex;
1122
- hasRequiredToAbsoluteIndex = 1;
1123
- var toIntegerOrInfinity = requireToIntegerOrInfinity();
1124
- var max = Math.max;
1125
- var min = Math.min;
1126
- // Helper for a popular repeating case of the spec:
1127
- // Let integer be ? ToInteger(index).
1128
- // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
1129
- toAbsoluteIndex = function toAbsoluteIndex(index, length) {
1130
- var integer = toIntegerOrInfinity(index);
1131
- return integer < 0 ? max(integer + length, 0) : min(integer, length);
1132
- };
1133
- return toAbsoluteIndex;
1134
- }
1135
-
1136
- var toLength;
1137
- var hasRequiredToLength;
1138
- function requireToLength() {
1139
- if (hasRequiredToLength) return toLength;
1140
- hasRequiredToLength = 1;
1141
- var toIntegerOrInfinity = requireToIntegerOrInfinity();
1142
- var min = Math.min;
1143
- // `ToLength` abstract operation
1144
- // https://tc39.es/ecma262/#sec-tolength
1145
- toLength = function toLength(argument) {
1146
- var len = toIntegerOrInfinity(argument);
1147
- return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1148
- };
1149
- return toLength;
1150
- }
1151
-
1152
- var lengthOfArrayLike;
1153
- var hasRequiredLengthOfArrayLike;
1154
- function requireLengthOfArrayLike() {
1155
- if (hasRequiredLengthOfArrayLike) return lengthOfArrayLike;
1156
- hasRequiredLengthOfArrayLike = 1;
1157
- var toLength = requireToLength();
1158
- // `LengthOfArrayLike` abstract operation
1159
- // https://tc39.es/ecma262/#sec-lengthofarraylike
1160
- lengthOfArrayLike = function lengthOfArrayLike(obj) {
1161
- return toLength(obj.length);
1162
- };
1163
- return lengthOfArrayLike;
1164
- }
1165
-
1166
- var arrayIncludes;
1167
- var hasRequiredArrayIncludes;
1168
- function requireArrayIncludes() {
1169
- if (hasRequiredArrayIncludes) return arrayIncludes;
1170
- hasRequiredArrayIncludes = 1;
1171
- var toIndexedObject = requireToIndexedObject();
1172
- var toAbsoluteIndex = requireToAbsoluteIndex();
1173
- var lengthOfArrayLike = requireLengthOfArrayLike();
1174
- // `Array.prototype.{ indexOf, includes }` methods implementation
1175
- var createMethod = function createMethod(IS_INCLUDES) {
1176
- return function($this, el, fromIndex) {
1177
- var O = toIndexedObject($this);
1178
- var length = lengthOfArrayLike(O);
1179
- if (length === 0) return !IS_INCLUDES && -1;
1180
- var index = toAbsoluteIndex(fromIndex, length);
1181
- var value;
1182
- // Array#includes uses SameValueZero equality algorithm
1183
- // eslint-disable-next-line no-self-compare -- NaN check
1184
- if (IS_INCLUDES && el !== el) while(length > index){
1185
- value = O[index++];
1186
- // eslint-disable-next-line no-self-compare -- NaN check
1187
- if (value !== value) return true;
1188
- // Array#indexOf ignores holes, Array#includes - not
1189
- }
1190
- else for(; length > index; index++){
1191
- if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
1192
- }
1193
- return !IS_INCLUDES && -1;
1194
- };
1195
- };
1196
- arrayIncludes = {
1197
- // `Array.prototype.includes` method
1198
- // https://tc39.es/ecma262/#sec-array.prototype.includes
1199
- includes: createMethod(true),
1200
- // `Array.prototype.indexOf` method
1201
- // https://tc39.es/ecma262/#sec-array.prototype.indexof
1202
- indexOf: createMethod(false)
1203
- };
1204
- return arrayIncludes;
1205
- }
1206
-
1207
- var objectKeysInternal;
1208
- var hasRequiredObjectKeysInternal;
1209
- function requireObjectKeysInternal() {
1210
- if (hasRequiredObjectKeysInternal) return objectKeysInternal;
1211
- hasRequiredObjectKeysInternal = 1;
1212
- var uncurryThis = requireFunctionUncurryThis();
1213
- var hasOwn = requireHasOwnProperty();
1214
- var toIndexedObject = requireToIndexedObject();
1215
- var indexOf = requireArrayIncludes().indexOf;
1216
- var hiddenKeys = requireHiddenKeys();
1217
- var push = uncurryThis([].push);
1218
- objectKeysInternal = function objectKeysInternal(object, names) {
1219
- var O = toIndexedObject(object);
1220
- var i = 0;
1221
- var result = [];
1222
- var key;
1223
- for(key in O)!hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
1224
- // Don't enum bug & hidden keys
1225
- while(names.length > i)if (hasOwn(O, key = names[i++])) {
1226
- ~indexOf(result, key) || push(result, key);
1227
- }
1228
- return result;
1229
- };
1230
- return objectKeysInternal;
1231
- }
1232
-
1233
- var enumBugKeys;
1234
- var hasRequiredEnumBugKeys;
1235
- function requireEnumBugKeys() {
1236
- if (hasRequiredEnumBugKeys) return enumBugKeys;
1237
- hasRequiredEnumBugKeys = 1;
1238
- // IE8- don't enum bug keys
1239
- enumBugKeys = [
1240
- 'constructor',
1241
- 'hasOwnProperty',
1242
- 'isPrototypeOf',
1243
- 'propertyIsEnumerable',
1244
- 'toLocaleString',
1245
- 'toString',
1246
- 'valueOf'
1247
- ];
1248
- return enumBugKeys;
1249
- }
1250
-
1251
- var hasRequiredObjectGetOwnPropertyNames;
1252
- function requireObjectGetOwnPropertyNames() {
1253
- if (hasRequiredObjectGetOwnPropertyNames) return objectGetOwnPropertyNames;
1254
- hasRequiredObjectGetOwnPropertyNames = 1;
1255
- var internalObjectKeys = requireObjectKeysInternal();
1256
- var enumBugKeys = requireEnumBugKeys();
1257
- var hiddenKeys = enumBugKeys.concat('length', 'prototype');
1258
- // `Object.getOwnPropertyNames` method
1259
- // https://tc39.es/ecma262/#sec-object.getownpropertynames
1260
- // eslint-disable-next-line es/no-object-getownpropertynames -- safe
1261
- objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
1262
- return internalObjectKeys(O, hiddenKeys);
1263
- };
1264
- return objectGetOwnPropertyNames;
1265
- }
1266
-
1267
- var objectGetOwnPropertySymbols = {};
1268
-
1269
- var hasRequiredObjectGetOwnPropertySymbols;
1270
- function requireObjectGetOwnPropertySymbols() {
1271
- if (hasRequiredObjectGetOwnPropertySymbols) return objectGetOwnPropertySymbols;
1272
- hasRequiredObjectGetOwnPropertySymbols = 1;
1273
- // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
1274
- objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
1275
- return objectGetOwnPropertySymbols;
1276
- }
1277
-
1278
- var ownKeys;
1279
- var hasRequiredOwnKeys;
1280
- function requireOwnKeys() {
1281
- if (hasRequiredOwnKeys) return ownKeys;
1282
- hasRequiredOwnKeys = 1;
1283
- var getBuiltIn = requireGetBuiltIn();
1284
- var uncurryThis = requireFunctionUncurryThis();
1285
- var getOwnPropertyNamesModule = requireObjectGetOwnPropertyNames();
1286
- var getOwnPropertySymbolsModule = requireObjectGetOwnPropertySymbols();
1287
- var anObject = requireAnObject();
1288
- var concat = uncurryThis([].concat);
1289
- // all object keys, includes non-enumerable and symbols
1290
- ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
1291
- var keys = getOwnPropertyNamesModule.f(anObject(it));
1292
- var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1293
- return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
1294
- };
1295
- return ownKeys;
1296
- }
1297
-
1298
- var copyConstructorProperties;
1299
- var hasRequiredCopyConstructorProperties;
1300
- function requireCopyConstructorProperties() {
1301
- if (hasRequiredCopyConstructorProperties) return copyConstructorProperties;
1302
- hasRequiredCopyConstructorProperties = 1;
1303
- var hasOwn = requireHasOwnProperty();
1304
- var ownKeys = requireOwnKeys();
1305
- var getOwnPropertyDescriptorModule = requireObjectGetOwnPropertyDescriptor();
1306
- var definePropertyModule = requireObjectDefineProperty();
1307
- copyConstructorProperties = function copyConstructorProperties(target, source, exceptions) {
1308
- var keys = ownKeys(source);
1309
- var defineProperty = definePropertyModule.f;
1310
- var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
1311
- for(var i = 0; i < keys.length; i++){
1312
- var key = keys[i];
1313
- if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
1314
- defineProperty(target, key, getOwnPropertyDescriptor(source, key));
1315
- }
1316
- }
1317
- };
1318
- return copyConstructorProperties;
1319
- }
1320
-
1321
- var isForced_1;
1322
- var hasRequiredIsForced;
1323
- function requireIsForced() {
1324
- if (hasRequiredIsForced) return isForced_1;
1325
- hasRequiredIsForced = 1;
1326
- var fails = requireFails();
1327
- var isCallable = requireIsCallable();
1328
- var replacement = /#|\.prototype\./;
1329
- var isForced = function isForced(feature, detection) {
1330
- var value = data[normalize(feature)];
1331
- return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
1332
- };
1333
- var normalize = isForced.normalize = function normalize(string) {
1334
- return String(string).replace(replacement, '.').toLowerCase();
1335
- };
1336
- var data = isForced.data = {};
1337
- var NATIVE = isForced.NATIVE = 'N';
1338
- var POLYFILL = isForced.POLYFILL = 'P';
1339
- isForced_1 = isForced;
1340
- return isForced_1;
1341
- }
1342
-
1343
- function _type_of$1(obj) {
1344
- "@swc/helpers - typeof";
1345
- return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
1346
- }
1347
- var _export;
1348
- var hasRequired_export;
1349
- function require_export() {
1350
- if (hasRequired_export) return _export;
1351
- hasRequired_export = 1;
1352
- var globalThis = requireGlobalThis();
1353
- var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
1354
- var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
1355
- var defineBuiltIn = requireDefineBuiltIn();
1356
- var defineGlobalProperty = requireDefineGlobalProperty();
1357
- var copyConstructorProperties = requireCopyConstructorProperties();
1358
- var isForced = requireIsForced();
1359
- /*
1360
- options.target - name of the target object
1361
- options.global - target is the global object
1362
- options.stat - export as static methods of target
1363
- options.proto - export as prototype methods of target
1364
- options.real - real prototype method for the `pure` version
1365
- options.forced - export even if the native feature is available
1366
- options.bind - bind methods to the target, required for the `pure` version
1367
- options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
1368
- options.unsafe - use the simple assignment of property instead of delete + defineProperty
1369
- options.sham - add a flag to not completely full polyfills
1370
- options.enumerable - export as enumerable property
1371
- options.dontCallGetSet - prevent calling a getter on target
1372
- options.name - the .name of the function if it does not match the key
1373
- */ _export = function _export(options, source) {
1374
- var TARGET = options.target;
1375
- var GLOBAL = options.global;
1376
- var STATIC = options.stat;
1377
- var FORCED, target, key, targetProperty, sourceProperty, descriptor;
1378
- if (GLOBAL) {
1379
- target = globalThis;
1380
- } else if (STATIC) {
1381
- target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
1382
- } else {
1383
- target = globalThis[TARGET] && globalThis[TARGET].prototype;
1384
- }
1385
- if (target) for(key in source){
1386
- sourceProperty = source[key];
1387
- if (options.dontCallGetSet) {
1388
- descriptor = getOwnPropertyDescriptor(target, key);
1389
- targetProperty = descriptor && descriptor.value;
1390
- } else targetProperty = target[key];
1391
- FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
1392
- // contained in target
1393
- if (!FORCED && targetProperty !== undefined) {
1394
- if ((typeof sourceProperty === "undefined" ? "undefined" : _type_of$1(sourceProperty)) == (typeof targetProperty === "undefined" ? "undefined" : _type_of$1(targetProperty))) continue;
1395
- copyConstructorProperties(sourceProperty, targetProperty);
1396
- }
1397
- // add a flag to not completely full polyfills
1398
- if (options.sham || targetProperty && targetProperty.sham) {
1399
- createNonEnumerableProperty(sourceProperty, 'sham', true);
1400
- }
1401
- defineBuiltIn(target, key, sourceProperty, options);
1402
- }
1403
- };
1404
- return _export;
1405
- }
1406
-
1407
- var objectKeys;
1408
- var hasRequiredObjectKeys;
1409
- function requireObjectKeys() {
1410
- if (hasRequiredObjectKeys) return objectKeys;
1411
- hasRequiredObjectKeys = 1;
1412
- var internalObjectKeys = requireObjectKeysInternal();
1413
- var enumBugKeys = requireEnumBugKeys();
1414
- // `Object.keys` method
1415
- // https://tc39.es/ecma262/#sec-object.keys
1416
- // eslint-disable-next-line es/no-object-keys -- safe
1417
- objectKeys = Object.keys || function keys(O) {
1418
- return internalObjectKeys(O, enumBugKeys);
1419
- };
1420
- return objectKeys;
1421
- }
1422
-
1423
- var objectAssign;
1424
- var hasRequiredObjectAssign;
1425
- function requireObjectAssign() {
1426
- if (hasRequiredObjectAssign) return objectAssign;
1427
- hasRequiredObjectAssign = 1;
1428
- var DESCRIPTORS = requireDescriptors();
1429
- var uncurryThis = requireFunctionUncurryThis();
1430
- var call = requireFunctionCall();
1431
- var fails = requireFails();
1432
- var objectKeys = requireObjectKeys();
1433
- var getOwnPropertySymbolsModule = requireObjectGetOwnPropertySymbols();
1434
- var propertyIsEnumerableModule = requireObjectPropertyIsEnumerable();
1435
- var toObject = requireToObject();
1436
- var IndexedObject = requireIndexedObject();
1437
- // eslint-disable-next-line es/no-object-assign -- safe
1438
- var $assign = Object.assign;
1439
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
1440
- var defineProperty = Object.defineProperty;
1441
- var concat = uncurryThis([].concat);
1442
- // `Object.assign` method
1443
- // https://tc39.es/ecma262/#sec-object.assign
1444
- objectAssign = !$assign || fails(function() {
1445
- // should have correct order of operations (Edge bug)
1446
- if (DESCRIPTORS && $assign({
1447
- b: 1
1448
- }, $assign(defineProperty({}, 'a', {
1449
- enumerable: true,
1450
- get: function get() {
1451
- defineProperty(this, 'b', {
1452
- value: 3,
1453
- enumerable: false
1454
- });
1455
- }
1456
- }), {
1457
- b: 2
1458
- })).b !== 1) return true;
1459
- // should work with symbols and should have deterministic property order (V8 bug)
1460
- var A = {};
1461
- var B = {};
1462
- // eslint-disable-next-line es/no-symbol -- safe
1463
- var symbol = Symbol('assign detection');
1464
- var alphabet = 'abcdefghijklmnopqrst';
1465
- A[symbol] = 7;
1466
- alphabet.split('').forEach(function(chr) {
1467
- B[chr] = chr;
1468
- });
1469
- return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;
1470
- }) ? function assign(target, source) {
1471
- var T = toObject(target);
1472
- var argumentsLength = arguments.length;
1473
- var index = 1;
1474
- var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1475
- var propertyIsEnumerable = propertyIsEnumerableModule.f;
1476
- while(argumentsLength > index){
1477
- var S = IndexedObject(arguments[index++]);
1478
- var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
1479
- var length = keys.length;
1480
- var j = 0;
1481
- var key;
1482
- while(length > j){
1483
- key = keys[j++];
1484
- if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
1485
- }
1486
- }
1487
- return T;
1488
- } : $assign;
1489
- return objectAssign;
1490
- }
1491
-
1492
- var hasRequiredEs_object_assign;
1493
- function requireEs_object_assign() {
1494
- if (hasRequiredEs_object_assign) return es_object_assign;
1495
- hasRequiredEs_object_assign = 1;
1496
- var $ = require_export();
1497
- var assign = requireObjectAssign();
1498
- // `Object.assign` method
1499
- // https://tc39.es/ecma262/#sec-object.assign
1500
- // eslint-disable-next-line es/no-object-assign -- required for testing
1501
- $({
1502
- target: 'Object',
1503
- stat: true,
1504
- arity: 2,
1505
- forced: Object.assign !== assign
1506
- }, {
1507
- assign: assign
1508
- });
1509
- return es_object_assign;
1510
- }
1511
-
1512
- var path;
1513
- var hasRequiredPath;
1514
- function requirePath() {
1515
- if (hasRequiredPath) return path;
1516
- hasRequiredPath = 1;
1517
- var globalThis = requireGlobalThis();
1518
- path = globalThis;
1519
- return path;
1520
- }
1521
-
1522
- var assign$2;
1523
- var hasRequiredAssign$2;
1524
- function requireAssign$2() {
1525
- if (hasRequiredAssign$2) return assign$2;
1526
- hasRequiredAssign$2 = 1;
1527
- requireEs_object_assign();
1528
- var path = requirePath();
1529
- assign$2 = path.Object.assign;
1530
- return assign$2;
1531
- }
1532
-
1533
- var assign$1;
1534
- var hasRequiredAssign$1;
1535
- function requireAssign$1() {
1536
- if (hasRequiredAssign$1) return assign$1;
1537
- hasRequiredAssign$1 = 1;
1538
- var parent = requireAssign$2();
1539
- assign$1 = parent;
1540
- return assign$1;
1541
- }
1542
-
1543
- var assign;
1544
- var hasRequiredAssign;
1545
- function requireAssign() {
1546
- if (hasRequiredAssign) return assign;
1547
- hasRequiredAssign = 1;
1548
- var parent = requireAssign$1();
1549
- assign = parent;
1550
- return assign;
1551
- }
1552
-
1553
- var es_object_keys = {};
1554
-
1555
- var hasRequiredEs_object_keys;
1556
- function requireEs_object_keys() {
1557
- if (hasRequiredEs_object_keys) return es_object_keys;
1558
- hasRequiredEs_object_keys = 1;
1559
- var $ = require_export();
1560
- var toObject = requireToObject();
1561
- var nativeKeys = requireObjectKeys();
1562
- var fails = requireFails();
1563
- var FAILS_ON_PRIMITIVES = fails(function() {
1564
- nativeKeys(1);
1565
- });
1566
- // `Object.keys` method
1567
- // https://tc39.es/ecma262/#sec-object.keys
1568
- $({
1569
- target: 'Object',
1570
- stat: true,
1571
- forced: FAILS_ON_PRIMITIVES
1572
- }, {
1573
- keys: function keys(it) {
1574
- return nativeKeys(toObject(it));
1575
- }
1576
- });
1577
- return es_object_keys;
1578
- }
1579
-
1580
- var keys$2;
1581
- var hasRequiredKeys$2;
1582
- function requireKeys$2() {
1583
- if (hasRequiredKeys$2) return keys$2;
1584
- hasRequiredKeys$2 = 1;
1585
- requireEs_object_keys();
1586
- var path = requirePath();
1587
- keys$2 = path.Object.keys;
1588
- return keys$2;
1589
- }
1590
-
1591
- var keys$1;
1592
- var hasRequiredKeys$1;
1593
- function requireKeys$1() {
1594
- if (hasRequiredKeys$1) return keys$1;
1595
- hasRequiredKeys$1 = 1;
1596
- var parent = requireKeys$2();
1597
- keys$1 = parent;
1598
- return keys$1;
1599
- }
1600
-
1601
- var keys;
1602
- var hasRequiredKeys;
1603
- function requireKeys() {
1604
- if (hasRequiredKeys) return keys;
1605
- hasRequiredKeys = 1;
1606
- var parent = requireKeys$1();
1607
- keys = parent;
1608
- return keys;
1609
- }
1610
-
1611
- var es_array_find = {};
1612
-
1613
- var functionUncurryThisClause;
1614
- var hasRequiredFunctionUncurryThisClause;
1615
- function requireFunctionUncurryThisClause() {
1616
- if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
1617
- hasRequiredFunctionUncurryThisClause = 1;
1618
- var classofRaw = requireClassofRaw();
1619
- var uncurryThis = requireFunctionUncurryThis();
1620
- functionUncurryThisClause = function functionUncurryThisClause(fn) {
1621
- // Nashorn bug:
1622
- // https://github.com/zloirock/core-js/issues/1128
1623
- // https://github.com/zloirock/core-js/issues/1130
1624
- if (classofRaw(fn) === 'Function') return uncurryThis(fn);
1625
- };
1626
- return functionUncurryThisClause;
1627
- }
1628
-
1629
- var functionBindContext;
1630
- var hasRequiredFunctionBindContext;
1631
- function requireFunctionBindContext() {
1632
- if (hasRequiredFunctionBindContext) return functionBindContext;
1633
- hasRequiredFunctionBindContext = 1;
1634
- var uncurryThis = requireFunctionUncurryThisClause();
1635
- var aCallable = requireACallable();
1636
- var NATIVE_BIND = requireFunctionBindNative();
1637
- var bind = uncurryThis(uncurryThis.bind);
1638
- // optional / simple context binding
1639
- functionBindContext = function functionBindContext(fn, that) {
1640
- aCallable(fn);
1641
- return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function() {
1642
- return fn.apply(that, arguments);
1643
- };
1644
- };
1645
- return functionBindContext;
1646
- }
1647
-
1648
- var isArray;
1649
- var hasRequiredIsArray;
1650
- function requireIsArray() {
1651
- if (hasRequiredIsArray) return isArray;
1652
- hasRequiredIsArray = 1;
1653
- var classof = requireClassofRaw();
1654
- // `IsArray` abstract operation
1655
- // https://tc39.es/ecma262/#sec-isarray
1656
- // eslint-disable-next-line es/no-array-isarray -- safe
1657
- isArray = Array.isArray || function isArray(argument) {
1658
- return classof(argument) === 'Array';
1659
- };
1660
- return isArray;
1661
- }
1662
-
1663
- var toStringTagSupport;
1664
- var hasRequiredToStringTagSupport;
1665
- function requireToStringTagSupport() {
1666
- if (hasRequiredToStringTagSupport) return toStringTagSupport;
1667
- hasRequiredToStringTagSupport = 1;
1668
- var wellKnownSymbol = requireWellKnownSymbol();
1669
- var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1670
- var test = {};
1671
- test[TO_STRING_TAG] = 'z';
1672
- toStringTagSupport = String(test) === '[object z]';
1673
- return toStringTagSupport;
1674
- }
1675
-
1676
- var classof;
1677
- var hasRequiredClassof;
1678
- function requireClassof() {
1679
- if (hasRequiredClassof) return classof;
1680
- hasRequiredClassof = 1;
1681
- var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
1682
- var isCallable = requireIsCallable();
1683
- var classofRaw = requireClassofRaw();
1684
- var wellKnownSymbol = requireWellKnownSymbol();
1685
- var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1686
- var $Object = Object;
1687
- // ES3 wrong here
1688
- var CORRECT_ARGUMENTS = classofRaw(function() {
1689
- return arguments;
1690
- }()) === 'Arguments';
1691
- // fallback for IE11 Script Access Denied error
1692
- var tryGet = function tryGet(it, key) {
1693
- try {
1694
- return it[key];
1695
- } catch (error) {}
1696
- };
1697
- // getting tag from ES6+ `Object.prototype.toString`
1698
- classof = TO_STRING_TAG_SUPPORT ? classofRaw : function classof(it) {
1699
- var O, tag, result;
1700
- return it === undefined ? 'Undefined' : it === null ? 'Null' : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
1701
- };
1702
- return classof;
1703
- }
1704
-
1705
- var isConstructor;
1706
- var hasRequiredIsConstructor;
1707
- function requireIsConstructor() {
1708
- if (hasRequiredIsConstructor) return isConstructor;
1709
- hasRequiredIsConstructor = 1;
1710
- var uncurryThis = requireFunctionUncurryThis();
1711
- var fails = requireFails();
1712
- var isCallable = requireIsCallable();
1713
- var classof = requireClassof();
1714
- var getBuiltIn = requireGetBuiltIn();
1715
- var inspectSource = requireInspectSource();
1716
- var noop = function noop() {};
1717
- var construct = getBuiltIn('Reflect', 'construct');
1718
- var constructorRegExp = /^\s*(?:class|function)\b/;
1719
- var exec = uncurryThis(constructorRegExp.exec);
1720
- var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
1721
- var isConstructorModern = function isConstructor(argument) {
1722
- if (!isCallable(argument)) return false;
1723
- try {
1724
- construct(noop, [], argument);
1725
- return true;
1726
- } catch (error) {
1727
- return false;
1728
- }
1729
- };
1730
- var isConstructorLegacy = function isConstructor(argument) {
1731
- if (!isCallable(argument)) return false;
1732
- switch(classof(argument)){
1733
- case 'AsyncFunction':
1734
- case 'GeneratorFunction':
1735
- case 'AsyncGeneratorFunction':
1736
- return false;
1737
- }
1738
- try {
1739
- // we can't check .prototype since constructors produced by .bind haven't it
1740
- // `Function#toString` throws on some built-it function in some legacy engines
1741
- // (for example, `DOMQuad` and similar in FF41-)
1742
- return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
1743
- } catch (error) {
1744
- return true;
1745
- }
1746
- };
1747
- isConstructorLegacy.sham = true;
1748
- // `IsConstructor` abstract operation
1749
- // https://tc39.es/ecma262/#sec-isconstructor
1750
- isConstructor = !construct || fails(function() {
1751
- var called;
1752
- return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
1753
- called = true;
1754
- }) || called;
1755
- }) ? isConstructorLegacy : isConstructorModern;
1756
- return isConstructor;
1757
- }
1758
-
1759
- var arraySpeciesConstructor;
1760
- var hasRequiredArraySpeciesConstructor;
1761
- function requireArraySpeciesConstructor() {
1762
- if (hasRequiredArraySpeciesConstructor) return arraySpeciesConstructor;
1763
- hasRequiredArraySpeciesConstructor = 1;
1764
- var isArray = requireIsArray();
1765
- var isConstructor = requireIsConstructor();
1766
- var isObject = requireIsObject();
1767
- var wellKnownSymbol = requireWellKnownSymbol();
1768
- var SPECIES = wellKnownSymbol('species');
1769
- var $Array = Array;
1770
- // a part of `ArraySpeciesCreate` abstract operation
1771
- // https://tc39.es/ecma262/#sec-arrayspeciescreate
1772
- arraySpeciesConstructor = function arraySpeciesConstructor(originalArray) {
1773
- var C;
1774
- if (isArray(originalArray)) {
1775
- C = originalArray.constructor;
1776
- // cross-realm fallback
1777
- if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;
1778
- else if (isObject(C)) {
1779
- C = C[SPECIES];
1780
- if (C === null) C = undefined;
1781
- }
1782
- }
1783
- return C === undefined ? $Array : C;
1784
- };
1785
- return arraySpeciesConstructor;
1786
- }
1787
-
1788
- var arraySpeciesCreate;
1789
- var hasRequiredArraySpeciesCreate;
1790
- function requireArraySpeciesCreate() {
1791
- if (hasRequiredArraySpeciesCreate) return arraySpeciesCreate;
1792
- hasRequiredArraySpeciesCreate = 1;
1793
- var arraySpeciesConstructor = requireArraySpeciesConstructor();
1794
- // `ArraySpeciesCreate` abstract operation
1795
- // https://tc39.es/ecma262/#sec-arrayspeciescreate
1796
- arraySpeciesCreate = function arraySpeciesCreate(originalArray, length) {
1797
- return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
1798
- };
1799
- return arraySpeciesCreate;
1800
- }
1801
-
1802
- var arrayIteration;
1803
- var hasRequiredArrayIteration;
1804
- function requireArrayIteration() {
1805
- if (hasRequiredArrayIteration) return arrayIteration;
1806
- hasRequiredArrayIteration = 1;
1807
- var bind = requireFunctionBindContext();
1808
- var uncurryThis = requireFunctionUncurryThis();
1809
- var IndexedObject = requireIndexedObject();
1810
- var toObject = requireToObject();
1811
- var lengthOfArrayLike = requireLengthOfArrayLike();
1812
- var arraySpeciesCreate = requireArraySpeciesCreate();
1813
- var push = uncurryThis([].push);
1814
- // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
1815
- var createMethod = function createMethod(TYPE) {
1816
- var IS_MAP = TYPE === 1;
1817
- var IS_FILTER = TYPE === 2;
1818
- var IS_SOME = TYPE === 3;
1819
- var IS_EVERY = TYPE === 4;
1820
- var IS_FIND_INDEX = TYPE === 6;
1821
- var IS_FILTER_REJECT = TYPE === 7;
1822
- var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;
1823
- return function($this, callbackfn, that, specificCreate) {
1824
- var O = toObject($this);
1825
- var self = IndexedObject(O);
1826
- var length = lengthOfArrayLike(self);
1827
- var boundFunction = bind(callbackfn, that);
1828
- var index = 0;
1829
- var create = specificCreate || arraySpeciesCreate;
1830
- var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
1831
- var value, result;
1832
- for(; length > index; index++)if (NO_HOLES || index in self) {
1833
- value = self[index];
1834
- result = boundFunction(value, index, O);
1835
- if (TYPE) {
1836
- if (IS_MAP) target[index] = result; // map
1837
- else if (result) switch(TYPE){
1838
- case 3:
1839
- return true; // some
1840
- case 5:
1841
- return value; // find
1842
- case 6:
1843
- return index; // findIndex
1844
- case 2:
1845
- push(target, value); // filter
1846
- }
1847
- else switch(TYPE){
1848
- case 4:
1849
- return false; // every
1850
- case 7:
1851
- push(target, value); // filterReject
1852
- }
1853
- }
1854
- }
1855
- return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
1856
- };
1857
- };
1858
- arrayIteration = {
1859
- // `Array.prototype.forEach` method
1860
- // https://tc39.es/ecma262/#sec-array.prototype.foreach
1861
- forEach: createMethod(0),
1862
- // `Array.prototype.map` method
1863
- // https://tc39.es/ecma262/#sec-array.prototype.map
1864
- map: createMethod(1),
1865
- // `Array.prototype.filter` method
1866
- // https://tc39.es/ecma262/#sec-array.prototype.filter
1867
- filter: createMethod(2),
1868
- // `Array.prototype.some` method
1869
- // https://tc39.es/ecma262/#sec-array.prototype.some
1870
- some: createMethod(3),
1871
- // `Array.prototype.every` method
1872
- // https://tc39.es/ecma262/#sec-array.prototype.every
1873
- every: createMethod(4),
1874
- // `Array.prototype.find` method
1875
- // https://tc39.es/ecma262/#sec-array.prototype.find
1876
- find: createMethod(5),
1877
- // `Array.prototype.findIndex` method
1878
- // https://tc39.es/ecma262/#sec-array.prototype.findIndex
1879
- findIndex: createMethod(6),
1880
- // `Array.prototype.filterReject` method
1881
- // https://github.com/tc39/proposal-array-filtering
1882
- filterReject: createMethod(7)
1883
- };
1884
- return arrayIteration;
1885
- }
1886
-
1887
- var objectDefineProperties = {};
1888
-
1889
- var hasRequiredObjectDefineProperties;
1890
- function requireObjectDefineProperties() {
1891
- if (hasRequiredObjectDefineProperties) return objectDefineProperties;
1892
- hasRequiredObjectDefineProperties = 1;
1893
- var DESCRIPTORS = requireDescriptors();
1894
- var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
1895
- var definePropertyModule = requireObjectDefineProperty();
1896
- var anObject = requireAnObject();
1897
- var toIndexedObject = requireToIndexedObject();
1898
- var objectKeys = requireObjectKeys();
1899
- // `Object.defineProperties` method
1900
- // https://tc39.es/ecma262/#sec-object.defineproperties
1901
- // eslint-disable-next-line es/no-object-defineproperties -- safe
1902
- objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
1903
- anObject(O);
1904
- var props = toIndexedObject(Properties);
1905
- var keys = objectKeys(Properties);
1906
- var length = keys.length;
1907
- var index = 0;
1908
- var key;
1909
- while(length > index)definePropertyModule.f(O, key = keys[index++], props[key]);
1910
- return O;
1911
- };
1912
- return objectDefineProperties;
1913
- }
1914
-
1915
- var html;
1916
- var hasRequiredHtml;
1917
- function requireHtml() {
1918
- if (hasRequiredHtml) return html;
1919
- hasRequiredHtml = 1;
1920
- var getBuiltIn = requireGetBuiltIn();
1921
- html = getBuiltIn('document', 'documentElement');
1922
- return html;
1923
- }
1924
-
1925
- var objectCreate;
1926
- var hasRequiredObjectCreate;
1927
- function requireObjectCreate() {
1928
- if (hasRequiredObjectCreate) return objectCreate;
1929
- hasRequiredObjectCreate = 1;
1930
- /* global ActiveXObject -- old IE, WSH */ var anObject = requireAnObject();
1931
- var definePropertiesModule = requireObjectDefineProperties();
1932
- var enumBugKeys = requireEnumBugKeys();
1933
- var hiddenKeys = requireHiddenKeys();
1934
- var html = requireHtml();
1935
- var documentCreateElement = requireDocumentCreateElement();
1936
- var sharedKey = requireSharedKey();
1937
- var GT = '>';
1938
- var LT = '<';
1939
- var PROTOTYPE = 'prototype';
1940
- var SCRIPT = 'script';
1941
- var IE_PROTO = sharedKey('IE_PROTO');
1942
- var EmptyConstructor = function EmptyConstructor() {};
1943
- var scriptTag = function scriptTag(content) {
1944
- return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
1945
- };
1946
- // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
1947
- var NullProtoObjectViaActiveX = function NullProtoObjectViaActiveX(activeXDocument) {
1948
- activeXDocument.write(scriptTag(''));
1949
- activeXDocument.close();
1950
- var temp = activeXDocument.parentWindow.Object;
1951
- // eslint-disable-next-line no-useless-assignment -- avoid memory leak
1952
- activeXDocument = null;
1953
- return temp;
1954
- };
1955
- // Create object with fake `null` prototype: use iframe Object with cleared prototype
1956
- var NullProtoObjectViaIFrame = function NullProtoObjectViaIFrame() {
1957
- // Thrash, waste and sodomy: IE GC bug
1958
- var iframe = documentCreateElement('iframe');
1959
- var JS = 'java' + SCRIPT + ':';
1960
- var iframeDocument;
1961
- iframe.style.display = 'none';
1962
- html.appendChild(iframe);
1963
- // https://github.com/zloirock/core-js/issues/475
1964
- iframe.src = String(JS);
1965
- iframeDocument = iframe.contentWindow.document;
1966
- iframeDocument.open();
1967
- iframeDocument.write(scriptTag('document.F=Object'));
1968
- iframeDocument.close();
1969
- return iframeDocument.F;
1970
- };
1971
- // Check for document.domain and active x support
1972
- // No need to use active x approach when document.domain is not set
1973
- // see https://github.com/es-shims/es5-shim/issues/150
1974
- // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
1975
- // avoid IE GC bug
1976
- var activeXDocument;
1977
- var NullProtoObject = function NullProtoObject1() {
1978
- try {
1979
- activeXDocument = new ActiveXObject('htmlfile');
1980
- } catch (error) {}
1981
- NullProtoObject = typeof document != 'undefined' ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) // old IE
1982
- : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument); // WSH
1983
- var length = enumBugKeys.length;
1984
- while(length--)delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
1985
- return NullProtoObject();
1986
- };
1987
- hiddenKeys[IE_PROTO] = true;
1988
- // `Object.create` method
1989
- // https://tc39.es/ecma262/#sec-object.create
1990
- // eslint-disable-next-line es/no-object-create -- safe
1991
- objectCreate = Object.create || function create(O, Properties) {
1992
- var result;
1993
- if (O !== null) {
1994
- EmptyConstructor[PROTOTYPE] = anObject(O);
1995
- result = new EmptyConstructor();
1996
- EmptyConstructor[PROTOTYPE] = null;
1997
- // add "__proto__" for Object.getPrototypeOf polyfill
1998
- result[IE_PROTO] = O;
1999
- } else result = NullProtoObject();
2000
- return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
2001
- };
2002
- return objectCreate;
2003
- }
2004
-
2005
- var addToUnscopables;
2006
- var hasRequiredAddToUnscopables;
2007
- function requireAddToUnscopables() {
2008
- if (hasRequiredAddToUnscopables) return addToUnscopables;
2009
- hasRequiredAddToUnscopables = 1;
2010
- var wellKnownSymbol = requireWellKnownSymbol();
2011
- var create = requireObjectCreate();
2012
- var defineProperty = requireObjectDefineProperty().f;
2013
- var UNSCOPABLES = wellKnownSymbol('unscopables');
2014
- var ArrayPrototype = Array.prototype;
2015
- // Array.prototype[@@unscopables]
2016
- // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
2017
- if (ArrayPrototype[UNSCOPABLES] === undefined) {
2018
- defineProperty(ArrayPrototype, UNSCOPABLES, {
2019
- configurable: true,
2020
- value: create(null)
2021
- });
2022
- }
2023
- // add a key to Array.prototype[@@unscopables]
2024
- addToUnscopables = function addToUnscopables(key) {
2025
- ArrayPrototype[UNSCOPABLES][key] = true;
2026
- };
2027
- return addToUnscopables;
2028
- }
2029
-
2030
- var hasRequiredEs_array_find;
2031
- function requireEs_array_find() {
2032
- if (hasRequiredEs_array_find) return es_array_find;
2033
- hasRequiredEs_array_find = 1;
2034
- var $ = require_export();
2035
- var $find = requireArrayIteration().find;
2036
- var addToUnscopables = requireAddToUnscopables();
2037
- var FIND = 'find';
2038
- var SKIPS_HOLES = true;
2039
- // Shouldn't skip holes
2040
- // eslint-disable-next-line es/no-array-prototype-find -- testing
2041
- if (FIND in []) Array(1)[FIND](function() {
2042
- SKIPS_HOLES = false;
2043
- });
2044
- // `Array.prototype.find` method
2045
- // https://tc39.es/ecma262/#sec-array.prototype.find
2046
- $({
2047
- target: 'Array',
2048
- proto: true,
2049
- forced: SKIPS_HOLES
2050
- }, {
2051
- find: function find(callbackfn /* , that = undefined */ ) {
2052
- return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
2053
- }
2054
- });
2055
- // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
2056
- addToUnscopables(FIND);
2057
- return es_array_find;
2058
- }
2059
-
2060
- var entryUnbind;
2061
- var hasRequiredEntryUnbind;
2062
- function requireEntryUnbind() {
2063
- if (hasRequiredEntryUnbind) return entryUnbind;
2064
- hasRequiredEntryUnbind = 1;
2065
- var globalThis = requireGlobalThis();
2066
- var uncurryThis = requireFunctionUncurryThis();
2067
- entryUnbind = function entryUnbind(CONSTRUCTOR, METHOD) {
2068
- return uncurryThis(globalThis[CONSTRUCTOR].prototype[METHOD]);
2069
- };
2070
- return entryUnbind;
2071
- }
2072
-
2073
- var find$2;
2074
- var hasRequiredFind$2;
2075
- function requireFind$2() {
2076
- if (hasRequiredFind$2) return find$2;
2077
- hasRequiredFind$2 = 1;
2078
- requireEs_array_find();
2079
- var entryUnbind = requireEntryUnbind();
2080
- find$2 = entryUnbind('Array', 'find');
2081
- return find$2;
2082
- }
2083
-
2084
- var find$1;
2085
- var hasRequiredFind$1;
2086
- function requireFind$1() {
2087
- if (hasRequiredFind$1) return find$1;
2088
- hasRequiredFind$1 = 1;
2089
- var parent = requireFind$2();
2090
- find$1 = parent;
2091
- return find$1;
2092
- }
2093
-
2094
- var find;
2095
- var hasRequiredFind;
2096
- function requireFind() {
2097
- if (hasRequiredFind) return find;
2098
- hasRequiredFind = 1;
2099
- var parent = requireFind$1();
2100
- find = parent;
2101
- return find;
2102
- }
2103
-
2104
- var bufferV6Polyfill = {};
2105
-
2106
- var hasRequiredBufferV6Polyfill;
2107
- function requireBufferV6Polyfill() {
2108
- if (hasRequiredBufferV6Polyfill) return bufferV6Polyfill;
2109
- hasRequiredBufferV6Polyfill = 1;
2110
- (function() {
2111
- if (Number(process.version.match(/^v(\d+\.\d+)/)[1]) >= 6.0) {
2112
- return;
2113
- }
2114
- function newBuffer(data, encoding, len) {
2115
- return new Buffer(data, encoding, len);
2116
- }
2117
- function newSlowBuffer(data, encoding, len) {
2118
- var SlowBuffer = require$$0.SlowBuffer;
2119
- return new SlowBuffer(data, encoding, len);
2120
- }
2121
- if (!Buffer.alloc) {
2122
- Buffer.alloc = newBuffer;
2123
- }
2124
- if (!Buffer.allocUnsafe) {
2125
- Buffer.allocUnsafe = newBuffer;
2126
- }
2127
- if (!Buffer.allocUnsafeSlow) {
2128
- Buffer.allocUnsafeSlow = newSlowBuffer;
2129
- }
2130
- if (!Buffer.from) {
2131
- Buffer.from = newBuffer;
2132
- }
2133
- try {
2134
- Buffer.from('1337', 'hex');
2135
- } catch (e) {
2136
- // wish I could do something here to fix the broken Buffer.from
2137
- try {
2138
- Buffer.from = newBuffer;
2139
- } catch (e) {
2140
- // but alas, I cannot
2141
- console.warn("Your node version has buggy Buffer.from support. Please update to node >= v4.5 or >= v6.3");
2142
- }
2143
- }
2144
- })();
2145
- return bufferV6Polyfill;
2146
- }
2147
-
2148
16
  var crossSpawn6_0_5 = {
2149
17
  exports: {}
2150
18
  };
@@ -2173,7 +41,7 @@ function requireWindows() {
2173
41
  hasRequiredWindows = 1;
2174
42
  windows = isexe;
2175
43
  isexe.sync = sync;
2176
- var fs = require$$0$1;
44
+ var fs = require$$0;
2177
45
  function checkPathExt(path, options) {
2178
46
  var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
2179
47
  if (!pathext) {
@@ -2215,7 +83,7 @@ function requireMode() {
2215
83
  hasRequiredMode = 1;
2216
84
  mode = isexe;
2217
85
  isexe.sync = sync;
2218
- var fs = require$$0$1;
86
+ var fs = require$$0;
2219
87
  function isexe(path, options, cb) {
2220
88
  fs.stat(path, function(er, stat) {
2221
89
  cb(er, er ? false : checkStat(stat, options));
@@ -2309,7 +177,7 @@ function requireWhich() {
2309
177
  which_1 = which;
2310
178
  which.sync = whichSync;
2311
179
  var isWindows = process.platform === 'win32' || process.env.OSTYPE === 'cygwin' || process.env.OSTYPE === 'msys';
2312
- var path = require$$0$2;
180
+ var path = require$$0$1;
2313
181
  var COLON = isWindows ? ';' : ':';
2314
182
  var isexe = requireIsexe();
2315
183
  function getNotFoundError(cmd) {
@@ -2439,7 +307,7 @@ var hasRequiredResolveCommand;
2439
307
  function requireResolveCommand() {
2440
308
  if (hasRequiredResolveCommand) return resolveCommand_1;
2441
309
  hasRequiredResolveCommand = 1;
2442
- var path = require$$0$2;
310
+ var path = require$$0$1;
2443
311
  var which = requireWhich();
2444
312
  var pathKey = requirePathKey()();
2445
313
  function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -2550,7 +418,7 @@ var hasRequiredReadShebang;
2550
418
  function requireReadShebang() {
2551
419
  if (hasRequiredReadShebang) return readShebang_1;
2552
420
  hasRequiredReadShebang = 1;
2553
- var fs = require$$0$1;
421
+ var fs = require$$0;
2554
422
  var shebangCommand = requireShebangCommand();
2555
423
  function readShebang(command) {
2556
424
  // Read the first 150 bytes from the file
@@ -3843,7 +1711,7 @@ var hasRequiredParse;
3843
1711
  function requireParse() {
3844
1712
  if (hasRequiredParse) return parse_1;
3845
1713
  hasRequiredParse = 1;
3846
- var path = require$$0$2;
1714
+ var path = require$$0$1;
3847
1715
  var niceTry = requireSrc$1();
3848
1716
  var resolveCommand = requireResolveCommand();
3849
1717
  var escape = require_escape();
@@ -4022,7 +1890,7 @@ var hasRequiredCrossSpawn6_0_5;
4022
1890
  function requireCrossSpawn6_0_5() {
4023
1891
  if (hasRequiredCrossSpawn6_0_5) return crossSpawn6_0_5.exports;
4024
1892
  hasRequiredCrossSpawn6_0_5 = 1;
4025
- var cp = require$$0$3;
1893
+ var cp = require$$0$2;
4026
1894
  var parse = requireParse();
4027
1895
  var enoent = requireEnoent();
4028
1896
  function spawn(command, args, options) {
@@ -4056,28 +1924,8 @@ var hasRequiredSrc;
4056
1924
  function requireSrc() {
4057
1925
  if (hasRequiredSrc) return src$1.exports;
4058
1926
  hasRequiredSrc = 1;
4059
- requireAssign();
4060
- requireKeys();
4061
- requireFind();
4062
- requireBufferV6Polyfill();
4063
- var path = require$$0$2;
4064
- if (!path.delimiter) {
4065
- var isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);
4066
- path.delimiter = isWindows ? ';' : ':';
4067
- }
4068
- // early node is missing spawnSync
4069
- var cp = require$$0$3;
4070
- if (!cp.spawnSync) {
4071
- var path1 = require$$0$2;
4072
- var spawnCallback = path1.join(__dirname, '..', 'dist', 'cjs', 'spawnCallback.js');
4073
- var functionExec = null; // break dependencies
4074
- cp.spawnSync = function spawnSyncPolyfill(cmd, args, options) {
4075
- if (!functionExec) functionExec = require$$6;
4076
- return functionExec({
4077
- callbacks: true
4078
- }, spawnCallback, cmd, args, options || {});
4079
- };
4080
- }
1927
+ var path = require$$0$1;
1928
+ var cp = require$$0$2;
4081
1929
  var spawn_ = requireCrossSpawn6_0_5();
4082
1930
  var NODES = [
4083
1931
  'node',