@granito/vitest-marbles 1.0.0 → 1.0.1

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 (5) hide show
  1. package/README.md +1 -0
  2. package/index.js +3635 -8
  3. package/lib/internal-matchers.d.ts +2 -2
  4. package/lib/types.d.ts +7 -12
  5. package/package.json +9 -9
package/index.js CHANGED
@@ -1,14 +1,3641 @@
1
+ var __create = Object.create;
2
+ var __defProp = Object.defineProperty;
3
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __getProtoOf = Object.getPrototypeOf;
6
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
7
+ var __commonJS = (cb, mod) => function __require() {
8
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
9
+ };
10
+ var __copyProps = (to, from, except, desc) => {
11
+ if (from && typeof from === "object" || typeof from === "function") {
12
+ for (let key of __getOwnPropNames(from))
13
+ if (!__hasOwnProp.call(to, key) && key !== except)
14
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15
+ }
16
+ return to;
17
+ };
18
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
19
+ // If the importer is in node compatibility mode or this is not an ESM
20
+ // file that has been converted to a CommonJS file using a Babel-
21
+ // compatible transform (i.e. "__esModule" has not been set), then set
22
+ // "default" to the CommonJS "module.exports" for node compatibility.
23
+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
24
+ mod
25
+ ));
26
+
27
+ // node_modules/rxjs/dist/cjs/internal/util/isFunction.js
28
+ var require_isFunction = __commonJS({
29
+ "node_modules/rxjs/dist/cjs/internal/util/isFunction.js"(exports) {
30
+ "use strict";
31
+ Object.defineProperty(exports, "__esModule", { value: true });
32
+ exports.isFunction = void 0;
33
+ function isFunction(value) {
34
+ return typeof value === "function";
35
+ }
36
+ exports.isFunction = isFunction;
37
+ }
38
+ });
39
+
40
+ // node_modules/rxjs/dist/cjs/internal/util/createErrorClass.js
41
+ var require_createErrorClass = __commonJS({
42
+ "node_modules/rxjs/dist/cjs/internal/util/createErrorClass.js"(exports) {
43
+ "use strict";
44
+ Object.defineProperty(exports, "__esModule", { value: true });
45
+ exports.createErrorClass = void 0;
46
+ function createErrorClass(createImpl) {
47
+ var _super = function(instance) {
48
+ Error.call(instance);
49
+ instance.stack = new Error().stack;
50
+ };
51
+ var ctorFunc = createImpl(_super);
52
+ ctorFunc.prototype = Object.create(Error.prototype);
53
+ ctorFunc.prototype.constructor = ctorFunc;
54
+ return ctorFunc;
55
+ }
56
+ exports.createErrorClass = createErrorClass;
57
+ }
58
+ });
59
+
60
+ // node_modules/rxjs/dist/cjs/internal/util/UnsubscriptionError.js
61
+ var require_UnsubscriptionError = __commonJS({
62
+ "node_modules/rxjs/dist/cjs/internal/util/UnsubscriptionError.js"(exports) {
63
+ "use strict";
64
+ Object.defineProperty(exports, "__esModule", { value: true });
65
+ exports.UnsubscriptionError = void 0;
66
+ var createErrorClass_1 = require_createErrorClass();
67
+ exports.UnsubscriptionError = createErrorClass_1.createErrorClass(function(_super) {
68
+ return function UnsubscriptionErrorImpl(errors) {
69
+ _super(this);
70
+ this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
71
+ return i + 1 + ") " + err.toString();
72
+ }).join("\n ") : "";
73
+ this.name = "UnsubscriptionError";
74
+ this.errors = errors;
75
+ };
76
+ });
77
+ }
78
+ });
79
+
80
+ // node_modules/rxjs/dist/cjs/internal/util/arrRemove.js
81
+ var require_arrRemove = __commonJS({
82
+ "node_modules/rxjs/dist/cjs/internal/util/arrRemove.js"(exports) {
83
+ "use strict";
84
+ Object.defineProperty(exports, "__esModule", { value: true });
85
+ exports.arrRemove = void 0;
86
+ function arrRemove(arr, item) {
87
+ if (arr) {
88
+ var index = arr.indexOf(item);
89
+ 0 <= index && arr.splice(index, 1);
90
+ }
91
+ }
92
+ exports.arrRemove = arrRemove;
93
+ }
94
+ });
95
+
96
+ // node_modules/rxjs/dist/cjs/internal/Subscription.js
97
+ var require_Subscription = __commonJS({
98
+ "node_modules/rxjs/dist/cjs/internal/Subscription.js"(exports) {
99
+ "use strict";
100
+ var __values = exports && exports.__values || function(o) {
101
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
102
+ if (m) return m.call(o);
103
+ if (o && typeof o.length === "number") return {
104
+ next: function() {
105
+ if (o && i >= o.length) o = void 0;
106
+ return { value: o && o[i++], done: !o };
107
+ }
108
+ };
109
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
110
+ };
111
+ var __read = exports && exports.__read || function(o, n) {
112
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
113
+ if (!m) return o;
114
+ var i = m.call(o), r, ar = [], e;
115
+ try {
116
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
117
+ } catch (error) {
118
+ e = { error };
119
+ } finally {
120
+ try {
121
+ if (r && !r.done && (m = i["return"])) m.call(i);
122
+ } finally {
123
+ if (e) throw e.error;
124
+ }
125
+ }
126
+ return ar;
127
+ };
128
+ var __spreadArray = exports && exports.__spreadArray || function(to, from) {
129
+ for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
130
+ to[j] = from[i];
131
+ return to;
132
+ };
133
+ Object.defineProperty(exports, "__esModule", { value: true });
134
+ exports.isSubscription = exports.EMPTY_SUBSCRIPTION = exports.Subscription = void 0;
135
+ var isFunction_1 = require_isFunction();
136
+ var UnsubscriptionError_1 = require_UnsubscriptionError();
137
+ var arrRemove_1 = require_arrRemove();
138
+ var Subscription = (function() {
139
+ function Subscription2(initialTeardown) {
140
+ this.initialTeardown = initialTeardown;
141
+ this.closed = false;
142
+ this._parentage = null;
143
+ this._finalizers = null;
144
+ }
145
+ Subscription2.prototype.unsubscribe = function() {
146
+ var e_1, _a, e_2, _b;
147
+ var errors;
148
+ if (!this.closed) {
149
+ this.closed = true;
150
+ var _parentage = this._parentage;
151
+ if (_parentage) {
152
+ this._parentage = null;
153
+ if (Array.isArray(_parentage)) {
154
+ try {
155
+ for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
156
+ var parent_1 = _parentage_1_1.value;
157
+ parent_1.remove(this);
158
+ }
159
+ } catch (e_1_1) {
160
+ e_1 = { error: e_1_1 };
161
+ } finally {
162
+ try {
163
+ if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
164
+ } finally {
165
+ if (e_1) throw e_1.error;
166
+ }
167
+ }
168
+ } else {
169
+ _parentage.remove(this);
170
+ }
171
+ }
172
+ var initialFinalizer = this.initialTeardown;
173
+ if (isFunction_1.isFunction(initialFinalizer)) {
174
+ try {
175
+ initialFinalizer();
176
+ } catch (e) {
177
+ errors = e instanceof UnsubscriptionError_1.UnsubscriptionError ? e.errors : [e];
178
+ }
179
+ }
180
+ var _finalizers = this._finalizers;
181
+ if (_finalizers) {
182
+ this._finalizers = null;
183
+ try {
184
+ for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
185
+ var finalizer = _finalizers_1_1.value;
186
+ try {
187
+ execFinalizer(finalizer);
188
+ } catch (err) {
189
+ errors = errors !== null && errors !== void 0 ? errors : [];
190
+ if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {
191
+ errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
192
+ } else {
193
+ errors.push(err);
194
+ }
195
+ }
196
+ }
197
+ } catch (e_2_1) {
198
+ e_2 = { error: e_2_1 };
199
+ } finally {
200
+ try {
201
+ if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
202
+ } finally {
203
+ if (e_2) throw e_2.error;
204
+ }
205
+ }
206
+ }
207
+ if (errors) {
208
+ throw new UnsubscriptionError_1.UnsubscriptionError(errors);
209
+ }
210
+ }
211
+ };
212
+ Subscription2.prototype.add = function(teardown) {
213
+ var _a;
214
+ if (teardown && teardown !== this) {
215
+ if (this.closed) {
216
+ execFinalizer(teardown);
217
+ } else {
218
+ if (teardown instanceof Subscription2) {
219
+ if (teardown.closed || teardown._hasParent(this)) {
220
+ return;
221
+ }
222
+ teardown._addParent(this);
223
+ }
224
+ (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
225
+ }
226
+ }
227
+ };
228
+ Subscription2.prototype._hasParent = function(parent) {
229
+ var _parentage = this._parentage;
230
+ return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
231
+ };
232
+ Subscription2.prototype._addParent = function(parent) {
233
+ var _parentage = this._parentage;
234
+ this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
235
+ };
236
+ Subscription2.prototype._removeParent = function(parent) {
237
+ var _parentage = this._parentage;
238
+ if (_parentage === parent) {
239
+ this._parentage = null;
240
+ } else if (Array.isArray(_parentage)) {
241
+ arrRemove_1.arrRemove(_parentage, parent);
242
+ }
243
+ };
244
+ Subscription2.prototype.remove = function(teardown) {
245
+ var _finalizers = this._finalizers;
246
+ _finalizers && arrRemove_1.arrRemove(_finalizers, teardown);
247
+ if (teardown instanceof Subscription2) {
248
+ teardown._removeParent(this);
249
+ }
250
+ };
251
+ Subscription2.EMPTY = (function() {
252
+ var empty = new Subscription2();
253
+ empty.closed = true;
254
+ return empty;
255
+ })();
256
+ return Subscription2;
257
+ })();
258
+ exports.Subscription = Subscription;
259
+ exports.EMPTY_SUBSCRIPTION = Subscription.EMPTY;
260
+ function isSubscription(value) {
261
+ return value instanceof Subscription || value && "closed" in value && isFunction_1.isFunction(value.remove) && isFunction_1.isFunction(value.add) && isFunction_1.isFunction(value.unsubscribe);
262
+ }
263
+ exports.isSubscription = isSubscription;
264
+ function execFinalizer(finalizer) {
265
+ if (isFunction_1.isFunction(finalizer)) {
266
+ finalizer();
267
+ } else {
268
+ finalizer.unsubscribe();
269
+ }
270
+ }
271
+ }
272
+ });
273
+
274
+ // node_modules/rxjs/dist/cjs/internal/config.js
275
+ var require_config = __commonJS({
276
+ "node_modules/rxjs/dist/cjs/internal/config.js"(exports) {
277
+ "use strict";
278
+ Object.defineProperty(exports, "__esModule", { value: true });
279
+ exports.config = void 0;
280
+ exports.config = {
281
+ onUnhandledError: null,
282
+ onStoppedNotification: null,
283
+ Promise: void 0,
284
+ useDeprecatedSynchronousErrorHandling: false,
285
+ useDeprecatedNextContext: false
286
+ };
287
+ }
288
+ });
289
+
290
+ // node_modules/rxjs/dist/cjs/internal/scheduler/timeoutProvider.js
291
+ var require_timeoutProvider = __commonJS({
292
+ "node_modules/rxjs/dist/cjs/internal/scheduler/timeoutProvider.js"(exports) {
293
+ "use strict";
294
+ var __read = exports && exports.__read || function(o, n) {
295
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
296
+ if (!m) return o;
297
+ var i = m.call(o), r, ar = [], e;
298
+ try {
299
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
300
+ } catch (error) {
301
+ e = { error };
302
+ } finally {
303
+ try {
304
+ if (r && !r.done && (m = i["return"])) m.call(i);
305
+ } finally {
306
+ if (e) throw e.error;
307
+ }
308
+ }
309
+ return ar;
310
+ };
311
+ var __spreadArray = exports && exports.__spreadArray || function(to, from) {
312
+ for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
313
+ to[j] = from[i];
314
+ return to;
315
+ };
316
+ Object.defineProperty(exports, "__esModule", { value: true });
317
+ exports.timeoutProvider = void 0;
318
+ exports.timeoutProvider = {
319
+ setTimeout: function(handler, timeout) {
320
+ var args = [];
321
+ for (var _i = 2; _i < arguments.length; _i++) {
322
+ args[_i - 2] = arguments[_i];
323
+ }
324
+ var delegate = exports.timeoutProvider.delegate;
325
+ if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
326
+ return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
327
+ }
328
+ return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
329
+ },
330
+ clearTimeout: function(handle) {
331
+ var delegate = exports.timeoutProvider.delegate;
332
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
333
+ },
334
+ delegate: void 0
335
+ };
336
+ }
337
+ });
338
+
339
+ // node_modules/rxjs/dist/cjs/internal/util/reportUnhandledError.js
340
+ var require_reportUnhandledError = __commonJS({
341
+ "node_modules/rxjs/dist/cjs/internal/util/reportUnhandledError.js"(exports) {
342
+ "use strict";
343
+ Object.defineProperty(exports, "__esModule", { value: true });
344
+ exports.reportUnhandledError = void 0;
345
+ var config_1 = require_config();
346
+ var timeoutProvider_1 = require_timeoutProvider();
347
+ function reportUnhandledError(err) {
348
+ timeoutProvider_1.timeoutProvider.setTimeout(function() {
349
+ var onUnhandledError = config_1.config.onUnhandledError;
350
+ if (onUnhandledError) {
351
+ onUnhandledError(err);
352
+ } else {
353
+ throw err;
354
+ }
355
+ });
356
+ }
357
+ exports.reportUnhandledError = reportUnhandledError;
358
+ }
359
+ });
360
+
361
+ // node_modules/rxjs/dist/cjs/internal/util/noop.js
362
+ var require_noop = __commonJS({
363
+ "node_modules/rxjs/dist/cjs/internal/util/noop.js"(exports) {
364
+ "use strict";
365
+ Object.defineProperty(exports, "__esModule", { value: true });
366
+ exports.noop = void 0;
367
+ function noop() {
368
+ }
369
+ exports.noop = noop;
370
+ }
371
+ });
372
+
373
+ // node_modules/rxjs/dist/cjs/internal/NotificationFactories.js
374
+ var require_NotificationFactories = __commonJS({
375
+ "node_modules/rxjs/dist/cjs/internal/NotificationFactories.js"(exports) {
376
+ "use strict";
377
+ Object.defineProperty(exports, "__esModule", { value: true });
378
+ exports.createNotification = exports.nextNotification = exports.errorNotification = exports.COMPLETE_NOTIFICATION = void 0;
379
+ exports.COMPLETE_NOTIFICATION = (function() {
380
+ return createNotification("C", void 0, void 0);
381
+ })();
382
+ function errorNotification(error) {
383
+ return createNotification("E", void 0, error);
384
+ }
385
+ exports.errorNotification = errorNotification;
386
+ function nextNotification(value) {
387
+ return createNotification("N", value, void 0);
388
+ }
389
+ exports.nextNotification = nextNotification;
390
+ function createNotification(kind, value, error) {
391
+ return {
392
+ kind,
393
+ value,
394
+ error
395
+ };
396
+ }
397
+ exports.createNotification = createNotification;
398
+ }
399
+ });
400
+
401
+ // node_modules/rxjs/dist/cjs/internal/util/errorContext.js
402
+ var require_errorContext = __commonJS({
403
+ "node_modules/rxjs/dist/cjs/internal/util/errorContext.js"(exports) {
404
+ "use strict";
405
+ Object.defineProperty(exports, "__esModule", { value: true });
406
+ exports.captureError = exports.errorContext = void 0;
407
+ var config_1 = require_config();
408
+ var context = null;
409
+ function errorContext(cb) {
410
+ if (config_1.config.useDeprecatedSynchronousErrorHandling) {
411
+ var isRoot = !context;
412
+ if (isRoot) {
413
+ context = { errorThrown: false, error: null };
414
+ }
415
+ cb();
416
+ if (isRoot) {
417
+ var _a = context, errorThrown = _a.errorThrown, error = _a.error;
418
+ context = null;
419
+ if (errorThrown) {
420
+ throw error;
421
+ }
422
+ }
423
+ } else {
424
+ cb();
425
+ }
426
+ }
427
+ exports.errorContext = errorContext;
428
+ function captureError(err) {
429
+ if (config_1.config.useDeprecatedSynchronousErrorHandling && context) {
430
+ context.errorThrown = true;
431
+ context.error = err;
432
+ }
433
+ }
434
+ exports.captureError = captureError;
435
+ }
436
+ });
437
+
438
+ // node_modules/rxjs/dist/cjs/internal/Subscriber.js
439
+ var require_Subscriber = __commonJS({
440
+ "node_modules/rxjs/dist/cjs/internal/Subscriber.js"(exports) {
441
+ "use strict";
442
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
443
+ var extendStatics = function(d, b) {
444
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
445
+ d2.__proto__ = b2;
446
+ } || function(d2, b2) {
447
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
448
+ };
449
+ return extendStatics(d, b);
450
+ };
451
+ return function(d, b) {
452
+ if (typeof b !== "function" && b !== null)
453
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
454
+ extendStatics(d, b);
455
+ function __() {
456
+ this.constructor = d;
457
+ }
458
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
459
+ };
460
+ })();
461
+ Object.defineProperty(exports, "__esModule", { value: true });
462
+ exports.EMPTY_OBSERVER = exports.SafeSubscriber = exports.Subscriber = void 0;
463
+ var isFunction_1 = require_isFunction();
464
+ var Subscription_1 = require_Subscription();
465
+ var config_1 = require_config();
466
+ var reportUnhandledError_1 = require_reportUnhandledError();
467
+ var noop_1 = require_noop();
468
+ var NotificationFactories_1 = require_NotificationFactories();
469
+ var timeoutProvider_1 = require_timeoutProvider();
470
+ var errorContext_1 = require_errorContext();
471
+ var Subscriber = (function(_super) {
472
+ __extends(Subscriber2, _super);
473
+ function Subscriber2(destination) {
474
+ var _this = _super.call(this) || this;
475
+ _this.isStopped = false;
476
+ if (destination) {
477
+ _this.destination = destination;
478
+ if (Subscription_1.isSubscription(destination)) {
479
+ destination.add(_this);
480
+ }
481
+ } else {
482
+ _this.destination = exports.EMPTY_OBSERVER;
483
+ }
484
+ return _this;
485
+ }
486
+ Subscriber2.create = function(next, error, complete) {
487
+ return new SafeSubscriber(next, error, complete);
488
+ };
489
+ Subscriber2.prototype.next = function(value) {
490
+ if (this.isStopped) {
491
+ handleStoppedNotification(NotificationFactories_1.nextNotification(value), this);
492
+ } else {
493
+ this._next(value);
494
+ }
495
+ };
496
+ Subscriber2.prototype.error = function(err) {
497
+ if (this.isStopped) {
498
+ handleStoppedNotification(NotificationFactories_1.errorNotification(err), this);
499
+ } else {
500
+ this.isStopped = true;
501
+ this._error(err);
502
+ }
503
+ };
504
+ Subscriber2.prototype.complete = function() {
505
+ if (this.isStopped) {
506
+ handleStoppedNotification(NotificationFactories_1.COMPLETE_NOTIFICATION, this);
507
+ } else {
508
+ this.isStopped = true;
509
+ this._complete();
510
+ }
511
+ };
512
+ Subscriber2.prototype.unsubscribe = function() {
513
+ if (!this.closed) {
514
+ this.isStopped = true;
515
+ _super.prototype.unsubscribe.call(this);
516
+ this.destination = null;
517
+ }
518
+ };
519
+ Subscriber2.prototype._next = function(value) {
520
+ this.destination.next(value);
521
+ };
522
+ Subscriber2.prototype._error = function(err) {
523
+ try {
524
+ this.destination.error(err);
525
+ } finally {
526
+ this.unsubscribe();
527
+ }
528
+ };
529
+ Subscriber2.prototype._complete = function() {
530
+ try {
531
+ this.destination.complete();
532
+ } finally {
533
+ this.unsubscribe();
534
+ }
535
+ };
536
+ return Subscriber2;
537
+ })(Subscription_1.Subscription);
538
+ exports.Subscriber = Subscriber;
539
+ var _bind = Function.prototype.bind;
540
+ function bind(fn, thisArg) {
541
+ return _bind.call(fn, thisArg);
542
+ }
543
+ var ConsumerObserver = (function() {
544
+ function ConsumerObserver2(partialObserver) {
545
+ this.partialObserver = partialObserver;
546
+ }
547
+ ConsumerObserver2.prototype.next = function(value) {
548
+ var partialObserver = this.partialObserver;
549
+ if (partialObserver.next) {
550
+ try {
551
+ partialObserver.next(value);
552
+ } catch (error) {
553
+ handleUnhandledError(error);
554
+ }
555
+ }
556
+ };
557
+ ConsumerObserver2.prototype.error = function(err) {
558
+ var partialObserver = this.partialObserver;
559
+ if (partialObserver.error) {
560
+ try {
561
+ partialObserver.error(err);
562
+ } catch (error) {
563
+ handleUnhandledError(error);
564
+ }
565
+ } else {
566
+ handleUnhandledError(err);
567
+ }
568
+ };
569
+ ConsumerObserver2.prototype.complete = function() {
570
+ var partialObserver = this.partialObserver;
571
+ if (partialObserver.complete) {
572
+ try {
573
+ partialObserver.complete();
574
+ } catch (error) {
575
+ handleUnhandledError(error);
576
+ }
577
+ }
578
+ };
579
+ return ConsumerObserver2;
580
+ })();
581
+ var SafeSubscriber = (function(_super) {
582
+ __extends(SafeSubscriber2, _super);
583
+ function SafeSubscriber2(observerOrNext, error, complete) {
584
+ var _this = _super.call(this) || this;
585
+ var partialObserver;
586
+ if (isFunction_1.isFunction(observerOrNext) || !observerOrNext) {
587
+ partialObserver = {
588
+ next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
589
+ error: error !== null && error !== void 0 ? error : void 0,
590
+ complete: complete !== null && complete !== void 0 ? complete : void 0
591
+ };
592
+ } else {
593
+ var context_1;
594
+ if (_this && config_1.config.useDeprecatedNextContext) {
595
+ context_1 = Object.create(observerOrNext);
596
+ context_1.unsubscribe = function() {
597
+ return _this.unsubscribe();
598
+ };
599
+ partialObserver = {
600
+ next: observerOrNext.next && bind(observerOrNext.next, context_1),
601
+ error: observerOrNext.error && bind(observerOrNext.error, context_1),
602
+ complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
603
+ };
604
+ } else {
605
+ partialObserver = observerOrNext;
606
+ }
607
+ }
608
+ _this.destination = new ConsumerObserver(partialObserver);
609
+ return _this;
610
+ }
611
+ return SafeSubscriber2;
612
+ })(Subscriber);
613
+ exports.SafeSubscriber = SafeSubscriber;
614
+ function handleUnhandledError(error) {
615
+ if (config_1.config.useDeprecatedSynchronousErrorHandling) {
616
+ errorContext_1.captureError(error);
617
+ } else {
618
+ reportUnhandledError_1.reportUnhandledError(error);
619
+ }
620
+ }
621
+ function defaultErrorHandler(err) {
622
+ throw err;
623
+ }
624
+ function handleStoppedNotification(notification, subscriber) {
625
+ var onStoppedNotification = config_1.config.onStoppedNotification;
626
+ onStoppedNotification && timeoutProvider_1.timeoutProvider.setTimeout(function() {
627
+ return onStoppedNotification(notification, subscriber);
628
+ });
629
+ }
630
+ exports.EMPTY_OBSERVER = {
631
+ closed: true,
632
+ next: noop_1.noop,
633
+ error: defaultErrorHandler,
634
+ complete: noop_1.noop
635
+ };
636
+ }
637
+ });
638
+
639
+ // node_modules/rxjs/dist/cjs/internal/symbol/observable.js
640
+ var require_observable = __commonJS({
641
+ "node_modules/rxjs/dist/cjs/internal/symbol/observable.js"(exports) {
642
+ "use strict";
643
+ Object.defineProperty(exports, "__esModule", { value: true });
644
+ exports.observable = void 0;
645
+ exports.observable = (function() {
646
+ return typeof Symbol === "function" && Symbol.observable || "@@observable";
647
+ })();
648
+ }
649
+ });
650
+
651
+ // node_modules/rxjs/dist/cjs/internal/util/identity.js
652
+ var require_identity = __commonJS({
653
+ "node_modules/rxjs/dist/cjs/internal/util/identity.js"(exports) {
654
+ "use strict";
655
+ Object.defineProperty(exports, "__esModule", { value: true });
656
+ exports.identity = void 0;
657
+ function identity(x) {
658
+ return x;
659
+ }
660
+ exports.identity = identity;
661
+ }
662
+ });
663
+
664
+ // node_modules/rxjs/dist/cjs/internal/util/pipe.js
665
+ var require_pipe = __commonJS({
666
+ "node_modules/rxjs/dist/cjs/internal/util/pipe.js"(exports) {
667
+ "use strict";
668
+ Object.defineProperty(exports, "__esModule", { value: true });
669
+ exports.pipeFromArray = exports.pipe = void 0;
670
+ var identity_1 = require_identity();
671
+ function pipe() {
672
+ var fns = [];
673
+ for (var _i = 0; _i < arguments.length; _i++) {
674
+ fns[_i] = arguments[_i];
675
+ }
676
+ return pipeFromArray(fns);
677
+ }
678
+ exports.pipe = pipe;
679
+ function pipeFromArray(fns) {
680
+ if (fns.length === 0) {
681
+ return identity_1.identity;
682
+ }
683
+ if (fns.length === 1) {
684
+ return fns[0];
685
+ }
686
+ return function piped(input) {
687
+ return fns.reduce(function(prev, fn) {
688
+ return fn(prev);
689
+ }, input);
690
+ };
691
+ }
692
+ exports.pipeFromArray = pipeFromArray;
693
+ }
694
+ });
695
+
696
+ // node_modules/rxjs/dist/cjs/internal/Observable.js
697
+ var require_Observable = __commonJS({
698
+ "node_modules/rxjs/dist/cjs/internal/Observable.js"(exports) {
699
+ "use strict";
700
+ Object.defineProperty(exports, "__esModule", { value: true });
701
+ exports.Observable = void 0;
702
+ var Subscriber_1 = require_Subscriber();
703
+ var Subscription_1 = require_Subscription();
704
+ var observable_1 = require_observable();
705
+ var pipe_1 = require_pipe();
706
+ var config_1 = require_config();
707
+ var isFunction_1 = require_isFunction();
708
+ var errorContext_1 = require_errorContext();
709
+ var Observable = (function() {
710
+ function Observable2(subscribe) {
711
+ if (subscribe) {
712
+ this._subscribe = subscribe;
713
+ }
714
+ }
715
+ Observable2.prototype.lift = function(operator) {
716
+ var observable = new Observable2();
717
+ observable.source = this;
718
+ observable.operator = operator;
719
+ return observable;
720
+ };
721
+ Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
722
+ var _this = this;
723
+ var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new Subscriber_1.SafeSubscriber(observerOrNext, error, complete);
724
+ errorContext_1.errorContext(function() {
725
+ var _a = _this, operator = _a.operator, source = _a.source;
726
+ subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
727
+ });
728
+ return subscriber;
729
+ };
730
+ Observable2.prototype._trySubscribe = function(sink) {
731
+ try {
732
+ return this._subscribe(sink);
733
+ } catch (err) {
734
+ sink.error(err);
735
+ }
736
+ };
737
+ Observable2.prototype.forEach = function(next, promiseCtor) {
738
+ var _this = this;
739
+ promiseCtor = getPromiseCtor(promiseCtor);
740
+ return new promiseCtor(function(resolve, reject) {
741
+ var subscriber = new Subscriber_1.SafeSubscriber({
742
+ next: function(value) {
743
+ try {
744
+ next(value);
745
+ } catch (err) {
746
+ reject(err);
747
+ subscriber.unsubscribe();
748
+ }
749
+ },
750
+ error: reject,
751
+ complete: resolve
752
+ });
753
+ _this.subscribe(subscriber);
754
+ });
755
+ };
756
+ Observable2.prototype._subscribe = function(subscriber) {
757
+ var _a;
758
+ return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
759
+ };
760
+ Observable2.prototype[observable_1.observable] = function() {
761
+ return this;
762
+ };
763
+ Observable2.prototype.pipe = function() {
764
+ var operations = [];
765
+ for (var _i = 0; _i < arguments.length; _i++) {
766
+ operations[_i] = arguments[_i];
767
+ }
768
+ return pipe_1.pipeFromArray(operations)(this);
769
+ };
770
+ Observable2.prototype.toPromise = function(promiseCtor) {
771
+ var _this = this;
772
+ promiseCtor = getPromiseCtor(promiseCtor);
773
+ return new promiseCtor(function(resolve, reject) {
774
+ var value;
775
+ _this.subscribe(function(x) {
776
+ return value = x;
777
+ }, function(err) {
778
+ return reject(err);
779
+ }, function() {
780
+ return resolve(value);
781
+ });
782
+ });
783
+ };
784
+ Observable2.create = function(subscribe) {
785
+ return new Observable2(subscribe);
786
+ };
787
+ return Observable2;
788
+ })();
789
+ exports.Observable = Observable;
790
+ function getPromiseCtor(promiseCtor) {
791
+ var _a;
792
+ return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config_1.config.Promise) !== null && _a !== void 0 ? _a : Promise;
793
+ }
794
+ function isObserver(value) {
795
+ return value && isFunction_1.isFunction(value.next) && isFunction_1.isFunction(value.error) && isFunction_1.isFunction(value.complete);
796
+ }
797
+ function isSubscriber(value) {
798
+ return value && value instanceof Subscriber_1.Subscriber || isObserver(value) && Subscription_1.isSubscription(value);
799
+ }
800
+ }
801
+ });
802
+
803
+ // node_modules/rxjs/dist/cjs/internal/testing/SubscriptionLog.js
804
+ var require_SubscriptionLog = __commonJS({
805
+ "node_modules/rxjs/dist/cjs/internal/testing/SubscriptionLog.js"(exports) {
806
+ "use strict";
807
+ Object.defineProperty(exports, "__esModule", { value: true });
808
+ exports.SubscriptionLog = void 0;
809
+ var SubscriptionLog = /* @__PURE__ */ (function() {
810
+ function SubscriptionLog2(subscribedFrame, unsubscribedFrame) {
811
+ if (unsubscribedFrame === void 0) {
812
+ unsubscribedFrame = Infinity;
813
+ }
814
+ this.subscribedFrame = subscribedFrame;
815
+ this.unsubscribedFrame = unsubscribedFrame;
816
+ }
817
+ return SubscriptionLog2;
818
+ })();
819
+ exports.SubscriptionLog = SubscriptionLog;
820
+ }
821
+ });
822
+
823
+ // node_modules/rxjs/dist/cjs/internal/testing/SubscriptionLoggable.js
824
+ var require_SubscriptionLoggable = __commonJS({
825
+ "node_modules/rxjs/dist/cjs/internal/testing/SubscriptionLoggable.js"(exports) {
826
+ "use strict";
827
+ Object.defineProperty(exports, "__esModule", { value: true });
828
+ exports.SubscriptionLoggable = void 0;
829
+ var SubscriptionLog_1 = require_SubscriptionLog();
830
+ var SubscriptionLoggable = (function() {
831
+ function SubscriptionLoggable2() {
832
+ this.subscriptions = [];
833
+ }
834
+ SubscriptionLoggable2.prototype.logSubscribedFrame = function() {
835
+ this.subscriptions.push(new SubscriptionLog_1.SubscriptionLog(this.scheduler.now()));
836
+ return this.subscriptions.length - 1;
837
+ };
838
+ SubscriptionLoggable2.prototype.logUnsubscribedFrame = function(index) {
839
+ var subscriptionLogs = this.subscriptions;
840
+ var oldSubscriptionLog = subscriptionLogs[index];
841
+ subscriptionLogs[index] = new SubscriptionLog_1.SubscriptionLog(oldSubscriptionLog.subscribedFrame, this.scheduler.now());
842
+ };
843
+ return SubscriptionLoggable2;
844
+ })();
845
+ exports.SubscriptionLoggable = SubscriptionLoggable;
846
+ }
847
+ });
848
+
849
+ // node_modules/rxjs/dist/cjs/internal/util/applyMixins.js
850
+ var require_applyMixins = __commonJS({
851
+ "node_modules/rxjs/dist/cjs/internal/util/applyMixins.js"(exports) {
852
+ "use strict";
853
+ Object.defineProperty(exports, "__esModule", { value: true });
854
+ exports.applyMixins = void 0;
855
+ function applyMixins(derivedCtor, baseCtors) {
856
+ for (var i = 0, len = baseCtors.length; i < len; i++) {
857
+ var baseCtor = baseCtors[i];
858
+ var propertyKeys = Object.getOwnPropertyNames(baseCtor.prototype);
859
+ for (var j = 0, len2 = propertyKeys.length; j < len2; j++) {
860
+ var name_1 = propertyKeys[j];
861
+ derivedCtor.prototype[name_1] = baseCtor.prototype[name_1];
862
+ }
863
+ }
864
+ }
865
+ exports.applyMixins = applyMixins;
866
+ }
867
+ });
868
+
869
+ // node_modules/rxjs/dist/cjs/internal/observable/empty.js
870
+ var require_empty = __commonJS({
871
+ "node_modules/rxjs/dist/cjs/internal/observable/empty.js"(exports) {
872
+ "use strict";
873
+ Object.defineProperty(exports, "__esModule", { value: true });
874
+ exports.empty = exports.EMPTY = void 0;
875
+ var Observable_1 = require_Observable();
876
+ exports.EMPTY = new Observable_1.Observable(function(subscriber) {
877
+ return subscriber.complete();
878
+ });
879
+ function empty(scheduler) {
880
+ return scheduler ? emptyScheduled(scheduler) : exports.EMPTY;
881
+ }
882
+ exports.empty = empty;
883
+ function emptyScheduled(scheduler) {
884
+ return new Observable_1.Observable(function(subscriber) {
885
+ return scheduler.schedule(function() {
886
+ return subscriber.complete();
887
+ });
888
+ });
889
+ }
890
+ }
891
+ });
892
+
893
+ // node_modules/rxjs/dist/cjs/internal/util/isScheduler.js
894
+ var require_isScheduler = __commonJS({
895
+ "node_modules/rxjs/dist/cjs/internal/util/isScheduler.js"(exports) {
896
+ "use strict";
897
+ Object.defineProperty(exports, "__esModule", { value: true });
898
+ exports.isScheduler = void 0;
899
+ var isFunction_1 = require_isFunction();
900
+ function isScheduler(value) {
901
+ return value && isFunction_1.isFunction(value.schedule);
902
+ }
903
+ exports.isScheduler = isScheduler;
904
+ }
905
+ });
906
+
907
+ // node_modules/rxjs/dist/cjs/internal/util/args.js
908
+ var require_args = __commonJS({
909
+ "node_modules/rxjs/dist/cjs/internal/util/args.js"(exports) {
910
+ "use strict";
911
+ Object.defineProperty(exports, "__esModule", { value: true });
912
+ exports.popNumber = exports.popScheduler = exports.popResultSelector = void 0;
913
+ var isFunction_1 = require_isFunction();
914
+ var isScheduler_1 = require_isScheduler();
915
+ function last(arr) {
916
+ return arr[arr.length - 1];
917
+ }
918
+ function popResultSelector(args) {
919
+ return isFunction_1.isFunction(last(args)) ? args.pop() : void 0;
920
+ }
921
+ exports.popResultSelector = popResultSelector;
922
+ function popScheduler(args) {
923
+ return isScheduler_1.isScheduler(last(args)) ? args.pop() : void 0;
924
+ }
925
+ exports.popScheduler = popScheduler;
926
+ function popNumber(args, defaultValue) {
927
+ return typeof last(args) === "number" ? args.pop() : defaultValue;
928
+ }
929
+ exports.popNumber = popNumber;
930
+ }
931
+ });
932
+
933
+ // node_modules/rxjs/dist/cjs/internal/util/isArrayLike.js
934
+ var require_isArrayLike = __commonJS({
935
+ "node_modules/rxjs/dist/cjs/internal/util/isArrayLike.js"(exports) {
936
+ "use strict";
937
+ Object.defineProperty(exports, "__esModule", { value: true });
938
+ exports.isArrayLike = void 0;
939
+ exports.isArrayLike = (function(x) {
940
+ return x && typeof x.length === "number" && typeof x !== "function";
941
+ });
942
+ }
943
+ });
944
+
945
+ // node_modules/rxjs/dist/cjs/internal/util/isPromise.js
946
+ var require_isPromise = __commonJS({
947
+ "node_modules/rxjs/dist/cjs/internal/util/isPromise.js"(exports) {
948
+ "use strict";
949
+ Object.defineProperty(exports, "__esModule", { value: true });
950
+ exports.isPromise = void 0;
951
+ var isFunction_1 = require_isFunction();
952
+ function isPromise(value) {
953
+ return isFunction_1.isFunction(value === null || value === void 0 ? void 0 : value.then);
954
+ }
955
+ exports.isPromise = isPromise;
956
+ }
957
+ });
958
+
959
+ // node_modules/rxjs/dist/cjs/internal/util/isInteropObservable.js
960
+ var require_isInteropObservable = __commonJS({
961
+ "node_modules/rxjs/dist/cjs/internal/util/isInteropObservable.js"(exports) {
962
+ "use strict";
963
+ Object.defineProperty(exports, "__esModule", { value: true });
964
+ exports.isInteropObservable = void 0;
965
+ var observable_1 = require_observable();
966
+ var isFunction_1 = require_isFunction();
967
+ function isInteropObservable(input) {
968
+ return isFunction_1.isFunction(input[observable_1.observable]);
969
+ }
970
+ exports.isInteropObservable = isInteropObservable;
971
+ }
972
+ });
973
+
974
+ // node_modules/rxjs/dist/cjs/internal/util/isAsyncIterable.js
975
+ var require_isAsyncIterable = __commonJS({
976
+ "node_modules/rxjs/dist/cjs/internal/util/isAsyncIterable.js"(exports) {
977
+ "use strict";
978
+ Object.defineProperty(exports, "__esModule", { value: true });
979
+ exports.isAsyncIterable = void 0;
980
+ var isFunction_1 = require_isFunction();
981
+ function isAsyncIterable(obj) {
982
+ return Symbol.asyncIterator && isFunction_1.isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
983
+ }
984
+ exports.isAsyncIterable = isAsyncIterable;
985
+ }
986
+ });
987
+
988
+ // node_modules/rxjs/dist/cjs/internal/util/throwUnobservableError.js
989
+ var require_throwUnobservableError = __commonJS({
990
+ "node_modules/rxjs/dist/cjs/internal/util/throwUnobservableError.js"(exports) {
991
+ "use strict";
992
+ Object.defineProperty(exports, "__esModule", { value: true });
993
+ exports.createInvalidObservableTypeError = void 0;
994
+ function createInvalidObservableTypeError(input) {
995
+ return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
996
+ }
997
+ exports.createInvalidObservableTypeError = createInvalidObservableTypeError;
998
+ }
999
+ });
1000
+
1001
+ // node_modules/rxjs/dist/cjs/internal/symbol/iterator.js
1002
+ var require_iterator = __commonJS({
1003
+ "node_modules/rxjs/dist/cjs/internal/symbol/iterator.js"(exports) {
1004
+ "use strict";
1005
+ Object.defineProperty(exports, "__esModule", { value: true });
1006
+ exports.iterator = exports.getSymbolIterator = void 0;
1007
+ function getSymbolIterator() {
1008
+ if (typeof Symbol !== "function" || !Symbol.iterator) {
1009
+ return "@@iterator";
1010
+ }
1011
+ return Symbol.iterator;
1012
+ }
1013
+ exports.getSymbolIterator = getSymbolIterator;
1014
+ exports.iterator = getSymbolIterator();
1015
+ }
1016
+ });
1017
+
1018
+ // node_modules/rxjs/dist/cjs/internal/util/isIterable.js
1019
+ var require_isIterable = __commonJS({
1020
+ "node_modules/rxjs/dist/cjs/internal/util/isIterable.js"(exports) {
1021
+ "use strict";
1022
+ Object.defineProperty(exports, "__esModule", { value: true });
1023
+ exports.isIterable = void 0;
1024
+ var iterator_1 = require_iterator();
1025
+ var isFunction_1 = require_isFunction();
1026
+ function isIterable(input) {
1027
+ return isFunction_1.isFunction(input === null || input === void 0 ? void 0 : input[iterator_1.iterator]);
1028
+ }
1029
+ exports.isIterable = isIterable;
1030
+ }
1031
+ });
1032
+
1033
+ // node_modules/rxjs/dist/cjs/internal/util/isReadableStreamLike.js
1034
+ var require_isReadableStreamLike = __commonJS({
1035
+ "node_modules/rxjs/dist/cjs/internal/util/isReadableStreamLike.js"(exports) {
1036
+ "use strict";
1037
+ var __generator = exports && exports.__generator || function(thisArg, body) {
1038
+ var _ = { label: 0, sent: function() {
1039
+ if (t[0] & 1) throw t[1];
1040
+ return t[1];
1041
+ }, trys: [], ops: [] }, f, y, t, g;
1042
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
1043
+ return this;
1044
+ }), g;
1045
+ function verb(n) {
1046
+ return function(v) {
1047
+ return step([n, v]);
1048
+ };
1049
+ }
1050
+ function step(op) {
1051
+ if (f) throw new TypeError("Generator is already executing.");
1052
+ while (_) try {
1053
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
1054
+ if (y = 0, t) op = [op[0] & 2, t.value];
1055
+ switch (op[0]) {
1056
+ case 0:
1057
+ case 1:
1058
+ t = op;
1059
+ break;
1060
+ case 4:
1061
+ _.label++;
1062
+ return { value: op[1], done: false };
1063
+ case 5:
1064
+ _.label++;
1065
+ y = op[1];
1066
+ op = [0];
1067
+ continue;
1068
+ case 7:
1069
+ op = _.ops.pop();
1070
+ _.trys.pop();
1071
+ continue;
1072
+ default:
1073
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
1074
+ _ = 0;
1075
+ continue;
1076
+ }
1077
+ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
1078
+ _.label = op[1];
1079
+ break;
1080
+ }
1081
+ if (op[0] === 6 && _.label < t[1]) {
1082
+ _.label = t[1];
1083
+ t = op;
1084
+ break;
1085
+ }
1086
+ if (t && _.label < t[2]) {
1087
+ _.label = t[2];
1088
+ _.ops.push(op);
1089
+ break;
1090
+ }
1091
+ if (t[2]) _.ops.pop();
1092
+ _.trys.pop();
1093
+ continue;
1094
+ }
1095
+ op = body.call(thisArg, _);
1096
+ } catch (e) {
1097
+ op = [6, e];
1098
+ y = 0;
1099
+ } finally {
1100
+ f = t = 0;
1101
+ }
1102
+ if (op[0] & 5) throw op[1];
1103
+ return { value: op[0] ? op[1] : void 0, done: true };
1104
+ }
1105
+ };
1106
+ var __await = exports && exports.__await || function(v) {
1107
+ return this instanceof __await ? (this.v = v, this) : new __await(v);
1108
+ };
1109
+ var __asyncGenerator = exports && exports.__asyncGenerator || function(thisArg, _arguments, generator) {
1110
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
1111
+ var g = generator.apply(thisArg, _arguments || []), i, q = [];
1112
+ return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
1113
+ return this;
1114
+ }, i;
1115
+ function verb(n) {
1116
+ if (g[n]) i[n] = function(v) {
1117
+ return new Promise(function(a, b) {
1118
+ q.push([n, v, a, b]) > 1 || resume(n, v);
1119
+ });
1120
+ };
1121
+ }
1122
+ function resume(n, v) {
1123
+ try {
1124
+ step(g[n](v));
1125
+ } catch (e) {
1126
+ settle(q[0][3], e);
1127
+ }
1128
+ }
1129
+ function step(r) {
1130
+ r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
1131
+ }
1132
+ function fulfill(value) {
1133
+ resume("next", value);
1134
+ }
1135
+ function reject(value) {
1136
+ resume("throw", value);
1137
+ }
1138
+ function settle(f, v) {
1139
+ if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
1140
+ }
1141
+ };
1142
+ Object.defineProperty(exports, "__esModule", { value: true });
1143
+ exports.isReadableStreamLike = exports.readableStreamLikeToAsyncGenerator = void 0;
1144
+ var isFunction_1 = require_isFunction();
1145
+ function readableStreamLikeToAsyncGenerator(readableStream) {
1146
+ return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
1147
+ var reader, _a, value, done;
1148
+ return __generator(this, function(_b) {
1149
+ switch (_b.label) {
1150
+ case 0:
1151
+ reader = readableStream.getReader();
1152
+ _b.label = 1;
1153
+ case 1:
1154
+ _b.trys.push([1, , 9, 10]);
1155
+ _b.label = 2;
1156
+ case 2:
1157
+ if (false) return [3, 8];
1158
+ return [4, __await(reader.read())];
1159
+ case 3:
1160
+ _a = _b.sent(), value = _a.value, done = _a.done;
1161
+ if (!done) return [3, 5];
1162
+ return [4, __await(void 0)];
1163
+ case 4:
1164
+ return [2, _b.sent()];
1165
+ case 5:
1166
+ return [4, __await(value)];
1167
+ case 6:
1168
+ return [4, _b.sent()];
1169
+ case 7:
1170
+ _b.sent();
1171
+ return [3, 2];
1172
+ case 8:
1173
+ return [3, 10];
1174
+ case 9:
1175
+ reader.releaseLock();
1176
+ return [7];
1177
+ case 10:
1178
+ return [2];
1179
+ }
1180
+ });
1181
+ });
1182
+ }
1183
+ exports.readableStreamLikeToAsyncGenerator = readableStreamLikeToAsyncGenerator;
1184
+ function isReadableStreamLike(obj) {
1185
+ return isFunction_1.isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
1186
+ }
1187
+ exports.isReadableStreamLike = isReadableStreamLike;
1188
+ }
1189
+ });
1190
+
1191
+ // node_modules/rxjs/dist/cjs/internal/observable/innerFrom.js
1192
+ var require_innerFrom = __commonJS({
1193
+ "node_modules/rxjs/dist/cjs/internal/observable/innerFrom.js"(exports) {
1194
+ "use strict";
1195
+ var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
1196
+ function adopt(value) {
1197
+ return value instanceof P ? value : new P(function(resolve) {
1198
+ resolve(value);
1199
+ });
1200
+ }
1201
+ return new (P || (P = Promise))(function(resolve, reject) {
1202
+ function fulfilled(value) {
1203
+ try {
1204
+ step(generator.next(value));
1205
+ } catch (e) {
1206
+ reject(e);
1207
+ }
1208
+ }
1209
+ function rejected(value) {
1210
+ try {
1211
+ step(generator["throw"](value));
1212
+ } catch (e) {
1213
+ reject(e);
1214
+ }
1215
+ }
1216
+ function step(result) {
1217
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
1218
+ }
1219
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
1220
+ });
1221
+ };
1222
+ var __generator = exports && exports.__generator || function(thisArg, body) {
1223
+ var _ = { label: 0, sent: function() {
1224
+ if (t[0] & 1) throw t[1];
1225
+ return t[1];
1226
+ }, trys: [], ops: [] }, f, y, t, g;
1227
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
1228
+ return this;
1229
+ }), g;
1230
+ function verb(n) {
1231
+ return function(v) {
1232
+ return step([n, v]);
1233
+ };
1234
+ }
1235
+ function step(op) {
1236
+ if (f) throw new TypeError("Generator is already executing.");
1237
+ while (_) try {
1238
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
1239
+ if (y = 0, t) op = [op[0] & 2, t.value];
1240
+ switch (op[0]) {
1241
+ case 0:
1242
+ case 1:
1243
+ t = op;
1244
+ break;
1245
+ case 4:
1246
+ _.label++;
1247
+ return { value: op[1], done: false };
1248
+ case 5:
1249
+ _.label++;
1250
+ y = op[1];
1251
+ op = [0];
1252
+ continue;
1253
+ case 7:
1254
+ op = _.ops.pop();
1255
+ _.trys.pop();
1256
+ continue;
1257
+ default:
1258
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
1259
+ _ = 0;
1260
+ continue;
1261
+ }
1262
+ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
1263
+ _.label = op[1];
1264
+ break;
1265
+ }
1266
+ if (op[0] === 6 && _.label < t[1]) {
1267
+ _.label = t[1];
1268
+ t = op;
1269
+ break;
1270
+ }
1271
+ if (t && _.label < t[2]) {
1272
+ _.label = t[2];
1273
+ _.ops.push(op);
1274
+ break;
1275
+ }
1276
+ if (t[2]) _.ops.pop();
1277
+ _.trys.pop();
1278
+ continue;
1279
+ }
1280
+ op = body.call(thisArg, _);
1281
+ } catch (e) {
1282
+ op = [6, e];
1283
+ y = 0;
1284
+ } finally {
1285
+ f = t = 0;
1286
+ }
1287
+ if (op[0] & 5) throw op[1];
1288
+ return { value: op[0] ? op[1] : void 0, done: true };
1289
+ }
1290
+ };
1291
+ var __asyncValues = exports && exports.__asyncValues || function(o) {
1292
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
1293
+ var m = o[Symbol.asyncIterator], i;
1294
+ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
1295
+ return this;
1296
+ }, i);
1297
+ function verb(n) {
1298
+ i[n] = o[n] && function(v) {
1299
+ return new Promise(function(resolve, reject) {
1300
+ v = o[n](v), settle(resolve, reject, v.done, v.value);
1301
+ });
1302
+ };
1303
+ }
1304
+ function settle(resolve, reject, d, v) {
1305
+ Promise.resolve(v).then(function(v2) {
1306
+ resolve({ value: v2, done: d });
1307
+ }, reject);
1308
+ }
1309
+ };
1310
+ var __values = exports && exports.__values || function(o) {
1311
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
1312
+ if (m) return m.call(o);
1313
+ if (o && typeof o.length === "number") return {
1314
+ next: function() {
1315
+ if (o && i >= o.length) o = void 0;
1316
+ return { value: o && o[i++], done: !o };
1317
+ }
1318
+ };
1319
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
1320
+ };
1321
+ Object.defineProperty(exports, "__esModule", { value: true });
1322
+ exports.fromReadableStreamLike = exports.fromAsyncIterable = exports.fromIterable = exports.fromPromise = exports.fromArrayLike = exports.fromInteropObservable = exports.innerFrom = void 0;
1323
+ var isArrayLike_1 = require_isArrayLike();
1324
+ var isPromise_1 = require_isPromise();
1325
+ var Observable_1 = require_Observable();
1326
+ var isInteropObservable_1 = require_isInteropObservable();
1327
+ var isAsyncIterable_1 = require_isAsyncIterable();
1328
+ var throwUnobservableError_1 = require_throwUnobservableError();
1329
+ var isIterable_1 = require_isIterable();
1330
+ var isReadableStreamLike_1 = require_isReadableStreamLike();
1331
+ var isFunction_1 = require_isFunction();
1332
+ var reportUnhandledError_1 = require_reportUnhandledError();
1333
+ var observable_1 = require_observable();
1334
+ function innerFrom(input) {
1335
+ if (input instanceof Observable_1.Observable) {
1336
+ return input;
1337
+ }
1338
+ if (input != null) {
1339
+ if (isInteropObservable_1.isInteropObservable(input)) {
1340
+ return fromInteropObservable(input);
1341
+ }
1342
+ if (isArrayLike_1.isArrayLike(input)) {
1343
+ return fromArrayLike(input);
1344
+ }
1345
+ if (isPromise_1.isPromise(input)) {
1346
+ return fromPromise(input);
1347
+ }
1348
+ if (isAsyncIterable_1.isAsyncIterable(input)) {
1349
+ return fromAsyncIterable(input);
1350
+ }
1351
+ if (isIterable_1.isIterable(input)) {
1352
+ return fromIterable(input);
1353
+ }
1354
+ if (isReadableStreamLike_1.isReadableStreamLike(input)) {
1355
+ return fromReadableStreamLike(input);
1356
+ }
1357
+ }
1358
+ throw throwUnobservableError_1.createInvalidObservableTypeError(input);
1359
+ }
1360
+ exports.innerFrom = innerFrom;
1361
+ function fromInteropObservable(obj) {
1362
+ return new Observable_1.Observable(function(subscriber) {
1363
+ var obs = obj[observable_1.observable]();
1364
+ if (isFunction_1.isFunction(obs.subscribe)) {
1365
+ return obs.subscribe(subscriber);
1366
+ }
1367
+ throw new TypeError("Provided object does not correctly implement Symbol.observable");
1368
+ });
1369
+ }
1370
+ exports.fromInteropObservable = fromInteropObservable;
1371
+ function fromArrayLike(array) {
1372
+ return new Observable_1.Observable(function(subscriber) {
1373
+ for (var i = 0; i < array.length && !subscriber.closed; i++) {
1374
+ subscriber.next(array[i]);
1375
+ }
1376
+ subscriber.complete();
1377
+ });
1378
+ }
1379
+ exports.fromArrayLike = fromArrayLike;
1380
+ function fromPromise(promise) {
1381
+ return new Observable_1.Observable(function(subscriber) {
1382
+ promise.then(function(value) {
1383
+ if (!subscriber.closed) {
1384
+ subscriber.next(value);
1385
+ subscriber.complete();
1386
+ }
1387
+ }, function(err) {
1388
+ return subscriber.error(err);
1389
+ }).then(null, reportUnhandledError_1.reportUnhandledError);
1390
+ });
1391
+ }
1392
+ exports.fromPromise = fromPromise;
1393
+ function fromIterable(iterable) {
1394
+ return new Observable_1.Observable(function(subscriber) {
1395
+ var e_1, _a;
1396
+ try {
1397
+ for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
1398
+ var value = iterable_1_1.value;
1399
+ subscriber.next(value);
1400
+ if (subscriber.closed) {
1401
+ return;
1402
+ }
1403
+ }
1404
+ } catch (e_1_1) {
1405
+ e_1 = { error: e_1_1 };
1406
+ } finally {
1407
+ try {
1408
+ if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
1409
+ } finally {
1410
+ if (e_1) throw e_1.error;
1411
+ }
1412
+ }
1413
+ subscriber.complete();
1414
+ });
1415
+ }
1416
+ exports.fromIterable = fromIterable;
1417
+ function fromAsyncIterable(asyncIterable) {
1418
+ return new Observable_1.Observable(function(subscriber) {
1419
+ process(asyncIterable, subscriber).catch(function(err) {
1420
+ return subscriber.error(err);
1421
+ });
1422
+ });
1423
+ }
1424
+ exports.fromAsyncIterable = fromAsyncIterable;
1425
+ function fromReadableStreamLike(readableStream) {
1426
+ return fromAsyncIterable(isReadableStreamLike_1.readableStreamLikeToAsyncGenerator(readableStream));
1427
+ }
1428
+ exports.fromReadableStreamLike = fromReadableStreamLike;
1429
+ function process(asyncIterable, subscriber) {
1430
+ var asyncIterable_1, asyncIterable_1_1;
1431
+ var e_2, _a;
1432
+ return __awaiter(this, void 0, void 0, function() {
1433
+ var value, e_2_1;
1434
+ return __generator(this, function(_b) {
1435
+ switch (_b.label) {
1436
+ case 0:
1437
+ _b.trys.push([0, 5, 6, 11]);
1438
+ asyncIterable_1 = __asyncValues(asyncIterable);
1439
+ _b.label = 1;
1440
+ case 1:
1441
+ return [4, asyncIterable_1.next()];
1442
+ case 2:
1443
+ if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
1444
+ value = asyncIterable_1_1.value;
1445
+ subscriber.next(value);
1446
+ if (subscriber.closed) {
1447
+ return [2];
1448
+ }
1449
+ _b.label = 3;
1450
+ case 3:
1451
+ return [3, 1];
1452
+ case 4:
1453
+ return [3, 11];
1454
+ case 5:
1455
+ e_2_1 = _b.sent();
1456
+ e_2 = { error: e_2_1 };
1457
+ return [3, 11];
1458
+ case 6:
1459
+ _b.trys.push([6, , 9, 10]);
1460
+ if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
1461
+ return [4, _a.call(asyncIterable_1)];
1462
+ case 7:
1463
+ _b.sent();
1464
+ _b.label = 8;
1465
+ case 8:
1466
+ return [3, 10];
1467
+ case 9:
1468
+ if (e_2) throw e_2.error;
1469
+ return [7];
1470
+ case 10:
1471
+ return [7];
1472
+ case 11:
1473
+ subscriber.complete();
1474
+ return [2];
1475
+ }
1476
+ });
1477
+ });
1478
+ }
1479
+ }
1480
+ });
1481
+
1482
+ // node_modules/rxjs/dist/cjs/internal/util/executeSchedule.js
1483
+ var require_executeSchedule = __commonJS({
1484
+ "node_modules/rxjs/dist/cjs/internal/util/executeSchedule.js"(exports) {
1485
+ "use strict";
1486
+ Object.defineProperty(exports, "__esModule", { value: true });
1487
+ exports.executeSchedule = void 0;
1488
+ function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
1489
+ if (delay === void 0) {
1490
+ delay = 0;
1491
+ }
1492
+ if (repeat === void 0) {
1493
+ repeat = false;
1494
+ }
1495
+ var scheduleSubscription = scheduler.schedule(function() {
1496
+ work();
1497
+ if (repeat) {
1498
+ parentSubscription.add(this.schedule(null, delay));
1499
+ } else {
1500
+ this.unsubscribe();
1501
+ }
1502
+ }, delay);
1503
+ parentSubscription.add(scheduleSubscription);
1504
+ if (!repeat) {
1505
+ return scheduleSubscription;
1506
+ }
1507
+ }
1508
+ exports.executeSchedule = executeSchedule;
1509
+ }
1510
+ });
1511
+
1512
+ // node_modules/rxjs/dist/cjs/internal/util/lift.js
1513
+ var require_lift = __commonJS({
1514
+ "node_modules/rxjs/dist/cjs/internal/util/lift.js"(exports) {
1515
+ "use strict";
1516
+ Object.defineProperty(exports, "__esModule", { value: true });
1517
+ exports.operate = exports.hasLift = void 0;
1518
+ var isFunction_1 = require_isFunction();
1519
+ function hasLift(source) {
1520
+ return isFunction_1.isFunction(source === null || source === void 0 ? void 0 : source.lift);
1521
+ }
1522
+ exports.hasLift = hasLift;
1523
+ function operate(init) {
1524
+ return function(source) {
1525
+ if (hasLift(source)) {
1526
+ return source.lift(function(liftedSource) {
1527
+ try {
1528
+ return init(liftedSource, this);
1529
+ } catch (err) {
1530
+ this.error(err);
1531
+ }
1532
+ });
1533
+ }
1534
+ throw new TypeError("Unable to lift unknown Observable type");
1535
+ };
1536
+ }
1537
+ exports.operate = operate;
1538
+ }
1539
+ });
1540
+
1541
+ // node_modules/rxjs/dist/cjs/internal/operators/OperatorSubscriber.js
1542
+ var require_OperatorSubscriber = __commonJS({
1543
+ "node_modules/rxjs/dist/cjs/internal/operators/OperatorSubscriber.js"(exports) {
1544
+ "use strict";
1545
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
1546
+ var extendStatics = function(d, b) {
1547
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
1548
+ d2.__proto__ = b2;
1549
+ } || function(d2, b2) {
1550
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
1551
+ };
1552
+ return extendStatics(d, b);
1553
+ };
1554
+ return function(d, b) {
1555
+ if (typeof b !== "function" && b !== null)
1556
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
1557
+ extendStatics(d, b);
1558
+ function __() {
1559
+ this.constructor = d;
1560
+ }
1561
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
1562
+ };
1563
+ })();
1564
+ Object.defineProperty(exports, "__esModule", { value: true });
1565
+ exports.OperatorSubscriber = exports.createOperatorSubscriber = void 0;
1566
+ var Subscriber_1 = require_Subscriber();
1567
+ function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
1568
+ return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
1569
+ }
1570
+ exports.createOperatorSubscriber = createOperatorSubscriber;
1571
+ var OperatorSubscriber = (function(_super) {
1572
+ __extends(OperatorSubscriber2, _super);
1573
+ function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
1574
+ var _this = _super.call(this, destination) || this;
1575
+ _this.onFinalize = onFinalize;
1576
+ _this.shouldUnsubscribe = shouldUnsubscribe;
1577
+ _this._next = onNext ? function(value) {
1578
+ try {
1579
+ onNext(value);
1580
+ } catch (err) {
1581
+ destination.error(err);
1582
+ }
1583
+ } : _super.prototype._next;
1584
+ _this._error = onError ? function(err) {
1585
+ try {
1586
+ onError(err);
1587
+ } catch (err2) {
1588
+ destination.error(err2);
1589
+ } finally {
1590
+ this.unsubscribe();
1591
+ }
1592
+ } : _super.prototype._error;
1593
+ _this._complete = onComplete ? function() {
1594
+ try {
1595
+ onComplete();
1596
+ } catch (err) {
1597
+ destination.error(err);
1598
+ } finally {
1599
+ this.unsubscribe();
1600
+ }
1601
+ } : _super.prototype._complete;
1602
+ return _this;
1603
+ }
1604
+ OperatorSubscriber2.prototype.unsubscribe = function() {
1605
+ var _a;
1606
+ if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
1607
+ var closed_1 = this.closed;
1608
+ _super.prototype.unsubscribe.call(this);
1609
+ !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
1610
+ }
1611
+ };
1612
+ return OperatorSubscriber2;
1613
+ })(Subscriber_1.Subscriber);
1614
+ exports.OperatorSubscriber = OperatorSubscriber;
1615
+ }
1616
+ });
1617
+
1618
+ // node_modules/rxjs/dist/cjs/internal/operators/observeOn.js
1619
+ var require_observeOn = __commonJS({
1620
+ "node_modules/rxjs/dist/cjs/internal/operators/observeOn.js"(exports) {
1621
+ "use strict";
1622
+ Object.defineProperty(exports, "__esModule", { value: true });
1623
+ exports.observeOn = void 0;
1624
+ var executeSchedule_1 = require_executeSchedule();
1625
+ var lift_1 = require_lift();
1626
+ var OperatorSubscriber_1 = require_OperatorSubscriber();
1627
+ function observeOn(scheduler, delay) {
1628
+ if (delay === void 0) {
1629
+ delay = 0;
1630
+ }
1631
+ return lift_1.operate(function(source, subscriber) {
1632
+ source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(value) {
1633
+ return executeSchedule_1.executeSchedule(subscriber, scheduler, function() {
1634
+ return subscriber.next(value);
1635
+ }, delay);
1636
+ }, function() {
1637
+ return executeSchedule_1.executeSchedule(subscriber, scheduler, function() {
1638
+ return subscriber.complete();
1639
+ }, delay);
1640
+ }, function(err) {
1641
+ return executeSchedule_1.executeSchedule(subscriber, scheduler, function() {
1642
+ return subscriber.error(err);
1643
+ }, delay);
1644
+ }));
1645
+ });
1646
+ }
1647
+ exports.observeOn = observeOn;
1648
+ }
1649
+ });
1650
+
1651
+ // node_modules/rxjs/dist/cjs/internal/operators/subscribeOn.js
1652
+ var require_subscribeOn = __commonJS({
1653
+ "node_modules/rxjs/dist/cjs/internal/operators/subscribeOn.js"(exports) {
1654
+ "use strict";
1655
+ Object.defineProperty(exports, "__esModule", { value: true });
1656
+ exports.subscribeOn = void 0;
1657
+ var lift_1 = require_lift();
1658
+ function subscribeOn(scheduler, delay) {
1659
+ if (delay === void 0) {
1660
+ delay = 0;
1661
+ }
1662
+ return lift_1.operate(function(source, subscriber) {
1663
+ subscriber.add(scheduler.schedule(function() {
1664
+ return source.subscribe(subscriber);
1665
+ }, delay));
1666
+ });
1667
+ }
1668
+ exports.subscribeOn = subscribeOn;
1669
+ }
1670
+ });
1671
+
1672
+ // node_modules/rxjs/dist/cjs/internal/scheduled/scheduleObservable.js
1673
+ var require_scheduleObservable = __commonJS({
1674
+ "node_modules/rxjs/dist/cjs/internal/scheduled/scheduleObservable.js"(exports) {
1675
+ "use strict";
1676
+ Object.defineProperty(exports, "__esModule", { value: true });
1677
+ exports.scheduleObservable = void 0;
1678
+ var innerFrom_1 = require_innerFrom();
1679
+ var observeOn_1 = require_observeOn();
1680
+ var subscribeOn_1 = require_subscribeOn();
1681
+ function scheduleObservable(input, scheduler) {
1682
+ return innerFrom_1.innerFrom(input).pipe(subscribeOn_1.subscribeOn(scheduler), observeOn_1.observeOn(scheduler));
1683
+ }
1684
+ exports.scheduleObservable = scheduleObservable;
1685
+ }
1686
+ });
1687
+
1688
+ // node_modules/rxjs/dist/cjs/internal/scheduled/schedulePromise.js
1689
+ var require_schedulePromise = __commonJS({
1690
+ "node_modules/rxjs/dist/cjs/internal/scheduled/schedulePromise.js"(exports) {
1691
+ "use strict";
1692
+ Object.defineProperty(exports, "__esModule", { value: true });
1693
+ exports.schedulePromise = void 0;
1694
+ var innerFrom_1 = require_innerFrom();
1695
+ var observeOn_1 = require_observeOn();
1696
+ var subscribeOn_1 = require_subscribeOn();
1697
+ function schedulePromise(input, scheduler) {
1698
+ return innerFrom_1.innerFrom(input).pipe(subscribeOn_1.subscribeOn(scheduler), observeOn_1.observeOn(scheduler));
1699
+ }
1700
+ exports.schedulePromise = schedulePromise;
1701
+ }
1702
+ });
1703
+
1704
+ // node_modules/rxjs/dist/cjs/internal/scheduled/scheduleArray.js
1705
+ var require_scheduleArray = __commonJS({
1706
+ "node_modules/rxjs/dist/cjs/internal/scheduled/scheduleArray.js"(exports) {
1707
+ "use strict";
1708
+ Object.defineProperty(exports, "__esModule", { value: true });
1709
+ exports.scheduleArray = void 0;
1710
+ var Observable_1 = require_Observable();
1711
+ function scheduleArray(input, scheduler) {
1712
+ return new Observable_1.Observable(function(subscriber) {
1713
+ var i = 0;
1714
+ return scheduler.schedule(function() {
1715
+ if (i === input.length) {
1716
+ subscriber.complete();
1717
+ } else {
1718
+ subscriber.next(input[i++]);
1719
+ if (!subscriber.closed) {
1720
+ this.schedule();
1721
+ }
1722
+ }
1723
+ });
1724
+ });
1725
+ }
1726
+ exports.scheduleArray = scheduleArray;
1727
+ }
1728
+ });
1729
+
1730
+ // node_modules/rxjs/dist/cjs/internal/scheduled/scheduleIterable.js
1731
+ var require_scheduleIterable = __commonJS({
1732
+ "node_modules/rxjs/dist/cjs/internal/scheduled/scheduleIterable.js"(exports) {
1733
+ "use strict";
1734
+ Object.defineProperty(exports, "__esModule", { value: true });
1735
+ exports.scheduleIterable = void 0;
1736
+ var Observable_1 = require_Observable();
1737
+ var iterator_1 = require_iterator();
1738
+ var isFunction_1 = require_isFunction();
1739
+ var executeSchedule_1 = require_executeSchedule();
1740
+ function scheduleIterable(input, scheduler) {
1741
+ return new Observable_1.Observable(function(subscriber) {
1742
+ var iterator;
1743
+ executeSchedule_1.executeSchedule(subscriber, scheduler, function() {
1744
+ iterator = input[iterator_1.iterator]();
1745
+ executeSchedule_1.executeSchedule(subscriber, scheduler, function() {
1746
+ var _a;
1747
+ var value;
1748
+ var done;
1749
+ try {
1750
+ _a = iterator.next(), value = _a.value, done = _a.done;
1751
+ } catch (err) {
1752
+ subscriber.error(err);
1753
+ return;
1754
+ }
1755
+ if (done) {
1756
+ subscriber.complete();
1757
+ } else {
1758
+ subscriber.next(value);
1759
+ }
1760
+ }, 0, true);
1761
+ });
1762
+ return function() {
1763
+ return isFunction_1.isFunction(iterator === null || iterator === void 0 ? void 0 : iterator.return) && iterator.return();
1764
+ };
1765
+ });
1766
+ }
1767
+ exports.scheduleIterable = scheduleIterable;
1768
+ }
1769
+ });
1770
+
1771
+ // node_modules/rxjs/dist/cjs/internal/scheduled/scheduleAsyncIterable.js
1772
+ var require_scheduleAsyncIterable = __commonJS({
1773
+ "node_modules/rxjs/dist/cjs/internal/scheduled/scheduleAsyncIterable.js"(exports) {
1774
+ "use strict";
1775
+ Object.defineProperty(exports, "__esModule", { value: true });
1776
+ exports.scheduleAsyncIterable = void 0;
1777
+ var Observable_1 = require_Observable();
1778
+ var executeSchedule_1 = require_executeSchedule();
1779
+ function scheduleAsyncIterable(input, scheduler) {
1780
+ if (!input) {
1781
+ throw new Error("Iterable cannot be null");
1782
+ }
1783
+ return new Observable_1.Observable(function(subscriber) {
1784
+ executeSchedule_1.executeSchedule(subscriber, scheduler, function() {
1785
+ var iterator = input[Symbol.asyncIterator]();
1786
+ executeSchedule_1.executeSchedule(subscriber, scheduler, function() {
1787
+ iterator.next().then(function(result) {
1788
+ if (result.done) {
1789
+ subscriber.complete();
1790
+ } else {
1791
+ subscriber.next(result.value);
1792
+ }
1793
+ });
1794
+ }, 0, true);
1795
+ });
1796
+ });
1797
+ }
1798
+ exports.scheduleAsyncIterable = scheduleAsyncIterable;
1799
+ }
1800
+ });
1801
+
1802
+ // node_modules/rxjs/dist/cjs/internal/scheduled/scheduleReadableStreamLike.js
1803
+ var require_scheduleReadableStreamLike = __commonJS({
1804
+ "node_modules/rxjs/dist/cjs/internal/scheduled/scheduleReadableStreamLike.js"(exports) {
1805
+ "use strict";
1806
+ Object.defineProperty(exports, "__esModule", { value: true });
1807
+ exports.scheduleReadableStreamLike = void 0;
1808
+ var scheduleAsyncIterable_1 = require_scheduleAsyncIterable();
1809
+ var isReadableStreamLike_1 = require_isReadableStreamLike();
1810
+ function scheduleReadableStreamLike(input, scheduler) {
1811
+ return scheduleAsyncIterable_1.scheduleAsyncIterable(isReadableStreamLike_1.readableStreamLikeToAsyncGenerator(input), scheduler);
1812
+ }
1813
+ exports.scheduleReadableStreamLike = scheduleReadableStreamLike;
1814
+ }
1815
+ });
1816
+
1817
+ // node_modules/rxjs/dist/cjs/internal/scheduled/scheduled.js
1818
+ var require_scheduled = __commonJS({
1819
+ "node_modules/rxjs/dist/cjs/internal/scheduled/scheduled.js"(exports) {
1820
+ "use strict";
1821
+ Object.defineProperty(exports, "__esModule", { value: true });
1822
+ exports.scheduled = void 0;
1823
+ var scheduleObservable_1 = require_scheduleObservable();
1824
+ var schedulePromise_1 = require_schedulePromise();
1825
+ var scheduleArray_1 = require_scheduleArray();
1826
+ var scheduleIterable_1 = require_scheduleIterable();
1827
+ var scheduleAsyncIterable_1 = require_scheduleAsyncIterable();
1828
+ var isInteropObservable_1 = require_isInteropObservable();
1829
+ var isPromise_1 = require_isPromise();
1830
+ var isArrayLike_1 = require_isArrayLike();
1831
+ var isIterable_1 = require_isIterable();
1832
+ var isAsyncIterable_1 = require_isAsyncIterable();
1833
+ var throwUnobservableError_1 = require_throwUnobservableError();
1834
+ var isReadableStreamLike_1 = require_isReadableStreamLike();
1835
+ var scheduleReadableStreamLike_1 = require_scheduleReadableStreamLike();
1836
+ function scheduled(input, scheduler) {
1837
+ if (input != null) {
1838
+ if (isInteropObservable_1.isInteropObservable(input)) {
1839
+ return scheduleObservable_1.scheduleObservable(input, scheduler);
1840
+ }
1841
+ if (isArrayLike_1.isArrayLike(input)) {
1842
+ return scheduleArray_1.scheduleArray(input, scheduler);
1843
+ }
1844
+ if (isPromise_1.isPromise(input)) {
1845
+ return schedulePromise_1.schedulePromise(input, scheduler);
1846
+ }
1847
+ if (isAsyncIterable_1.isAsyncIterable(input)) {
1848
+ return scheduleAsyncIterable_1.scheduleAsyncIterable(input, scheduler);
1849
+ }
1850
+ if (isIterable_1.isIterable(input)) {
1851
+ return scheduleIterable_1.scheduleIterable(input, scheduler);
1852
+ }
1853
+ if (isReadableStreamLike_1.isReadableStreamLike(input)) {
1854
+ return scheduleReadableStreamLike_1.scheduleReadableStreamLike(input, scheduler);
1855
+ }
1856
+ }
1857
+ throw throwUnobservableError_1.createInvalidObservableTypeError(input);
1858
+ }
1859
+ exports.scheduled = scheduled;
1860
+ }
1861
+ });
1862
+
1863
+ // node_modules/rxjs/dist/cjs/internal/observable/from.js
1864
+ var require_from = __commonJS({
1865
+ "node_modules/rxjs/dist/cjs/internal/observable/from.js"(exports) {
1866
+ "use strict";
1867
+ Object.defineProperty(exports, "__esModule", { value: true });
1868
+ exports.from = void 0;
1869
+ var scheduled_1 = require_scheduled();
1870
+ var innerFrom_1 = require_innerFrom();
1871
+ function from(input, scheduler) {
1872
+ return scheduler ? scheduled_1.scheduled(input, scheduler) : innerFrom_1.innerFrom(input);
1873
+ }
1874
+ exports.from = from;
1875
+ }
1876
+ });
1877
+
1878
+ // node_modules/rxjs/dist/cjs/internal/observable/of.js
1879
+ var require_of = __commonJS({
1880
+ "node_modules/rxjs/dist/cjs/internal/observable/of.js"(exports) {
1881
+ "use strict";
1882
+ Object.defineProperty(exports, "__esModule", { value: true });
1883
+ exports.of = void 0;
1884
+ var args_1 = require_args();
1885
+ var from_1 = require_from();
1886
+ function of() {
1887
+ var args = [];
1888
+ for (var _i = 0; _i < arguments.length; _i++) {
1889
+ args[_i] = arguments[_i];
1890
+ }
1891
+ var scheduler = args_1.popScheduler(args);
1892
+ return from_1.from(args, scheduler);
1893
+ }
1894
+ exports.of = of;
1895
+ }
1896
+ });
1897
+
1898
+ // node_modules/rxjs/dist/cjs/internal/observable/throwError.js
1899
+ var require_throwError = __commonJS({
1900
+ "node_modules/rxjs/dist/cjs/internal/observable/throwError.js"(exports) {
1901
+ "use strict";
1902
+ Object.defineProperty(exports, "__esModule", { value: true });
1903
+ exports.throwError = void 0;
1904
+ var Observable_1 = require_Observable();
1905
+ var isFunction_1 = require_isFunction();
1906
+ function throwError(errorOrErrorFactory, scheduler) {
1907
+ var errorFactory = isFunction_1.isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function() {
1908
+ return errorOrErrorFactory;
1909
+ };
1910
+ var init = function(subscriber) {
1911
+ return subscriber.error(errorFactory());
1912
+ };
1913
+ return new Observable_1.Observable(scheduler ? function(subscriber) {
1914
+ return scheduler.schedule(init, 0, subscriber);
1915
+ } : init);
1916
+ }
1917
+ exports.throwError = throwError;
1918
+ }
1919
+ });
1920
+
1921
+ // node_modules/rxjs/dist/cjs/internal/Notification.js
1922
+ var require_Notification = __commonJS({
1923
+ "node_modules/rxjs/dist/cjs/internal/Notification.js"(exports) {
1924
+ "use strict";
1925
+ Object.defineProperty(exports, "__esModule", { value: true });
1926
+ exports.observeNotification = exports.Notification = exports.NotificationKind = void 0;
1927
+ var empty_1 = require_empty();
1928
+ var of_1 = require_of();
1929
+ var throwError_1 = require_throwError();
1930
+ var isFunction_1 = require_isFunction();
1931
+ var NotificationKind;
1932
+ (function(NotificationKind2) {
1933
+ NotificationKind2["NEXT"] = "N";
1934
+ NotificationKind2["ERROR"] = "E";
1935
+ NotificationKind2["COMPLETE"] = "C";
1936
+ })(NotificationKind = exports.NotificationKind || (exports.NotificationKind = {}));
1937
+ var Notification = (function() {
1938
+ function Notification2(kind, value, error) {
1939
+ this.kind = kind;
1940
+ this.value = value;
1941
+ this.error = error;
1942
+ this.hasValue = kind === "N";
1943
+ }
1944
+ Notification2.prototype.observe = function(observer) {
1945
+ return observeNotification(this, observer);
1946
+ };
1947
+ Notification2.prototype.do = function(nextHandler, errorHandler, completeHandler) {
1948
+ var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
1949
+ return kind === "N" ? nextHandler === null || nextHandler === void 0 ? void 0 : nextHandler(value) : kind === "E" ? errorHandler === null || errorHandler === void 0 ? void 0 : errorHandler(error) : completeHandler === null || completeHandler === void 0 ? void 0 : completeHandler();
1950
+ };
1951
+ Notification2.prototype.accept = function(nextOrObserver, error, complete) {
1952
+ var _a;
1953
+ return isFunction_1.isFunction((_a = nextOrObserver) === null || _a === void 0 ? void 0 : _a.next) ? this.observe(nextOrObserver) : this.do(nextOrObserver, error, complete);
1954
+ };
1955
+ Notification2.prototype.toObservable = function() {
1956
+ var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
1957
+ var result = kind === "N" ? of_1.of(value) : kind === "E" ? throwError_1.throwError(function() {
1958
+ return error;
1959
+ }) : kind === "C" ? empty_1.EMPTY : 0;
1960
+ if (!result) {
1961
+ throw new TypeError("Unexpected notification kind " + kind);
1962
+ }
1963
+ return result;
1964
+ };
1965
+ Notification2.createNext = function(value) {
1966
+ return new Notification2("N", value);
1967
+ };
1968
+ Notification2.createError = function(err) {
1969
+ return new Notification2("E", void 0, err);
1970
+ };
1971
+ Notification2.createComplete = function() {
1972
+ return Notification2.completeNotification;
1973
+ };
1974
+ Notification2.completeNotification = new Notification2("C");
1975
+ return Notification2;
1976
+ })();
1977
+ exports.Notification = Notification;
1978
+ function observeNotification(notification, observer) {
1979
+ var _a, _b, _c;
1980
+ var _d = notification, kind = _d.kind, value = _d.value, error = _d.error;
1981
+ if (typeof kind !== "string") {
1982
+ throw new TypeError('Invalid notification, missing "kind"');
1983
+ }
1984
+ kind === "N" ? (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, value) : kind === "E" ? (_b = observer.error) === null || _b === void 0 ? void 0 : _b.call(observer, error) : (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);
1985
+ }
1986
+ exports.observeNotification = observeNotification;
1987
+ }
1988
+ });
1989
+
1990
+ // node_modules/rxjs/dist/cjs/internal/testing/ColdObservable.js
1991
+ var require_ColdObservable = __commonJS({
1992
+ "node_modules/rxjs/dist/cjs/internal/testing/ColdObservable.js"(exports) {
1993
+ "use strict";
1994
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
1995
+ var extendStatics = function(d, b) {
1996
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
1997
+ d2.__proto__ = b2;
1998
+ } || function(d2, b2) {
1999
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2000
+ };
2001
+ return extendStatics(d, b);
2002
+ };
2003
+ return function(d, b) {
2004
+ if (typeof b !== "function" && b !== null)
2005
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2006
+ extendStatics(d, b);
2007
+ function __() {
2008
+ this.constructor = d;
2009
+ }
2010
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2011
+ };
2012
+ })();
2013
+ Object.defineProperty(exports, "__esModule", { value: true });
2014
+ exports.ColdObservable = void 0;
2015
+ var Observable_1 = require_Observable();
2016
+ var Subscription_1 = require_Subscription();
2017
+ var SubscriptionLoggable_1 = require_SubscriptionLoggable();
2018
+ var applyMixins_1 = require_applyMixins();
2019
+ var Notification_1 = require_Notification();
2020
+ var ColdObservable = (function(_super) {
2021
+ __extends(ColdObservable2, _super);
2022
+ function ColdObservable2(messages, scheduler) {
2023
+ var _this = _super.call(this, function(subscriber) {
2024
+ var observable = this;
2025
+ var index = observable.logSubscribedFrame();
2026
+ var subscription = new Subscription_1.Subscription();
2027
+ subscription.add(new Subscription_1.Subscription(function() {
2028
+ observable.logUnsubscribedFrame(index);
2029
+ }));
2030
+ observable.scheduleMessages(subscriber);
2031
+ return subscription;
2032
+ }) || this;
2033
+ _this.messages = messages;
2034
+ _this.subscriptions = [];
2035
+ _this.scheduler = scheduler;
2036
+ return _this;
2037
+ }
2038
+ ColdObservable2.prototype.scheduleMessages = function(subscriber) {
2039
+ var messagesLength = this.messages.length;
2040
+ for (var i = 0; i < messagesLength; i++) {
2041
+ var message = this.messages[i];
2042
+ subscriber.add(this.scheduler.schedule(function(state) {
2043
+ var _a = state, notification = _a.message.notification, destination = _a.subscriber;
2044
+ Notification_1.observeNotification(notification, destination);
2045
+ }, message.frame, { message, subscriber }));
2046
+ }
2047
+ };
2048
+ return ColdObservable2;
2049
+ })(Observable_1.Observable);
2050
+ exports.ColdObservable = ColdObservable;
2051
+ applyMixins_1.applyMixins(ColdObservable, [SubscriptionLoggable_1.SubscriptionLoggable]);
2052
+ }
2053
+ });
2054
+
2055
+ // node_modules/rxjs/dist/cjs/internal/util/ObjectUnsubscribedError.js
2056
+ var require_ObjectUnsubscribedError = __commonJS({
2057
+ "node_modules/rxjs/dist/cjs/internal/util/ObjectUnsubscribedError.js"(exports) {
2058
+ "use strict";
2059
+ Object.defineProperty(exports, "__esModule", { value: true });
2060
+ exports.ObjectUnsubscribedError = void 0;
2061
+ var createErrorClass_1 = require_createErrorClass();
2062
+ exports.ObjectUnsubscribedError = createErrorClass_1.createErrorClass(function(_super) {
2063
+ return function ObjectUnsubscribedErrorImpl() {
2064
+ _super(this);
2065
+ this.name = "ObjectUnsubscribedError";
2066
+ this.message = "object unsubscribed";
2067
+ };
2068
+ });
2069
+ }
2070
+ });
2071
+
2072
+ // node_modules/rxjs/dist/cjs/internal/Subject.js
2073
+ var require_Subject = __commonJS({
2074
+ "node_modules/rxjs/dist/cjs/internal/Subject.js"(exports) {
2075
+ "use strict";
2076
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
2077
+ var extendStatics = function(d, b) {
2078
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
2079
+ d2.__proto__ = b2;
2080
+ } || function(d2, b2) {
2081
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2082
+ };
2083
+ return extendStatics(d, b);
2084
+ };
2085
+ return function(d, b) {
2086
+ if (typeof b !== "function" && b !== null)
2087
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2088
+ extendStatics(d, b);
2089
+ function __() {
2090
+ this.constructor = d;
2091
+ }
2092
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2093
+ };
2094
+ })();
2095
+ var __values = exports && exports.__values || function(o) {
2096
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
2097
+ if (m) return m.call(o);
2098
+ if (o && typeof o.length === "number") return {
2099
+ next: function() {
2100
+ if (o && i >= o.length) o = void 0;
2101
+ return { value: o && o[i++], done: !o };
2102
+ }
2103
+ };
2104
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
2105
+ };
2106
+ Object.defineProperty(exports, "__esModule", { value: true });
2107
+ exports.AnonymousSubject = exports.Subject = void 0;
2108
+ var Observable_1 = require_Observable();
2109
+ var Subscription_1 = require_Subscription();
2110
+ var ObjectUnsubscribedError_1 = require_ObjectUnsubscribedError();
2111
+ var arrRemove_1 = require_arrRemove();
2112
+ var errorContext_1 = require_errorContext();
2113
+ var Subject = (function(_super) {
2114
+ __extends(Subject2, _super);
2115
+ function Subject2() {
2116
+ var _this = _super.call(this) || this;
2117
+ _this.closed = false;
2118
+ _this.currentObservers = null;
2119
+ _this.observers = [];
2120
+ _this.isStopped = false;
2121
+ _this.hasError = false;
2122
+ _this.thrownError = null;
2123
+ return _this;
2124
+ }
2125
+ Subject2.prototype.lift = function(operator) {
2126
+ var subject = new AnonymousSubject(this, this);
2127
+ subject.operator = operator;
2128
+ return subject;
2129
+ };
2130
+ Subject2.prototype._throwIfClosed = function() {
2131
+ if (this.closed) {
2132
+ throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();
2133
+ }
2134
+ };
2135
+ Subject2.prototype.next = function(value) {
2136
+ var _this = this;
2137
+ errorContext_1.errorContext(function() {
2138
+ var e_1, _a;
2139
+ _this._throwIfClosed();
2140
+ if (!_this.isStopped) {
2141
+ if (!_this.currentObservers) {
2142
+ _this.currentObservers = Array.from(_this.observers);
2143
+ }
2144
+ try {
2145
+ for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
2146
+ var observer = _c.value;
2147
+ observer.next(value);
2148
+ }
2149
+ } catch (e_1_1) {
2150
+ e_1 = { error: e_1_1 };
2151
+ } finally {
2152
+ try {
2153
+ if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
2154
+ } finally {
2155
+ if (e_1) throw e_1.error;
2156
+ }
2157
+ }
2158
+ }
2159
+ });
2160
+ };
2161
+ Subject2.prototype.error = function(err) {
2162
+ var _this = this;
2163
+ errorContext_1.errorContext(function() {
2164
+ _this._throwIfClosed();
2165
+ if (!_this.isStopped) {
2166
+ _this.hasError = _this.isStopped = true;
2167
+ _this.thrownError = err;
2168
+ var observers = _this.observers;
2169
+ while (observers.length) {
2170
+ observers.shift().error(err);
2171
+ }
2172
+ }
2173
+ });
2174
+ };
2175
+ Subject2.prototype.complete = function() {
2176
+ var _this = this;
2177
+ errorContext_1.errorContext(function() {
2178
+ _this._throwIfClosed();
2179
+ if (!_this.isStopped) {
2180
+ _this.isStopped = true;
2181
+ var observers = _this.observers;
2182
+ while (observers.length) {
2183
+ observers.shift().complete();
2184
+ }
2185
+ }
2186
+ });
2187
+ };
2188
+ Subject2.prototype.unsubscribe = function() {
2189
+ this.isStopped = this.closed = true;
2190
+ this.observers = this.currentObservers = null;
2191
+ };
2192
+ Object.defineProperty(Subject2.prototype, "observed", {
2193
+ get: function() {
2194
+ var _a;
2195
+ return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
2196
+ },
2197
+ enumerable: false,
2198
+ configurable: true
2199
+ });
2200
+ Subject2.prototype._trySubscribe = function(subscriber) {
2201
+ this._throwIfClosed();
2202
+ return _super.prototype._trySubscribe.call(this, subscriber);
2203
+ };
2204
+ Subject2.prototype._subscribe = function(subscriber) {
2205
+ this._throwIfClosed();
2206
+ this._checkFinalizedStatuses(subscriber);
2207
+ return this._innerSubscribe(subscriber);
2208
+ };
2209
+ Subject2.prototype._innerSubscribe = function(subscriber) {
2210
+ var _this = this;
2211
+ var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
2212
+ if (hasError || isStopped) {
2213
+ return Subscription_1.EMPTY_SUBSCRIPTION;
2214
+ }
2215
+ this.currentObservers = null;
2216
+ observers.push(subscriber);
2217
+ return new Subscription_1.Subscription(function() {
2218
+ _this.currentObservers = null;
2219
+ arrRemove_1.arrRemove(observers, subscriber);
2220
+ });
2221
+ };
2222
+ Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
2223
+ var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
2224
+ if (hasError) {
2225
+ subscriber.error(thrownError);
2226
+ } else if (isStopped) {
2227
+ subscriber.complete();
2228
+ }
2229
+ };
2230
+ Subject2.prototype.asObservable = function() {
2231
+ var observable = new Observable_1.Observable();
2232
+ observable.source = this;
2233
+ return observable;
2234
+ };
2235
+ Subject2.create = function(destination, source) {
2236
+ return new AnonymousSubject(destination, source);
2237
+ };
2238
+ return Subject2;
2239
+ })(Observable_1.Observable);
2240
+ exports.Subject = Subject;
2241
+ var AnonymousSubject = (function(_super) {
2242
+ __extends(AnonymousSubject2, _super);
2243
+ function AnonymousSubject2(destination, source) {
2244
+ var _this = _super.call(this) || this;
2245
+ _this.destination = destination;
2246
+ _this.source = source;
2247
+ return _this;
2248
+ }
2249
+ AnonymousSubject2.prototype.next = function(value) {
2250
+ var _a, _b;
2251
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
2252
+ };
2253
+ AnonymousSubject2.prototype.error = function(err) {
2254
+ var _a, _b;
2255
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
2256
+ };
2257
+ AnonymousSubject2.prototype.complete = function() {
2258
+ var _a, _b;
2259
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
2260
+ };
2261
+ AnonymousSubject2.prototype._subscribe = function(subscriber) {
2262
+ var _a, _b;
2263
+ return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : Subscription_1.EMPTY_SUBSCRIPTION;
2264
+ };
2265
+ return AnonymousSubject2;
2266
+ })(Subject);
2267
+ exports.AnonymousSubject = AnonymousSubject;
2268
+ }
2269
+ });
2270
+
2271
+ // node_modules/rxjs/dist/cjs/internal/testing/HotObservable.js
2272
+ var require_HotObservable = __commonJS({
2273
+ "node_modules/rxjs/dist/cjs/internal/testing/HotObservable.js"(exports) {
2274
+ "use strict";
2275
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
2276
+ var extendStatics = function(d, b) {
2277
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
2278
+ d2.__proto__ = b2;
2279
+ } || function(d2, b2) {
2280
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2281
+ };
2282
+ return extendStatics(d, b);
2283
+ };
2284
+ return function(d, b) {
2285
+ if (typeof b !== "function" && b !== null)
2286
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2287
+ extendStatics(d, b);
2288
+ function __() {
2289
+ this.constructor = d;
2290
+ }
2291
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2292
+ };
2293
+ })();
2294
+ Object.defineProperty(exports, "__esModule", { value: true });
2295
+ exports.HotObservable = void 0;
2296
+ var Subject_1 = require_Subject();
2297
+ var Subscription_1 = require_Subscription();
2298
+ var SubscriptionLoggable_1 = require_SubscriptionLoggable();
2299
+ var applyMixins_1 = require_applyMixins();
2300
+ var Notification_1 = require_Notification();
2301
+ var HotObservable = (function(_super) {
2302
+ __extends(HotObservable2, _super);
2303
+ function HotObservable2(messages, scheduler) {
2304
+ var _this = _super.call(this) || this;
2305
+ _this.messages = messages;
2306
+ _this.subscriptions = [];
2307
+ _this.scheduler = scheduler;
2308
+ return _this;
2309
+ }
2310
+ HotObservable2.prototype._subscribe = function(subscriber) {
2311
+ var subject = this;
2312
+ var index = subject.logSubscribedFrame();
2313
+ var subscription = new Subscription_1.Subscription();
2314
+ subscription.add(new Subscription_1.Subscription(function() {
2315
+ subject.logUnsubscribedFrame(index);
2316
+ }));
2317
+ subscription.add(_super.prototype._subscribe.call(this, subscriber));
2318
+ return subscription;
2319
+ };
2320
+ HotObservable2.prototype.setup = function() {
2321
+ var subject = this;
2322
+ var messagesLength = subject.messages.length;
2323
+ var _loop_1 = function(i2) {
2324
+ (function() {
2325
+ var _a = subject.messages[i2], notification = _a.notification, frame = _a.frame;
2326
+ subject.scheduler.schedule(function() {
2327
+ Notification_1.observeNotification(notification, subject);
2328
+ }, frame);
2329
+ })();
2330
+ };
2331
+ for (var i = 0; i < messagesLength; i++) {
2332
+ _loop_1(i);
2333
+ }
2334
+ };
2335
+ return HotObservable2;
2336
+ })(Subject_1.Subject);
2337
+ exports.HotObservable = HotObservable;
2338
+ applyMixins_1.applyMixins(HotObservable, [SubscriptionLoggable_1.SubscriptionLoggable]);
2339
+ }
2340
+ });
2341
+
2342
+ // node_modules/rxjs/dist/cjs/internal/scheduler/Action.js
2343
+ var require_Action = __commonJS({
2344
+ "node_modules/rxjs/dist/cjs/internal/scheduler/Action.js"(exports) {
2345
+ "use strict";
2346
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
2347
+ var extendStatics = function(d, b) {
2348
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
2349
+ d2.__proto__ = b2;
2350
+ } || function(d2, b2) {
2351
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2352
+ };
2353
+ return extendStatics(d, b);
2354
+ };
2355
+ return function(d, b) {
2356
+ if (typeof b !== "function" && b !== null)
2357
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2358
+ extendStatics(d, b);
2359
+ function __() {
2360
+ this.constructor = d;
2361
+ }
2362
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2363
+ };
2364
+ })();
2365
+ Object.defineProperty(exports, "__esModule", { value: true });
2366
+ exports.Action = void 0;
2367
+ var Subscription_1 = require_Subscription();
2368
+ var Action = (function(_super) {
2369
+ __extends(Action2, _super);
2370
+ function Action2(scheduler, work) {
2371
+ return _super.call(this) || this;
2372
+ }
2373
+ Action2.prototype.schedule = function(state, delay) {
2374
+ if (delay === void 0) {
2375
+ delay = 0;
2376
+ }
2377
+ return this;
2378
+ };
2379
+ return Action2;
2380
+ })(Subscription_1.Subscription);
2381
+ exports.Action = Action;
2382
+ }
2383
+ });
2384
+
2385
+ // node_modules/rxjs/dist/cjs/internal/scheduler/intervalProvider.js
2386
+ var require_intervalProvider = __commonJS({
2387
+ "node_modules/rxjs/dist/cjs/internal/scheduler/intervalProvider.js"(exports) {
2388
+ "use strict";
2389
+ var __read = exports && exports.__read || function(o, n) {
2390
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
2391
+ if (!m) return o;
2392
+ var i = m.call(o), r, ar = [], e;
2393
+ try {
2394
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
2395
+ } catch (error) {
2396
+ e = { error };
2397
+ } finally {
2398
+ try {
2399
+ if (r && !r.done && (m = i["return"])) m.call(i);
2400
+ } finally {
2401
+ if (e) throw e.error;
2402
+ }
2403
+ }
2404
+ return ar;
2405
+ };
2406
+ var __spreadArray = exports && exports.__spreadArray || function(to, from) {
2407
+ for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
2408
+ to[j] = from[i];
2409
+ return to;
2410
+ };
2411
+ Object.defineProperty(exports, "__esModule", { value: true });
2412
+ exports.intervalProvider = void 0;
2413
+ exports.intervalProvider = {
2414
+ setInterval: function(handler, timeout) {
2415
+ var args = [];
2416
+ for (var _i = 2; _i < arguments.length; _i++) {
2417
+ args[_i - 2] = arguments[_i];
2418
+ }
2419
+ var delegate = exports.intervalProvider.delegate;
2420
+ if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
2421
+ return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout], __read(args)));
2422
+ }
2423
+ return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
2424
+ },
2425
+ clearInterval: function(handle) {
2426
+ var delegate = exports.intervalProvider.delegate;
2427
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
2428
+ },
2429
+ delegate: void 0
2430
+ };
2431
+ }
2432
+ });
2433
+
2434
+ // node_modules/rxjs/dist/cjs/internal/scheduler/AsyncAction.js
2435
+ var require_AsyncAction = __commonJS({
2436
+ "node_modules/rxjs/dist/cjs/internal/scheduler/AsyncAction.js"(exports) {
2437
+ "use strict";
2438
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
2439
+ var extendStatics = function(d, b) {
2440
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
2441
+ d2.__proto__ = b2;
2442
+ } || function(d2, b2) {
2443
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2444
+ };
2445
+ return extendStatics(d, b);
2446
+ };
2447
+ return function(d, b) {
2448
+ if (typeof b !== "function" && b !== null)
2449
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2450
+ extendStatics(d, b);
2451
+ function __() {
2452
+ this.constructor = d;
2453
+ }
2454
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2455
+ };
2456
+ })();
2457
+ Object.defineProperty(exports, "__esModule", { value: true });
2458
+ exports.AsyncAction = void 0;
2459
+ var Action_1 = require_Action();
2460
+ var intervalProvider_1 = require_intervalProvider();
2461
+ var arrRemove_1 = require_arrRemove();
2462
+ var AsyncAction = (function(_super) {
2463
+ __extends(AsyncAction2, _super);
2464
+ function AsyncAction2(scheduler, work) {
2465
+ var _this = _super.call(this, scheduler, work) || this;
2466
+ _this.scheduler = scheduler;
2467
+ _this.work = work;
2468
+ _this.pending = false;
2469
+ return _this;
2470
+ }
2471
+ AsyncAction2.prototype.schedule = function(state, delay) {
2472
+ var _a;
2473
+ if (delay === void 0) {
2474
+ delay = 0;
2475
+ }
2476
+ if (this.closed) {
2477
+ return this;
2478
+ }
2479
+ this.state = state;
2480
+ var id = this.id;
2481
+ var scheduler = this.scheduler;
2482
+ if (id != null) {
2483
+ this.id = this.recycleAsyncId(scheduler, id, delay);
2484
+ }
2485
+ this.pending = true;
2486
+ this.delay = delay;
2487
+ this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
2488
+ return this;
2489
+ };
2490
+ AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay) {
2491
+ if (delay === void 0) {
2492
+ delay = 0;
2493
+ }
2494
+ return intervalProvider_1.intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
2495
+ };
2496
+ AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay) {
2497
+ if (delay === void 0) {
2498
+ delay = 0;
2499
+ }
2500
+ if (delay != null && this.delay === delay && this.pending === false) {
2501
+ return id;
2502
+ }
2503
+ if (id != null) {
2504
+ intervalProvider_1.intervalProvider.clearInterval(id);
2505
+ }
2506
+ return void 0;
2507
+ };
2508
+ AsyncAction2.prototype.execute = function(state, delay) {
2509
+ if (this.closed) {
2510
+ return new Error("executing a cancelled action");
2511
+ }
2512
+ this.pending = false;
2513
+ var error = this._execute(state, delay);
2514
+ if (error) {
2515
+ return error;
2516
+ } else if (this.pending === false && this.id != null) {
2517
+ this.id = this.recycleAsyncId(this.scheduler, this.id, null);
2518
+ }
2519
+ };
2520
+ AsyncAction2.prototype._execute = function(state, _delay) {
2521
+ var errored = false;
2522
+ var errorValue;
2523
+ try {
2524
+ this.work(state);
2525
+ } catch (e) {
2526
+ errored = true;
2527
+ errorValue = e ? e : new Error("Scheduled action threw falsy error");
2528
+ }
2529
+ if (errored) {
2530
+ this.unsubscribe();
2531
+ return errorValue;
2532
+ }
2533
+ };
2534
+ AsyncAction2.prototype.unsubscribe = function() {
2535
+ if (!this.closed) {
2536
+ var _a = this, id = _a.id, scheduler = _a.scheduler;
2537
+ var actions = scheduler.actions;
2538
+ this.work = this.state = this.scheduler = null;
2539
+ this.pending = false;
2540
+ arrRemove_1.arrRemove(actions, this);
2541
+ if (id != null) {
2542
+ this.id = this.recycleAsyncId(scheduler, id, null);
2543
+ }
2544
+ this.delay = null;
2545
+ _super.prototype.unsubscribe.call(this);
2546
+ }
2547
+ };
2548
+ return AsyncAction2;
2549
+ })(Action_1.Action);
2550
+ exports.AsyncAction = AsyncAction;
2551
+ }
2552
+ });
2553
+
2554
+ // node_modules/rxjs/dist/cjs/internal/scheduler/dateTimestampProvider.js
2555
+ var require_dateTimestampProvider = __commonJS({
2556
+ "node_modules/rxjs/dist/cjs/internal/scheduler/dateTimestampProvider.js"(exports) {
2557
+ "use strict";
2558
+ Object.defineProperty(exports, "__esModule", { value: true });
2559
+ exports.dateTimestampProvider = void 0;
2560
+ exports.dateTimestampProvider = {
2561
+ now: function() {
2562
+ return (exports.dateTimestampProvider.delegate || Date).now();
2563
+ },
2564
+ delegate: void 0
2565
+ };
2566
+ }
2567
+ });
2568
+
2569
+ // node_modules/rxjs/dist/cjs/internal/Scheduler.js
2570
+ var require_Scheduler = __commonJS({
2571
+ "node_modules/rxjs/dist/cjs/internal/Scheduler.js"(exports) {
2572
+ "use strict";
2573
+ Object.defineProperty(exports, "__esModule", { value: true });
2574
+ exports.Scheduler = void 0;
2575
+ var dateTimestampProvider_1 = require_dateTimestampProvider();
2576
+ var Scheduler2 = (function() {
2577
+ function Scheduler3(schedulerActionCtor, now) {
2578
+ if (now === void 0) {
2579
+ now = Scheduler3.now;
2580
+ }
2581
+ this.schedulerActionCtor = schedulerActionCtor;
2582
+ this.now = now;
2583
+ }
2584
+ Scheduler3.prototype.schedule = function(work, delay, state) {
2585
+ if (delay === void 0) {
2586
+ delay = 0;
2587
+ }
2588
+ return new this.schedulerActionCtor(this, work).schedule(state, delay);
2589
+ };
2590
+ Scheduler3.now = dateTimestampProvider_1.dateTimestampProvider.now;
2591
+ return Scheduler3;
2592
+ })();
2593
+ exports.Scheduler = Scheduler2;
2594
+ }
2595
+ });
2596
+
2597
+ // node_modules/rxjs/dist/cjs/internal/scheduler/AsyncScheduler.js
2598
+ var require_AsyncScheduler = __commonJS({
2599
+ "node_modules/rxjs/dist/cjs/internal/scheduler/AsyncScheduler.js"(exports) {
2600
+ "use strict";
2601
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
2602
+ var extendStatics = function(d, b) {
2603
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
2604
+ d2.__proto__ = b2;
2605
+ } || function(d2, b2) {
2606
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2607
+ };
2608
+ return extendStatics(d, b);
2609
+ };
2610
+ return function(d, b) {
2611
+ if (typeof b !== "function" && b !== null)
2612
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2613
+ extendStatics(d, b);
2614
+ function __() {
2615
+ this.constructor = d;
2616
+ }
2617
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2618
+ };
2619
+ })();
2620
+ Object.defineProperty(exports, "__esModule", { value: true });
2621
+ exports.AsyncScheduler = void 0;
2622
+ var Scheduler_1 = require_Scheduler();
2623
+ var AsyncScheduler = (function(_super) {
2624
+ __extends(AsyncScheduler2, _super);
2625
+ function AsyncScheduler2(SchedulerAction, now) {
2626
+ if (now === void 0) {
2627
+ now = Scheduler_1.Scheduler.now;
2628
+ }
2629
+ var _this = _super.call(this, SchedulerAction, now) || this;
2630
+ _this.actions = [];
2631
+ _this._active = false;
2632
+ return _this;
2633
+ }
2634
+ AsyncScheduler2.prototype.flush = function(action) {
2635
+ var actions = this.actions;
2636
+ if (this._active) {
2637
+ actions.push(action);
2638
+ return;
2639
+ }
2640
+ var error;
2641
+ this._active = true;
2642
+ do {
2643
+ if (error = action.execute(action.state, action.delay)) {
2644
+ break;
2645
+ }
2646
+ } while (action = actions.shift());
2647
+ this._active = false;
2648
+ if (error) {
2649
+ while (action = actions.shift()) {
2650
+ action.unsubscribe();
2651
+ }
2652
+ throw error;
2653
+ }
2654
+ };
2655
+ return AsyncScheduler2;
2656
+ })(Scheduler_1.Scheduler);
2657
+ exports.AsyncScheduler = AsyncScheduler;
2658
+ }
2659
+ });
2660
+
2661
+ // node_modules/rxjs/dist/cjs/internal/scheduler/VirtualTimeScheduler.js
2662
+ var require_VirtualTimeScheduler = __commonJS({
2663
+ "node_modules/rxjs/dist/cjs/internal/scheduler/VirtualTimeScheduler.js"(exports) {
2664
+ "use strict";
2665
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
2666
+ var extendStatics = function(d, b) {
2667
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
2668
+ d2.__proto__ = b2;
2669
+ } || function(d2, b2) {
2670
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2671
+ };
2672
+ return extendStatics(d, b);
2673
+ };
2674
+ return function(d, b) {
2675
+ if (typeof b !== "function" && b !== null)
2676
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2677
+ extendStatics(d, b);
2678
+ function __() {
2679
+ this.constructor = d;
2680
+ }
2681
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2682
+ };
2683
+ })();
2684
+ Object.defineProperty(exports, "__esModule", { value: true });
2685
+ exports.VirtualAction = exports.VirtualTimeScheduler = void 0;
2686
+ var AsyncAction_1 = require_AsyncAction();
2687
+ var Subscription_1 = require_Subscription();
2688
+ var AsyncScheduler_1 = require_AsyncScheduler();
2689
+ var VirtualTimeScheduler = (function(_super) {
2690
+ __extends(VirtualTimeScheduler2, _super);
2691
+ function VirtualTimeScheduler2(schedulerActionCtor, maxFrames) {
2692
+ if (schedulerActionCtor === void 0) {
2693
+ schedulerActionCtor = VirtualAction;
2694
+ }
2695
+ if (maxFrames === void 0) {
2696
+ maxFrames = Infinity;
2697
+ }
2698
+ var _this = _super.call(this, schedulerActionCtor, function() {
2699
+ return _this.frame;
2700
+ }) || this;
2701
+ _this.maxFrames = maxFrames;
2702
+ _this.frame = 0;
2703
+ _this.index = -1;
2704
+ return _this;
2705
+ }
2706
+ VirtualTimeScheduler2.prototype.flush = function() {
2707
+ var _a = this, actions = _a.actions, maxFrames = _a.maxFrames;
2708
+ var error;
2709
+ var action;
2710
+ while ((action = actions[0]) && action.delay <= maxFrames) {
2711
+ actions.shift();
2712
+ this.frame = action.delay;
2713
+ if (error = action.execute(action.state, action.delay)) {
2714
+ break;
2715
+ }
2716
+ }
2717
+ if (error) {
2718
+ while (action = actions.shift()) {
2719
+ action.unsubscribe();
2720
+ }
2721
+ throw error;
2722
+ }
2723
+ };
2724
+ VirtualTimeScheduler2.frameTimeFactor = 10;
2725
+ return VirtualTimeScheduler2;
2726
+ })(AsyncScheduler_1.AsyncScheduler);
2727
+ exports.VirtualTimeScheduler = VirtualTimeScheduler;
2728
+ var VirtualAction = (function(_super) {
2729
+ __extends(VirtualAction2, _super);
2730
+ function VirtualAction2(scheduler, work, index) {
2731
+ if (index === void 0) {
2732
+ index = scheduler.index += 1;
2733
+ }
2734
+ var _this = _super.call(this, scheduler, work) || this;
2735
+ _this.scheduler = scheduler;
2736
+ _this.work = work;
2737
+ _this.index = index;
2738
+ _this.active = true;
2739
+ _this.index = scheduler.index = index;
2740
+ return _this;
2741
+ }
2742
+ VirtualAction2.prototype.schedule = function(state, delay) {
2743
+ if (delay === void 0) {
2744
+ delay = 0;
2745
+ }
2746
+ if (Number.isFinite(delay)) {
2747
+ if (!this.id) {
2748
+ return _super.prototype.schedule.call(this, state, delay);
2749
+ }
2750
+ this.active = false;
2751
+ var action = new VirtualAction2(this.scheduler, this.work);
2752
+ this.add(action);
2753
+ return action.schedule(state, delay);
2754
+ } else {
2755
+ return Subscription_1.Subscription.EMPTY;
2756
+ }
2757
+ };
2758
+ VirtualAction2.prototype.requestAsyncId = function(scheduler, id, delay) {
2759
+ if (delay === void 0) {
2760
+ delay = 0;
2761
+ }
2762
+ this.delay = scheduler.frame + delay;
2763
+ var actions = scheduler.actions;
2764
+ actions.push(this);
2765
+ actions.sort(VirtualAction2.sortActions);
2766
+ return 1;
2767
+ };
2768
+ VirtualAction2.prototype.recycleAsyncId = function(scheduler, id, delay) {
2769
+ if (delay === void 0) {
2770
+ delay = 0;
2771
+ }
2772
+ return void 0;
2773
+ };
2774
+ VirtualAction2.prototype._execute = function(state, delay) {
2775
+ if (this.active === true) {
2776
+ return _super.prototype._execute.call(this, state, delay);
2777
+ }
2778
+ };
2779
+ VirtualAction2.sortActions = function(a, b) {
2780
+ if (a.delay === b.delay) {
2781
+ if (a.index === b.index) {
2782
+ return 0;
2783
+ } else if (a.index > b.index) {
2784
+ return 1;
2785
+ } else {
2786
+ return -1;
2787
+ }
2788
+ } else if (a.delay > b.delay) {
2789
+ return 1;
2790
+ } else {
2791
+ return -1;
2792
+ }
2793
+ };
2794
+ return VirtualAction2;
2795
+ })(AsyncAction_1.AsyncAction);
2796
+ exports.VirtualAction = VirtualAction;
2797
+ }
2798
+ });
2799
+
2800
+ // node_modules/rxjs/dist/cjs/internal/scheduler/performanceTimestampProvider.js
2801
+ var require_performanceTimestampProvider = __commonJS({
2802
+ "node_modules/rxjs/dist/cjs/internal/scheduler/performanceTimestampProvider.js"(exports) {
2803
+ "use strict";
2804
+ Object.defineProperty(exports, "__esModule", { value: true });
2805
+ exports.performanceTimestampProvider = void 0;
2806
+ exports.performanceTimestampProvider = {
2807
+ now: function() {
2808
+ return (exports.performanceTimestampProvider.delegate || performance).now();
2809
+ },
2810
+ delegate: void 0
2811
+ };
2812
+ }
2813
+ });
2814
+
2815
+ // node_modules/rxjs/dist/cjs/internal/scheduler/animationFrameProvider.js
2816
+ var require_animationFrameProvider = __commonJS({
2817
+ "node_modules/rxjs/dist/cjs/internal/scheduler/animationFrameProvider.js"(exports) {
2818
+ "use strict";
2819
+ var __read = exports && exports.__read || function(o, n) {
2820
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
2821
+ if (!m) return o;
2822
+ var i = m.call(o), r, ar = [], e;
2823
+ try {
2824
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
2825
+ } catch (error) {
2826
+ e = { error };
2827
+ } finally {
2828
+ try {
2829
+ if (r && !r.done && (m = i["return"])) m.call(i);
2830
+ } finally {
2831
+ if (e) throw e.error;
2832
+ }
2833
+ }
2834
+ return ar;
2835
+ };
2836
+ var __spreadArray = exports && exports.__spreadArray || function(to, from) {
2837
+ for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
2838
+ to[j] = from[i];
2839
+ return to;
2840
+ };
2841
+ Object.defineProperty(exports, "__esModule", { value: true });
2842
+ exports.animationFrameProvider = void 0;
2843
+ var Subscription_1 = require_Subscription();
2844
+ exports.animationFrameProvider = {
2845
+ schedule: function(callback) {
2846
+ var request = requestAnimationFrame;
2847
+ var cancel = cancelAnimationFrame;
2848
+ var delegate = exports.animationFrameProvider.delegate;
2849
+ if (delegate) {
2850
+ request = delegate.requestAnimationFrame;
2851
+ cancel = delegate.cancelAnimationFrame;
2852
+ }
2853
+ var handle = request(function(timestamp) {
2854
+ cancel = void 0;
2855
+ callback(timestamp);
2856
+ });
2857
+ return new Subscription_1.Subscription(function() {
2858
+ return cancel === null || cancel === void 0 ? void 0 : cancel(handle);
2859
+ });
2860
+ },
2861
+ requestAnimationFrame: function() {
2862
+ var args = [];
2863
+ for (var _i = 0; _i < arguments.length; _i++) {
2864
+ args[_i] = arguments[_i];
2865
+ }
2866
+ var delegate = exports.animationFrameProvider.delegate;
2867
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.requestAnimationFrame) || requestAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
2868
+ },
2869
+ cancelAnimationFrame: function() {
2870
+ var args = [];
2871
+ for (var _i = 0; _i < arguments.length; _i++) {
2872
+ args[_i] = arguments[_i];
2873
+ }
2874
+ var delegate = exports.animationFrameProvider.delegate;
2875
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.cancelAnimationFrame) || cancelAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
2876
+ },
2877
+ delegate: void 0
2878
+ };
2879
+ }
2880
+ });
2881
+
2882
+ // node_modules/rxjs/dist/cjs/internal/util/Immediate.js
2883
+ var require_Immediate = __commonJS({
2884
+ "node_modules/rxjs/dist/cjs/internal/util/Immediate.js"(exports) {
2885
+ "use strict";
2886
+ Object.defineProperty(exports, "__esModule", { value: true });
2887
+ exports.TestTools = exports.Immediate = void 0;
2888
+ var nextHandle = 1;
2889
+ var resolved;
2890
+ var activeHandles = {};
2891
+ function findAndClearHandle(handle) {
2892
+ if (handle in activeHandles) {
2893
+ delete activeHandles[handle];
2894
+ return true;
2895
+ }
2896
+ return false;
2897
+ }
2898
+ exports.Immediate = {
2899
+ setImmediate: function(cb) {
2900
+ var handle = nextHandle++;
2901
+ activeHandles[handle] = true;
2902
+ if (!resolved) {
2903
+ resolved = Promise.resolve();
2904
+ }
2905
+ resolved.then(function() {
2906
+ return findAndClearHandle(handle) && cb();
2907
+ });
2908
+ return handle;
2909
+ },
2910
+ clearImmediate: function(handle) {
2911
+ findAndClearHandle(handle);
2912
+ }
2913
+ };
2914
+ exports.TestTools = {
2915
+ pending: function() {
2916
+ return Object.keys(activeHandles).length;
2917
+ }
2918
+ };
2919
+ }
2920
+ });
2921
+
2922
+ // node_modules/rxjs/dist/cjs/internal/scheduler/immediateProvider.js
2923
+ var require_immediateProvider = __commonJS({
2924
+ "node_modules/rxjs/dist/cjs/internal/scheduler/immediateProvider.js"(exports) {
2925
+ "use strict";
2926
+ var __read = exports && exports.__read || function(o, n) {
2927
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
2928
+ if (!m) return o;
2929
+ var i = m.call(o), r, ar = [], e;
2930
+ try {
2931
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
2932
+ } catch (error) {
2933
+ e = { error };
2934
+ } finally {
2935
+ try {
2936
+ if (r && !r.done && (m = i["return"])) m.call(i);
2937
+ } finally {
2938
+ if (e) throw e.error;
2939
+ }
2940
+ }
2941
+ return ar;
2942
+ };
2943
+ var __spreadArray = exports && exports.__spreadArray || function(to, from) {
2944
+ for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
2945
+ to[j] = from[i];
2946
+ return to;
2947
+ };
2948
+ Object.defineProperty(exports, "__esModule", { value: true });
2949
+ exports.immediateProvider = void 0;
2950
+ var Immediate_1 = require_Immediate();
2951
+ var setImmediate = Immediate_1.Immediate.setImmediate;
2952
+ var clearImmediate = Immediate_1.Immediate.clearImmediate;
2953
+ exports.immediateProvider = {
2954
+ setImmediate: function() {
2955
+ var args = [];
2956
+ for (var _i = 0; _i < arguments.length; _i++) {
2957
+ args[_i] = arguments[_i];
2958
+ }
2959
+ var delegate = exports.immediateProvider.delegate;
2960
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.setImmediate) || setImmediate).apply(void 0, __spreadArray([], __read(args)));
2961
+ },
2962
+ clearImmediate: function(handle) {
2963
+ var delegate = exports.immediateProvider.delegate;
2964
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearImmediate) || clearImmediate)(handle);
2965
+ },
2966
+ delegate: void 0
2967
+ };
2968
+ }
2969
+ });
2970
+
2971
+ // node_modules/rxjs/dist/cjs/internal/testing/TestScheduler.js
2972
+ var require_TestScheduler = __commonJS({
2973
+ "node_modules/rxjs/dist/cjs/internal/testing/TestScheduler.js"(exports) {
2974
+ "use strict";
2975
+ var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
2976
+ var extendStatics = function(d, b) {
2977
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
2978
+ d2.__proto__ = b2;
2979
+ } || function(d2, b2) {
2980
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
2981
+ };
2982
+ return extendStatics(d, b);
2983
+ };
2984
+ return function(d, b) {
2985
+ if (typeof b !== "function" && b !== null)
2986
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
2987
+ extendStatics(d, b);
2988
+ function __() {
2989
+ this.constructor = d;
2990
+ }
2991
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2992
+ };
2993
+ })();
2994
+ var __read = exports && exports.__read || function(o, n) {
2995
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
2996
+ if (!m) return o;
2997
+ var i = m.call(o), r, ar = [], e;
2998
+ try {
2999
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
3000
+ } catch (error) {
3001
+ e = { error };
3002
+ } finally {
3003
+ try {
3004
+ if (r && !r.done && (m = i["return"])) m.call(i);
3005
+ } finally {
3006
+ if (e) throw e.error;
3007
+ }
3008
+ }
3009
+ return ar;
3010
+ };
3011
+ var __spreadArray = exports && exports.__spreadArray || function(to, from) {
3012
+ for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
3013
+ to[j] = from[i];
3014
+ return to;
3015
+ };
3016
+ var __values = exports && exports.__values || function(o) {
3017
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
3018
+ if (m) return m.call(o);
3019
+ if (o && typeof o.length === "number") return {
3020
+ next: function() {
3021
+ if (o && i >= o.length) o = void 0;
3022
+ return { value: o && o[i++], done: !o };
3023
+ }
3024
+ };
3025
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
3026
+ };
3027
+ Object.defineProperty(exports, "__esModule", { value: true });
3028
+ exports.TestScheduler = void 0;
3029
+ var Observable_1 = require_Observable();
3030
+ var ColdObservable_1 = require_ColdObservable();
3031
+ var HotObservable_1 = require_HotObservable();
3032
+ var SubscriptionLog_1 = require_SubscriptionLog();
3033
+ var VirtualTimeScheduler_1 = require_VirtualTimeScheduler();
3034
+ var NotificationFactories_1 = require_NotificationFactories();
3035
+ var dateTimestampProvider_1 = require_dateTimestampProvider();
3036
+ var performanceTimestampProvider_1 = require_performanceTimestampProvider();
3037
+ var animationFrameProvider_1 = require_animationFrameProvider();
3038
+ var immediateProvider_1 = require_immediateProvider();
3039
+ var intervalProvider_1 = require_intervalProvider();
3040
+ var timeoutProvider_1 = require_timeoutProvider();
3041
+ var defaultMaxFrame = 750;
3042
+ var TestScheduler3 = (function(_super) {
3043
+ __extends(TestScheduler4, _super);
3044
+ function TestScheduler4(assertDeepEqual2) {
3045
+ var _this = _super.call(this, VirtualTimeScheduler_1.VirtualAction, defaultMaxFrame) || this;
3046
+ _this.assertDeepEqual = assertDeepEqual2;
3047
+ _this.hotObservables = [];
3048
+ _this.coldObservables = [];
3049
+ _this.flushTests = [];
3050
+ _this.runMode = false;
3051
+ return _this;
3052
+ }
3053
+ TestScheduler4.prototype.createTime = function(marbles) {
3054
+ var indexOf = this.runMode ? marbles.trim().indexOf("|") : marbles.indexOf("|");
3055
+ if (indexOf === -1) {
3056
+ throw new Error('marble diagram for time should have a completion marker "|"');
3057
+ }
3058
+ return indexOf * TestScheduler4.frameTimeFactor;
3059
+ };
3060
+ TestScheduler4.prototype.createColdObservable = function(marbles, values, error) {
3061
+ if (marbles.indexOf("^") !== -1) {
3062
+ throw new Error('cold observable cannot have subscription offset "^"');
3063
+ }
3064
+ if (marbles.indexOf("!") !== -1) {
3065
+ throw new Error('cold observable cannot have unsubscription marker "!"');
3066
+ }
3067
+ var messages = TestScheduler4.parseMarbles(marbles, values, error, void 0, this.runMode);
3068
+ var cold2 = new ColdObservable_1.ColdObservable(messages, this);
3069
+ this.coldObservables.push(cold2);
3070
+ return cold2;
3071
+ };
3072
+ TestScheduler4.prototype.createHotObservable = function(marbles, values, error) {
3073
+ if (marbles.indexOf("!") !== -1) {
3074
+ throw new Error('hot observable cannot have unsubscription marker "!"');
3075
+ }
3076
+ var messages = TestScheduler4.parseMarbles(marbles, values, error, void 0, this.runMode);
3077
+ var subject = new HotObservable_1.HotObservable(messages, this);
3078
+ this.hotObservables.push(subject);
3079
+ return subject;
3080
+ };
3081
+ TestScheduler4.prototype.materializeInnerObservable = function(observable, outerFrame) {
3082
+ var _this = this;
3083
+ var messages = [];
3084
+ observable.subscribe({
3085
+ next: function(value) {
3086
+ messages.push({ frame: _this.frame - outerFrame, notification: NotificationFactories_1.nextNotification(value) });
3087
+ },
3088
+ error: function(error) {
3089
+ messages.push({ frame: _this.frame - outerFrame, notification: NotificationFactories_1.errorNotification(error) });
3090
+ },
3091
+ complete: function() {
3092
+ messages.push({ frame: _this.frame - outerFrame, notification: NotificationFactories_1.COMPLETE_NOTIFICATION });
3093
+ }
3094
+ });
3095
+ return messages;
3096
+ };
3097
+ TestScheduler4.prototype.expectObservable = function(observable, subscriptionMarbles) {
3098
+ var _this = this;
3099
+ if (subscriptionMarbles === void 0) {
3100
+ subscriptionMarbles = null;
3101
+ }
3102
+ var actual = [];
3103
+ var flushTest = { actual, ready: false };
3104
+ var subscriptionParsed = TestScheduler4.parseMarblesAsSubscriptions(subscriptionMarbles, this.runMode);
3105
+ var subscriptionFrame = subscriptionParsed.subscribedFrame === Infinity ? 0 : subscriptionParsed.subscribedFrame;
3106
+ var unsubscriptionFrame = subscriptionParsed.unsubscribedFrame;
3107
+ var subscription;
3108
+ this.schedule(function() {
3109
+ subscription = observable.subscribe({
3110
+ next: function(x) {
3111
+ var value = x instanceof Observable_1.Observable ? _this.materializeInnerObservable(x, _this.frame) : x;
3112
+ actual.push({ frame: _this.frame, notification: NotificationFactories_1.nextNotification(value) });
3113
+ },
3114
+ error: function(error) {
3115
+ actual.push({ frame: _this.frame, notification: NotificationFactories_1.errorNotification(error) });
3116
+ },
3117
+ complete: function() {
3118
+ actual.push({ frame: _this.frame, notification: NotificationFactories_1.COMPLETE_NOTIFICATION });
3119
+ }
3120
+ });
3121
+ }, subscriptionFrame);
3122
+ if (unsubscriptionFrame !== Infinity) {
3123
+ this.schedule(function() {
3124
+ return subscription.unsubscribe();
3125
+ }, unsubscriptionFrame);
3126
+ }
3127
+ this.flushTests.push(flushTest);
3128
+ var runMode = this.runMode;
3129
+ return {
3130
+ toBe: function(marbles, values, errorValue) {
3131
+ flushTest.ready = true;
3132
+ flushTest.expected = TestScheduler4.parseMarbles(marbles, values, errorValue, true, runMode);
3133
+ },
3134
+ toEqual: function(other) {
3135
+ flushTest.ready = true;
3136
+ flushTest.expected = [];
3137
+ _this.schedule(function() {
3138
+ subscription = other.subscribe({
3139
+ next: function(x) {
3140
+ var value = x instanceof Observable_1.Observable ? _this.materializeInnerObservable(x, _this.frame) : x;
3141
+ flushTest.expected.push({ frame: _this.frame, notification: NotificationFactories_1.nextNotification(value) });
3142
+ },
3143
+ error: function(error) {
3144
+ flushTest.expected.push({ frame: _this.frame, notification: NotificationFactories_1.errorNotification(error) });
3145
+ },
3146
+ complete: function() {
3147
+ flushTest.expected.push({ frame: _this.frame, notification: NotificationFactories_1.COMPLETE_NOTIFICATION });
3148
+ }
3149
+ });
3150
+ }, subscriptionFrame);
3151
+ }
3152
+ };
3153
+ };
3154
+ TestScheduler4.prototype.expectSubscriptions = function(actualSubscriptionLogs) {
3155
+ var flushTest = { actual: actualSubscriptionLogs, ready: false };
3156
+ this.flushTests.push(flushTest);
3157
+ var runMode = this.runMode;
3158
+ return {
3159
+ toBe: function(marblesOrMarblesArray) {
3160
+ var marblesArray = typeof marblesOrMarblesArray === "string" ? [marblesOrMarblesArray] : marblesOrMarblesArray;
3161
+ flushTest.ready = true;
3162
+ flushTest.expected = marblesArray.map(function(marbles) {
3163
+ return TestScheduler4.parseMarblesAsSubscriptions(marbles, runMode);
3164
+ }).filter(function(marbles) {
3165
+ return marbles.subscribedFrame !== Infinity;
3166
+ });
3167
+ }
3168
+ };
3169
+ };
3170
+ TestScheduler4.prototype.flush = function() {
3171
+ var _this = this;
3172
+ var hotObservables = this.hotObservables;
3173
+ while (hotObservables.length > 0) {
3174
+ hotObservables.shift().setup();
3175
+ }
3176
+ _super.prototype.flush.call(this);
3177
+ this.flushTests = this.flushTests.filter(function(test) {
3178
+ if (test.ready) {
3179
+ _this.assertDeepEqual(test.actual, test.expected);
3180
+ return false;
3181
+ }
3182
+ return true;
3183
+ });
3184
+ };
3185
+ TestScheduler4.parseMarblesAsSubscriptions = function(marbles, runMode) {
3186
+ var _this = this;
3187
+ if (runMode === void 0) {
3188
+ runMode = false;
3189
+ }
3190
+ if (typeof marbles !== "string") {
3191
+ return new SubscriptionLog_1.SubscriptionLog(Infinity);
3192
+ }
3193
+ var characters = __spreadArray([], __read(marbles));
3194
+ var len = characters.length;
3195
+ var groupStart = -1;
3196
+ var subscriptionFrame = Infinity;
3197
+ var unsubscriptionFrame = Infinity;
3198
+ var frame = 0;
3199
+ var _loop_1 = function(i2) {
3200
+ var nextFrame = frame;
3201
+ var advanceFrameBy = function(count) {
3202
+ nextFrame += count * _this.frameTimeFactor;
3203
+ };
3204
+ var c = characters[i2];
3205
+ switch (c) {
3206
+ case " ":
3207
+ if (!runMode) {
3208
+ advanceFrameBy(1);
3209
+ }
3210
+ break;
3211
+ case "-":
3212
+ advanceFrameBy(1);
3213
+ break;
3214
+ case "(":
3215
+ groupStart = frame;
3216
+ advanceFrameBy(1);
3217
+ break;
3218
+ case ")":
3219
+ groupStart = -1;
3220
+ advanceFrameBy(1);
3221
+ break;
3222
+ case "^":
3223
+ if (subscriptionFrame !== Infinity) {
3224
+ throw new Error("found a second subscription point '^' in a subscription marble diagram. There can only be one.");
3225
+ }
3226
+ subscriptionFrame = groupStart > -1 ? groupStart : frame;
3227
+ advanceFrameBy(1);
3228
+ break;
3229
+ case "!":
3230
+ if (unsubscriptionFrame !== Infinity) {
3231
+ throw new Error("found a second unsubscription point '!' in a subscription marble diagram. There can only be one.");
3232
+ }
3233
+ unsubscriptionFrame = groupStart > -1 ? groupStart : frame;
3234
+ break;
3235
+ default:
3236
+ if (runMode && c.match(/^[0-9]$/)) {
3237
+ if (i2 === 0 || characters[i2 - 1] === " ") {
3238
+ var buffer = characters.slice(i2).join("");
3239
+ var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
3240
+ if (match) {
3241
+ i2 += match[0].length - 1;
3242
+ var duration = parseFloat(match[1]);
3243
+ var unit = match[2];
3244
+ var durationInMs = void 0;
3245
+ switch (unit) {
3246
+ case "ms":
3247
+ durationInMs = duration;
3248
+ break;
3249
+ case "s":
3250
+ durationInMs = duration * 1e3;
3251
+ break;
3252
+ case "m":
3253
+ durationInMs = duration * 1e3 * 60;
3254
+ break;
3255
+ default:
3256
+ break;
3257
+ }
3258
+ advanceFrameBy(durationInMs / this_1.frameTimeFactor);
3259
+ break;
3260
+ }
3261
+ }
3262
+ }
3263
+ throw new Error("there can only be '^' and '!' markers in a subscription marble diagram. Found instead '" + c + "'.");
3264
+ }
3265
+ frame = nextFrame;
3266
+ out_i_1 = i2;
3267
+ };
3268
+ var this_1 = this, out_i_1;
3269
+ for (var i = 0; i < len; i++) {
3270
+ _loop_1(i);
3271
+ i = out_i_1;
3272
+ }
3273
+ if (unsubscriptionFrame < 0) {
3274
+ return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame);
3275
+ } else {
3276
+ return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame, unsubscriptionFrame);
3277
+ }
3278
+ };
3279
+ TestScheduler4.parseMarbles = function(marbles, values, errorValue, materializeInnerObservables, runMode) {
3280
+ var _this = this;
3281
+ if (materializeInnerObservables === void 0) {
3282
+ materializeInnerObservables = false;
3283
+ }
3284
+ if (runMode === void 0) {
3285
+ runMode = false;
3286
+ }
3287
+ if (marbles.indexOf("!") !== -1) {
3288
+ throw new Error('conventional marble diagrams cannot have the unsubscription marker "!"');
3289
+ }
3290
+ var characters = __spreadArray([], __read(marbles));
3291
+ var len = characters.length;
3292
+ var testMessages = [];
3293
+ var subIndex = runMode ? marbles.replace(/^[ ]+/, "").indexOf("^") : marbles.indexOf("^");
3294
+ var frame = subIndex === -1 ? 0 : subIndex * -this.frameTimeFactor;
3295
+ var getValue = typeof values !== "object" ? function(x) {
3296
+ return x;
3297
+ } : function(x) {
3298
+ if (materializeInnerObservables && values[x] instanceof ColdObservable_1.ColdObservable) {
3299
+ return values[x].messages;
3300
+ }
3301
+ return values[x];
3302
+ };
3303
+ var groupStart = -1;
3304
+ var _loop_2 = function(i2) {
3305
+ var nextFrame = frame;
3306
+ var advanceFrameBy = function(count) {
3307
+ nextFrame += count * _this.frameTimeFactor;
3308
+ };
3309
+ var notification = void 0;
3310
+ var c = characters[i2];
3311
+ switch (c) {
3312
+ case " ":
3313
+ if (!runMode) {
3314
+ advanceFrameBy(1);
3315
+ }
3316
+ break;
3317
+ case "-":
3318
+ advanceFrameBy(1);
3319
+ break;
3320
+ case "(":
3321
+ groupStart = frame;
3322
+ advanceFrameBy(1);
3323
+ break;
3324
+ case ")":
3325
+ groupStart = -1;
3326
+ advanceFrameBy(1);
3327
+ break;
3328
+ case "|":
3329
+ notification = NotificationFactories_1.COMPLETE_NOTIFICATION;
3330
+ advanceFrameBy(1);
3331
+ break;
3332
+ case "^":
3333
+ advanceFrameBy(1);
3334
+ break;
3335
+ case "#":
3336
+ notification = NotificationFactories_1.errorNotification(errorValue || "error");
3337
+ advanceFrameBy(1);
3338
+ break;
3339
+ default:
3340
+ if (runMode && c.match(/^[0-9]$/)) {
3341
+ if (i2 === 0 || characters[i2 - 1] === " ") {
3342
+ var buffer = characters.slice(i2).join("");
3343
+ var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
3344
+ if (match) {
3345
+ i2 += match[0].length - 1;
3346
+ var duration = parseFloat(match[1]);
3347
+ var unit = match[2];
3348
+ var durationInMs = void 0;
3349
+ switch (unit) {
3350
+ case "ms":
3351
+ durationInMs = duration;
3352
+ break;
3353
+ case "s":
3354
+ durationInMs = duration * 1e3;
3355
+ break;
3356
+ case "m":
3357
+ durationInMs = duration * 1e3 * 60;
3358
+ break;
3359
+ default:
3360
+ break;
3361
+ }
3362
+ advanceFrameBy(durationInMs / this_2.frameTimeFactor);
3363
+ break;
3364
+ }
3365
+ }
3366
+ }
3367
+ notification = NotificationFactories_1.nextNotification(getValue(c));
3368
+ advanceFrameBy(1);
3369
+ break;
3370
+ }
3371
+ if (notification) {
3372
+ testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification });
3373
+ }
3374
+ frame = nextFrame;
3375
+ out_i_2 = i2;
3376
+ };
3377
+ var this_2 = this, out_i_2;
3378
+ for (var i = 0; i < len; i++) {
3379
+ _loop_2(i);
3380
+ i = out_i_2;
3381
+ }
3382
+ return testMessages;
3383
+ };
3384
+ TestScheduler4.prototype.createAnimator = function() {
3385
+ var _this = this;
3386
+ if (!this.runMode) {
3387
+ throw new Error("animate() must only be used in run mode");
3388
+ }
3389
+ var lastHandle = 0;
3390
+ var map;
3391
+ var delegate = {
3392
+ requestAnimationFrame: function(callback) {
3393
+ if (!map) {
3394
+ throw new Error("animate() was not called within run()");
3395
+ }
3396
+ var handle = ++lastHandle;
3397
+ map.set(handle, callback);
3398
+ return handle;
3399
+ },
3400
+ cancelAnimationFrame: function(handle) {
3401
+ if (!map) {
3402
+ throw new Error("animate() was not called within run()");
3403
+ }
3404
+ map.delete(handle);
3405
+ }
3406
+ };
3407
+ var animate = function(marbles) {
3408
+ var e_1, _a;
3409
+ if (map) {
3410
+ throw new Error("animate() must not be called more than once within run()");
3411
+ }
3412
+ if (/[|#]/.test(marbles)) {
3413
+ throw new Error("animate() must not complete or error");
3414
+ }
3415
+ map = /* @__PURE__ */ new Map();
3416
+ var messages = TestScheduler4.parseMarbles(marbles, void 0, void 0, void 0, true);
3417
+ try {
3418
+ for (var messages_1 = __values(messages), messages_1_1 = messages_1.next(); !messages_1_1.done; messages_1_1 = messages_1.next()) {
3419
+ var message = messages_1_1.value;
3420
+ _this.schedule(function() {
3421
+ var e_2, _a2;
3422
+ var now = _this.now();
3423
+ var callbacks = Array.from(map.values());
3424
+ map.clear();
3425
+ try {
3426
+ for (var callbacks_1 = (e_2 = void 0, __values(callbacks)), callbacks_1_1 = callbacks_1.next(); !callbacks_1_1.done; callbacks_1_1 = callbacks_1.next()) {
3427
+ var callback = callbacks_1_1.value;
3428
+ callback(now);
3429
+ }
3430
+ } catch (e_2_1) {
3431
+ e_2 = { error: e_2_1 };
3432
+ } finally {
3433
+ try {
3434
+ if (callbacks_1_1 && !callbacks_1_1.done && (_a2 = callbacks_1.return)) _a2.call(callbacks_1);
3435
+ } finally {
3436
+ if (e_2) throw e_2.error;
3437
+ }
3438
+ }
3439
+ }, message.frame);
3440
+ }
3441
+ } catch (e_1_1) {
3442
+ e_1 = { error: e_1_1 };
3443
+ } finally {
3444
+ try {
3445
+ if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return)) _a.call(messages_1);
3446
+ } finally {
3447
+ if (e_1) throw e_1.error;
3448
+ }
3449
+ }
3450
+ };
3451
+ return { animate, delegate };
3452
+ };
3453
+ TestScheduler4.prototype.createDelegates = function() {
3454
+ var _this = this;
3455
+ var lastHandle = 0;
3456
+ var scheduleLookup = /* @__PURE__ */ new Map();
3457
+ var run = function() {
3458
+ var now = _this.now();
3459
+ var scheduledRecords = Array.from(scheduleLookup.values());
3460
+ var scheduledRecordsDue = scheduledRecords.filter(function(_a2) {
3461
+ var due = _a2.due;
3462
+ return due <= now;
3463
+ });
3464
+ var dueImmediates = scheduledRecordsDue.filter(function(_a2) {
3465
+ var type = _a2.type;
3466
+ return type === "immediate";
3467
+ });
3468
+ if (dueImmediates.length > 0) {
3469
+ var _a = dueImmediates[0], handle = _a.handle, handler = _a.handler;
3470
+ scheduleLookup.delete(handle);
3471
+ handler();
3472
+ return;
3473
+ }
3474
+ var dueIntervals = scheduledRecordsDue.filter(function(_a2) {
3475
+ var type = _a2.type;
3476
+ return type === "interval";
3477
+ });
3478
+ if (dueIntervals.length > 0) {
3479
+ var firstDueInterval = dueIntervals[0];
3480
+ var duration = firstDueInterval.duration, handler = firstDueInterval.handler;
3481
+ firstDueInterval.due = now + duration;
3482
+ firstDueInterval.subscription = _this.schedule(run, duration);
3483
+ handler();
3484
+ return;
3485
+ }
3486
+ var dueTimeouts = scheduledRecordsDue.filter(function(_a2) {
3487
+ var type = _a2.type;
3488
+ return type === "timeout";
3489
+ });
3490
+ if (dueTimeouts.length > 0) {
3491
+ var _b = dueTimeouts[0], handle = _b.handle, handler = _b.handler;
3492
+ scheduleLookup.delete(handle);
3493
+ handler();
3494
+ return;
3495
+ }
3496
+ throw new Error("Expected a due immediate or interval");
3497
+ };
3498
+ var immediate = {
3499
+ setImmediate: function(handler) {
3500
+ var handle = ++lastHandle;
3501
+ scheduleLookup.set(handle, {
3502
+ due: _this.now(),
3503
+ duration: 0,
3504
+ handle,
3505
+ handler,
3506
+ subscription: _this.schedule(run, 0),
3507
+ type: "immediate"
3508
+ });
3509
+ return handle;
3510
+ },
3511
+ clearImmediate: function(handle) {
3512
+ var value = scheduleLookup.get(handle);
3513
+ if (value) {
3514
+ value.subscription.unsubscribe();
3515
+ scheduleLookup.delete(handle);
3516
+ }
3517
+ }
3518
+ };
3519
+ var interval = {
3520
+ setInterval: function(handler, duration) {
3521
+ if (duration === void 0) {
3522
+ duration = 0;
3523
+ }
3524
+ var handle = ++lastHandle;
3525
+ scheduleLookup.set(handle, {
3526
+ due: _this.now() + duration,
3527
+ duration,
3528
+ handle,
3529
+ handler,
3530
+ subscription: _this.schedule(run, duration),
3531
+ type: "interval"
3532
+ });
3533
+ return handle;
3534
+ },
3535
+ clearInterval: function(handle) {
3536
+ var value = scheduleLookup.get(handle);
3537
+ if (value) {
3538
+ value.subscription.unsubscribe();
3539
+ scheduleLookup.delete(handle);
3540
+ }
3541
+ }
3542
+ };
3543
+ var timeout = {
3544
+ setTimeout: function(handler, duration) {
3545
+ if (duration === void 0) {
3546
+ duration = 0;
3547
+ }
3548
+ var handle = ++lastHandle;
3549
+ scheduleLookup.set(handle, {
3550
+ due: _this.now() + duration,
3551
+ duration,
3552
+ handle,
3553
+ handler,
3554
+ subscription: _this.schedule(run, duration),
3555
+ type: "timeout"
3556
+ });
3557
+ return handle;
3558
+ },
3559
+ clearTimeout: function(handle) {
3560
+ var value = scheduleLookup.get(handle);
3561
+ if (value) {
3562
+ value.subscription.unsubscribe();
3563
+ scheduleLookup.delete(handle);
3564
+ }
3565
+ }
3566
+ };
3567
+ return { immediate, interval, timeout };
3568
+ };
3569
+ TestScheduler4.prototype.run = function(callback) {
3570
+ var prevFrameTimeFactor = TestScheduler4.frameTimeFactor;
3571
+ var prevMaxFrames = this.maxFrames;
3572
+ TestScheduler4.frameTimeFactor = 1;
3573
+ this.maxFrames = Infinity;
3574
+ this.runMode = true;
3575
+ var animator = this.createAnimator();
3576
+ var delegates = this.createDelegates();
3577
+ animationFrameProvider_1.animationFrameProvider.delegate = animator.delegate;
3578
+ dateTimestampProvider_1.dateTimestampProvider.delegate = this;
3579
+ immediateProvider_1.immediateProvider.delegate = delegates.immediate;
3580
+ intervalProvider_1.intervalProvider.delegate = delegates.interval;
3581
+ timeoutProvider_1.timeoutProvider.delegate = delegates.timeout;
3582
+ performanceTimestampProvider_1.performanceTimestampProvider.delegate = this;
3583
+ var helpers = {
3584
+ cold: this.createColdObservable.bind(this),
3585
+ hot: this.createHotObservable.bind(this),
3586
+ flush: this.flush.bind(this),
3587
+ time: this.createTime.bind(this),
3588
+ expectObservable: this.expectObservable.bind(this),
3589
+ expectSubscriptions: this.expectSubscriptions.bind(this),
3590
+ animate: animator.animate
3591
+ };
3592
+ try {
3593
+ var ret = callback(helpers);
3594
+ this.flush();
3595
+ return ret;
3596
+ } finally {
3597
+ TestScheduler4.frameTimeFactor = prevFrameTimeFactor;
3598
+ this.maxFrames = prevMaxFrames;
3599
+ this.runMode = false;
3600
+ animationFrameProvider_1.animationFrameProvider.delegate = void 0;
3601
+ dateTimestampProvider_1.dateTimestampProvider.delegate = void 0;
3602
+ immediateProvider_1.immediateProvider.delegate = void 0;
3603
+ intervalProvider_1.intervalProvider.delegate = void 0;
3604
+ timeoutProvider_1.timeoutProvider.delegate = void 0;
3605
+ performanceTimestampProvider_1.performanceTimestampProvider.delegate = void 0;
3606
+ }
3607
+ };
3608
+ TestScheduler4.frameTimeFactor = 10;
3609
+ return TestScheduler4;
3610
+ })(VirtualTimeScheduler_1.VirtualTimeScheduler);
3611
+ exports.TestScheduler = TestScheduler3;
3612
+ }
3613
+ });
3614
+
3615
+ // node_modules/rxjs/dist/cjs/testing/index.js
3616
+ var require_testing = __commonJS({
3617
+ "node_modules/rxjs/dist/cjs/testing/index.js"(exports) {
3618
+ "use strict";
3619
+ Object.defineProperty(exports, "__esModule", { value: true });
3620
+ exports.TestScheduler = void 0;
3621
+ var TestScheduler_1 = require_TestScheduler();
3622
+ Object.defineProperty(exports, "TestScheduler", { enumerable: true, get: function() {
3623
+ return TestScheduler_1.TestScheduler;
3624
+ } });
3625
+ }
3626
+ });
3627
+
1
3628
  // src/lib/scheduler.ts
2
- import { TestScheduler } from "rxjs/testing";
3629
+ var import_testing = __toESM(require_testing(), 1);
3
3630
 
4
3631
  // src/lib/marblizer.ts
5
3632
  var frameStep = 10;
6
3633
  function marblize(logs) {
7
3634
  return logs.map(
8
- (log) => marblizeLogEntry(log.subscribedFrame / frameStep, "^" /* Subscription */) + marblizeLogEntry(
9
- (log.unsubscribedFrame - log.subscribedFrame) / frameStep - 1,
10
- "!" /* Unsubscription */
11
- )
3635
+ (log) => marblizeLogEntry(
3636
+ log.subscribedFrame / frameStep,
3637
+ "^" /* Subscription */
3638
+ ) + marblizeLogEntry((log.unsubscribedFrame - log.subscribedFrame) / frameStep - 1, "!" /* Unsubscription */)
12
3639
  );
13
3640
  }
14
3641
  function marblizeLogEntry(logPoint, symbol) {
@@ -109,7 +3736,7 @@ function isSubscriptions(log) {
109
3736
  var Scheduler = class _Scheduler {
110
3737
  static instance;
111
3738
  static init() {
112
- _Scheduler.instance = new TestScheduler(assertDeepEqual);
3739
+ _Scheduler.instance = new import_testing.TestScheduler(assertDeepEqual);
113
3740
  }
114
3741
  static get() {
115
3742
  if (!_Scheduler.instance)
@@ -136,7 +3763,7 @@ function schedule(work, delay) {
136
3763
  }
137
3764
 
138
3765
  // src/lib/matchers.ts
139
- import { TestScheduler as TestScheduler2 } from "rxjs/testing";
3766
+ var import_testing2 = __toESM(require_testing(), 1);
140
3767
  var success = {
141
3768
  pass: true,
142
3769
  message: () => ""
@@ -173,7 +3800,7 @@ beforeEach(() => {
173
3800
  onFlush = [];
174
3801
  });
175
3802
  afterEach(() => {
176
- Scheduler.get().run(() => TestScheduler2.frameTimeFactor = 10);
3803
+ Scheduler.get().run(() => import_testing2.TestScheduler.frameTimeFactor = 10);
177
3804
  while (onFlush.length > 0)
178
3805
  onFlush.shift()?.();
179
3806
  Scheduler.reset();