@rstest/core 0.0.1 → 0.0.3

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.
Files changed (14) hide show
  1. package/LICENSE +658 -0
  2. package/dist/202.js +365 -0
  3. package/dist/353.js +1 -1
  4. package/dist/81.js +1467 -0
  5. package/dist/813.js +5 -3
  6. package/dist/{773.js → 867.js} +189 -163
  7. package/dist/973.js +0 -72
  8. package/dist/992.js +27 -13
  9. package/dist/cli.js +138 -122
  10. package/dist/worker.js +326 -168
  11. package/dist-types/node.d.ts +1 -2
  12. package/dist-types/public.d.ts +95 -3
  13. package/dist-types/worker.d.ts +1 -2
  14. package/package.json +30 -11
package/dist/81.js ADDED
@@ -0,0 +1,1467 @@
1
+ export const __webpack_ids__ = [
2
+ "81"
3
+ ];
4
+ export const __webpack_modules__ = {
5
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/called-in-order.js": function(module, __unused_webpack_exports, __webpack_require__) {
6
+ var every = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/array.js").every;
7
+ function hasCallsLeft(callMap, spy) {
8
+ if (void 0 === callMap[spy.id]) callMap[spy.id] = 0;
9
+ return callMap[spy.id] < spy.callCount;
10
+ }
11
+ function checkAdjacentCalls(callMap, spy, index, spies) {
12
+ var calledBeforeNext = true;
13
+ if (index !== spies.length - 1) calledBeforeNext = spy.calledBefore(spies[index + 1]);
14
+ if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
15
+ callMap[spy.id] += 1;
16
+ return true;
17
+ }
18
+ return false;
19
+ }
20
+ function calledInOrder(spies) {
21
+ var callMap = {};
22
+ var _spies = arguments.length > 1 ? arguments : spies;
23
+ return every(_spies, checkAdjacentCalls.bind(null, callMap));
24
+ }
25
+ module.exports = calledInOrder;
26
+ },
27
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/class-name.js": function(module) {
28
+ function className(value) {
29
+ const name = value.constructor && value.constructor.name;
30
+ return name || null;
31
+ }
32
+ module.exports = className;
33
+ },
34
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/deprecated.js": function(__unused_webpack_module, exports) {
35
+ exports.wrap = function(func, msg) {
36
+ var wrapped = function() {
37
+ exports.printWarning(msg);
38
+ return func.apply(this, arguments);
39
+ };
40
+ if (func.prototype) wrapped.prototype = func.prototype;
41
+ return wrapped;
42
+ };
43
+ exports.defaultMsg = function(packageName, funcName) {
44
+ return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
45
+ };
46
+ exports.printWarning = function(msg) {
47
+ if ("object" == typeof process && process.emitWarning) process.emitWarning(msg);
48
+ else if (console.info) console.info(msg);
49
+ else console.log(msg);
50
+ };
51
+ },
52
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/every.js": function(module) {
53
+ module.exports = function every(obj, fn) {
54
+ var pass = true;
55
+ try {
56
+ obj.forEach(function() {
57
+ if (!fn.apply(this, arguments)) throw new Error();
58
+ });
59
+ } catch (e) {
60
+ pass = false;
61
+ }
62
+ return pass;
63
+ };
64
+ },
65
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/function-name.js": function(module) {
66
+ module.exports = function functionName(func) {
67
+ if (!func) return "";
68
+ try {
69
+ return func.displayName || func.name || (String(func).match(/function ([^\s(]+)/) || [])[1];
70
+ } catch (e) {
71
+ return "";
72
+ }
73
+ };
74
+ },
75
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/global.js": function(module) {
76
+ var globalObject;
77
+ globalObject = "undefined" != typeof global ? global : "undefined" != typeof window ? window : self;
78
+ module.exports = globalObject;
79
+ },
80
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
81
+ module.exports = {
82
+ global: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/global.js"),
83
+ calledInOrder: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/called-in-order.js"),
84
+ className: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/class-name.js"),
85
+ deprecated: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/deprecated.js"),
86
+ every: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/every.js"),
87
+ functionName: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/function-name.js"),
88
+ orderByFirstCall: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/order-by-first-call.js"),
89
+ prototypes: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/index.js"),
90
+ typeOf: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/type-of.js"),
91
+ valueToString: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/value-to-string.js")
92
+ };
93
+ },
94
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/order-by-first-call.js": function(module, __unused_webpack_exports, __webpack_require__) {
95
+ var sort = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/array.js").sort;
96
+ var slice = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/array.js").slice;
97
+ function comparator(a, b) {
98
+ var aCall = a.getCall(0);
99
+ var bCall = b.getCall(0);
100
+ var aId = aCall && aCall.callId || -1;
101
+ var bId = bCall && bCall.callId || -1;
102
+ return aId < bId ? -1 : 1;
103
+ }
104
+ function orderByFirstCall(spies) {
105
+ return sort(slice(spies), comparator);
106
+ }
107
+ module.exports = orderByFirstCall;
108
+ },
109
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/array.js": function(module, __unused_webpack_exports, __webpack_require__) {
110
+ var copyPrototype = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js");
111
+ module.exports = copyPrototype(Array.prototype);
112
+ },
113
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js": function(module, __unused_webpack_exports, __webpack_require__) {
114
+ var call = Function.call;
115
+ var throwsOnProto = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/throws-on-proto.js");
116
+ var disallowedProperties = [
117
+ "size",
118
+ "caller",
119
+ "callee",
120
+ "arguments"
121
+ ];
122
+ if (throwsOnProto) disallowedProperties.push("__proto__");
123
+ module.exports = function copyPrototypeMethods(prototype) {
124
+ return Object.getOwnPropertyNames(prototype).reduce(function(result, name) {
125
+ if (disallowedProperties.includes(name)) return result;
126
+ if ("function" != typeof prototype[name]) return result;
127
+ result[name] = call.bind(prototype[name]);
128
+ return result;
129
+ }, Object.create(null));
130
+ };
131
+ },
132
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/function.js": function(module, __unused_webpack_exports, __webpack_require__) {
133
+ var copyPrototype = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js");
134
+ module.exports = copyPrototype(Function.prototype);
135
+ },
136
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
137
+ module.exports = {
138
+ array: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/array.js"),
139
+ function: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/function.js"),
140
+ map: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/map.js"),
141
+ object: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/object.js"),
142
+ set: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/set.js"),
143
+ string: __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/string.js")
144
+ };
145
+ },
146
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/map.js": function(module, __unused_webpack_exports, __webpack_require__) {
147
+ var copyPrototype = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js");
148
+ module.exports = copyPrototype(Map.prototype);
149
+ },
150
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/object.js": function(module, __unused_webpack_exports, __webpack_require__) {
151
+ var copyPrototype = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js");
152
+ module.exports = copyPrototype(Object.prototype);
153
+ },
154
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/set.js": function(module, __unused_webpack_exports, __webpack_require__) {
155
+ var copyPrototype = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js");
156
+ module.exports = copyPrototype(Set.prototype);
157
+ },
158
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/string.js": function(module, __unused_webpack_exports, __webpack_require__) {
159
+ var copyPrototype = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js");
160
+ module.exports = copyPrototype(String.prototype);
161
+ },
162
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/throws-on-proto.js": function(module) {
163
+ let throwsOnProto;
164
+ try {
165
+ const object = {};
166
+ object.__proto__;
167
+ throwsOnProto = false;
168
+ } catch (_) {
169
+ throwsOnProto = true;
170
+ }
171
+ module.exports = throwsOnProto;
172
+ },
173
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/type-of.js": function(module, __unused_webpack_exports, __webpack_require__) {
174
+ var type = __webpack_require__("../../node_modules/.pnpm/type-detect@4.0.8/node_modules/type-detect/type-detect.js");
175
+ module.exports = function typeOf(value) {
176
+ return type(value).toLowerCase();
177
+ };
178
+ },
179
+ "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/value-to-string.js": function(module) {
180
+ function valueToString(value) {
181
+ if (value && value.toString) return value.toString();
182
+ return String(value);
183
+ }
184
+ module.exports = valueToString;
185
+ },
186
+ "../../node_modules/.pnpm/@sinonjs+fake-timers@14.0.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js": function(__unused_webpack_module, exports, __webpack_require__) {
187
+ const globalObject = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/index.js").global;
188
+ let timersModule, timersPromisesModule;
189
+ try {
190
+ timersModule = __webpack_require__("timers");
191
+ } catch (e) {}
192
+ try {
193
+ timersPromisesModule = __webpack_require__("timers/promises");
194
+ } catch (e) {}
195
+ function withGlobal(_global) {
196
+ const maxTimeout = Math.pow(2, 31) - 1;
197
+ const idCounterStart = 1e12;
198
+ const NOOP = function() {};
199
+ const NOOP_ARRAY = function() {
200
+ return [];
201
+ };
202
+ const isPresent = {};
203
+ let timeoutResult, addTimerReturnsObject = false;
204
+ if (_global.setTimeout) {
205
+ isPresent.setTimeout = true;
206
+ timeoutResult = _global.setTimeout(NOOP, 0);
207
+ addTimerReturnsObject = "object" == typeof timeoutResult;
208
+ }
209
+ isPresent.clearTimeout = Boolean(_global.clearTimeout);
210
+ isPresent.setInterval = Boolean(_global.setInterval);
211
+ isPresent.clearInterval = Boolean(_global.clearInterval);
212
+ isPresent.hrtime = _global.process && "function" == typeof _global.process.hrtime;
213
+ isPresent.hrtimeBigint = isPresent.hrtime && "function" == typeof _global.process.hrtime.bigint;
214
+ isPresent.nextTick = _global.process && "function" == typeof _global.process.nextTick;
215
+ const utilPromisify = _global.process && __webpack_require__("util").promisify;
216
+ isPresent.performance = _global.performance && "function" == typeof _global.performance.now;
217
+ const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
218
+ const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
219
+ isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
220
+ isPresent.requestAnimationFrame = _global.requestAnimationFrame && "function" == typeof _global.requestAnimationFrame;
221
+ isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && "function" == typeof _global.cancelAnimationFrame;
222
+ isPresent.requestIdleCallback = _global.requestIdleCallback && "function" == typeof _global.requestIdleCallback;
223
+ isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && "function" == typeof _global.cancelIdleCallback;
224
+ isPresent.setImmediate = _global.setImmediate && "function" == typeof _global.setImmediate;
225
+ isPresent.clearImmediate = _global.clearImmediate && "function" == typeof _global.clearImmediate;
226
+ isPresent.Intl = _global.Intl && "object" == typeof _global.Intl;
227
+ if (_global.clearTimeout) _global.clearTimeout(timeoutResult);
228
+ const NativeDate = _global.Date;
229
+ const NativeIntl = isPresent.Intl ? Object.defineProperties(Object.create(null), Object.getOwnPropertyDescriptors(_global.Intl)) : void 0;
230
+ let uniqueTimerId = idCounterStart;
231
+ if (void 0 === NativeDate) throw new Error("The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)");
232
+ isPresent.Date = true;
233
+ class FakePerformanceEntry {
234
+ constructor(name, entryType, startTime, duration){
235
+ this.name = name;
236
+ this.entryType = entryType;
237
+ this.startTime = startTime;
238
+ this.duration = duration;
239
+ }
240
+ toJSON() {
241
+ return JSON.stringify({
242
+ ...this
243
+ });
244
+ }
245
+ }
246
+ function isNumberFinite(num) {
247
+ if (Number.isFinite) return Number.isFinite(num);
248
+ return isFinite(num);
249
+ }
250
+ let isNearInfiniteLimit = false;
251
+ function checkIsNearInfiniteLimit(clock, i) {
252
+ if (clock.loopLimit && i === clock.loopLimit - 1) isNearInfiniteLimit = true;
253
+ }
254
+ function resetIsNearInfiniteLimit() {
255
+ isNearInfiniteLimit = false;
256
+ }
257
+ function parseTime(str) {
258
+ if (!str) return 0;
259
+ const strings = str.split(":");
260
+ const l = strings.length;
261
+ let i = l;
262
+ let ms = 0;
263
+ let parsed;
264
+ if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) throw new Error("tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits");
265
+ while(i--){
266
+ parsed = parseInt(strings[i], 10);
267
+ if (parsed >= 60) throw new Error(`Invalid time ${str}`);
268
+ ms += parsed * Math.pow(60, l - i - 1);
269
+ }
270
+ return 1000 * ms;
271
+ }
272
+ function nanoRemainder(msFloat) {
273
+ const modulo = 1e6;
274
+ const remainder = 1e6 * msFloat % modulo;
275
+ const positiveRemainder = remainder < 0 ? remainder + modulo : remainder;
276
+ return Math.floor(positiveRemainder);
277
+ }
278
+ function getEpoch(epoch) {
279
+ if (!epoch) return 0;
280
+ if ("function" == typeof epoch.getTime) return epoch.getTime();
281
+ if ("number" == typeof epoch) return epoch;
282
+ throw new TypeError("now should be milliseconds since UNIX epoch");
283
+ }
284
+ function inRange(from, to, timer) {
285
+ return timer && timer.callAt >= from && timer.callAt <= to;
286
+ }
287
+ function getInfiniteLoopError(clock, job) {
288
+ const infiniteLoopError = new Error(`Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`);
289
+ if (!job.error) return infiniteLoopError;
290
+ const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
291
+ let clockMethodPattern = new RegExp(String(Object.keys(clock).join("|")));
292
+ if (addTimerReturnsObject) clockMethodPattern = new RegExp(`\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`);
293
+ let matchedLineIndex = -1;
294
+ job.error.stack.split("\n").some(function(line, i) {
295
+ const matchedComputedTarget = line.match(computedTargetPattern);
296
+ if (matchedComputedTarget) {
297
+ matchedLineIndex = i;
298
+ return true;
299
+ }
300
+ const matchedClockMethod = line.match(clockMethodPattern);
301
+ if (matchedClockMethod) {
302
+ matchedLineIndex = i;
303
+ return false;
304
+ }
305
+ return matchedLineIndex >= 0;
306
+ });
307
+ const stack = `${infiniteLoopError}\n${job.type || "Microtask"} - ${job.func.name || "anonymous"}\n${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
308
+ try {
309
+ Object.defineProperty(infiniteLoopError, "stack", {
310
+ value: stack
311
+ });
312
+ } catch (e) {}
313
+ return infiniteLoopError;
314
+ }
315
+ function createDate() {
316
+ class ClockDate extends NativeDate {
317
+ constructor(year, month, date, hour, minute, second, ms){
318
+ if (0 === arguments.length) super(ClockDate.clock.now);
319
+ else super(...arguments);
320
+ Object.defineProperty(this, "constructor", {
321
+ value: NativeDate,
322
+ enumerable: false
323
+ });
324
+ }
325
+ static [Symbol.hasInstance](instance) {
326
+ return instance instanceof NativeDate;
327
+ }
328
+ }
329
+ ClockDate.isFake = true;
330
+ if (NativeDate.now) ClockDate.now = function now() {
331
+ return ClockDate.clock.now;
332
+ };
333
+ if (NativeDate.toSource) ClockDate.toSource = function toSource() {
334
+ return NativeDate.toSource();
335
+ };
336
+ ClockDate.toString = function toString() {
337
+ return NativeDate.toString();
338
+ };
339
+ const ClockDateProxy = new Proxy(ClockDate, {
340
+ apply () {
341
+ if (this instanceof ClockDate) throw new TypeError("A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic.");
342
+ return new NativeDate(ClockDate.clock.now).toString();
343
+ }
344
+ });
345
+ return ClockDateProxy;
346
+ }
347
+ function createIntl() {
348
+ const ClockIntl = {};
349
+ Object.getOwnPropertyNames(NativeIntl).forEach((property)=>ClockIntl[property] = NativeIntl[property]);
350
+ ClockIntl.DateTimeFormat = function(...args) {
351
+ const realFormatter = new NativeIntl.DateTimeFormat(...args);
352
+ const formatter = {};
353
+ [
354
+ "formatRange",
355
+ "formatRangeToParts",
356
+ "resolvedOptions"
357
+ ].forEach((method)=>{
358
+ formatter[method] = realFormatter[method].bind(realFormatter);
359
+ });
360
+ [
361
+ "format",
362
+ "formatToParts"
363
+ ].forEach((method)=>{
364
+ formatter[method] = function(date) {
365
+ return realFormatter[method](date || ClockIntl.clock.now);
366
+ };
367
+ });
368
+ return formatter;
369
+ };
370
+ ClockIntl.DateTimeFormat.prototype = Object.create(NativeIntl.DateTimeFormat.prototype);
371
+ ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf;
372
+ return ClockIntl;
373
+ }
374
+ function enqueueJob(clock, job) {
375
+ if (!clock.jobs) clock.jobs = [];
376
+ clock.jobs.push(job);
377
+ }
378
+ function runJobs(clock) {
379
+ if (!clock.jobs) return;
380
+ for(let i = 0; i < clock.jobs.length; i++){
381
+ const job = clock.jobs[i];
382
+ job.func.apply(null, job.args);
383
+ checkIsNearInfiniteLimit(clock, i);
384
+ if (clock.loopLimit && i > clock.loopLimit) throw getInfiniteLoopError(clock, job);
385
+ }
386
+ resetIsNearInfiniteLimit();
387
+ clock.jobs = [];
388
+ }
389
+ function addTimer(clock, timer) {
390
+ if (void 0 === timer.func) throw new Error("Callback must be provided to timer calls");
391
+ if (addTimerReturnsObject) {
392
+ if ("function" != typeof timer.func) throw new TypeError(`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`);
393
+ }
394
+ if (isNearInfiniteLimit) timer.error = new Error();
395
+ timer.type = timer.immediate ? "Immediate" : "Timeout";
396
+ if (timer.hasOwnProperty("delay")) {
397
+ if ("number" != typeof timer.delay) timer.delay = parseInt(timer.delay, 10);
398
+ if (!isNumberFinite(timer.delay)) timer.delay = 0;
399
+ timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
400
+ timer.delay = Math.max(0, timer.delay);
401
+ }
402
+ if (timer.hasOwnProperty("interval")) {
403
+ timer.type = "Interval";
404
+ timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
405
+ }
406
+ if (timer.hasOwnProperty("animation")) {
407
+ timer.type = "AnimationFrame";
408
+ timer.animation = true;
409
+ }
410
+ if (timer.hasOwnProperty("idleCallback")) {
411
+ timer.type = "IdleCallback";
412
+ timer.idleCallback = true;
413
+ }
414
+ if (!clock.timers) clock.timers = {};
415
+ timer.id = uniqueTimerId++;
416
+ timer.createdAt = clock.now;
417
+ timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
418
+ clock.timers[timer.id] = timer;
419
+ if (addTimerReturnsObject) {
420
+ const res = {
421
+ refed: true,
422
+ ref: function() {
423
+ this.refed = true;
424
+ return res;
425
+ },
426
+ unref: function() {
427
+ this.refed = false;
428
+ return res;
429
+ },
430
+ hasRef: function() {
431
+ return this.refed;
432
+ },
433
+ refresh: function() {
434
+ timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
435
+ clock.timers[timer.id] = timer;
436
+ return res;
437
+ },
438
+ [Symbol.toPrimitive]: function() {
439
+ return timer.id;
440
+ }
441
+ };
442
+ return res;
443
+ }
444
+ return timer.id;
445
+ }
446
+ function compareTimers(a, b) {
447
+ if (a.callAt < b.callAt) return -1;
448
+ if (a.callAt > b.callAt) return 1;
449
+ if (a.immediate && !b.immediate) return -1;
450
+ if (!a.immediate && b.immediate) return 1;
451
+ if (a.createdAt < b.createdAt) return -1;
452
+ if (a.createdAt > b.createdAt) return 1;
453
+ if (a.id < b.id) return -1;
454
+ if (a.id > b.id) return 1;
455
+ }
456
+ function firstTimerInRange(clock, from, to) {
457
+ const timers = clock.timers;
458
+ let timer = null;
459
+ let id, isInRange;
460
+ for(id in timers)if (timers.hasOwnProperty(id)) {
461
+ isInRange = inRange(from, to, timers[id]);
462
+ if (isInRange && (!timer || 1 === compareTimers(timer, timers[id]))) timer = timers[id];
463
+ }
464
+ return timer;
465
+ }
466
+ function firstTimer(clock) {
467
+ const timers = clock.timers;
468
+ let timer = null;
469
+ let id;
470
+ for(id in timers)if (timers.hasOwnProperty(id)) {
471
+ if (!timer || 1 === compareTimers(timer, timers[id])) timer = timers[id];
472
+ }
473
+ return timer;
474
+ }
475
+ function lastTimer(clock) {
476
+ const timers = clock.timers;
477
+ let timer = null;
478
+ let id;
479
+ for(id in timers)if (timers.hasOwnProperty(id)) {
480
+ if (!timer || -1 === compareTimers(timer, timers[id])) timer = timers[id];
481
+ }
482
+ return timer;
483
+ }
484
+ function callTimer(clock, timer) {
485
+ if ("number" == typeof timer.interval) clock.timers[timer.id].callAt += timer.interval;
486
+ else delete clock.timers[timer.id];
487
+ if ("function" == typeof timer.func) timer.func.apply(null, timer.args);
488
+ else {
489
+ const eval2 = eval;
490
+ (function() {
491
+ eval2(timer.func);
492
+ })();
493
+ }
494
+ }
495
+ function getClearHandler(ttype) {
496
+ if ("IdleCallback" === ttype || "AnimationFrame" === ttype) return `cancel${ttype}`;
497
+ return `clear${ttype}`;
498
+ }
499
+ function getScheduleHandler(ttype) {
500
+ if ("IdleCallback" === ttype || "AnimationFrame" === ttype) return `request${ttype}`;
501
+ return `set${ttype}`;
502
+ }
503
+ function createWarnOnce() {
504
+ let calls = 0;
505
+ return function(msg) {
506
+ calls++ || console.warn(msg);
507
+ };
508
+ }
509
+ const warnOnce = createWarnOnce();
510
+ function clearTimer(clock, timerId, ttype) {
511
+ if (!timerId) return;
512
+ if (!clock.timers) clock.timers = {};
513
+ const id = Number(timerId);
514
+ if (Number.isNaN(id) || id < idCounterStart) {
515
+ const handlerName = getClearHandler(ttype);
516
+ if (true === clock.shouldClearNativeTimers) {
517
+ const nativeHandler = clock[`_${handlerName}`];
518
+ return "function" == typeof nativeHandler ? nativeHandler(timerId) : void 0;
519
+ }
520
+ warnOnce(`FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.\nTo automatically clean-up native timers, use \`shouldClearNativeTimers\`.`);
521
+ }
522
+ if (clock.timers.hasOwnProperty(id)) {
523
+ const timer = clock.timers[id];
524
+ if (timer.type === ttype || "Timeout" === timer.type && "Interval" === ttype || "Interval" === timer.type && "Timeout" === ttype) delete clock.timers[id];
525
+ else {
526
+ const clear = getClearHandler(ttype);
527
+ const schedule = getScheduleHandler(timer.type);
528
+ throw new Error(`Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`);
529
+ }
530
+ }
531
+ }
532
+ function uninstall(clock, config) {
533
+ let method, i, l;
534
+ const installedHrTime = "_hrtime";
535
+ const installedNextTick = "_nextTick";
536
+ for(i = 0, l = clock.methods.length; i < l; i++){
537
+ method = clock.methods[i];
538
+ if ("hrtime" === method && _global.process) _global.process.hrtime = clock[installedHrTime];
539
+ else if ("nextTick" === method && _global.process) _global.process.nextTick = clock[installedNextTick];
540
+ else if ("performance" === method) {
541
+ const originalPerfDescriptor = Object.getOwnPropertyDescriptor(clock, `_${method}`);
542
+ if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) Object.defineProperty(_global, method, originalPerfDescriptor);
543
+ else if (originalPerfDescriptor.configurable) _global[method] = clock[`_${method}`];
544
+ } else if (_global[method] && _global[method].hadOwnProperty) _global[method] = clock[`_${method}`];
545
+ else try {
546
+ delete _global[method];
547
+ } catch (ignore) {}
548
+ if (void 0 !== clock.timersModuleMethods) for(let j = 0; j < clock.timersModuleMethods.length; j++){
549
+ const entry = clock.timersModuleMethods[j];
550
+ timersModule[entry.methodName] = entry.original;
551
+ }
552
+ if (void 0 !== clock.timersPromisesModuleMethods) for(let j = 0; j < clock.timersPromisesModuleMethods.length; j++){
553
+ const entry = clock.timersPromisesModuleMethods[j];
554
+ timersPromisesModule[entry.methodName] = entry.original;
555
+ }
556
+ }
557
+ if (true === config.shouldAdvanceTime) _global.clearInterval(clock.attachedInterval);
558
+ clock.methods = [];
559
+ for (const [listener, signal] of clock.abortListenerMap.entries()){
560
+ signal.removeEventListener("abort", listener);
561
+ clock.abortListenerMap.delete(listener);
562
+ }
563
+ if (!clock.timers) return [];
564
+ return Object.keys(clock.timers).map(function mapper(key) {
565
+ return clock.timers[key];
566
+ });
567
+ }
568
+ function hijackMethod(target, method, clock) {
569
+ clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
570
+ clock[`_${method}`] = target[method];
571
+ if ("Date" === method) target[method] = clock[method];
572
+ else if ("Intl" === method) target[method] = clock[method];
573
+ else if ("performance" === method) {
574
+ const originalPerfDescriptor = Object.getOwnPropertyDescriptor(target, method);
575
+ if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
576
+ Object.defineProperty(clock, `_${method}`, originalPerfDescriptor);
577
+ const perfDescriptor = Object.getOwnPropertyDescriptor(clock, method);
578
+ Object.defineProperty(target, method, perfDescriptor);
579
+ } else target[method] = clock[method];
580
+ } else {
581
+ target[method] = function() {
582
+ return clock[method].apply(clock, arguments);
583
+ };
584
+ Object.defineProperties(target[method], Object.getOwnPropertyDescriptors(clock[method]));
585
+ }
586
+ target[method].clock = clock;
587
+ }
588
+ function doIntervalTick(clock, advanceTimeDelta) {
589
+ clock.tick(advanceTimeDelta);
590
+ }
591
+ const timers = {
592
+ setTimeout: _global.setTimeout,
593
+ clearTimeout: _global.clearTimeout,
594
+ setInterval: _global.setInterval,
595
+ clearInterval: _global.clearInterval,
596
+ Date: _global.Date
597
+ };
598
+ if (isPresent.setImmediate) timers.setImmediate = _global.setImmediate;
599
+ if (isPresent.clearImmediate) timers.clearImmediate = _global.clearImmediate;
600
+ if (isPresent.hrtime) timers.hrtime = _global.process.hrtime;
601
+ if (isPresent.nextTick) timers.nextTick = _global.process.nextTick;
602
+ if (isPresent.performance) timers.performance = _global.performance;
603
+ if (isPresent.requestAnimationFrame) timers.requestAnimationFrame = _global.requestAnimationFrame;
604
+ if (isPresent.queueMicrotask) timers.queueMicrotask = _global.queueMicrotask;
605
+ if (isPresent.cancelAnimationFrame) timers.cancelAnimationFrame = _global.cancelAnimationFrame;
606
+ if (isPresent.requestIdleCallback) timers.requestIdleCallback = _global.requestIdleCallback;
607
+ if (isPresent.cancelIdleCallback) timers.cancelIdleCallback = _global.cancelIdleCallback;
608
+ if (isPresent.Intl) timers.Intl = NativeIntl;
609
+ const originalSetTimeout = _global.setImmediate || _global.setTimeout;
610
+ function createClock(start, loopLimit) {
611
+ start = Math.floor(getEpoch(start));
612
+ loopLimit = loopLimit || 1000;
613
+ let nanos = 0;
614
+ const adjustedSystemTime = [
615
+ 0,
616
+ 0
617
+ ];
618
+ const clock = {
619
+ now: start,
620
+ Date: createDate(),
621
+ loopLimit: loopLimit
622
+ };
623
+ clock.Date.clock = clock;
624
+ function getTimeToNextFrame() {
625
+ return 16 - (clock.now - start) % 16;
626
+ }
627
+ function hrtime(prev) {
628
+ const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
629
+ const secsSinceStart = Math.floor(millisSinceStart / 1000);
630
+ const remainderInNanos = (millisSinceStart - 1e3 * secsSinceStart) * 1e6 + nanos - adjustedSystemTime[1];
631
+ if (Array.isArray(prev)) {
632
+ if (prev[1] > 1e9) throw new TypeError("Number of nanoseconds can't exceed a billion");
633
+ const oldSecs = prev[0];
634
+ let nanoDiff = remainderInNanos - prev[1];
635
+ let secDiff = secsSinceStart - oldSecs;
636
+ if (nanoDiff < 0) {
637
+ nanoDiff += 1e9;
638
+ secDiff -= 1;
639
+ }
640
+ return [
641
+ secDiff,
642
+ nanoDiff
643
+ ];
644
+ }
645
+ return [
646
+ secsSinceStart,
647
+ remainderInNanos
648
+ ];
649
+ }
650
+ function fakePerformanceNow() {
651
+ const hrt = hrtime();
652
+ const millis = 1000 * hrt[0] + hrt[1] / 1e6;
653
+ return millis;
654
+ }
655
+ if (isPresent.hrtimeBigint) hrtime.bigint = function() {
656
+ const parts = hrtime();
657
+ return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
658
+ };
659
+ if (isPresent.Intl) {
660
+ clock.Intl = createIntl();
661
+ clock.Intl.clock = clock;
662
+ }
663
+ clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
664
+ let timeToNextIdlePeriod = 0;
665
+ if (clock.countTimers() > 0) timeToNextIdlePeriod = 50;
666
+ const result = addTimer(clock, {
667
+ func: func,
668
+ args: Array.prototype.slice.call(arguments, 2),
669
+ delay: void 0 === timeout ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod),
670
+ idleCallback: true
671
+ });
672
+ return Number(result);
673
+ };
674
+ clock.cancelIdleCallback = function cancelIdleCallback(timerId) {
675
+ return clearTimer(clock, timerId, "IdleCallback");
676
+ };
677
+ clock.setTimeout = function setTimeout(func, timeout) {
678
+ return addTimer(clock, {
679
+ func: func,
680
+ args: Array.prototype.slice.call(arguments, 2),
681
+ delay: timeout
682
+ });
683
+ };
684
+ if (void 0 !== _global.Promise && utilPromisify) clock.setTimeout[utilPromisify.custom] = function promisifiedSetTimeout(timeout, arg) {
685
+ return new _global.Promise(function setTimeoutExecutor(resolve) {
686
+ addTimer(clock, {
687
+ func: resolve,
688
+ args: [
689
+ arg
690
+ ],
691
+ delay: timeout
692
+ });
693
+ });
694
+ };
695
+ clock.clearTimeout = function clearTimeout(timerId) {
696
+ return clearTimer(clock, timerId, "Timeout");
697
+ };
698
+ clock.nextTick = function nextTick(func) {
699
+ return enqueueJob(clock, {
700
+ func: func,
701
+ args: Array.prototype.slice.call(arguments, 1),
702
+ error: isNearInfiniteLimit ? new Error() : null
703
+ });
704
+ };
705
+ clock.queueMicrotask = function queueMicrotask(func) {
706
+ return clock.nextTick(func);
707
+ };
708
+ clock.setInterval = function setInterval(func, timeout) {
709
+ timeout = parseInt(timeout, 10);
710
+ return addTimer(clock, {
711
+ func: func,
712
+ args: Array.prototype.slice.call(arguments, 2),
713
+ delay: timeout,
714
+ interval: timeout
715
+ });
716
+ };
717
+ clock.clearInterval = function clearInterval(timerId) {
718
+ return clearTimer(clock, timerId, "Interval");
719
+ };
720
+ if (isPresent.setImmediate) {
721
+ clock.setImmediate = function setImmediate(func) {
722
+ return addTimer(clock, {
723
+ func: func,
724
+ args: Array.prototype.slice.call(arguments, 1),
725
+ immediate: true
726
+ });
727
+ };
728
+ if (void 0 !== _global.Promise && utilPromisify) clock.setImmediate[utilPromisify.custom] = function promisifiedSetImmediate(arg) {
729
+ return new _global.Promise(function setImmediateExecutor(resolve) {
730
+ addTimer(clock, {
731
+ func: resolve,
732
+ args: [
733
+ arg
734
+ ],
735
+ immediate: true
736
+ });
737
+ });
738
+ };
739
+ clock.clearImmediate = function clearImmediate(timerId) {
740
+ return clearTimer(clock, timerId, "Immediate");
741
+ };
742
+ }
743
+ clock.countTimers = function countTimers() {
744
+ return Object.keys(clock.timers || {}).length + (clock.jobs || []).length;
745
+ };
746
+ clock.requestAnimationFrame = function requestAnimationFrame(func) {
747
+ const result = addTimer(clock, {
748
+ func: func,
749
+ delay: getTimeToNextFrame(),
750
+ get args () {
751
+ return [
752
+ fakePerformanceNow()
753
+ ];
754
+ },
755
+ animation: true
756
+ });
757
+ return Number(result);
758
+ };
759
+ clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {
760
+ return clearTimer(clock, timerId, "AnimationFrame");
761
+ };
762
+ clock.runMicrotasks = function runMicrotasks() {
763
+ runJobs(clock);
764
+ };
765
+ function doTick(tickValue, isAsync, resolve, reject) {
766
+ const msFloat = "number" == typeof tickValue ? tickValue : parseTime(tickValue);
767
+ const ms = Math.floor(msFloat);
768
+ const remainder = nanoRemainder(msFloat);
769
+ let nanosTotal = nanos + remainder;
770
+ let tickTo = clock.now + ms;
771
+ if (msFloat < 0) throw new TypeError("Negative ticks are not supported");
772
+ if (nanosTotal >= 1e6) {
773
+ tickTo += 1;
774
+ nanosTotal -= 1e6;
775
+ }
776
+ nanos = nanosTotal;
777
+ let tickFrom = clock.now;
778
+ let previous = clock.now;
779
+ let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall;
780
+ clock.duringTick = true;
781
+ oldNow = clock.now;
782
+ runJobs(clock);
783
+ if (oldNow !== clock.now) {
784
+ tickFrom += clock.now - oldNow;
785
+ tickTo += clock.now - oldNow;
786
+ }
787
+ function doTickInner() {
788
+ timer = firstTimerInRange(clock, tickFrom, tickTo);
789
+ while(timer && tickFrom <= tickTo){
790
+ if (clock.timers[timer.id]) {
791
+ tickFrom = timer.callAt;
792
+ clock.now = timer.callAt;
793
+ oldNow = clock.now;
794
+ try {
795
+ runJobs(clock);
796
+ callTimer(clock, timer);
797
+ } catch (e) {
798
+ firstException = firstException || e;
799
+ }
800
+ if (isAsync) return void originalSetTimeout(nextPromiseTick);
801
+ compensationCheck();
802
+ }
803
+ postTimerCall();
804
+ }
805
+ oldNow = clock.now;
806
+ runJobs(clock);
807
+ if (oldNow !== clock.now) {
808
+ tickFrom += clock.now - oldNow;
809
+ tickTo += clock.now - oldNow;
810
+ }
811
+ clock.duringTick = false;
812
+ timer = firstTimerInRange(clock, tickFrom, tickTo);
813
+ if (timer) try {
814
+ clock.tick(tickTo - clock.now);
815
+ } catch (e) {
816
+ firstException = firstException || e;
817
+ }
818
+ else {
819
+ clock.now = tickTo;
820
+ nanos = nanosTotal;
821
+ }
822
+ if (firstException) throw firstException;
823
+ if (!isAsync) return clock.now;
824
+ resolve(clock.now);
825
+ }
826
+ nextPromiseTick = isAsync && function() {
827
+ try {
828
+ compensationCheck();
829
+ postTimerCall();
830
+ doTickInner();
831
+ } catch (e) {
832
+ reject(e);
833
+ }
834
+ };
835
+ compensationCheck = function() {
836
+ if (oldNow !== clock.now) {
837
+ tickFrom += clock.now - oldNow;
838
+ tickTo += clock.now - oldNow;
839
+ previous += clock.now - oldNow;
840
+ }
841
+ };
842
+ postTimerCall = function() {
843
+ timer = firstTimerInRange(clock, previous, tickTo);
844
+ previous = tickFrom;
845
+ };
846
+ return doTickInner();
847
+ }
848
+ clock.tick = function tick(tickValue) {
849
+ return doTick(tickValue, false);
850
+ };
851
+ if (void 0 !== _global.Promise) clock.tickAsync = function tickAsync(tickValue) {
852
+ return new _global.Promise(function(resolve, reject) {
853
+ originalSetTimeout(function() {
854
+ try {
855
+ doTick(tickValue, true, resolve, reject);
856
+ } catch (e) {
857
+ reject(e);
858
+ }
859
+ });
860
+ });
861
+ };
862
+ clock.next = function next() {
863
+ runJobs(clock);
864
+ const timer = firstTimer(clock);
865
+ if (!timer) return clock.now;
866
+ clock.duringTick = true;
867
+ try {
868
+ clock.now = timer.callAt;
869
+ callTimer(clock, timer);
870
+ runJobs(clock);
871
+ return clock.now;
872
+ } finally{
873
+ clock.duringTick = false;
874
+ }
875
+ };
876
+ if (void 0 !== _global.Promise) clock.nextAsync = function nextAsync() {
877
+ return new _global.Promise(function(resolve, reject) {
878
+ originalSetTimeout(function() {
879
+ try {
880
+ const timer = firstTimer(clock);
881
+ if (!timer) return void resolve(clock.now);
882
+ let err;
883
+ clock.duringTick = true;
884
+ clock.now = timer.callAt;
885
+ try {
886
+ callTimer(clock, timer);
887
+ } catch (e) {
888
+ err = e;
889
+ }
890
+ clock.duringTick = false;
891
+ originalSetTimeout(function() {
892
+ if (err) reject(err);
893
+ else resolve(clock.now);
894
+ });
895
+ } catch (e) {
896
+ reject(e);
897
+ }
898
+ });
899
+ });
900
+ };
901
+ clock.runAll = function runAll() {
902
+ let numTimers, i;
903
+ runJobs(clock);
904
+ for(i = 0; i < clock.loopLimit; i++){
905
+ if (!clock.timers) {
906
+ resetIsNearInfiniteLimit();
907
+ return clock.now;
908
+ }
909
+ numTimers = Object.keys(clock.timers).length;
910
+ if (0 === numTimers) {
911
+ resetIsNearInfiniteLimit();
912
+ return clock.now;
913
+ }
914
+ clock.next();
915
+ checkIsNearInfiniteLimit(clock, i);
916
+ }
917
+ const excessJob = firstTimer(clock);
918
+ throw getInfiniteLoopError(clock, excessJob);
919
+ };
920
+ clock.runToFrame = function runToFrame() {
921
+ return clock.tick(getTimeToNextFrame());
922
+ };
923
+ if (void 0 !== _global.Promise) clock.runAllAsync = function runAllAsync() {
924
+ return new _global.Promise(function(resolve, reject) {
925
+ let i = 0;
926
+ function doRun() {
927
+ originalSetTimeout(function() {
928
+ try {
929
+ runJobs(clock);
930
+ let numTimers;
931
+ if (i < clock.loopLimit) {
932
+ if (!clock.timers) {
933
+ resetIsNearInfiniteLimit();
934
+ resolve(clock.now);
935
+ return;
936
+ }
937
+ numTimers = Object.keys(clock.timers).length;
938
+ if (0 === numTimers) {
939
+ resetIsNearInfiniteLimit();
940
+ resolve(clock.now);
941
+ return;
942
+ }
943
+ clock.next();
944
+ i++;
945
+ doRun();
946
+ checkIsNearInfiniteLimit(clock, i);
947
+ return;
948
+ }
949
+ const excessJob = firstTimer(clock);
950
+ reject(getInfiniteLoopError(clock, excessJob));
951
+ } catch (e) {
952
+ reject(e);
953
+ }
954
+ });
955
+ }
956
+ doRun();
957
+ });
958
+ };
959
+ clock.runToLast = function runToLast() {
960
+ const timer = lastTimer(clock);
961
+ if (!timer) {
962
+ runJobs(clock);
963
+ return clock.now;
964
+ }
965
+ return clock.tick(timer.callAt - clock.now);
966
+ };
967
+ if (void 0 !== _global.Promise) clock.runToLastAsync = function runToLastAsync() {
968
+ return new _global.Promise(function(resolve, reject) {
969
+ originalSetTimeout(function() {
970
+ try {
971
+ const timer = lastTimer(clock);
972
+ if (!timer) {
973
+ runJobs(clock);
974
+ resolve(clock.now);
975
+ }
976
+ resolve(clock.tickAsync(timer.callAt - clock.now));
977
+ } catch (e) {
978
+ reject(e);
979
+ }
980
+ });
981
+ });
982
+ };
983
+ clock.reset = function reset() {
984
+ nanos = 0;
985
+ clock.timers = {};
986
+ clock.jobs = [];
987
+ clock.now = start;
988
+ };
989
+ clock.setSystemTime = function setSystemTime(systemTime) {
990
+ const newNow = getEpoch(systemTime);
991
+ const difference = newNow - clock.now;
992
+ let id, timer;
993
+ adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
994
+ adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
995
+ clock.now = newNow;
996
+ nanos = 0;
997
+ for(id in clock.timers)if (clock.timers.hasOwnProperty(id)) {
998
+ timer = clock.timers[id];
999
+ timer.createdAt += difference;
1000
+ timer.callAt += difference;
1001
+ }
1002
+ };
1003
+ clock.jump = function jump(tickValue) {
1004
+ const msFloat = "number" == typeof tickValue ? tickValue : parseTime(tickValue);
1005
+ const ms = Math.floor(msFloat);
1006
+ for (const timer of Object.values(clock.timers))if (clock.now + ms > timer.callAt) timer.callAt = clock.now + ms;
1007
+ clock.tick(ms);
1008
+ };
1009
+ if (isPresent.performance) {
1010
+ clock.performance = Object.create(null);
1011
+ clock.performance.now = fakePerformanceNow;
1012
+ }
1013
+ if (isPresent.hrtime) clock.hrtime = hrtime;
1014
+ return clock;
1015
+ }
1016
+ function install(config) {
1017
+ if (arguments.length > 1 || config instanceof Date || Array.isArray(config) || "number" == typeof config) throw new TypeError(`FakeTimers.install called with ${String(config)} install requires an object parameter`);
1018
+ if (true === _global.Date.isFake) throw new TypeError("Can't install fake timers twice on the same global object.");
1019
+ config = void 0 !== config ? config : {};
1020
+ config.shouldAdvanceTime = config.shouldAdvanceTime || false;
1021
+ config.advanceTimeDelta = config.advanceTimeDelta || 20;
1022
+ config.shouldClearNativeTimers = config.shouldClearNativeTimers || false;
1023
+ if (config.target) throw new TypeError("config.target is no longer supported. Use `withGlobal(target)` instead.");
1024
+ function handleMissingTimer(timer) {
1025
+ if (config.ignoreMissingTimers) return;
1026
+ throw new ReferenceError(`non-existent timers and/or objects cannot be faked: '${timer}'`);
1027
+ }
1028
+ let i, l;
1029
+ const clock = createClock(config.now, config.loopLimit);
1030
+ clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
1031
+ clock.uninstall = function() {
1032
+ return uninstall(clock, config);
1033
+ };
1034
+ clock.abortListenerMap = new Map();
1035
+ clock.methods = config.toFake || [];
1036
+ if (0 === clock.methods.length) clock.methods = Object.keys(timers);
1037
+ if (true === config.shouldAdvanceTime) {
1038
+ const intervalTick = doIntervalTick.bind(null, clock, config.advanceTimeDelta);
1039
+ const intervalId = _global.setInterval(intervalTick, config.advanceTimeDelta);
1040
+ clock.attachedInterval = intervalId;
1041
+ }
1042
+ if (clock.methods.includes("performance")) {
1043
+ const proto = (()=>{
1044
+ if (hasPerformanceConstructorPrototype) return _global.performance.constructor.prototype;
1045
+ if (hasPerformancePrototype) return _global.Performance.prototype;
1046
+ })();
1047
+ if (proto) {
1048
+ Object.getOwnPropertyNames(proto).forEach(function(name) {
1049
+ if ("now" !== name) clock.performance[name] = 0 === name.indexOf("getEntries") ? NOOP_ARRAY : NOOP;
1050
+ });
1051
+ clock.performance.mark = (name)=>new FakePerformanceEntry(name, "mark", 0, 0);
1052
+ clock.performance.measure = (name)=>new FakePerformanceEntry(name, "measure", 0, 100);
1053
+ clock.performance.timeOrigin = getEpoch(config.now);
1054
+ } else if ((config.toFake || []).includes("performance")) return handleMissingTimer("performance");
1055
+ }
1056
+ if (_global === globalObject && timersModule) clock.timersModuleMethods = [];
1057
+ if (_global === globalObject && timersPromisesModule) clock.timersPromisesModuleMethods = [];
1058
+ for(i = 0, l = clock.methods.length; i < l; i++){
1059
+ const nameOfMethodToReplace = clock.methods[i];
1060
+ if (!isPresent[nameOfMethodToReplace]) {
1061
+ handleMissingTimer(nameOfMethodToReplace);
1062
+ continue;
1063
+ }
1064
+ if ("hrtime" === nameOfMethodToReplace) {
1065
+ if (_global.process && "function" == typeof _global.process.hrtime) hijackMethod(_global.process, nameOfMethodToReplace, clock);
1066
+ } else if ("nextTick" === nameOfMethodToReplace) {
1067
+ if (_global.process && "function" == typeof _global.process.nextTick) hijackMethod(_global.process, nameOfMethodToReplace, clock);
1068
+ } else hijackMethod(_global, nameOfMethodToReplace, clock);
1069
+ if (void 0 !== clock.timersModuleMethods && timersModule[nameOfMethodToReplace]) {
1070
+ const original = timersModule[nameOfMethodToReplace];
1071
+ clock.timersModuleMethods.push({
1072
+ methodName: nameOfMethodToReplace,
1073
+ original: original
1074
+ });
1075
+ timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
1076
+ }
1077
+ if (void 0 !== clock.timersPromisesModuleMethods) {
1078
+ if ("setTimeout" === nameOfMethodToReplace) {
1079
+ clock.timersPromisesModuleMethods.push({
1080
+ methodName: "setTimeout",
1081
+ original: timersPromisesModule.setTimeout
1082
+ });
1083
+ timersPromisesModule.setTimeout = (delay, value, options = {})=>new Promise((resolve, reject)=>{
1084
+ const abort = ()=>{
1085
+ options.signal.removeEventListener("abort", abort);
1086
+ clock.abortListenerMap.delete(abort);
1087
+ clock.clearTimeout(handle);
1088
+ reject(options.signal.reason);
1089
+ };
1090
+ const handle = clock.setTimeout(()=>{
1091
+ if (options.signal) {
1092
+ options.signal.removeEventListener("abort", abort);
1093
+ clock.abortListenerMap.delete(abort);
1094
+ }
1095
+ resolve(value);
1096
+ }, delay);
1097
+ if (options.signal) if (options.signal.aborted) abort();
1098
+ else {
1099
+ options.signal.addEventListener("abort", abort);
1100
+ clock.abortListenerMap.set(abort, options.signal);
1101
+ }
1102
+ });
1103
+ } else if ("setImmediate" === nameOfMethodToReplace) {
1104
+ clock.timersPromisesModuleMethods.push({
1105
+ methodName: "setImmediate",
1106
+ original: timersPromisesModule.setImmediate
1107
+ });
1108
+ timersPromisesModule.setImmediate = (value, options = {})=>new Promise((resolve, reject)=>{
1109
+ const abort = ()=>{
1110
+ options.signal.removeEventListener("abort", abort);
1111
+ clock.abortListenerMap.delete(abort);
1112
+ clock.clearImmediate(handle);
1113
+ reject(options.signal.reason);
1114
+ };
1115
+ const handle = clock.setImmediate(()=>{
1116
+ if (options.signal) {
1117
+ options.signal.removeEventListener("abort", abort);
1118
+ clock.abortListenerMap.delete(abort);
1119
+ }
1120
+ resolve(value);
1121
+ });
1122
+ if (options.signal) if (options.signal.aborted) abort();
1123
+ else {
1124
+ options.signal.addEventListener("abort", abort);
1125
+ clock.abortListenerMap.set(abort, options.signal);
1126
+ }
1127
+ });
1128
+ } else if ("setInterval" === nameOfMethodToReplace) {
1129
+ clock.timersPromisesModuleMethods.push({
1130
+ methodName: "setInterval",
1131
+ original: timersPromisesModule.setInterval
1132
+ });
1133
+ timersPromisesModule.setInterval = (delay, value, options = {})=>({
1134
+ [Symbol.asyncIterator]: ()=>{
1135
+ const createResolvable = ()=>{
1136
+ let resolve, reject;
1137
+ const promise = new Promise((res, rej)=>{
1138
+ resolve = res;
1139
+ reject = rej;
1140
+ });
1141
+ promise.resolve = resolve;
1142
+ promise.reject = reject;
1143
+ return promise;
1144
+ };
1145
+ let done = false;
1146
+ let hasThrown = false;
1147
+ let returnCall;
1148
+ let nextAvailable = 0;
1149
+ const nextQueue = [];
1150
+ const handle = clock.setInterval(()=>{
1151
+ if (nextQueue.length > 0) nextQueue.shift().resolve();
1152
+ else nextAvailable++;
1153
+ }, delay);
1154
+ const abort = ()=>{
1155
+ options.signal.removeEventListener("abort", abort);
1156
+ clock.abortListenerMap.delete(abort);
1157
+ clock.clearInterval(handle);
1158
+ done = true;
1159
+ for (const resolvable of nextQueue)resolvable.resolve();
1160
+ };
1161
+ if (options.signal) if (options.signal.aborted) done = true;
1162
+ else {
1163
+ options.signal.addEventListener("abort", abort);
1164
+ clock.abortListenerMap.set(abort, options.signal);
1165
+ }
1166
+ return {
1167
+ next: async ()=>{
1168
+ if (options.signal?.aborted && !hasThrown) {
1169
+ hasThrown = true;
1170
+ throw options.signal.reason;
1171
+ }
1172
+ if (done) return {
1173
+ done: true,
1174
+ value: void 0
1175
+ };
1176
+ if (nextAvailable > 0) {
1177
+ nextAvailable--;
1178
+ return {
1179
+ done: false,
1180
+ value: value
1181
+ };
1182
+ }
1183
+ const resolvable = createResolvable();
1184
+ nextQueue.push(resolvable);
1185
+ await resolvable;
1186
+ if (returnCall && 0 === nextQueue.length) returnCall.resolve();
1187
+ if (options.signal?.aborted && !hasThrown) {
1188
+ hasThrown = true;
1189
+ throw options.signal.reason;
1190
+ }
1191
+ if (done) return {
1192
+ done: true,
1193
+ value: void 0
1194
+ };
1195
+ return {
1196
+ done: false,
1197
+ value: value
1198
+ };
1199
+ },
1200
+ return: async ()=>{
1201
+ if (done) return {
1202
+ done: true,
1203
+ value: void 0
1204
+ };
1205
+ if (nextQueue.length > 0) {
1206
+ returnCall = createResolvable();
1207
+ await returnCall;
1208
+ }
1209
+ clock.clearInterval(handle);
1210
+ done = true;
1211
+ if (options.signal) {
1212
+ options.signal.removeEventListener("abort", abort);
1213
+ clock.abortListenerMap.delete(abort);
1214
+ }
1215
+ return {
1216
+ done: true,
1217
+ value: void 0
1218
+ };
1219
+ }
1220
+ };
1221
+ }
1222
+ });
1223
+ }
1224
+ }
1225
+ }
1226
+ return clock;
1227
+ }
1228
+ return {
1229
+ timers: timers,
1230
+ createClock: createClock,
1231
+ install: install,
1232
+ withGlobal: withGlobal
1233
+ };
1234
+ }
1235
+ const defaultImplementation = withGlobal(globalObject);
1236
+ defaultImplementation.timers;
1237
+ defaultImplementation.createClock;
1238
+ defaultImplementation.install;
1239
+ exports.withGlobal = withGlobal;
1240
+ },
1241
+ "../../node_modules/.pnpm/type-detect@4.0.8/node_modules/type-detect/type-detect.js": function(module) {
1242
+ (function(global1, factory) {
1243
+ module.exports = factory();
1244
+ })(0, function() {
1245
+ 'use strict';
1246
+ var promiseExists = 'function' == typeof Promise;
1247
+ var globalObject = 'object' == typeof self ? self : global;
1248
+ var symbolExists = 'undefined' != typeof Symbol;
1249
+ var mapExists = 'undefined' != typeof Map;
1250
+ var setExists = 'undefined' != typeof Set;
1251
+ var weakMapExists = 'undefined' != typeof WeakMap;
1252
+ var weakSetExists = 'undefined' != typeof WeakSet;
1253
+ var dataViewExists = 'undefined' != typeof DataView;
1254
+ var symbolIteratorExists = symbolExists && void 0 !== Symbol.iterator;
1255
+ var symbolToStringTagExists = symbolExists && void 0 !== Symbol.toStringTag;
1256
+ var setEntriesExists = setExists && 'function' == typeof Set.prototype.entries;
1257
+ var mapEntriesExists = mapExists && 'function' == typeof Map.prototype.entries;
1258
+ var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf(new Set().entries());
1259
+ var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf(new Map().entries());
1260
+ var arrayIteratorExists = symbolIteratorExists && 'function' == typeof Array.prototype[Symbol.iterator];
1261
+ var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
1262
+ var stringIteratorExists = symbolIteratorExists && 'function' == typeof String.prototype[Symbol.iterator];
1263
+ var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(''[Symbol.iterator]());
1264
+ var toStringLeftSliceLength = 8;
1265
+ var toStringRightSliceLength = -1;
1266
+ function typeDetect(obj) {
1267
+ var typeofObj = typeof obj;
1268
+ if ('object' !== typeofObj) return typeofObj;
1269
+ if (null === obj) return 'null';
1270
+ if (obj === globalObject) return 'global';
1271
+ if (Array.isArray(obj) && (false === symbolToStringTagExists || !(Symbol.toStringTag in obj))) return 'Array';
1272
+ if ('object' == typeof window && null !== window) {
1273
+ if ('object' == typeof window.location && obj === window.location) return 'Location';
1274
+ if ('object' == typeof window.document && obj === window.document) return 'Document';
1275
+ if ('object' == typeof window.navigator) {
1276
+ if ('object' == typeof window.navigator.mimeTypes && obj === window.navigator.mimeTypes) return 'MimeTypeArray';
1277
+ if ('object' == typeof window.navigator.plugins && obj === window.navigator.plugins) return 'PluginArray';
1278
+ }
1279
+ if (('function' == typeof window.HTMLElement || 'object' == typeof window.HTMLElement) && obj instanceof window.HTMLElement) {
1280
+ if ('BLOCKQUOTE' === obj.tagName) return 'HTMLQuoteElement';
1281
+ if ('TD' === obj.tagName) return 'HTMLTableDataCellElement';
1282
+ if ('TH' === obj.tagName) return 'HTMLTableHeaderCellElement';
1283
+ }
1284
+ }
1285
+ var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
1286
+ if ('string' == typeof stringTag) return stringTag;
1287
+ var objPrototype = Object.getPrototypeOf(obj);
1288
+ if (objPrototype === RegExp.prototype) return 'RegExp';
1289
+ if (objPrototype === Date.prototype) return 'Date';
1290
+ if (promiseExists && objPrototype === Promise.prototype) return 'Promise';
1291
+ if (setExists && objPrototype === Set.prototype) return 'Set';
1292
+ if (mapExists && objPrototype === Map.prototype) return 'Map';
1293
+ if (weakSetExists && objPrototype === WeakSet.prototype) return 'WeakSet';
1294
+ if (weakMapExists && objPrototype === WeakMap.prototype) return 'WeakMap';
1295
+ if (dataViewExists && objPrototype === DataView.prototype) return 'DataView';
1296
+ if (mapExists && objPrototype === mapIteratorPrototype) return 'Map Iterator';
1297
+ if (setExists && objPrototype === setIteratorPrototype) return 'Set Iterator';
1298
+ if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) return 'Array Iterator';
1299
+ if (stringIteratorExists && objPrototype === stringIteratorPrototype) return 'String Iterator';
1300
+ if (null === objPrototype) return 'Object';
1301
+ return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
1302
+ }
1303
+ return typeDetect;
1304
+ });
1305
+ },
1306
+ "../../node_modules/.pnpm/tinyspy@4.0.3/node_modules/tinyspy/dist/index.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1307
+ __webpack_require__.d(__webpack_exports__, {
1308
+ XD: ()=>internalSpyOn,
1309
+ eN: ()=>getInternalState
1310
+ });
1311
+ function assert(condition, message) {
1312
+ if (!condition) throw new Error(message);
1313
+ }
1314
+ function isType(type, value) {
1315
+ return typeof value === type;
1316
+ }
1317
+ function isPromise(value) {
1318
+ return value instanceof Promise;
1319
+ }
1320
+ function define(obj, key, descriptor) {
1321
+ Object.defineProperty(obj, key, descriptor);
1322
+ }
1323
+ function defineValue(obj, key, value) {
1324
+ define(obj, key, {
1325
+ value,
1326
+ configurable: !0,
1327
+ writable: !0
1328
+ });
1329
+ }
1330
+ var SYMBOL_STATE = Symbol.for("tinyspy:spy");
1331
+ var spies = /* @__PURE__ */ new Set(), reset = (state)=>{
1332
+ state.called = !1, state.callCount = 0, state.calls = [], state.results = [], state.resolves = [], state.next = [];
1333
+ }, defineState = (spy2)=>(define(spy2, SYMBOL_STATE, {
1334
+ value: {
1335
+ reset: ()=>reset(spy2[SYMBOL_STATE])
1336
+ }
1337
+ }), spy2[SYMBOL_STATE]), getInternalState = (spy2)=>spy2[SYMBOL_STATE] || defineState(spy2);
1338
+ function createInternalSpy(cb) {
1339
+ assert(isType("function", cb) || isType("undefined", cb), "cannot spy on a non-function value");
1340
+ let fn = function(...args) {
1341
+ let state2 = getInternalState(fn);
1342
+ state2.called = !0, state2.callCount++, state2.calls.push(args);
1343
+ let next = state2.next.shift();
1344
+ if (next) {
1345
+ state2.results.push(next);
1346
+ let [type2, result2] = next;
1347
+ if ("ok" === type2) return result2;
1348
+ throw result2;
1349
+ }
1350
+ let result, type = "ok", resultIndex = state2.results.length;
1351
+ if (state2.impl) try {
1352
+ new.target ? result = Reflect.construct(state2.impl, args, new.target) : result = state2.impl.apply(this, args), type = "ok";
1353
+ } catch (err) {
1354
+ throw result = err, type = "error", state2.results.push([
1355
+ type,
1356
+ err
1357
+ ]), err;
1358
+ }
1359
+ let resultTuple = [
1360
+ type,
1361
+ result
1362
+ ];
1363
+ return isPromise(result) && result.then((r)=>state2.resolves[resultIndex] = [
1364
+ "ok",
1365
+ r
1366
+ ], (e)=>state2.resolves[resultIndex] = [
1367
+ "error",
1368
+ e
1369
+ ]), state2.results.push(resultTuple), result;
1370
+ };
1371
+ defineValue(fn, "_isMockFunction", !0), defineValue(fn, "length", cb ? cb.length : 0), defineValue(fn, "name", cb && cb.name || "spy");
1372
+ let state = getInternalState(fn);
1373
+ return state.reset(), state.impl = cb, fn;
1374
+ }
1375
+ function isMockFunction(obj) {
1376
+ return !!obj && !0 === obj._isMockFunction;
1377
+ }
1378
+ var getDescriptor = (obj, method)=>{
1379
+ let objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
1380
+ if (objDescriptor) return [
1381
+ obj,
1382
+ objDescriptor
1383
+ ];
1384
+ let currentProto = Object.getPrototypeOf(obj);
1385
+ for(; null !== currentProto;){
1386
+ let descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
1387
+ if (descriptor) return [
1388
+ currentProto,
1389
+ descriptor
1390
+ ];
1391
+ currentProto = Object.getPrototypeOf(currentProto);
1392
+ }
1393
+ }, setPototype = (fn, val)=>{
1394
+ null != val && "function" == typeof val && null != val.prototype && Object.setPrototypeOf(fn.prototype, val.prototype);
1395
+ };
1396
+ function internalSpyOn(obj, methodName, mock) {
1397
+ assert(!isType("undefined", obj), "spyOn could not find an object to spy upon"), assert(isType("object", obj) || isType("function", obj), "cannot spyOn on a primitive value");
1398
+ let [accessName, accessType] = (()=>{
1399
+ if (!isType("object", methodName)) return [
1400
+ methodName,
1401
+ "value"
1402
+ ];
1403
+ if ("getter" in methodName && "setter" in methodName) throw new Error("cannot spy on both getter and setter");
1404
+ if ("getter" in methodName) return [
1405
+ methodName.getter,
1406
+ "get"
1407
+ ];
1408
+ if ("setter" in methodName) return [
1409
+ methodName.setter,
1410
+ "set"
1411
+ ];
1412
+ throw new Error("specify getter or setter to spy on");
1413
+ })(), [originalDescriptorObject, originalDescriptor] = getDescriptor(obj, accessName) || [];
1414
+ assert(originalDescriptor || accessName in obj, `${String(accessName)} does not exist`);
1415
+ let ssr = !1;
1416
+ "value" === accessType && originalDescriptor && !originalDescriptor.value && originalDescriptor.get && (accessType = "get", ssr = !0, mock = originalDescriptor.get());
1417
+ let original;
1418
+ originalDescriptor ? original = originalDescriptor[accessType] : "value" !== accessType ? original = ()=>obj[accessName] : original = obj[accessName], original && isSpyFunction(original) && (original = original[SYMBOL_STATE].getOriginal());
1419
+ let reassign = (cb)=>{
1420
+ let { value, ...desc } = originalDescriptor || {
1421
+ configurable: !0,
1422
+ writable: !0
1423
+ };
1424
+ "value" !== accessType && delete desc.writable, desc[accessType] = cb, define(obj, accessName, desc);
1425
+ }, restore = ()=>{
1426
+ originalDescriptorObject !== obj ? Reflect.deleteProperty(obj, accessName) : originalDescriptor && !original ? define(obj, accessName, originalDescriptor) : reassign(original);
1427
+ };
1428
+ mock || (mock = original);
1429
+ let spy2 = wrap(createInternalSpy(mock), mock);
1430
+ "value" === accessType && setPototype(spy2, original);
1431
+ let state = spy2[SYMBOL_STATE];
1432
+ return defineValue(state, "restore", restore), defineValue(state, "getOriginal", ()=>ssr ? original() : original), defineValue(state, "willCall", (newCb)=>(state.impl = newCb, spy2)), reassign(ssr ? ()=>(setPototype(spy2, mock), spy2) : spy2), spies.add(spy2), spy2;
1433
+ }
1434
+ var ignoreProperties = /* @__PURE__ */ new Set([
1435
+ "length",
1436
+ "name",
1437
+ "prototype"
1438
+ ]);
1439
+ function getAllProperties(original) {
1440
+ let properties = /* @__PURE__ */ new Set(), descriptors2 = {};
1441
+ for(; original && original !== Object.prototype && original !== Function.prototype;){
1442
+ let ownProperties = [
1443
+ ...Object.getOwnPropertyNames(original),
1444
+ ...Object.getOwnPropertySymbols(original)
1445
+ ];
1446
+ for (let prop of ownProperties)descriptors2[prop] || ignoreProperties.has(prop) || (properties.add(prop), descriptors2[prop] = Object.getOwnPropertyDescriptor(original, prop));
1447
+ original = Object.getPrototypeOf(original);
1448
+ }
1449
+ return {
1450
+ properties,
1451
+ descriptors: descriptors2
1452
+ };
1453
+ }
1454
+ function wrap(mock, original) {
1455
+ if (!original || SYMBOL_STATE in original) return mock;
1456
+ let { properties, descriptors: descriptors2 } = getAllProperties(original);
1457
+ for (let key of properties){
1458
+ let descriptor = descriptors2[key];
1459
+ getDescriptor(mock, key) || define(mock, key, descriptor);
1460
+ }
1461
+ return mock;
1462
+ }
1463
+ function isSpyFunction(obj) {
1464
+ return isMockFunction(obj) && "getOriginal" in obj[SYMBOL_STATE];
1465
+ }
1466
+ }
1467
+ };