@swirly/parser-rxjs 0.17.6 → 0.19.0

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.
package/dist/bundle.js ADDED
@@ -0,0 +1,2842 @@
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, from2, except, desc) => {
11
+ if (from2 && typeof from2 === "object" || typeof from2 === "function") {
12
+ for (let key of __getOwnPropNames(from2))
13
+ if (!__hasOwnProp.call(to, key) && key !== except)
14
+ __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
15
+ }
16
+ return to;
17
+ };
18
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
19
+
20
+ // node_modules/tslib/tslib.js
21
+ var require_tslib = __commonJS({
22
+ "node_modules/tslib/tslib.js"(exports, module) {
23
+ var __extends2;
24
+ var __assign2;
25
+ var __rest2;
26
+ var __decorate2;
27
+ var __param2;
28
+ var __metadata2;
29
+ var __awaiter2;
30
+ var __generator2;
31
+ var __exportStar2;
32
+ var __values2;
33
+ var __read2;
34
+ var __spread2;
35
+ var __spreadArrays2;
36
+ var __spreadArray2;
37
+ var __await2;
38
+ var __asyncGenerator2;
39
+ var __asyncDelegator2;
40
+ var __asyncValues2;
41
+ var __makeTemplateObject2;
42
+ var __importStar2;
43
+ var __importDefault2;
44
+ var __classPrivateFieldGet2;
45
+ var __classPrivateFieldSet2;
46
+ var __classPrivateFieldIn2;
47
+ var __createBinding2;
48
+ (function(factory) {
49
+ var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
50
+ if (typeof define === "function" && define.amd) {
51
+ define("tslib", ["exports"], function(exports2) {
52
+ factory(createExporter(root, createExporter(exports2)));
53
+ });
54
+ } else if (typeof module === "object" && typeof module.exports === "object") {
55
+ factory(createExporter(root, createExporter(module.exports)));
56
+ } else {
57
+ factory(createExporter(root));
58
+ }
59
+ function createExporter(exports2, previous) {
60
+ if (exports2 !== root) {
61
+ if (typeof Object.create === "function") {
62
+ Object.defineProperty(exports2, "__esModule", { value: true });
63
+ } else {
64
+ exports2.__esModule = true;
65
+ }
66
+ }
67
+ return function(id, v) {
68
+ return exports2[id] = previous ? previous(id, v) : v;
69
+ };
70
+ }
71
+ })(function(exporter) {
72
+ var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
73
+ d.__proto__ = b;
74
+ } || function(d, b) {
75
+ for (var p in b)
76
+ if (Object.prototype.hasOwnProperty.call(b, p))
77
+ d[p] = b[p];
78
+ };
79
+ __extends2 = function(d, b) {
80
+ if (typeof b !== "function" && b !== null)
81
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
82
+ extendStatics(d, b);
83
+ function __() {
84
+ this.constructor = d;
85
+ }
86
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
87
+ };
88
+ __assign2 = Object.assign || function(t) {
89
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
90
+ s = arguments[i];
91
+ for (var p in s)
92
+ if (Object.prototype.hasOwnProperty.call(s, p))
93
+ t[p] = s[p];
94
+ }
95
+ return t;
96
+ };
97
+ __rest2 = function(s, e) {
98
+ var t = {};
99
+ for (var p in s)
100
+ if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
101
+ t[p] = s[p];
102
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
103
+ for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
104
+ if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
105
+ t[p[i]] = s[p[i]];
106
+ }
107
+ return t;
108
+ };
109
+ __decorate2 = function(decorators, target, key, desc) {
110
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
111
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
112
+ r = Reflect.decorate(decorators, target, key, desc);
113
+ else
114
+ for (var i = decorators.length - 1; i >= 0; i--)
115
+ if (d = decorators[i])
116
+ r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
117
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
118
+ };
119
+ __param2 = function(paramIndex, decorator) {
120
+ return function(target, key) {
121
+ decorator(target, key, paramIndex);
122
+ };
123
+ };
124
+ __metadata2 = function(metadataKey, metadataValue) {
125
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
126
+ return Reflect.metadata(metadataKey, metadataValue);
127
+ };
128
+ __awaiter2 = function(thisArg, _arguments, P, generator) {
129
+ function adopt(value) {
130
+ return value instanceof P ? value : new P(function(resolve) {
131
+ resolve(value);
132
+ });
133
+ }
134
+ return new (P || (P = Promise))(function(resolve, reject) {
135
+ function fulfilled(value) {
136
+ try {
137
+ step(generator.next(value));
138
+ } catch (e) {
139
+ reject(e);
140
+ }
141
+ }
142
+ function rejected(value) {
143
+ try {
144
+ step(generator["throw"](value));
145
+ } catch (e) {
146
+ reject(e);
147
+ }
148
+ }
149
+ function step(result) {
150
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
151
+ }
152
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
153
+ });
154
+ };
155
+ __generator2 = function(thisArg, body) {
156
+ var _ = { label: 0, sent: function() {
157
+ if (t[0] & 1)
158
+ throw t[1];
159
+ return t[1];
160
+ }, trys: [], ops: [] }, f, y, t, g;
161
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
162
+ return this;
163
+ }), g;
164
+ function verb(n) {
165
+ return function(v) {
166
+ return step([n, v]);
167
+ };
168
+ }
169
+ function step(op) {
170
+ if (f)
171
+ throw new TypeError("Generator is already executing.");
172
+ while (_)
173
+ try {
174
+ 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)
175
+ return t;
176
+ if (y = 0, t)
177
+ op = [op[0] & 2, t.value];
178
+ switch (op[0]) {
179
+ case 0:
180
+ case 1:
181
+ t = op;
182
+ break;
183
+ case 4:
184
+ _.label++;
185
+ return { value: op[1], done: false };
186
+ case 5:
187
+ _.label++;
188
+ y = op[1];
189
+ op = [0];
190
+ continue;
191
+ case 7:
192
+ op = _.ops.pop();
193
+ _.trys.pop();
194
+ continue;
195
+ default:
196
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
197
+ _ = 0;
198
+ continue;
199
+ }
200
+ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
201
+ _.label = op[1];
202
+ break;
203
+ }
204
+ if (op[0] === 6 && _.label < t[1]) {
205
+ _.label = t[1];
206
+ t = op;
207
+ break;
208
+ }
209
+ if (t && _.label < t[2]) {
210
+ _.label = t[2];
211
+ _.ops.push(op);
212
+ break;
213
+ }
214
+ if (t[2])
215
+ _.ops.pop();
216
+ _.trys.pop();
217
+ continue;
218
+ }
219
+ op = body.call(thisArg, _);
220
+ } catch (e) {
221
+ op = [6, e];
222
+ y = 0;
223
+ } finally {
224
+ f = t = 0;
225
+ }
226
+ if (op[0] & 5)
227
+ throw op[1];
228
+ return { value: op[0] ? op[1] : void 0, done: true };
229
+ }
230
+ };
231
+ __exportStar2 = function(m, o) {
232
+ for (var p in m)
233
+ if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
234
+ __createBinding2(o, m, p);
235
+ };
236
+ __createBinding2 = Object.create ? function(o, m, k, k2) {
237
+ if (k2 === void 0)
238
+ k2 = k;
239
+ var desc = Object.getOwnPropertyDescriptor(m, k);
240
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
241
+ desc = { enumerable: true, get: function() {
242
+ return m[k];
243
+ } };
244
+ }
245
+ Object.defineProperty(o, k2, desc);
246
+ } : function(o, m, k, k2) {
247
+ if (k2 === void 0)
248
+ k2 = k;
249
+ o[k2] = m[k];
250
+ };
251
+ __values2 = function(o) {
252
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
253
+ if (m)
254
+ return m.call(o);
255
+ if (o && typeof o.length === "number")
256
+ return {
257
+ next: function() {
258
+ if (o && i >= o.length)
259
+ o = void 0;
260
+ return { value: o && o[i++], done: !o };
261
+ }
262
+ };
263
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
264
+ };
265
+ __read2 = function(o, n) {
266
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
267
+ if (!m)
268
+ return o;
269
+ var i = m.call(o), r, ar = [], e;
270
+ try {
271
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
272
+ ar.push(r.value);
273
+ } catch (error) {
274
+ e = { error };
275
+ } finally {
276
+ try {
277
+ if (r && !r.done && (m = i["return"]))
278
+ m.call(i);
279
+ } finally {
280
+ if (e)
281
+ throw e.error;
282
+ }
283
+ }
284
+ return ar;
285
+ };
286
+ __spread2 = function() {
287
+ for (var ar = [], i = 0; i < arguments.length; i++)
288
+ ar = ar.concat(__read2(arguments[i]));
289
+ return ar;
290
+ };
291
+ __spreadArrays2 = function() {
292
+ for (var s = 0, i = 0, il = arguments.length; i < il; i++)
293
+ s += arguments[i].length;
294
+ for (var r = Array(s), k = 0, i = 0; i < il; i++)
295
+ for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
296
+ r[k] = a[j];
297
+ return r;
298
+ };
299
+ __spreadArray2 = function(to, from2, pack) {
300
+ if (pack || arguments.length === 2)
301
+ for (var i = 0, l = from2.length, ar; i < l; i++) {
302
+ if (ar || !(i in from2)) {
303
+ if (!ar)
304
+ ar = Array.prototype.slice.call(from2, 0, i);
305
+ ar[i] = from2[i];
306
+ }
307
+ }
308
+ return to.concat(ar || Array.prototype.slice.call(from2));
309
+ };
310
+ __await2 = function(v) {
311
+ return this instanceof __await2 ? (this.v = v, this) : new __await2(v);
312
+ };
313
+ __asyncGenerator2 = function(thisArg, _arguments, generator) {
314
+ if (!Symbol.asyncIterator)
315
+ throw new TypeError("Symbol.asyncIterator is not defined.");
316
+ var g = generator.apply(thisArg, _arguments || []), i, q = [];
317
+ return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
318
+ return this;
319
+ }, i;
320
+ function verb(n) {
321
+ if (g[n])
322
+ i[n] = function(v) {
323
+ return new Promise(function(a, b) {
324
+ q.push([n, v, a, b]) > 1 || resume(n, v);
325
+ });
326
+ };
327
+ }
328
+ function resume(n, v) {
329
+ try {
330
+ step(g[n](v));
331
+ } catch (e) {
332
+ settle(q[0][3], e);
333
+ }
334
+ }
335
+ function step(r) {
336
+ r.value instanceof __await2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
337
+ }
338
+ function fulfill(value) {
339
+ resume("next", value);
340
+ }
341
+ function reject(value) {
342
+ resume("throw", value);
343
+ }
344
+ function settle(f, v) {
345
+ if (f(v), q.shift(), q.length)
346
+ resume(q[0][0], q[0][1]);
347
+ }
348
+ };
349
+ __asyncDelegator2 = function(o) {
350
+ var i, p;
351
+ return i = {}, verb("next"), verb("throw", function(e) {
352
+ throw e;
353
+ }), verb("return"), i[Symbol.iterator] = function() {
354
+ return this;
355
+ }, i;
356
+ function verb(n, f) {
357
+ i[n] = o[n] ? function(v) {
358
+ return (p = !p) ? { value: __await2(o[n](v)), done: n === "return" } : f ? f(v) : v;
359
+ } : f;
360
+ }
361
+ };
362
+ __asyncValues2 = function(o) {
363
+ if (!Symbol.asyncIterator)
364
+ throw new TypeError("Symbol.asyncIterator is not defined.");
365
+ var m = o[Symbol.asyncIterator], i;
366
+ return m ? m.call(o) : (o = typeof __values2 === "function" ? __values2(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
367
+ return this;
368
+ }, i);
369
+ function verb(n) {
370
+ i[n] = o[n] && function(v) {
371
+ return new Promise(function(resolve, reject) {
372
+ v = o[n](v), settle(resolve, reject, v.done, v.value);
373
+ });
374
+ };
375
+ }
376
+ function settle(resolve, reject, d, v) {
377
+ Promise.resolve(v).then(function(v2) {
378
+ resolve({ value: v2, done: d });
379
+ }, reject);
380
+ }
381
+ };
382
+ __makeTemplateObject2 = function(cooked, raw) {
383
+ if (Object.defineProperty) {
384
+ Object.defineProperty(cooked, "raw", { value: raw });
385
+ } else {
386
+ cooked.raw = raw;
387
+ }
388
+ return cooked;
389
+ };
390
+ var __setModuleDefault = Object.create ? function(o, v) {
391
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
392
+ } : function(o, v) {
393
+ o["default"] = v;
394
+ };
395
+ __importStar2 = function(mod) {
396
+ if (mod && mod.__esModule)
397
+ return mod;
398
+ var result = {};
399
+ if (mod != null) {
400
+ for (var k in mod)
401
+ if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
402
+ __createBinding2(result, mod, k);
403
+ }
404
+ __setModuleDefault(result, mod);
405
+ return result;
406
+ };
407
+ __importDefault2 = function(mod) {
408
+ return mod && mod.__esModule ? mod : { "default": mod };
409
+ };
410
+ __classPrivateFieldGet2 = function(receiver, state, kind, f) {
411
+ if (kind === "a" && !f)
412
+ throw new TypeError("Private accessor was defined without a getter");
413
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
414
+ throw new TypeError("Cannot read private member from an object whose class did not declare it");
415
+ return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
416
+ };
417
+ __classPrivateFieldSet2 = function(receiver, state, value, kind, f) {
418
+ if (kind === "m")
419
+ throw new TypeError("Private method is not writable");
420
+ if (kind === "a" && !f)
421
+ throw new TypeError("Private accessor was defined without a setter");
422
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
423
+ throw new TypeError("Cannot write private member to an object whose class did not declare it");
424
+ return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
425
+ };
426
+ __classPrivateFieldIn2 = function(state, receiver) {
427
+ if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function")
428
+ throw new TypeError("Cannot use 'in' operator on non-object");
429
+ return typeof state === "function" ? receiver === state : state.has(receiver);
430
+ };
431
+ exporter("__extends", __extends2);
432
+ exporter("__assign", __assign2);
433
+ exporter("__rest", __rest2);
434
+ exporter("__decorate", __decorate2);
435
+ exporter("__param", __param2);
436
+ exporter("__metadata", __metadata2);
437
+ exporter("__awaiter", __awaiter2);
438
+ exporter("__generator", __generator2);
439
+ exporter("__exportStar", __exportStar2);
440
+ exporter("__createBinding", __createBinding2);
441
+ exporter("__values", __values2);
442
+ exporter("__read", __read2);
443
+ exporter("__spread", __spread2);
444
+ exporter("__spreadArrays", __spreadArrays2);
445
+ exporter("__spreadArray", __spreadArray2);
446
+ exporter("__await", __await2);
447
+ exporter("__asyncGenerator", __asyncGenerator2);
448
+ exporter("__asyncDelegator", __asyncDelegator2);
449
+ exporter("__asyncValues", __asyncValues2);
450
+ exporter("__makeTemplateObject", __makeTemplateObject2);
451
+ exporter("__importStar", __importStar2);
452
+ exporter("__importDefault", __importDefault2);
453
+ exporter("__classPrivateFieldGet", __classPrivateFieldGet2);
454
+ exporter("__classPrivateFieldSet", __classPrivateFieldSet2);
455
+ exporter("__classPrivateFieldIn", __classPrivateFieldIn2);
456
+ });
457
+ }
458
+ });
459
+
460
+ // node_modules/tslib/modules/index.js
461
+ var import_tslib = __toESM(require_tslib(), 1);
462
+ var {
463
+ __extends,
464
+ __assign,
465
+ __rest,
466
+ __decorate,
467
+ __param,
468
+ __metadata,
469
+ __awaiter,
470
+ __generator,
471
+ __exportStar,
472
+ __createBinding,
473
+ __values,
474
+ __read,
475
+ __spread,
476
+ __spreadArrays,
477
+ __spreadArray,
478
+ __await,
479
+ __asyncGenerator,
480
+ __asyncDelegator,
481
+ __asyncValues,
482
+ __makeTemplateObject,
483
+ __importStar,
484
+ __importDefault,
485
+ __classPrivateFieldGet,
486
+ __classPrivateFieldSet,
487
+ __classPrivateFieldIn
488
+ } = import_tslib.default;
489
+
490
+ // node_modules/rxjs/dist/esm5/internal/util/isFunction.js
491
+ function isFunction(value) {
492
+ return typeof value === "function";
493
+ }
494
+
495
+ // node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
496
+ function createErrorClass(createImpl) {
497
+ var _super = function(instance) {
498
+ Error.call(instance);
499
+ instance.stack = new Error().stack;
500
+ };
501
+ var ctorFunc = createImpl(_super);
502
+ ctorFunc.prototype = Object.create(Error.prototype);
503
+ ctorFunc.prototype.constructor = ctorFunc;
504
+ return ctorFunc;
505
+ }
506
+
507
+ // node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
508
+ var UnsubscriptionError = createErrorClass(function(_super) {
509
+ return function UnsubscriptionErrorImpl(errors) {
510
+ _super(this);
511
+ this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
512
+ return i + 1 + ") " + err.toString();
513
+ }).join("\n ") : "";
514
+ this.name = "UnsubscriptionError";
515
+ this.errors = errors;
516
+ };
517
+ });
518
+
519
+ // node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
520
+ function arrRemove(arr, item) {
521
+ if (arr) {
522
+ var index = arr.indexOf(item);
523
+ 0 <= index && arr.splice(index, 1);
524
+ }
525
+ }
526
+
527
+ // node_modules/rxjs/dist/esm5/internal/Subscription.js
528
+ var Subscription = function() {
529
+ function Subscription2(initialTeardown) {
530
+ this.initialTeardown = initialTeardown;
531
+ this.closed = false;
532
+ this._parentage = null;
533
+ this._finalizers = null;
534
+ }
535
+ Subscription2.prototype.unsubscribe = function() {
536
+ var e_1, _a, e_2, _b;
537
+ var errors;
538
+ if (!this.closed) {
539
+ this.closed = true;
540
+ var _parentage = this._parentage;
541
+ if (_parentage) {
542
+ this._parentage = null;
543
+ if (Array.isArray(_parentage)) {
544
+ try {
545
+ for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
546
+ var parent_1 = _parentage_1_1.value;
547
+ parent_1.remove(this);
548
+ }
549
+ } catch (e_1_1) {
550
+ e_1 = { error: e_1_1 };
551
+ } finally {
552
+ try {
553
+ if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return))
554
+ _a.call(_parentage_1);
555
+ } finally {
556
+ if (e_1)
557
+ throw e_1.error;
558
+ }
559
+ }
560
+ } else {
561
+ _parentage.remove(this);
562
+ }
563
+ }
564
+ var initialFinalizer = this.initialTeardown;
565
+ if (isFunction(initialFinalizer)) {
566
+ try {
567
+ initialFinalizer();
568
+ } catch (e) {
569
+ errors = e instanceof UnsubscriptionError ? e.errors : [e];
570
+ }
571
+ }
572
+ var _finalizers = this._finalizers;
573
+ if (_finalizers) {
574
+ this._finalizers = null;
575
+ try {
576
+ for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
577
+ var finalizer = _finalizers_1_1.value;
578
+ try {
579
+ execFinalizer(finalizer);
580
+ } catch (err) {
581
+ errors = errors !== null && errors !== void 0 ? errors : [];
582
+ if (err instanceof UnsubscriptionError) {
583
+ errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
584
+ } else {
585
+ errors.push(err);
586
+ }
587
+ }
588
+ }
589
+ } catch (e_2_1) {
590
+ e_2 = { error: e_2_1 };
591
+ } finally {
592
+ try {
593
+ if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return))
594
+ _b.call(_finalizers_1);
595
+ } finally {
596
+ if (e_2)
597
+ throw e_2.error;
598
+ }
599
+ }
600
+ }
601
+ if (errors) {
602
+ throw new UnsubscriptionError(errors);
603
+ }
604
+ }
605
+ };
606
+ Subscription2.prototype.add = function(teardown) {
607
+ var _a;
608
+ if (teardown && teardown !== this) {
609
+ if (this.closed) {
610
+ execFinalizer(teardown);
611
+ } else {
612
+ if (teardown instanceof Subscription2) {
613
+ if (teardown.closed || teardown._hasParent(this)) {
614
+ return;
615
+ }
616
+ teardown._addParent(this);
617
+ }
618
+ (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
619
+ }
620
+ }
621
+ };
622
+ Subscription2.prototype._hasParent = function(parent) {
623
+ var _parentage = this._parentage;
624
+ return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
625
+ };
626
+ Subscription2.prototype._addParent = function(parent) {
627
+ var _parentage = this._parentage;
628
+ this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
629
+ };
630
+ Subscription2.prototype._removeParent = function(parent) {
631
+ var _parentage = this._parentage;
632
+ if (_parentage === parent) {
633
+ this._parentage = null;
634
+ } else if (Array.isArray(_parentage)) {
635
+ arrRemove(_parentage, parent);
636
+ }
637
+ };
638
+ Subscription2.prototype.remove = function(teardown) {
639
+ var _finalizers = this._finalizers;
640
+ _finalizers && arrRemove(_finalizers, teardown);
641
+ if (teardown instanceof Subscription2) {
642
+ teardown._removeParent(this);
643
+ }
644
+ };
645
+ Subscription2.EMPTY = function() {
646
+ var empty = new Subscription2();
647
+ empty.closed = true;
648
+ return empty;
649
+ }();
650
+ return Subscription2;
651
+ }();
652
+ var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
653
+ function isSubscription(value) {
654
+ return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
655
+ }
656
+ function execFinalizer(finalizer) {
657
+ if (isFunction(finalizer)) {
658
+ finalizer();
659
+ } else {
660
+ finalizer.unsubscribe();
661
+ }
662
+ }
663
+
664
+ // node_modules/rxjs/dist/esm5/internal/config.js
665
+ var config = {
666
+ onUnhandledError: null,
667
+ onStoppedNotification: null,
668
+ Promise: void 0,
669
+ useDeprecatedSynchronousErrorHandling: false,
670
+ useDeprecatedNextContext: false
671
+ };
672
+
673
+ // node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
674
+ var timeoutProvider = {
675
+ setTimeout: function(handler, timeout) {
676
+ var args = [];
677
+ for (var _i = 2; _i < arguments.length; _i++) {
678
+ args[_i - 2] = arguments[_i];
679
+ }
680
+ var delegate = timeoutProvider.delegate;
681
+ if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
682
+ return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
683
+ }
684
+ return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
685
+ },
686
+ clearTimeout: function(handle) {
687
+ var delegate = timeoutProvider.delegate;
688
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
689
+ },
690
+ delegate: void 0
691
+ };
692
+
693
+ // node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
694
+ function reportUnhandledError(err) {
695
+ timeoutProvider.setTimeout(function() {
696
+ var onUnhandledError = config.onUnhandledError;
697
+ if (onUnhandledError) {
698
+ onUnhandledError(err);
699
+ } else {
700
+ throw err;
701
+ }
702
+ });
703
+ }
704
+
705
+ // node_modules/rxjs/dist/esm5/internal/util/noop.js
706
+ function noop() {
707
+ }
708
+
709
+ // node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
710
+ var COMPLETE_NOTIFICATION = function() {
711
+ return createNotification("C", void 0, void 0);
712
+ }();
713
+ function errorNotification(error) {
714
+ return createNotification("E", void 0, error);
715
+ }
716
+ function nextNotification(value) {
717
+ return createNotification("N", value, void 0);
718
+ }
719
+ function createNotification(kind, value, error) {
720
+ return {
721
+ kind,
722
+ value,
723
+ error
724
+ };
725
+ }
726
+
727
+ // node_modules/rxjs/dist/esm5/internal/util/errorContext.js
728
+ var context = null;
729
+ function errorContext(cb) {
730
+ if (config.useDeprecatedSynchronousErrorHandling) {
731
+ var isRoot = !context;
732
+ if (isRoot) {
733
+ context = { errorThrown: false, error: null };
734
+ }
735
+ cb();
736
+ if (isRoot) {
737
+ var _a = context, errorThrown = _a.errorThrown, error = _a.error;
738
+ context = null;
739
+ if (errorThrown) {
740
+ throw error;
741
+ }
742
+ }
743
+ } else {
744
+ cb();
745
+ }
746
+ }
747
+ function captureError(err) {
748
+ if (config.useDeprecatedSynchronousErrorHandling && context) {
749
+ context.errorThrown = true;
750
+ context.error = err;
751
+ }
752
+ }
753
+
754
+ // node_modules/rxjs/dist/esm5/internal/Subscriber.js
755
+ var Subscriber = function(_super) {
756
+ __extends(Subscriber2, _super);
757
+ function Subscriber2(destination) {
758
+ var _this = _super.call(this) || this;
759
+ _this.isStopped = false;
760
+ if (destination) {
761
+ _this.destination = destination;
762
+ if (isSubscription(destination)) {
763
+ destination.add(_this);
764
+ }
765
+ } else {
766
+ _this.destination = EMPTY_OBSERVER;
767
+ }
768
+ return _this;
769
+ }
770
+ Subscriber2.create = function(next, error, complete) {
771
+ return new SafeSubscriber(next, error, complete);
772
+ };
773
+ Subscriber2.prototype.next = function(value) {
774
+ if (this.isStopped) {
775
+ handleStoppedNotification(nextNotification(value), this);
776
+ } else {
777
+ this._next(value);
778
+ }
779
+ };
780
+ Subscriber2.prototype.error = function(err) {
781
+ if (this.isStopped) {
782
+ handleStoppedNotification(errorNotification(err), this);
783
+ } else {
784
+ this.isStopped = true;
785
+ this._error(err);
786
+ }
787
+ };
788
+ Subscriber2.prototype.complete = function() {
789
+ if (this.isStopped) {
790
+ handleStoppedNotification(COMPLETE_NOTIFICATION, this);
791
+ } else {
792
+ this.isStopped = true;
793
+ this._complete();
794
+ }
795
+ };
796
+ Subscriber2.prototype.unsubscribe = function() {
797
+ if (!this.closed) {
798
+ this.isStopped = true;
799
+ _super.prototype.unsubscribe.call(this);
800
+ this.destination = null;
801
+ }
802
+ };
803
+ Subscriber2.prototype._next = function(value) {
804
+ this.destination.next(value);
805
+ };
806
+ Subscriber2.prototype._error = function(err) {
807
+ try {
808
+ this.destination.error(err);
809
+ } finally {
810
+ this.unsubscribe();
811
+ }
812
+ };
813
+ Subscriber2.prototype._complete = function() {
814
+ try {
815
+ this.destination.complete();
816
+ } finally {
817
+ this.unsubscribe();
818
+ }
819
+ };
820
+ return Subscriber2;
821
+ }(Subscription);
822
+ var _bind = Function.prototype.bind;
823
+ function bind(fn, thisArg) {
824
+ return _bind.call(fn, thisArg);
825
+ }
826
+ var ConsumerObserver = function() {
827
+ function ConsumerObserver2(partialObserver) {
828
+ this.partialObserver = partialObserver;
829
+ }
830
+ ConsumerObserver2.prototype.next = function(value) {
831
+ var partialObserver = this.partialObserver;
832
+ if (partialObserver.next) {
833
+ try {
834
+ partialObserver.next(value);
835
+ } catch (error) {
836
+ handleUnhandledError(error);
837
+ }
838
+ }
839
+ };
840
+ ConsumerObserver2.prototype.error = function(err) {
841
+ var partialObserver = this.partialObserver;
842
+ if (partialObserver.error) {
843
+ try {
844
+ partialObserver.error(err);
845
+ } catch (error) {
846
+ handleUnhandledError(error);
847
+ }
848
+ } else {
849
+ handleUnhandledError(err);
850
+ }
851
+ };
852
+ ConsumerObserver2.prototype.complete = function() {
853
+ var partialObserver = this.partialObserver;
854
+ if (partialObserver.complete) {
855
+ try {
856
+ partialObserver.complete();
857
+ } catch (error) {
858
+ handleUnhandledError(error);
859
+ }
860
+ }
861
+ };
862
+ return ConsumerObserver2;
863
+ }();
864
+ var SafeSubscriber = function(_super) {
865
+ __extends(SafeSubscriber2, _super);
866
+ function SafeSubscriber2(observerOrNext, error, complete) {
867
+ var _this = _super.call(this) || this;
868
+ var partialObserver;
869
+ if (isFunction(observerOrNext) || !observerOrNext) {
870
+ partialObserver = {
871
+ next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
872
+ error: error !== null && error !== void 0 ? error : void 0,
873
+ complete: complete !== null && complete !== void 0 ? complete : void 0
874
+ };
875
+ } else {
876
+ var context_1;
877
+ if (_this && config.useDeprecatedNextContext) {
878
+ context_1 = Object.create(observerOrNext);
879
+ context_1.unsubscribe = function() {
880
+ return _this.unsubscribe();
881
+ };
882
+ partialObserver = {
883
+ next: observerOrNext.next && bind(observerOrNext.next, context_1),
884
+ error: observerOrNext.error && bind(observerOrNext.error, context_1),
885
+ complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
886
+ };
887
+ } else {
888
+ partialObserver = observerOrNext;
889
+ }
890
+ }
891
+ _this.destination = new ConsumerObserver(partialObserver);
892
+ return _this;
893
+ }
894
+ return SafeSubscriber2;
895
+ }(Subscriber);
896
+ function handleUnhandledError(error) {
897
+ if (config.useDeprecatedSynchronousErrorHandling) {
898
+ captureError(error);
899
+ } else {
900
+ reportUnhandledError(error);
901
+ }
902
+ }
903
+ function defaultErrorHandler(err) {
904
+ throw err;
905
+ }
906
+ function handleStoppedNotification(notification, subscriber) {
907
+ var onStoppedNotification = config.onStoppedNotification;
908
+ onStoppedNotification && timeoutProvider.setTimeout(function() {
909
+ return onStoppedNotification(notification, subscriber);
910
+ });
911
+ }
912
+ var EMPTY_OBSERVER = {
913
+ closed: true,
914
+ next: noop,
915
+ error: defaultErrorHandler,
916
+ complete: noop
917
+ };
918
+
919
+ // node_modules/rxjs/dist/esm5/internal/symbol/observable.js
920
+ var observable = function() {
921
+ return typeof Symbol === "function" && Symbol.observable || "@@observable";
922
+ }();
923
+
924
+ // node_modules/rxjs/dist/esm5/internal/util/identity.js
925
+ function identity(x) {
926
+ return x;
927
+ }
928
+
929
+ // node_modules/rxjs/dist/esm5/internal/util/pipe.js
930
+ function pipeFromArray(fns) {
931
+ if (fns.length === 0) {
932
+ return identity;
933
+ }
934
+ if (fns.length === 1) {
935
+ return fns[0];
936
+ }
937
+ return function piped(input) {
938
+ return fns.reduce(function(prev, fn) {
939
+ return fn(prev);
940
+ }, input);
941
+ };
942
+ }
943
+
944
+ // node_modules/rxjs/dist/esm5/internal/Observable.js
945
+ var Observable = function() {
946
+ function Observable2(subscribe) {
947
+ if (subscribe) {
948
+ this._subscribe = subscribe;
949
+ }
950
+ }
951
+ Observable2.prototype.lift = function(operator) {
952
+ var observable2 = new Observable2();
953
+ observable2.source = this;
954
+ observable2.operator = operator;
955
+ return observable2;
956
+ };
957
+ Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
958
+ var _this = this;
959
+ var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
960
+ errorContext(function() {
961
+ var _a = _this, operator = _a.operator, source = _a.source;
962
+ subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
963
+ });
964
+ return subscriber;
965
+ };
966
+ Observable2.prototype._trySubscribe = function(sink) {
967
+ try {
968
+ return this._subscribe(sink);
969
+ } catch (err) {
970
+ sink.error(err);
971
+ }
972
+ };
973
+ Observable2.prototype.forEach = function(next, promiseCtor) {
974
+ var _this = this;
975
+ promiseCtor = getPromiseCtor(promiseCtor);
976
+ return new promiseCtor(function(resolve, reject) {
977
+ var subscriber = new SafeSubscriber({
978
+ next: function(value) {
979
+ try {
980
+ next(value);
981
+ } catch (err) {
982
+ reject(err);
983
+ subscriber.unsubscribe();
984
+ }
985
+ },
986
+ error: reject,
987
+ complete: resolve
988
+ });
989
+ _this.subscribe(subscriber);
990
+ });
991
+ };
992
+ Observable2.prototype._subscribe = function(subscriber) {
993
+ var _a;
994
+ return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
995
+ };
996
+ Observable2.prototype[observable] = function() {
997
+ return this;
998
+ };
999
+ Observable2.prototype.pipe = function() {
1000
+ var operations = [];
1001
+ for (var _i = 0; _i < arguments.length; _i++) {
1002
+ operations[_i] = arguments[_i];
1003
+ }
1004
+ return pipeFromArray(operations)(this);
1005
+ };
1006
+ Observable2.prototype.toPromise = function(promiseCtor) {
1007
+ var _this = this;
1008
+ promiseCtor = getPromiseCtor(promiseCtor);
1009
+ return new promiseCtor(function(resolve, reject) {
1010
+ var value;
1011
+ _this.subscribe(function(x) {
1012
+ return value = x;
1013
+ }, function(err) {
1014
+ return reject(err);
1015
+ }, function() {
1016
+ return resolve(value);
1017
+ });
1018
+ });
1019
+ };
1020
+ Observable2.create = function(subscribe) {
1021
+ return new Observable2(subscribe);
1022
+ };
1023
+ return Observable2;
1024
+ }();
1025
+ function getPromiseCtor(promiseCtor) {
1026
+ var _a;
1027
+ return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
1028
+ }
1029
+ function isObserver(value) {
1030
+ return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
1031
+ }
1032
+ function isSubscriber(value) {
1033
+ return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
1034
+ }
1035
+
1036
+ // node_modules/rxjs/dist/esm5/internal/testing/SubscriptionLog.js
1037
+ var SubscriptionLog = function() {
1038
+ function SubscriptionLog2(subscribedFrame, unsubscribedFrame) {
1039
+ if (unsubscribedFrame === void 0) {
1040
+ unsubscribedFrame = Infinity;
1041
+ }
1042
+ this.subscribedFrame = subscribedFrame;
1043
+ this.unsubscribedFrame = unsubscribedFrame;
1044
+ }
1045
+ return SubscriptionLog2;
1046
+ }();
1047
+
1048
+ // node_modules/rxjs/dist/esm5/internal/testing/SubscriptionLoggable.js
1049
+ var SubscriptionLoggable = function() {
1050
+ function SubscriptionLoggable2() {
1051
+ this.subscriptions = [];
1052
+ }
1053
+ SubscriptionLoggable2.prototype.logSubscribedFrame = function() {
1054
+ this.subscriptions.push(new SubscriptionLog(this.scheduler.now()));
1055
+ return this.subscriptions.length - 1;
1056
+ };
1057
+ SubscriptionLoggable2.prototype.logUnsubscribedFrame = function(index) {
1058
+ var subscriptionLogs = this.subscriptions;
1059
+ var oldSubscriptionLog = subscriptionLogs[index];
1060
+ subscriptionLogs[index] = new SubscriptionLog(oldSubscriptionLog.subscribedFrame, this.scheduler.now());
1061
+ };
1062
+ return SubscriptionLoggable2;
1063
+ }();
1064
+
1065
+ // node_modules/rxjs/dist/esm5/internal/util/applyMixins.js
1066
+ function applyMixins(derivedCtor, baseCtors) {
1067
+ for (var i = 0, len = baseCtors.length; i < len; i++) {
1068
+ var baseCtor = baseCtors[i];
1069
+ var propertyKeys = Object.getOwnPropertyNames(baseCtor.prototype);
1070
+ for (var j = 0, len2 = propertyKeys.length; j < len2; j++) {
1071
+ var name_1 = propertyKeys[j];
1072
+ derivedCtor.prototype[name_1] = baseCtor.prototype[name_1];
1073
+ }
1074
+ }
1075
+ }
1076
+
1077
+ // node_modules/rxjs/dist/esm5/internal/observable/empty.js
1078
+ var EMPTY = new Observable(function(subscriber) {
1079
+ return subscriber.complete();
1080
+ });
1081
+
1082
+ // node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
1083
+ function isScheduler(value) {
1084
+ return value && isFunction(value.schedule);
1085
+ }
1086
+
1087
+ // node_modules/rxjs/dist/esm5/internal/util/args.js
1088
+ function last(arr) {
1089
+ return arr[arr.length - 1];
1090
+ }
1091
+ function popScheduler(args) {
1092
+ return isScheduler(last(args)) ? args.pop() : void 0;
1093
+ }
1094
+
1095
+ // node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js
1096
+ var isArrayLike = function(x) {
1097
+ return x && typeof x.length === "number" && typeof x !== "function";
1098
+ };
1099
+
1100
+ // node_modules/rxjs/dist/esm5/internal/util/isPromise.js
1101
+ function isPromise(value) {
1102
+ return isFunction(value === null || value === void 0 ? void 0 : value.then);
1103
+ }
1104
+
1105
+ // node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js
1106
+ function isInteropObservable(input) {
1107
+ return isFunction(input[observable]);
1108
+ }
1109
+
1110
+ // node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js
1111
+ function isAsyncIterable(obj) {
1112
+ return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
1113
+ }
1114
+
1115
+ // node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js
1116
+ function createInvalidObservableTypeError(input) {
1117
+ 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.");
1118
+ }
1119
+
1120
+ // node_modules/rxjs/dist/esm5/internal/symbol/iterator.js
1121
+ function getSymbolIterator() {
1122
+ if (typeof Symbol !== "function" || !Symbol.iterator) {
1123
+ return "@@iterator";
1124
+ }
1125
+ return Symbol.iterator;
1126
+ }
1127
+ var iterator = getSymbolIterator();
1128
+
1129
+ // node_modules/rxjs/dist/esm5/internal/util/isIterable.js
1130
+ function isIterable(input) {
1131
+ return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
1132
+ }
1133
+
1134
+ // node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js
1135
+ function readableStreamLikeToAsyncGenerator(readableStream) {
1136
+ return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
1137
+ var reader, _a, value, done;
1138
+ return __generator(this, function(_b) {
1139
+ switch (_b.label) {
1140
+ case 0:
1141
+ reader = readableStream.getReader();
1142
+ _b.label = 1;
1143
+ case 1:
1144
+ _b.trys.push([1, , 9, 10]);
1145
+ _b.label = 2;
1146
+ case 2:
1147
+ if (false)
1148
+ return [3, 8];
1149
+ return [4, __await(reader.read())];
1150
+ case 3:
1151
+ _a = _b.sent(), value = _a.value, done = _a.done;
1152
+ if (!done)
1153
+ return [3, 5];
1154
+ return [4, __await(void 0)];
1155
+ case 4:
1156
+ return [2, _b.sent()];
1157
+ case 5:
1158
+ return [4, __await(value)];
1159
+ case 6:
1160
+ return [4, _b.sent()];
1161
+ case 7:
1162
+ _b.sent();
1163
+ return [3, 2];
1164
+ case 8:
1165
+ return [3, 10];
1166
+ case 9:
1167
+ reader.releaseLock();
1168
+ return [7];
1169
+ case 10:
1170
+ return [2];
1171
+ }
1172
+ });
1173
+ });
1174
+ }
1175
+ function isReadableStreamLike(obj) {
1176
+ return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
1177
+ }
1178
+
1179
+ // node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js
1180
+ function innerFrom(input) {
1181
+ if (input instanceof Observable) {
1182
+ return input;
1183
+ }
1184
+ if (input != null) {
1185
+ if (isInteropObservable(input)) {
1186
+ return fromInteropObservable(input);
1187
+ }
1188
+ if (isArrayLike(input)) {
1189
+ return fromArrayLike(input);
1190
+ }
1191
+ if (isPromise(input)) {
1192
+ return fromPromise(input);
1193
+ }
1194
+ if (isAsyncIterable(input)) {
1195
+ return fromAsyncIterable(input);
1196
+ }
1197
+ if (isIterable(input)) {
1198
+ return fromIterable(input);
1199
+ }
1200
+ if (isReadableStreamLike(input)) {
1201
+ return fromReadableStreamLike(input);
1202
+ }
1203
+ }
1204
+ throw createInvalidObservableTypeError(input);
1205
+ }
1206
+ function fromInteropObservable(obj) {
1207
+ return new Observable(function(subscriber) {
1208
+ var obs = obj[observable]();
1209
+ if (isFunction(obs.subscribe)) {
1210
+ return obs.subscribe(subscriber);
1211
+ }
1212
+ throw new TypeError("Provided object does not correctly implement Symbol.observable");
1213
+ });
1214
+ }
1215
+ function fromArrayLike(array) {
1216
+ return new Observable(function(subscriber) {
1217
+ for (var i = 0; i < array.length && !subscriber.closed; i++) {
1218
+ subscriber.next(array[i]);
1219
+ }
1220
+ subscriber.complete();
1221
+ });
1222
+ }
1223
+ function fromPromise(promise) {
1224
+ return new Observable(function(subscriber) {
1225
+ promise.then(function(value) {
1226
+ if (!subscriber.closed) {
1227
+ subscriber.next(value);
1228
+ subscriber.complete();
1229
+ }
1230
+ }, function(err) {
1231
+ return subscriber.error(err);
1232
+ }).then(null, reportUnhandledError);
1233
+ });
1234
+ }
1235
+ function fromIterable(iterable) {
1236
+ return new Observable(function(subscriber) {
1237
+ var e_1, _a;
1238
+ try {
1239
+ for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
1240
+ var value = iterable_1_1.value;
1241
+ subscriber.next(value);
1242
+ if (subscriber.closed) {
1243
+ return;
1244
+ }
1245
+ }
1246
+ } catch (e_1_1) {
1247
+ e_1 = { error: e_1_1 };
1248
+ } finally {
1249
+ try {
1250
+ if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return))
1251
+ _a.call(iterable_1);
1252
+ } finally {
1253
+ if (e_1)
1254
+ throw e_1.error;
1255
+ }
1256
+ }
1257
+ subscriber.complete();
1258
+ });
1259
+ }
1260
+ function fromAsyncIterable(asyncIterable) {
1261
+ return new Observable(function(subscriber) {
1262
+ process(asyncIterable, subscriber).catch(function(err) {
1263
+ return subscriber.error(err);
1264
+ });
1265
+ });
1266
+ }
1267
+ function fromReadableStreamLike(readableStream) {
1268
+ return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
1269
+ }
1270
+ function process(asyncIterable, subscriber) {
1271
+ var asyncIterable_1, asyncIterable_1_1;
1272
+ var e_2, _a;
1273
+ return __awaiter(this, void 0, void 0, function() {
1274
+ var value, e_2_1;
1275
+ return __generator(this, function(_b) {
1276
+ switch (_b.label) {
1277
+ case 0:
1278
+ _b.trys.push([0, 5, 6, 11]);
1279
+ asyncIterable_1 = __asyncValues(asyncIterable);
1280
+ _b.label = 1;
1281
+ case 1:
1282
+ return [4, asyncIterable_1.next()];
1283
+ case 2:
1284
+ if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done))
1285
+ return [3, 4];
1286
+ value = asyncIterable_1_1.value;
1287
+ subscriber.next(value);
1288
+ if (subscriber.closed) {
1289
+ return [2];
1290
+ }
1291
+ _b.label = 3;
1292
+ case 3:
1293
+ return [3, 1];
1294
+ case 4:
1295
+ return [3, 11];
1296
+ case 5:
1297
+ e_2_1 = _b.sent();
1298
+ e_2 = { error: e_2_1 };
1299
+ return [3, 11];
1300
+ case 6:
1301
+ _b.trys.push([6, , 9, 10]);
1302
+ if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)))
1303
+ return [3, 8];
1304
+ return [4, _a.call(asyncIterable_1)];
1305
+ case 7:
1306
+ _b.sent();
1307
+ _b.label = 8;
1308
+ case 8:
1309
+ return [3, 10];
1310
+ case 9:
1311
+ if (e_2)
1312
+ throw e_2.error;
1313
+ return [7];
1314
+ case 10:
1315
+ return [7];
1316
+ case 11:
1317
+ subscriber.complete();
1318
+ return [2];
1319
+ }
1320
+ });
1321
+ });
1322
+ }
1323
+
1324
+ // node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js
1325
+ function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
1326
+ if (delay === void 0) {
1327
+ delay = 0;
1328
+ }
1329
+ if (repeat === void 0) {
1330
+ repeat = false;
1331
+ }
1332
+ var scheduleSubscription = scheduler.schedule(function() {
1333
+ work();
1334
+ if (repeat) {
1335
+ parentSubscription.add(this.schedule(null, delay));
1336
+ } else {
1337
+ this.unsubscribe();
1338
+ }
1339
+ }, delay);
1340
+ parentSubscription.add(scheduleSubscription);
1341
+ if (!repeat) {
1342
+ return scheduleSubscription;
1343
+ }
1344
+ }
1345
+
1346
+ // node_modules/rxjs/dist/esm5/internal/util/lift.js
1347
+ function hasLift(source) {
1348
+ return isFunction(source === null || source === void 0 ? void 0 : source.lift);
1349
+ }
1350
+ function operate(init) {
1351
+ return function(source) {
1352
+ if (hasLift(source)) {
1353
+ return source.lift(function(liftedSource) {
1354
+ try {
1355
+ return init(liftedSource, this);
1356
+ } catch (err) {
1357
+ this.error(err);
1358
+ }
1359
+ });
1360
+ }
1361
+ throw new TypeError("Unable to lift unknown Observable type");
1362
+ };
1363
+ }
1364
+
1365
+ // node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
1366
+ function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
1367
+ return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
1368
+ }
1369
+ var OperatorSubscriber = function(_super) {
1370
+ __extends(OperatorSubscriber2, _super);
1371
+ function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
1372
+ var _this = _super.call(this, destination) || this;
1373
+ _this.onFinalize = onFinalize;
1374
+ _this.shouldUnsubscribe = shouldUnsubscribe;
1375
+ _this._next = onNext ? function(value) {
1376
+ try {
1377
+ onNext(value);
1378
+ } catch (err) {
1379
+ destination.error(err);
1380
+ }
1381
+ } : _super.prototype._next;
1382
+ _this._error = onError ? function(err) {
1383
+ try {
1384
+ onError(err);
1385
+ } catch (err2) {
1386
+ destination.error(err2);
1387
+ } finally {
1388
+ this.unsubscribe();
1389
+ }
1390
+ } : _super.prototype._error;
1391
+ _this._complete = onComplete ? function() {
1392
+ try {
1393
+ onComplete();
1394
+ } catch (err) {
1395
+ destination.error(err);
1396
+ } finally {
1397
+ this.unsubscribe();
1398
+ }
1399
+ } : _super.prototype._complete;
1400
+ return _this;
1401
+ }
1402
+ OperatorSubscriber2.prototype.unsubscribe = function() {
1403
+ var _a;
1404
+ if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
1405
+ var closed_1 = this.closed;
1406
+ _super.prototype.unsubscribe.call(this);
1407
+ !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
1408
+ }
1409
+ };
1410
+ return OperatorSubscriber2;
1411
+ }(Subscriber);
1412
+
1413
+ // node_modules/rxjs/dist/esm5/internal/operators/observeOn.js
1414
+ function observeOn(scheduler, delay) {
1415
+ if (delay === void 0) {
1416
+ delay = 0;
1417
+ }
1418
+ return operate(function(source, subscriber) {
1419
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
1420
+ return executeSchedule(subscriber, scheduler, function() {
1421
+ return subscriber.next(value);
1422
+ }, delay);
1423
+ }, function() {
1424
+ return executeSchedule(subscriber, scheduler, function() {
1425
+ return subscriber.complete();
1426
+ }, delay);
1427
+ }, function(err) {
1428
+ return executeSchedule(subscriber, scheduler, function() {
1429
+ return subscriber.error(err);
1430
+ }, delay);
1431
+ }));
1432
+ });
1433
+ }
1434
+
1435
+ // node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js
1436
+ function subscribeOn(scheduler, delay) {
1437
+ if (delay === void 0) {
1438
+ delay = 0;
1439
+ }
1440
+ return operate(function(source, subscriber) {
1441
+ subscriber.add(scheduler.schedule(function() {
1442
+ return source.subscribe(subscriber);
1443
+ }, delay));
1444
+ });
1445
+ }
1446
+
1447
+ // node_modules/rxjs/dist/esm5/internal/scheduled/scheduleObservable.js
1448
+ function scheduleObservable(input, scheduler) {
1449
+ return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
1450
+ }
1451
+
1452
+ // node_modules/rxjs/dist/esm5/internal/scheduled/schedulePromise.js
1453
+ function schedulePromise(input, scheduler) {
1454
+ return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
1455
+ }
1456
+
1457
+ // node_modules/rxjs/dist/esm5/internal/scheduled/scheduleArray.js
1458
+ function scheduleArray(input, scheduler) {
1459
+ return new Observable(function(subscriber) {
1460
+ var i = 0;
1461
+ return scheduler.schedule(function() {
1462
+ if (i === input.length) {
1463
+ subscriber.complete();
1464
+ } else {
1465
+ subscriber.next(input[i++]);
1466
+ if (!subscriber.closed) {
1467
+ this.schedule();
1468
+ }
1469
+ }
1470
+ });
1471
+ });
1472
+ }
1473
+
1474
+ // node_modules/rxjs/dist/esm5/internal/scheduled/scheduleIterable.js
1475
+ function scheduleIterable(input, scheduler) {
1476
+ return new Observable(function(subscriber) {
1477
+ var iterator2;
1478
+ executeSchedule(subscriber, scheduler, function() {
1479
+ iterator2 = input[iterator]();
1480
+ executeSchedule(subscriber, scheduler, function() {
1481
+ var _a;
1482
+ var value;
1483
+ var done;
1484
+ try {
1485
+ _a = iterator2.next(), value = _a.value, done = _a.done;
1486
+ } catch (err) {
1487
+ subscriber.error(err);
1488
+ return;
1489
+ }
1490
+ if (done) {
1491
+ subscriber.complete();
1492
+ } else {
1493
+ subscriber.next(value);
1494
+ }
1495
+ }, 0, true);
1496
+ });
1497
+ return function() {
1498
+ return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
1499
+ };
1500
+ });
1501
+ }
1502
+
1503
+ // node_modules/rxjs/dist/esm5/internal/scheduled/scheduleAsyncIterable.js
1504
+ function scheduleAsyncIterable(input, scheduler) {
1505
+ if (!input) {
1506
+ throw new Error("Iterable cannot be null");
1507
+ }
1508
+ return new Observable(function(subscriber) {
1509
+ executeSchedule(subscriber, scheduler, function() {
1510
+ var iterator2 = input[Symbol.asyncIterator]();
1511
+ executeSchedule(subscriber, scheduler, function() {
1512
+ iterator2.next().then(function(result) {
1513
+ if (result.done) {
1514
+ subscriber.complete();
1515
+ } else {
1516
+ subscriber.next(result.value);
1517
+ }
1518
+ });
1519
+ }, 0, true);
1520
+ });
1521
+ });
1522
+ }
1523
+
1524
+ // node_modules/rxjs/dist/esm5/internal/scheduled/scheduleReadableStreamLike.js
1525
+ function scheduleReadableStreamLike(input, scheduler) {
1526
+ return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
1527
+ }
1528
+
1529
+ // node_modules/rxjs/dist/esm5/internal/scheduled/scheduled.js
1530
+ function scheduled(input, scheduler) {
1531
+ if (input != null) {
1532
+ if (isInteropObservable(input)) {
1533
+ return scheduleObservable(input, scheduler);
1534
+ }
1535
+ if (isArrayLike(input)) {
1536
+ return scheduleArray(input, scheduler);
1537
+ }
1538
+ if (isPromise(input)) {
1539
+ return schedulePromise(input, scheduler);
1540
+ }
1541
+ if (isAsyncIterable(input)) {
1542
+ return scheduleAsyncIterable(input, scheduler);
1543
+ }
1544
+ if (isIterable(input)) {
1545
+ return scheduleIterable(input, scheduler);
1546
+ }
1547
+ if (isReadableStreamLike(input)) {
1548
+ return scheduleReadableStreamLike(input, scheduler);
1549
+ }
1550
+ }
1551
+ throw createInvalidObservableTypeError(input);
1552
+ }
1553
+
1554
+ // node_modules/rxjs/dist/esm5/internal/observable/from.js
1555
+ function from(input, scheduler) {
1556
+ return scheduler ? scheduled(input, scheduler) : innerFrom(input);
1557
+ }
1558
+
1559
+ // node_modules/rxjs/dist/esm5/internal/observable/of.js
1560
+ function of() {
1561
+ var args = [];
1562
+ for (var _i = 0; _i < arguments.length; _i++) {
1563
+ args[_i] = arguments[_i];
1564
+ }
1565
+ var scheduler = popScheduler(args);
1566
+ return from(args, scheduler);
1567
+ }
1568
+
1569
+ // node_modules/rxjs/dist/esm5/internal/observable/throwError.js
1570
+ function throwError(errorOrErrorFactory, scheduler) {
1571
+ var errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function() {
1572
+ return errorOrErrorFactory;
1573
+ };
1574
+ var init = function(subscriber) {
1575
+ return subscriber.error(errorFactory());
1576
+ };
1577
+ return new Observable(scheduler ? function(subscriber) {
1578
+ return scheduler.schedule(init, 0, subscriber);
1579
+ } : init);
1580
+ }
1581
+
1582
+ // node_modules/rxjs/dist/esm5/internal/Notification.js
1583
+ var NotificationKind;
1584
+ (function(NotificationKind2) {
1585
+ NotificationKind2["NEXT"] = "N";
1586
+ NotificationKind2["ERROR"] = "E";
1587
+ NotificationKind2["COMPLETE"] = "C";
1588
+ })(NotificationKind || (NotificationKind = {}));
1589
+ var Notification = function() {
1590
+ function Notification2(kind, value, error) {
1591
+ this.kind = kind;
1592
+ this.value = value;
1593
+ this.error = error;
1594
+ this.hasValue = kind === "N";
1595
+ }
1596
+ Notification2.prototype.observe = function(observer) {
1597
+ return observeNotification(this, observer);
1598
+ };
1599
+ Notification2.prototype.do = function(nextHandler, errorHandler, completeHandler) {
1600
+ var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
1601
+ 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();
1602
+ };
1603
+ Notification2.prototype.accept = function(nextOrObserver, error, complete) {
1604
+ var _a;
1605
+ return isFunction((_a = nextOrObserver) === null || _a === void 0 ? void 0 : _a.next) ? this.observe(nextOrObserver) : this.do(nextOrObserver, error, complete);
1606
+ };
1607
+ Notification2.prototype.toObservable = function() {
1608
+ var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
1609
+ var result = kind === "N" ? of(value) : kind === "E" ? throwError(function() {
1610
+ return error;
1611
+ }) : kind === "C" ? EMPTY : 0;
1612
+ if (!result) {
1613
+ throw new TypeError("Unexpected notification kind " + kind);
1614
+ }
1615
+ return result;
1616
+ };
1617
+ Notification2.createNext = function(value) {
1618
+ return new Notification2("N", value);
1619
+ };
1620
+ Notification2.createError = function(err) {
1621
+ return new Notification2("E", void 0, err);
1622
+ };
1623
+ Notification2.createComplete = function() {
1624
+ return Notification2.completeNotification;
1625
+ };
1626
+ Notification2.completeNotification = new Notification2("C");
1627
+ return Notification2;
1628
+ }();
1629
+ function observeNotification(notification, observer) {
1630
+ var _a, _b, _c;
1631
+ var _d = notification, kind = _d.kind, value = _d.value, error = _d.error;
1632
+ if (typeof kind !== "string") {
1633
+ throw new TypeError('Invalid notification, missing "kind"');
1634
+ }
1635
+ 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);
1636
+ }
1637
+
1638
+ // node_modules/rxjs/dist/esm5/internal/testing/ColdObservable.js
1639
+ var ColdObservable = function(_super) {
1640
+ __extends(ColdObservable2, _super);
1641
+ function ColdObservable2(messages, scheduler) {
1642
+ var _this = _super.call(this, function(subscriber) {
1643
+ var observable2 = this;
1644
+ var index = observable2.logSubscribedFrame();
1645
+ var subscription = new Subscription();
1646
+ subscription.add(new Subscription(function() {
1647
+ observable2.logUnsubscribedFrame(index);
1648
+ }));
1649
+ observable2.scheduleMessages(subscriber);
1650
+ return subscription;
1651
+ }) || this;
1652
+ _this.messages = messages;
1653
+ _this.subscriptions = [];
1654
+ _this.scheduler = scheduler;
1655
+ return _this;
1656
+ }
1657
+ ColdObservable2.prototype.scheduleMessages = function(subscriber) {
1658
+ var messagesLength = this.messages.length;
1659
+ for (var i = 0; i < messagesLength; i++) {
1660
+ var message = this.messages[i];
1661
+ subscriber.add(this.scheduler.schedule(function(state) {
1662
+ var _a = state, notification = _a.message.notification, destination = _a.subscriber;
1663
+ observeNotification(notification, destination);
1664
+ }, message.frame, { message, subscriber }));
1665
+ }
1666
+ };
1667
+ return ColdObservable2;
1668
+ }(Observable);
1669
+ applyMixins(ColdObservable, [SubscriptionLoggable]);
1670
+
1671
+ // node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js
1672
+ var ObjectUnsubscribedError = createErrorClass(function(_super) {
1673
+ return function ObjectUnsubscribedErrorImpl() {
1674
+ _super(this);
1675
+ this.name = "ObjectUnsubscribedError";
1676
+ this.message = "object unsubscribed";
1677
+ };
1678
+ });
1679
+
1680
+ // node_modules/rxjs/dist/esm5/internal/Subject.js
1681
+ var Subject = function(_super) {
1682
+ __extends(Subject2, _super);
1683
+ function Subject2() {
1684
+ var _this = _super.call(this) || this;
1685
+ _this.closed = false;
1686
+ _this.currentObservers = null;
1687
+ _this.observers = [];
1688
+ _this.isStopped = false;
1689
+ _this.hasError = false;
1690
+ _this.thrownError = null;
1691
+ return _this;
1692
+ }
1693
+ Subject2.prototype.lift = function(operator) {
1694
+ var subject = new AnonymousSubject(this, this);
1695
+ subject.operator = operator;
1696
+ return subject;
1697
+ };
1698
+ Subject2.prototype._throwIfClosed = function() {
1699
+ if (this.closed) {
1700
+ throw new ObjectUnsubscribedError();
1701
+ }
1702
+ };
1703
+ Subject2.prototype.next = function(value) {
1704
+ var _this = this;
1705
+ errorContext(function() {
1706
+ var e_1, _a;
1707
+ _this._throwIfClosed();
1708
+ if (!_this.isStopped) {
1709
+ if (!_this.currentObservers) {
1710
+ _this.currentObservers = Array.from(_this.observers);
1711
+ }
1712
+ try {
1713
+ for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
1714
+ var observer = _c.value;
1715
+ observer.next(value);
1716
+ }
1717
+ } catch (e_1_1) {
1718
+ e_1 = { error: e_1_1 };
1719
+ } finally {
1720
+ try {
1721
+ if (_c && !_c.done && (_a = _b.return))
1722
+ _a.call(_b);
1723
+ } finally {
1724
+ if (e_1)
1725
+ throw e_1.error;
1726
+ }
1727
+ }
1728
+ }
1729
+ });
1730
+ };
1731
+ Subject2.prototype.error = function(err) {
1732
+ var _this = this;
1733
+ errorContext(function() {
1734
+ _this._throwIfClosed();
1735
+ if (!_this.isStopped) {
1736
+ _this.hasError = _this.isStopped = true;
1737
+ _this.thrownError = err;
1738
+ var observers = _this.observers;
1739
+ while (observers.length) {
1740
+ observers.shift().error(err);
1741
+ }
1742
+ }
1743
+ });
1744
+ };
1745
+ Subject2.prototype.complete = function() {
1746
+ var _this = this;
1747
+ errorContext(function() {
1748
+ _this._throwIfClosed();
1749
+ if (!_this.isStopped) {
1750
+ _this.isStopped = true;
1751
+ var observers = _this.observers;
1752
+ while (observers.length) {
1753
+ observers.shift().complete();
1754
+ }
1755
+ }
1756
+ });
1757
+ };
1758
+ Subject2.prototype.unsubscribe = function() {
1759
+ this.isStopped = this.closed = true;
1760
+ this.observers = this.currentObservers = null;
1761
+ };
1762
+ Object.defineProperty(Subject2.prototype, "observed", {
1763
+ get: function() {
1764
+ var _a;
1765
+ return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
1766
+ },
1767
+ enumerable: false,
1768
+ configurable: true
1769
+ });
1770
+ Subject2.prototype._trySubscribe = function(subscriber) {
1771
+ this._throwIfClosed();
1772
+ return _super.prototype._trySubscribe.call(this, subscriber);
1773
+ };
1774
+ Subject2.prototype._subscribe = function(subscriber) {
1775
+ this._throwIfClosed();
1776
+ this._checkFinalizedStatuses(subscriber);
1777
+ return this._innerSubscribe(subscriber);
1778
+ };
1779
+ Subject2.prototype._innerSubscribe = function(subscriber) {
1780
+ var _this = this;
1781
+ var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
1782
+ if (hasError || isStopped) {
1783
+ return EMPTY_SUBSCRIPTION;
1784
+ }
1785
+ this.currentObservers = null;
1786
+ observers.push(subscriber);
1787
+ return new Subscription(function() {
1788
+ _this.currentObservers = null;
1789
+ arrRemove(observers, subscriber);
1790
+ });
1791
+ };
1792
+ Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
1793
+ var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
1794
+ if (hasError) {
1795
+ subscriber.error(thrownError);
1796
+ } else if (isStopped) {
1797
+ subscriber.complete();
1798
+ }
1799
+ };
1800
+ Subject2.prototype.asObservable = function() {
1801
+ var observable2 = new Observable();
1802
+ observable2.source = this;
1803
+ return observable2;
1804
+ };
1805
+ Subject2.create = function(destination, source) {
1806
+ return new AnonymousSubject(destination, source);
1807
+ };
1808
+ return Subject2;
1809
+ }(Observable);
1810
+ var AnonymousSubject = function(_super) {
1811
+ __extends(AnonymousSubject2, _super);
1812
+ function AnonymousSubject2(destination, source) {
1813
+ var _this = _super.call(this) || this;
1814
+ _this.destination = destination;
1815
+ _this.source = source;
1816
+ return _this;
1817
+ }
1818
+ AnonymousSubject2.prototype.next = function(value) {
1819
+ var _a, _b;
1820
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
1821
+ };
1822
+ AnonymousSubject2.prototype.error = function(err) {
1823
+ var _a, _b;
1824
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
1825
+ };
1826
+ AnonymousSubject2.prototype.complete = function() {
1827
+ var _a, _b;
1828
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
1829
+ };
1830
+ AnonymousSubject2.prototype._subscribe = function(subscriber) {
1831
+ var _a, _b;
1832
+ return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
1833
+ };
1834
+ return AnonymousSubject2;
1835
+ }(Subject);
1836
+
1837
+ // node_modules/rxjs/dist/esm5/internal/testing/HotObservable.js
1838
+ var HotObservable = function(_super) {
1839
+ __extends(HotObservable2, _super);
1840
+ function HotObservable2(messages, scheduler) {
1841
+ var _this = _super.call(this) || this;
1842
+ _this.messages = messages;
1843
+ _this.subscriptions = [];
1844
+ _this.scheduler = scheduler;
1845
+ return _this;
1846
+ }
1847
+ HotObservable2.prototype._subscribe = function(subscriber) {
1848
+ var subject = this;
1849
+ var index = subject.logSubscribedFrame();
1850
+ var subscription = new Subscription();
1851
+ subscription.add(new Subscription(function() {
1852
+ subject.logUnsubscribedFrame(index);
1853
+ }));
1854
+ subscription.add(_super.prototype._subscribe.call(this, subscriber));
1855
+ return subscription;
1856
+ };
1857
+ HotObservable2.prototype.setup = function() {
1858
+ var subject = this;
1859
+ var messagesLength = subject.messages.length;
1860
+ var _loop_1 = function(i2) {
1861
+ (function() {
1862
+ var _a = subject.messages[i2], notification = _a.notification, frame = _a.frame;
1863
+ subject.scheduler.schedule(function() {
1864
+ observeNotification(notification, subject);
1865
+ }, frame);
1866
+ })();
1867
+ };
1868
+ for (var i = 0; i < messagesLength; i++) {
1869
+ _loop_1(i);
1870
+ }
1871
+ };
1872
+ return HotObservable2;
1873
+ }(Subject);
1874
+ applyMixins(HotObservable, [SubscriptionLoggable]);
1875
+
1876
+ // node_modules/rxjs/dist/esm5/internal/scheduler/Action.js
1877
+ var Action = function(_super) {
1878
+ __extends(Action2, _super);
1879
+ function Action2(scheduler, work) {
1880
+ return _super.call(this) || this;
1881
+ }
1882
+ Action2.prototype.schedule = function(state, delay) {
1883
+ if (delay === void 0) {
1884
+ delay = 0;
1885
+ }
1886
+ return this;
1887
+ };
1888
+ return Action2;
1889
+ }(Subscription);
1890
+
1891
+ // node_modules/rxjs/dist/esm5/internal/scheduler/intervalProvider.js
1892
+ var intervalProvider = {
1893
+ setInterval: function(handler, timeout) {
1894
+ var args = [];
1895
+ for (var _i = 2; _i < arguments.length; _i++) {
1896
+ args[_i - 2] = arguments[_i];
1897
+ }
1898
+ var delegate = intervalProvider.delegate;
1899
+ if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
1900
+ return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout], __read(args)));
1901
+ }
1902
+ return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
1903
+ },
1904
+ clearInterval: function(handle) {
1905
+ var delegate = intervalProvider.delegate;
1906
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
1907
+ },
1908
+ delegate: void 0
1909
+ };
1910
+
1911
+ // node_modules/rxjs/dist/esm5/internal/scheduler/AsyncAction.js
1912
+ var AsyncAction = function(_super) {
1913
+ __extends(AsyncAction2, _super);
1914
+ function AsyncAction2(scheduler, work) {
1915
+ var _this = _super.call(this, scheduler, work) || this;
1916
+ _this.scheduler = scheduler;
1917
+ _this.work = work;
1918
+ _this.pending = false;
1919
+ return _this;
1920
+ }
1921
+ AsyncAction2.prototype.schedule = function(state, delay) {
1922
+ if (delay === void 0) {
1923
+ delay = 0;
1924
+ }
1925
+ if (this.closed) {
1926
+ return this;
1927
+ }
1928
+ this.state = state;
1929
+ var id = this.id;
1930
+ var scheduler = this.scheduler;
1931
+ if (id != null) {
1932
+ this.id = this.recycleAsyncId(scheduler, id, delay);
1933
+ }
1934
+ this.pending = true;
1935
+ this.delay = delay;
1936
+ this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);
1937
+ return this;
1938
+ };
1939
+ AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay) {
1940
+ if (delay === void 0) {
1941
+ delay = 0;
1942
+ }
1943
+ return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
1944
+ };
1945
+ AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay) {
1946
+ if (delay === void 0) {
1947
+ delay = 0;
1948
+ }
1949
+ if (delay != null && this.delay === delay && this.pending === false) {
1950
+ return id;
1951
+ }
1952
+ intervalProvider.clearInterval(id);
1953
+ return void 0;
1954
+ };
1955
+ AsyncAction2.prototype.execute = function(state, delay) {
1956
+ if (this.closed) {
1957
+ return new Error("executing a cancelled action");
1958
+ }
1959
+ this.pending = false;
1960
+ var error = this._execute(state, delay);
1961
+ if (error) {
1962
+ return error;
1963
+ } else if (this.pending === false && this.id != null) {
1964
+ this.id = this.recycleAsyncId(this.scheduler, this.id, null);
1965
+ }
1966
+ };
1967
+ AsyncAction2.prototype._execute = function(state, _delay) {
1968
+ var errored = false;
1969
+ var errorValue;
1970
+ try {
1971
+ this.work(state);
1972
+ } catch (e) {
1973
+ errored = true;
1974
+ errorValue = e ? e : new Error("Scheduled action threw falsy error");
1975
+ }
1976
+ if (errored) {
1977
+ this.unsubscribe();
1978
+ return errorValue;
1979
+ }
1980
+ };
1981
+ AsyncAction2.prototype.unsubscribe = function() {
1982
+ if (!this.closed) {
1983
+ var _a = this, id = _a.id, scheduler = _a.scheduler;
1984
+ var actions = scheduler.actions;
1985
+ this.work = this.state = this.scheduler = null;
1986
+ this.pending = false;
1987
+ arrRemove(actions, this);
1988
+ if (id != null) {
1989
+ this.id = this.recycleAsyncId(scheduler, id, null);
1990
+ }
1991
+ this.delay = null;
1992
+ _super.prototype.unsubscribe.call(this);
1993
+ }
1994
+ };
1995
+ return AsyncAction2;
1996
+ }(Action);
1997
+
1998
+ // node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js
1999
+ var dateTimestampProvider = {
2000
+ now: function() {
2001
+ return (dateTimestampProvider.delegate || Date).now();
2002
+ },
2003
+ delegate: void 0
2004
+ };
2005
+
2006
+ // node_modules/rxjs/dist/esm5/internal/Scheduler.js
2007
+ var Scheduler = function() {
2008
+ function Scheduler2(schedulerActionCtor, now) {
2009
+ if (now === void 0) {
2010
+ now = Scheduler2.now;
2011
+ }
2012
+ this.schedulerActionCtor = schedulerActionCtor;
2013
+ this.now = now;
2014
+ }
2015
+ Scheduler2.prototype.schedule = function(work, delay, state) {
2016
+ if (delay === void 0) {
2017
+ delay = 0;
2018
+ }
2019
+ return new this.schedulerActionCtor(this, work).schedule(state, delay);
2020
+ };
2021
+ Scheduler2.now = dateTimestampProvider.now;
2022
+ return Scheduler2;
2023
+ }();
2024
+
2025
+ // node_modules/rxjs/dist/esm5/internal/scheduler/AsyncScheduler.js
2026
+ var AsyncScheduler = function(_super) {
2027
+ __extends(AsyncScheduler2, _super);
2028
+ function AsyncScheduler2(SchedulerAction, now) {
2029
+ if (now === void 0) {
2030
+ now = Scheduler.now;
2031
+ }
2032
+ var _this = _super.call(this, SchedulerAction, now) || this;
2033
+ _this.actions = [];
2034
+ _this._active = false;
2035
+ _this._scheduled = void 0;
2036
+ return _this;
2037
+ }
2038
+ AsyncScheduler2.prototype.flush = function(action) {
2039
+ var actions = this.actions;
2040
+ if (this._active) {
2041
+ actions.push(action);
2042
+ return;
2043
+ }
2044
+ var error;
2045
+ this._active = true;
2046
+ do {
2047
+ if (error = action.execute(action.state, action.delay)) {
2048
+ break;
2049
+ }
2050
+ } while (action = actions.shift());
2051
+ this._active = false;
2052
+ if (error) {
2053
+ while (action = actions.shift()) {
2054
+ action.unsubscribe();
2055
+ }
2056
+ throw error;
2057
+ }
2058
+ };
2059
+ return AsyncScheduler2;
2060
+ }(Scheduler);
2061
+
2062
+ // node_modules/rxjs/dist/esm5/internal/scheduler/VirtualTimeScheduler.js
2063
+ var VirtualTimeScheduler = function(_super) {
2064
+ __extends(VirtualTimeScheduler2, _super);
2065
+ function VirtualTimeScheduler2(schedulerActionCtor, maxFrames) {
2066
+ if (schedulerActionCtor === void 0) {
2067
+ schedulerActionCtor = VirtualAction;
2068
+ }
2069
+ if (maxFrames === void 0) {
2070
+ maxFrames = Infinity;
2071
+ }
2072
+ var _this = _super.call(this, schedulerActionCtor, function() {
2073
+ return _this.frame;
2074
+ }) || this;
2075
+ _this.maxFrames = maxFrames;
2076
+ _this.frame = 0;
2077
+ _this.index = -1;
2078
+ return _this;
2079
+ }
2080
+ VirtualTimeScheduler2.prototype.flush = function() {
2081
+ var _a = this, actions = _a.actions, maxFrames = _a.maxFrames;
2082
+ var error;
2083
+ var action;
2084
+ while ((action = actions[0]) && action.delay <= maxFrames) {
2085
+ actions.shift();
2086
+ this.frame = action.delay;
2087
+ if (error = action.execute(action.state, action.delay)) {
2088
+ break;
2089
+ }
2090
+ }
2091
+ if (error) {
2092
+ while (action = actions.shift()) {
2093
+ action.unsubscribe();
2094
+ }
2095
+ throw error;
2096
+ }
2097
+ };
2098
+ VirtualTimeScheduler2.frameTimeFactor = 10;
2099
+ return VirtualTimeScheduler2;
2100
+ }(AsyncScheduler);
2101
+ var VirtualAction = function(_super) {
2102
+ __extends(VirtualAction2, _super);
2103
+ function VirtualAction2(scheduler, work, index) {
2104
+ if (index === void 0) {
2105
+ index = scheduler.index += 1;
2106
+ }
2107
+ var _this = _super.call(this, scheduler, work) || this;
2108
+ _this.scheduler = scheduler;
2109
+ _this.work = work;
2110
+ _this.index = index;
2111
+ _this.active = true;
2112
+ _this.index = scheduler.index = index;
2113
+ return _this;
2114
+ }
2115
+ VirtualAction2.prototype.schedule = function(state, delay) {
2116
+ if (delay === void 0) {
2117
+ delay = 0;
2118
+ }
2119
+ if (Number.isFinite(delay)) {
2120
+ if (!this.id) {
2121
+ return _super.prototype.schedule.call(this, state, delay);
2122
+ }
2123
+ this.active = false;
2124
+ var action = new VirtualAction2(this.scheduler, this.work);
2125
+ this.add(action);
2126
+ return action.schedule(state, delay);
2127
+ } else {
2128
+ return Subscription.EMPTY;
2129
+ }
2130
+ };
2131
+ VirtualAction2.prototype.requestAsyncId = function(scheduler, id, delay) {
2132
+ if (delay === void 0) {
2133
+ delay = 0;
2134
+ }
2135
+ this.delay = scheduler.frame + delay;
2136
+ var actions = scheduler.actions;
2137
+ actions.push(this);
2138
+ actions.sort(VirtualAction2.sortActions);
2139
+ return true;
2140
+ };
2141
+ VirtualAction2.prototype.recycleAsyncId = function(scheduler, id, delay) {
2142
+ if (delay === void 0) {
2143
+ delay = 0;
2144
+ }
2145
+ return void 0;
2146
+ };
2147
+ VirtualAction2.prototype._execute = function(state, delay) {
2148
+ if (this.active === true) {
2149
+ return _super.prototype._execute.call(this, state, delay);
2150
+ }
2151
+ };
2152
+ VirtualAction2.sortActions = function(a, b) {
2153
+ if (a.delay === b.delay) {
2154
+ if (a.index === b.index) {
2155
+ return 0;
2156
+ } else if (a.index > b.index) {
2157
+ return 1;
2158
+ } else {
2159
+ return -1;
2160
+ }
2161
+ } else if (a.delay > b.delay) {
2162
+ return 1;
2163
+ } else {
2164
+ return -1;
2165
+ }
2166
+ };
2167
+ return VirtualAction2;
2168
+ }(AsyncAction);
2169
+
2170
+ // node_modules/rxjs/dist/esm5/internal/scheduler/performanceTimestampProvider.js
2171
+ var performanceTimestampProvider = {
2172
+ now: function() {
2173
+ return (performanceTimestampProvider.delegate || performance).now();
2174
+ },
2175
+ delegate: void 0
2176
+ };
2177
+
2178
+ // node_modules/rxjs/dist/esm5/internal/scheduler/animationFrameProvider.js
2179
+ var animationFrameProvider = {
2180
+ schedule: function(callback) {
2181
+ var request = requestAnimationFrame;
2182
+ var cancel = cancelAnimationFrame;
2183
+ var delegate = animationFrameProvider.delegate;
2184
+ if (delegate) {
2185
+ request = delegate.requestAnimationFrame;
2186
+ cancel = delegate.cancelAnimationFrame;
2187
+ }
2188
+ var handle = request(function(timestamp) {
2189
+ cancel = void 0;
2190
+ callback(timestamp);
2191
+ });
2192
+ return new Subscription(function() {
2193
+ return cancel === null || cancel === void 0 ? void 0 : cancel(handle);
2194
+ });
2195
+ },
2196
+ requestAnimationFrame: function() {
2197
+ var args = [];
2198
+ for (var _i = 0; _i < arguments.length; _i++) {
2199
+ args[_i] = arguments[_i];
2200
+ }
2201
+ var delegate = animationFrameProvider.delegate;
2202
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.requestAnimationFrame) || requestAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
2203
+ },
2204
+ cancelAnimationFrame: function() {
2205
+ var args = [];
2206
+ for (var _i = 0; _i < arguments.length; _i++) {
2207
+ args[_i] = arguments[_i];
2208
+ }
2209
+ var delegate = animationFrameProvider.delegate;
2210
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.cancelAnimationFrame) || cancelAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
2211
+ },
2212
+ delegate: void 0
2213
+ };
2214
+
2215
+ // node_modules/rxjs/dist/esm5/internal/util/Immediate.js
2216
+ var nextHandle = 1;
2217
+ var resolved;
2218
+ var activeHandles = {};
2219
+ function findAndClearHandle(handle) {
2220
+ if (handle in activeHandles) {
2221
+ delete activeHandles[handle];
2222
+ return true;
2223
+ }
2224
+ return false;
2225
+ }
2226
+ var Immediate = {
2227
+ setImmediate: function(cb) {
2228
+ var handle = nextHandle++;
2229
+ activeHandles[handle] = true;
2230
+ if (!resolved) {
2231
+ resolved = Promise.resolve();
2232
+ }
2233
+ resolved.then(function() {
2234
+ return findAndClearHandle(handle) && cb();
2235
+ });
2236
+ return handle;
2237
+ },
2238
+ clearImmediate: function(handle) {
2239
+ findAndClearHandle(handle);
2240
+ }
2241
+ };
2242
+
2243
+ // node_modules/rxjs/dist/esm5/internal/scheduler/immediateProvider.js
2244
+ var setImmediate = Immediate.setImmediate;
2245
+ var clearImmediate = Immediate.clearImmediate;
2246
+ var immediateProvider = {
2247
+ setImmediate: function() {
2248
+ var args = [];
2249
+ for (var _i = 0; _i < arguments.length; _i++) {
2250
+ args[_i] = arguments[_i];
2251
+ }
2252
+ var delegate = immediateProvider.delegate;
2253
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.setImmediate) || setImmediate).apply(void 0, __spreadArray([], __read(args)));
2254
+ },
2255
+ clearImmediate: function(handle) {
2256
+ var delegate = immediateProvider.delegate;
2257
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearImmediate) || clearImmediate)(handle);
2258
+ },
2259
+ delegate: void 0
2260
+ };
2261
+
2262
+ // node_modules/rxjs/dist/esm5/internal/testing/TestScheduler.js
2263
+ var defaultMaxFrame = 750;
2264
+ var TestScheduler = function(_super) {
2265
+ __extends(TestScheduler2, _super);
2266
+ function TestScheduler2(assertDeepEqual) {
2267
+ var _this = _super.call(this, VirtualAction, defaultMaxFrame) || this;
2268
+ _this.assertDeepEqual = assertDeepEqual;
2269
+ _this.hotObservables = [];
2270
+ _this.coldObservables = [];
2271
+ _this.flushTests = [];
2272
+ _this.runMode = false;
2273
+ return _this;
2274
+ }
2275
+ TestScheduler2.prototype.createTime = function(marbles) {
2276
+ var indexOf = this.runMode ? marbles.trim().indexOf("|") : marbles.indexOf("|");
2277
+ if (indexOf === -1) {
2278
+ throw new Error('marble diagram for time should have a completion marker "|"');
2279
+ }
2280
+ return indexOf * TestScheduler2.frameTimeFactor;
2281
+ };
2282
+ TestScheduler2.prototype.createColdObservable = function(marbles, values, error) {
2283
+ if (marbles.indexOf("^") !== -1) {
2284
+ throw new Error('cold observable cannot have subscription offset "^"');
2285
+ }
2286
+ if (marbles.indexOf("!") !== -1) {
2287
+ throw new Error('cold observable cannot have unsubscription marker "!"');
2288
+ }
2289
+ var messages = TestScheduler2.parseMarbles(marbles, values, error, void 0, this.runMode);
2290
+ var cold = new ColdObservable(messages, this);
2291
+ this.coldObservables.push(cold);
2292
+ return cold;
2293
+ };
2294
+ TestScheduler2.prototype.createHotObservable = function(marbles, values, error) {
2295
+ if (marbles.indexOf("!") !== -1) {
2296
+ throw new Error('hot observable cannot have unsubscription marker "!"');
2297
+ }
2298
+ var messages = TestScheduler2.parseMarbles(marbles, values, error, void 0, this.runMode);
2299
+ var subject = new HotObservable(messages, this);
2300
+ this.hotObservables.push(subject);
2301
+ return subject;
2302
+ };
2303
+ TestScheduler2.prototype.materializeInnerObservable = function(observable2, outerFrame) {
2304
+ var _this = this;
2305
+ var messages = [];
2306
+ observable2.subscribe({
2307
+ next: function(value) {
2308
+ messages.push({ frame: _this.frame - outerFrame, notification: nextNotification(value) });
2309
+ },
2310
+ error: function(error) {
2311
+ messages.push({ frame: _this.frame - outerFrame, notification: errorNotification(error) });
2312
+ },
2313
+ complete: function() {
2314
+ messages.push({ frame: _this.frame - outerFrame, notification: COMPLETE_NOTIFICATION });
2315
+ }
2316
+ });
2317
+ return messages;
2318
+ };
2319
+ TestScheduler2.prototype.expectObservable = function(observable2, subscriptionMarbles) {
2320
+ var _this = this;
2321
+ if (subscriptionMarbles === void 0) {
2322
+ subscriptionMarbles = null;
2323
+ }
2324
+ var actual = [];
2325
+ var flushTest = { actual, ready: false };
2326
+ var subscriptionParsed = TestScheduler2.parseMarblesAsSubscriptions(subscriptionMarbles, this.runMode);
2327
+ var subscriptionFrame = subscriptionParsed.subscribedFrame === Infinity ? 0 : subscriptionParsed.subscribedFrame;
2328
+ var unsubscriptionFrame = subscriptionParsed.unsubscribedFrame;
2329
+ var subscription;
2330
+ this.schedule(function() {
2331
+ subscription = observable2.subscribe({
2332
+ next: function(x) {
2333
+ var value = x instanceof Observable ? _this.materializeInnerObservable(x, _this.frame) : x;
2334
+ actual.push({ frame: _this.frame, notification: nextNotification(value) });
2335
+ },
2336
+ error: function(error) {
2337
+ actual.push({ frame: _this.frame, notification: errorNotification(error) });
2338
+ },
2339
+ complete: function() {
2340
+ actual.push({ frame: _this.frame, notification: COMPLETE_NOTIFICATION });
2341
+ }
2342
+ });
2343
+ }, subscriptionFrame);
2344
+ if (unsubscriptionFrame !== Infinity) {
2345
+ this.schedule(function() {
2346
+ return subscription.unsubscribe();
2347
+ }, unsubscriptionFrame);
2348
+ }
2349
+ this.flushTests.push(flushTest);
2350
+ var runMode = this.runMode;
2351
+ return {
2352
+ toBe: function(marbles, values, errorValue) {
2353
+ flushTest.ready = true;
2354
+ flushTest.expected = TestScheduler2.parseMarbles(marbles, values, errorValue, true, runMode);
2355
+ },
2356
+ toEqual: function(other) {
2357
+ flushTest.ready = true;
2358
+ flushTest.expected = [];
2359
+ _this.schedule(function() {
2360
+ subscription = other.subscribe({
2361
+ next: function(x) {
2362
+ var value = x instanceof Observable ? _this.materializeInnerObservable(x, _this.frame) : x;
2363
+ flushTest.expected.push({ frame: _this.frame, notification: nextNotification(value) });
2364
+ },
2365
+ error: function(error) {
2366
+ flushTest.expected.push({ frame: _this.frame, notification: errorNotification(error) });
2367
+ },
2368
+ complete: function() {
2369
+ flushTest.expected.push({ frame: _this.frame, notification: COMPLETE_NOTIFICATION });
2370
+ }
2371
+ });
2372
+ }, subscriptionFrame);
2373
+ }
2374
+ };
2375
+ };
2376
+ TestScheduler2.prototype.expectSubscriptions = function(actualSubscriptionLogs) {
2377
+ var flushTest = { actual: actualSubscriptionLogs, ready: false };
2378
+ this.flushTests.push(flushTest);
2379
+ var runMode = this.runMode;
2380
+ return {
2381
+ toBe: function(marblesOrMarblesArray) {
2382
+ var marblesArray = typeof marblesOrMarblesArray === "string" ? [marblesOrMarblesArray] : marblesOrMarblesArray;
2383
+ flushTest.ready = true;
2384
+ flushTest.expected = marblesArray.map(function(marbles) {
2385
+ return TestScheduler2.parseMarblesAsSubscriptions(marbles, runMode);
2386
+ }).filter(function(marbles) {
2387
+ return marbles.subscribedFrame !== Infinity;
2388
+ });
2389
+ }
2390
+ };
2391
+ };
2392
+ TestScheduler2.prototype.flush = function() {
2393
+ var _this = this;
2394
+ var hotObservables = this.hotObservables;
2395
+ while (hotObservables.length > 0) {
2396
+ hotObservables.shift().setup();
2397
+ }
2398
+ _super.prototype.flush.call(this);
2399
+ this.flushTests = this.flushTests.filter(function(test) {
2400
+ if (test.ready) {
2401
+ _this.assertDeepEqual(test.actual, test.expected);
2402
+ return false;
2403
+ }
2404
+ return true;
2405
+ });
2406
+ };
2407
+ TestScheduler2.parseMarblesAsSubscriptions = function(marbles, runMode) {
2408
+ var _this = this;
2409
+ if (runMode === void 0) {
2410
+ runMode = false;
2411
+ }
2412
+ if (typeof marbles !== "string") {
2413
+ return new SubscriptionLog(Infinity);
2414
+ }
2415
+ var characters = __spreadArray([], __read(marbles));
2416
+ var len = characters.length;
2417
+ var groupStart = -1;
2418
+ var subscriptionFrame = Infinity;
2419
+ var unsubscriptionFrame = Infinity;
2420
+ var frame = 0;
2421
+ var _loop_1 = function(i2) {
2422
+ var nextFrame = frame;
2423
+ var advanceFrameBy = function(count) {
2424
+ nextFrame += count * _this.frameTimeFactor;
2425
+ };
2426
+ var c = characters[i2];
2427
+ switch (c) {
2428
+ case " ":
2429
+ if (!runMode) {
2430
+ advanceFrameBy(1);
2431
+ }
2432
+ break;
2433
+ case "-":
2434
+ advanceFrameBy(1);
2435
+ break;
2436
+ case "(":
2437
+ groupStart = frame;
2438
+ advanceFrameBy(1);
2439
+ break;
2440
+ case ")":
2441
+ groupStart = -1;
2442
+ advanceFrameBy(1);
2443
+ break;
2444
+ case "^":
2445
+ if (subscriptionFrame !== Infinity) {
2446
+ throw new Error("found a second subscription point '^' in a subscription marble diagram. There can only be one.");
2447
+ }
2448
+ subscriptionFrame = groupStart > -1 ? groupStart : frame;
2449
+ advanceFrameBy(1);
2450
+ break;
2451
+ case "!":
2452
+ if (unsubscriptionFrame !== Infinity) {
2453
+ throw new Error("found a second unsubscription point '!' in a subscription marble diagram. There can only be one.");
2454
+ }
2455
+ unsubscriptionFrame = groupStart > -1 ? groupStart : frame;
2456
+ break;
2457
+ default:
2458
+ if (runMode && c.match(/^[0-9]$/)) {
2459
+ if (i2 === 0 || characters[i2 - 1] === " ") {
2460
+ var buffer = characters.slice(i2).join("");
2461
+ var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
2462
+ if (match) {
2463
+ i2 += match[0].length - 1;
2464
+ var duration = parseFloat(match[1]);
2465
+ var unit = match[2];
2466
+ var durationInMs = void 0;
2467
+ switch (unit) {
2468
+ case "ms":
2469
+ durationInMs = duration;
2470
+ break;
2471
+ case "s":
2472
+ durationInMs = duration * 1e3;
2473
+ break;
2474
+ case "m":
2475
+ durationInMs = duration * 1e3 * 60;
2476
+ break;
2477
+ default:
2478
+ break;
2479
+ }
2480
+ advanceFrameBy(durationInMs / this_1.frameTimeFactor);
2481
+ break;
2482
+ }
2483
+ }
2484
+ }
2485
+ throw new Error("there can only be '^' and '!' markers in a subscription marble diagram. Found instead '" + c + "'.");
2486
+ }
2487
+ frame = nextFrame;
2488
+ out_i_1 = i2;
2489
+ };
2490
+ var this_1 = this, out_i_1;
2491
+ for (var i = 0; i < len; i++) {
2492
+ _loop_1(i);
2493
+ i = out_i_1;
2494
+ }
2495
+ if (unsubscriptionFrame < 0) {
2496
+ return new SubscriptionLog(subscriptionFrame);
2497
+ } else {
2498
+ return new SubscriptionLog(subscriptionFrame, unsubscriptionFrame);
2499
+ }
2500
+ };
2501
+ TestScheduler2.parseMarbles = function(marbles, values, errorValue, materializeInnerObservables, runMode) {
2502
+ var _this = this;
2503
+ if (materializeInnerObservables === void 0) {
2504
+ materializeInnerObservables = false;
2505
+ }
2506
+ if (runMode === void 0) {
2507
+ runMode = false;
2508
+ }
2509
+ if (marbles.indexOf("!") !== -1) {
2510
+ throw new Error('conventional marble diagrams cannot have the unsubscription marker "!"');
2511
+ }
2512
+ var characters = __spreadArray([], __read(marbles));
2513
+ var len = characters.length;
2514
+ var testMessages = [];
2515
+ var subIndex = runMode ? marbles.replace(/^[ ]+/, "").indexOf("^") : marbles.indexOf("^");
2516
+ var frame = subIndex === -1 ? 0 : subIndex * -this.frameTimeFactor;
2517
+ var getValue = typeof values !== "object" ? function(x) {
2518
+ return x;
2519
+ } : function(x) {
2520
+ if (materializeInnerObservables && values[x] instanceof ColdObservable) {
2521
+ return values[x].messages;
2522
+ }
2523
+ return values[x];
2524
+ };
2525
+ var groupStart = -1;
2526
+ var _loop_2 = function(i2) {
2527
+ var nextFrame = frame;
2528
+ var advanceFrameBy = function(count) {
2529
+ nextFrame += count * _this.frameTimeFactor;
2530
+ };
2531
+ var notification = void 0;
2532
+ var c = characters[i2];
2533
+ switch (c) {
2534
+ case " ":
2535
+ if (!runMode) {
2536
+ advanceFrameBy(1);
2537
+ }
2538
+ break;
2539
+ case "-":
2540
+ advanceFrameBy(1);
2541
+ break;
2542
+ case "(":
2543
+ groupStart = frame;
2544
+ advanceFrameBy(1);
2545
+ break;
2546
+ case ")":
2547
+ groupStart = -1;
2548
+ advanceFrameBy(1);
2549
+ break;
2550
+ case "|":
2551
+ notification = COMPLETE_NOTIFICATION;
2552
+ advanceFrameBy(1);
2553
+ break;
2554
+ case "^":
2555
+ advanceFrameBy(1);
2556
+ break;
2557
+ case "#":
2558
+ notification = errorNotification(errorValue || "error");
2559
+ advanceFrameBy(1);
2560
+ break;
2561
+ default:
2562
+ if (runMode && c.match(/^[0-9]$/)) {
2563
+ if (i2 === 0 || characters[i2 - 1] === " ") {
2564
+ var buffer = characters.slice(i2).join("");
2565
+ var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
2566
+ if (match) {
2567
+ i2 += match[0].length - 1;
2568
+ var duration = parseFloat(match[1]);
2569
+ var unit = match[2];
2570
+ var durationInMs = void 0;
2571
+ switch (unit) {
2572
+ case "ms":
2573
+ durationInMs = duration;
2574
+ break;
2575
+ case "s":
2576
+ durationInMs = duration * 1e3;
2577
+ break;
2578
+ case "m":
2579
+ durationInMs = duration * 1e3 * 60;
2580
+ break;
2581
+ default:
2582
+ break;
2583
+ }
2584
+ advanceFrameBy(durationInMs / this_2.frameTimeFactor);
2585
+ break;
2586
+ }
2587
+ }
2588
+ }
2589
+ notification = nextNotification(getValue(c));
2590
+ advanceFrameBy(1);
2591
+ break;
2592
+ }
2593
+ if (notification) {
2594
+ testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification });
2595
+ }
2596
+ frame = nextFrame;
2597
+ out_i_2 = i2;
2598
+ };
2599
+ var this_2 = this, out_i_2;
2600
+ for (var i = 0; i < len; i++) {
2601
+ _loop_2(i);
2602
+ i = out_i_2;
2603
+ }
2604
+ return testMessages;
2605
+ };
2606
+ TestScheduler2.prototype.createAnimator = function() {
2607
+ var _this = this;
2608
+ if (!this.runMode) {
2609
+ throw new Error("animate() must only be used in run mode");
2610
+ }
2611
+ var lastHandle = 0;
2612
+ var map;
2613
+ var delegate = {
2614
+ requestAnimationFrame: function(callback) {
2615
+ if (!map) {
2616
+ throw new Error("animate() was not called within run()");
2617
+ }
2618
+ var handle = ++lastHandle;
2619
+ map.set(handle, callback);
2620
+ return handle;
2621
+ },
2622
+ cancelAnimationFrame: function(handle) {
2623
+ if (!map) {
2624
+ throw new Error("animate() was not called within run()");
2625
+ }
2626
+ map.delete(handle);
2627
+ }
2628
+ };
2629
+ var animate = function(marbles) {
2630
+ var e_1, _a;
2631
+ if (map) {
2632
+ throw new Error("animate() must not be called more than once within run()");
2633
+ }
2634
+ if (/[|#]/.test(marbles)) {
2635
+ throw new Error("animate() must not complete or error");
2636
+ }
2637
+ map = /* @__PURE__ */ new Map();
2638
+ var messages = TestScheduler2.parseMarbles(marbles, void 0, void 0, void 0, true);
2639
+ try {
2640
+ for (var messages_1 = __values(messages), messages_1_1 = messages_1.next(); !messages_1_1.done; messages_1_1 = messages_1.next()) {
2641
+ var message = messages_1_1.value;
2642
+ _this.schedule(function() {
2643
+ var e_2, _a2;
2644
+ var now = _this.now();
2645
+ var callbacks = Array.from(map.values());
2646
+ map.clear();
2647
+ try {
2648
+ 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()) {
2649
+ var callback = callbacks_1_1.value;
2650
+ callback(now);
2651
+ }
2652
+ } catch (e_2_1) {
2653
+ e_2 = { error: e_2_1 };
2654
+ } finally {
2655
+ try {
2656
+ if (callbacks_1_1 && !callbacks_1_1.done && (_a2 = callbacks_1.return))
2657
+ _a2.call(callbacks_1);
2658
+ } finally {
2659
+ if (e_2)
2660
+ throw e_2.error;
2661
+ }
2662
+ }
2663
+ }, message.frame);
2664
+ }
2665
+ } catch (e_1_1) {
2666
+ e_1 = { error: e_1_1 };
2667
+ } finally {
2668
+ try {
2669
+ if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return))
2670
+ _a.call(messages_1);
2671
+ } finally {
2672
+ if (e_1)
2673
+ throw e_1.error;
2674
+ }
2675
+ }
2676
+ };
2677
+ return { animate, delegate };
2678
+ };
2679
+ TestScheduler2.prototype.createDelegates = function() {
2680
+ var _this = this;
2681
+ var lastHandle = 0;
2682
+ var scheduleLookup = /* @__PURE__ */ new Map();
2683
+ var run = function() {
2684
+ var now = _this.now();
2685
+ var scheduledRecords = Array.from(scheduleLookup.values());
2686
+ var scheduledRecordsDue = scheduledRecords.filter(function(_a2) {
2687
+ var due = _a2.due;
2688
+ return due <= now;
2689
+ });
2690
+ var dueImmediates = scheduledRecordsDue.filter(function(_a2) {
2691
+ var type = _a2.type;
2692
+ return type === "immediate";
2693
+ });
2694
+ if (dueImmediates.length > 0) {
2695
+ var _a = dueImmediates[0], handle = _a.handle, handler = _a.handler;
2696
+ scheduleLookup.delete(handle);
2697
+ handler();
2698
+ return;
2699
+ }
2700
+ var dueIntervals = scheduledRecordsDue.filter(function(_a2) {
2701
+ var type = _a2.type;
2702
+ return type === "interval";
2703
+ });
2704
+ if (dueIntervals.length > 0) {
2705
+ var firstDueInterval = dueIntervals[0];
2706
+ var duration = firstDueInterval.duration, handler = firstDueInterval.handler;
2707
+ firstDueInterval.due = now + duration;
2708
+ firstDueInterval.subscription = _this.schedule(run, duration);
2709
+ handler();
2710
+ return;
2711
+ }
2712
+ var dueTimeouts = scheduledRecordsDue.filter(function(_a2) {
2713
+ var type = _a2.type;
2714
+ return type === "timeout";
2715
+ });
2716
+ if (dueTimeouts.length > 0) {
2717
+ var _b = dueTimeouts[0], handle = _b.handle, handler = _b.handler;
2718
+ scheduleLookup.delete(handle);
2719
+ handler();
2720
+ return;
2721
+ }
2722
+ throw new Error("Expected a due immediate or interval");
2723
+ };
2724
+ var immediate = {
2725
+ setImmediate: function(handler) {
2726
+ var handle = ++lastHandle;
2727
+ scheduleLookup.set(handle, {
2728
+ due: _this.now(),
2729
+ duration: 0,
2730
+ handle,
2731
+ handler,
2732
+ subscription: _this.schedule(run, 0),
2733
+ type: "immediate"
2734
+ });
2735
+ return handle;
2736
+ },
2737
+ clearImmediate: function(handle) {
2738
+ var value = scheduleLookup.get(handle);
2739
+ if (value) {
2740
+ value.subscription.unsubscribe();
2741
+ scheduleLookup.delete(handle);
2742
+ }
2743
+ }
2744
+ };
2745
+ var interval = {
2746
+ setInterval: function(handler, duration) {
2747
+ if (duration === void 0) {
2748
+ duration = 0;
2749
+ }
2750
+ var handle = ++lastHandle;
2751
+ scheduleLookup.set(handle, {
2752
+ due: _this.now() + duration,
2753
+ duration,
2754
+ handle,
2755
+ handler,
2756
+ subscription: _this.schedule(run, duration),
2757
+ type: "interval"
2758
+ });
2759
+ return handle;
2760
+ },
2761
+ clearInterval: function(handle) {
2762
+ var value = scheduleLookup.get(handle);
2763
+ if (value) {
2764
+ value.subscription.unsubscribe();
2765
+ scheduleLookup.delete(handle);
2766
+ }
2767
+ }
2768
+ };
2769
+ var timeout = {
2770
+ setTimeout: function(handler, duration) {
2771
+ if (duration === void 0) {
2772
+ duration = 0;
2773
+ }
2774
+ var handle = ++lastHandle;
2775
+ scheduleLookup.set(handle, {
2776
+ due: _this.now() + duration,
2777
+ duration,
2778
+ handle,
2779
+ handler,
2780
+ subscription: _this.schedule(run, duration),
2781
+ type: "timeout"
2782
+ });
2783
+ return handle;
2784
+ },
2785
+ clearTimeout: function(handle) {
2786
+ var value = scheduleLookup.get(handle);
2787
+ if (value) {
2788
+ value.subscription.unsubscribe();
2789
+ scheduleLookup.delete(handle);
2790
+ }
2791
+ }
2792
+ };
2793
+ return { immediate, interval, timeout };
2794
+ };
2795
+ TestScheduler2.prototype.run = function(callback) {
2796
+ var prevFrameTimeFactor = TestScheduler2.frameTimeFactor;
2797
+ var prevMaxFrames = this.maxFrames;
2798
+ TestScheduler2.frameTimeFactor = 1;
2799
+ this.maxFrames = Infinity;
2800
+ this.runMode = true;
2801
+ var animator = this.createAnimator();
2802
+ var delegates = this.createDelegates();
2803
+ animationFrameProvider.delegate = animator.delegate;
2804
+ dateTimestampProvider.delegate = this;
2805
+ immediateProvider.delegate = delegates.immediate;
2806
+ intervalProvider.delegate = delegates.interval;
2807
+ timeoutProvider.delegate = delegates.timeout;
2808
+ performanceTimestampProvider.delegate = this;
2809
+ var helpers = {
2810
+ cold: this.createColdObservable.bind(this),
2811
+ hot: this.createHotObservable.bind(this),
2812
+ flush: this.flush.bind(this),
2813
+ time: this.createTime.bind(this),
2814
+ expectObservable: this.expectObservable.bind(this),
2815
+ expectSubscriptions: this.expectSubscriptions.bind(this),
2816
+ animate: animator.animate
2817
+ };
2818
+ try {
2819
+ var ret = callback(helpers);
2820
+ this.flush();
2821
+ return ret;
2822
+ } finally {
2823
+ TestScheduler2.frameTimeFactor = prevFrameTimeFactor;
2824
+ this.maxFrames = prevMaxFrames;
2825
+ this.runMode = false;
2826
+ animationFrameProvider.delegate = void 0;
2827
+ dateTimestampProvider.delegate = void 0;
2828
+ immediateProvider.delegate = void 0;
2829
+ intervalProvider.delegate = void 0;
2830
+ timeoutProvider.delegate = void 0;
2831
+ performanceTimestampProvider.delegate = void 0;
2832
+ }
2833
+ };
2834
+ TestScheduler2.frameTimeFactor = 10;
2835
+ return TestScheduler2;
2836
+ }(VirtualTimeScheduler);
2837
+
2838
+ // src/index.ts
2839
+ var parseMarbles = TestScheduler.parseMarbles.bind(TestScheduler);
2840
+ export {
2841
+ parseMarbles
2842
+ };