/******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function webpack_require(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules) { /******/ return installedModules.exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules.call(module.exports, module, module.exports, webpack_require); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (webpack_modules) /******/ webpack_require.m = modules; /******/ /******/ // expose the module cache /******/ webpack_require.c = installedModules; /******/ /******/ // define getter function for harmony exports /******/ webpack_require.d = function(exports, name, getter) { /******/ if(!webpack_require.o(exports, name)) { /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); /******/ } /******/ }; /******/ /******/ // define __esModule on exports /******/ webpack_require.r = function(exports) { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; /******/ /******/ // create a fake namespace object /******/ // mode & 1: value is a module id, require it /******/ // mode & 2: merge all properties of value into the ns /******/ // mode & 4: return value when already ns object /******/ // mode & 8|1: behave like require /******/ webpack_require.t = function(value, mode) { /******/ if(mode & 1) value = webpack_require(value); /******/ if(mode & 8) return value; /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; /******/ var ns = Object.create(null); /******/ webpack_require.r(ns); /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); /******/ if(mode & 2 && typeof value != 'string') for(var key in value) webpack_require.d(ns, key, function(key) { return value; }.bind(null, key)); /******/ return ns; /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ webpack_require.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module; } : /******/ function getModuleExports() { return module; }; /******/ webpack_require.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ webpack_require.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // webpack_public_path /******/ webpack_require.p = “”; /******/ /******/ /******/ // Load entry module and return exports /******/ return webpack_require(_webpack_require_.s = “./assets/ts/app.ts”); /******/ }) /************************************************************************/ /******/ ({
/***/ “./assets/ts/app.ts”: /*!**************************!*\
!*** ./assets/ts/app.ts ***! \**************************/
/*! no static exports found */ /*! ModuleConcatenation bailout: Module is not an ECMAScript module */ /***/ (function(module, exports, webpack_require) {
“use strict”;
Object.defineProperty(exports, “__esModule”, { value: true }); var rxjs_1 = webpack_require(/*! rxjs */ “./node_modules/rxjs/_esm5/index.js”); var bodyEvent = rxjs_1.fromEvent(document, 'DOMContentLoaded'); var bodyAddClass = function (className) {
var body = document.body; body.classList.add(className);
}; bodyEvent.subscribe(function () { return bodyAddClass('render'); });
/***/ }),
/***/ “./node_modules/rxjs/_esm5/index.js”: /*!********************************************************!*\
!*** ./node_modules/rxjs/_esm5/index.js + 101 modules ***! \********************************************************/
/*! exports provided: Observable, ConnectableObservable, GroupedObservable, observable, Subject, BehaviorSubject, ReplaySubject, AsyncSubject, asapScheduler, asyncScheduler, queueScheduler, animationFrameScheduler, VirtualTimeScheduler, VirtualAction, Scheduler, Subscription, Subscriber, Notification, NotificationKind, pipe, noop, identity, isObservable, ArgumentOutOfRangeError, EmptyError, ObjectUnsubscribedError, UnsubscriptionError, TimeoutError, bindCallback, bindNodeCallback, combineLatest, concat, defer, empty, forkJoin, from, fromEvent, fromEventPattern, generate, iif, interval, merge, never, of, onErrorResumeNext, pairs, partition, race, range, throwError, timer, using, zip, scheduled, EMPTY, NEVER, config */ /***/ (function(module, webpack_exports, webpack_require) {
“use strict”; webpack_require.r(webpack_exports);
// CONCATENATED MODULE: ./node_modules/tslib/tslib.es6.js /*! ***************************************************************************** Copyright © Microsoft Corporation. All rights reserved. Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ /* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) { for (var s, i = 1, n = arguments.length; i < n; i++) { s = arguments[i]; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; } return t; } return __assign.apply(this, arguments);
}
function __rest(s, e) {
var t = {}; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; } return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) { function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } step((generator = generator.apply(thisArg, _arguments || [])).next()); });
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); while (_) try { if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; if (y = 0, t) op = [op[0] & 2, t.value]; switch (op[0]) { case 0: case 1: t = op; break; case 4: _.label++; return { value: op[1], done: false }; case 5: _.label++; y = op[1]; op = [0]; continue; case 7: op = _.ops.pop(); _.trys.pop(); continue; default: if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } if (t[2]) _.ops.pop(); _.trys.pop(); continue; } op = body.call(thisArg, _); } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; }
}
function __exportStar(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; if (m) return m.call(o); return { next: function () { if (o && i >= o.length) o = void 0; return { value: o && o[i++], done: !o }; } };
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator]; if (!m) return o; var i = m.call(o), r, ar = [], e; try { while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); } catch (error) { e = { error: error }; } finally { try { if (r && !r.done && (m = i["return"])) m.call(i); } finally { if (e) throw e.error; } } return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j]; return r;
};
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), i, q = []; return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } function fulfill(value) { resume("next", value); } function reject(value) { resume("throw", value); } function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p; return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator], i; return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } return cooked;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod; var result = {}; if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; result.default = mod; return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isFunction.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function isFunction(x) {
return typeof x === 'function';
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/config.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ var _enable_super_gross_mode_that_will_cause_bad_things = false; var config = {
Promise: undefined, set useDeprecatedSynchronousErrorHandling(value) { if (value) { var error = /*@__PURE__*/ new Error(); /*@__PURE__*/ console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n' + error.stack); } else if (_enable_super_gross_mode_that_will_cause_bad_things) { /*@__PURE__*/ console.log('RxJS: Back to a better error behavior. Thank you. <3'); } _enable_super_gross_mode_that_will_cause_bad_things = value; }, get useDeprecatedSynchronousErrorHandling() { return _enable_super_gross_mode_that_will_cause_bad_things; },
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/hostReportError.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function hostReportError(err) {
setTimeout(function () { throw err; }, 0);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/Observer.js /** PURE_IMPORTS_START _config,_util_hostReportError PURE_IMPORTS_END */
var empty = {
closed: true, next: function (value) { }, error: function (err) { if (config.useDeprecatedSynchronousErrorHandling) { throw err; } else { hostReportError(err); } }, complete: function () { }
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isArray.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ var isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isObject.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function isObject(x) {
return x !== null && typeof x === 'object';
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/UnsubscriptionError.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function UnsubscriptionErrorImpl(errors) {
Error.call(this); this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n ') : ''; this.name = 'UnsubscriptionError'; this.errors = errors; return this;
} UnsubscriptionErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype); var UnsubscriptionError = UnsubscriptionErrorImpl;
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/Subscription.js /** PURE_IMPORTS_START _util_isArray,_util_isObject,_util_isFunction,_util_UnsubscriptionError PURE_IMPORTS_END */
var Subscription_Subscription = /*@__PURE__*/ (function () {
function Subscription(unsubscribe) { this.closed = false; this._parentOrParents = null; this._subscriptions = null; if (unsubscribe) { this._unsubscribe = unsubscribe; } } Subscription.prototype.unsubscribe = function () { var errors; if (this.closed) { return; } var _a = this, _parentOrParents = _a._parentOrParents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions; this.closed = true; this._parentOrParents = null; this._subscriptions = null; if (_parentOrParents instanceof Subscription) { _parentOrParents.remove(this); } else if (_parentOrParents !== null) { for (var index = 0; index < _parentOrParents.length; ++index) { var parent_1 = _parentOrParents[index]; parent_1.remove(this); } } if (isFunction(_unsubscribe)) { try { _unsubscribe.call(this); } catch (e) { errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e]; } } if (isArray(_subscriptions)) { var index = -1; var len = _subscriptions.length; while (++index < len) { var sub = _subscriptions[index]; if (isObject(sub)) { try { sub.unsubscribe(); } catch (e) { errors = errors || []; if (e instanceof UnsubscriptionError) { errors = errors.concat(flattenUnsubscriptionErrors(e.errors)); } else { errors.push(e); } } } } } if (errors) { throw new UnsubscriptionError(errors); } }; Subscription.prototype.add = function (teardown) { var subscription = teardown; if (!teardown) { return Subscription.EMPTY; } switch (typeof teardown) { case 'function': subscription = new Subscription(teardown); case 'object': if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') { return subscription; } else if (this.closed) { subscription.unsubscribe(); return subscription; } else if (!(subscription instanceof Subscription)) { var tmp = subscription; subscription = new Subscription(); subscription._subscriptions = [tmp]; } break; default: { throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.'); } } var _parentOrParents = subscription._parentOrParents; if (_parentOrParents === null) { subscription._parentOrParents = this; } else if (_parentOrParents instanceof Subscription) { if (_parentOrParents === this) { return subscription; } subscription._parentOrParents = [_parentOrParents, this]; } else if (_parentOrParents.indexOf(this) === -1) { _parentOrParents.push(this); } else { return subscription; } var subscriptions = this._subscriptions; if (subscriptions === null) { this._subscriptions = [subscription]; } else { subscriptions.push(subscription); } return subscription; }; Subscription.prototype.remove = function (subscription) { var subscriptions = this._subscriptions; if (subscriptions) { var subscriptionIndex = subscriptions.indexOf(subscription); if (subscriptionIndex !== -1) { subscriptions.splice(subscriptionIndex, 1); } } }; Subscription.EMPTY = (function (empty) { empty.closed = true; return empty; }(new Subscription())); return Subscription;
}());
function flattenUnsubscriptionErrors(errors) {
return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError) ? err.errors : err); }, []);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/symbol/rxSubscriber.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ var rxSubscriber = typeof Symbol === 'function'
? /*@__PURE__*/ Symbol('rxSubscriber') : '@@rxSubscriber_' + /*@__PURE__*/ Math.random();
var $$rxSubscriber = rxSubscriber;
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/Subscriber.js /** PURE_IMPORTS_START tslib,_util_isFunction,_Observer,_Subscription,_internal_symbol_rxSubscriber,_config,_util_hostReportError PURE_IMPORTS_END */
var Subscriber_Subscriber = /*@__PURE__*/ (function (_super) {
__extends(Subscriber, _super); function Subscriber(destinationOrNext, error, complete) { var _this = _super.call(this) || this; _this.syncErrorValue = null; _this.syncErrorThrown = false; _this.syncErrorThrowable = false; _this.isStopped = false; switch (arguments.length) { case 0: _this.destination = empty; break; case 1: if (!destinationOrNext) { _this.destination = empty; break; } if (typeof destinationOrNext === 'object') { if (destinationOrNext instanceof Subscriber) { _this.syncErrorThrowable = destinationOrNext.syncErrorThrowable; _this.destination = destinationOrNext; destinationOrNext.add(_this); } else { _this.syncErrorThrowable = true; _this.destination = new Subscriber_SafeSubscriber(_this, destinationOrNext); } break; } default: _this.syncErrorThrowable = true; _this.destination = new Subscriber_SafeSubscriber(_this, destinationOrNext, error, complete); break; } return _this; } Subscriber.prototype[rxSubscriber] = function () { return this; }; Subscriber.create = function (next, error, complete) { var subscriber = new Subscriber(next, error, complete); subscriber.syncErrorThrowable = false; return subscriber; }; Subscriber.prototype.next = function (value) { if (!this.isStopped) { this._next(value); } }; Subscriber.prototype.error = function (err) { if (!this.isStopped) { this.isStopped = true; this._error(err); } }; Subscriber.prototype.complete = function () { if (!this.isStopped) { this.isStopped = true; this._complete(); } }; Subscriber.prototype.unsubscribe = function () { if (this.closed) { return; } this.isStopped = true; _super.prototype.unsubscribe.call(this); }; Subscriber.prototype._next = function (value) { this.destination.next(value); }; Subscriber.prototype._error = function (err) { this.destination.error(err); this.unsubscribe(); }; Subscriber.prototype._complete = function () { this.destination.complete(); this.unsubscribe(); }; Subscriber.prototype._unsubscribeAndRecycle = function () { var _parentOrParents = this._parentOrParents; this._parentOrParents = null; this.unsubscribe(); this.closed = false; this.isStopped = false; this._parentOrParents = _parentOrParents; return this; }; return Subscriber;
}(Subscription_Subscription));
var Subscriber_SafeSubscriber = /*@__PURE__*/ (function (_super) {
__extends(SafeSubscriber, _super); function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) { var _this = _super.call(this) || this; _this._parentSubscriber = _parentSubscriber; var next; var context = _this; if (isFunction(observerOrNext)) { next = observerOrNext; } else if (observerOrNext) { next = observerOrNext.next; error = observerOrNext.error; complete = observerOrNext.complete; if (observerOrNext !== empty) { context = Object.create(observerOrNext); if (isFunction(context.unsubscribe)) { _this.add(context.unsubscribe.bind(context)); } context.unsubscribe = _this.unsubscribe.bind(_this); } } _this._context = context; _this._next = next; _this._error = error; _this._complete = complete; return _this; } SafeSubscriber.prototype.next = function (value) { if (!this.isStopped && this._next) { var _parentSubscriber = this._parentSubscriber; if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) { this.__tryOrUnsub(this._next, value); } else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) { this.unsubscribe(); } } }; SafeSubscriber.prototype.error = function (err) { if (!this.isStopped) { var _parentSubscriber = this._parentSubscriber; var useDeprecatedSynchronousErrorHandling = config.useDeprecatedSynchronousErrorHandling; if (this._error) { if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) { this.__tryOrUnsub(this._error, err); this.unsubscribe(); } else { this.__tryOrSetError(_parentSubscriber, this._error, err); this.unsubscribe(); } } else if (!_parentSubscriber.syncErrorThrowable) { this.unsubscribe(); if (useDeprecatedSynchronousErrorHandling) { throw err; } hostReportError(err); } else { if (useDeprecatedSynchronousErrorHandling) { _parentSubscriber.syncErrorValue = err; _parentSubscriber.syncErrorThrown = true; } else { hostReportError(err); } this.unsubscribe(); } } }; SafeSubscriber.prototype.complete = function () { var _this = this; if (!this.isStopped) { var _parentSubscriber = this._parentSubscriber; if (this._complete) { var wrappedComplete = function () { return _this._complete.call(_this._context); }; if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) { this.__tryOrUnsub(wrappedComplete); this.unsubscribe(); } else { this.__tryOrSetError(_parentSubscriber, wrappedComplete); this.unsubscribe(); } } else { this.unsubscribe(); } } }; SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) { try { fn.call(this._context, value); } catch (err) { this.unsubscribe(); if (config.useDeprecatedSynchronousErrorHandling) { throw err; } else { hostReportError(err); } } }; SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) { if (!config.useDeprecatedSynchronousErrorHandling) { throw new Error('bad call'); } try { fn.call(this._context, value); } catch (err) { if (config.useDeprecatedSynchronousErrorHandling) { parent.syncErrorValue = err; parent.syncErrorThrown = true; return true; } else { hostReportError(err); return true; } } return false; }; SafeSubscriber.prototype._unsubscribe = function () { var _parentSubscriber = this._parentSubscriber; this._context = null; this._parentSubscriber = null; _parentSubscriber.unsubscribe(); }; return SafeSubscriber;
}(Subscriber_Subscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/canReportError.js /** PURE_IMPORTS_START _Subscriber PURE_IMPORTS_END */
function canReportError(observer) {
while (observer) { var _a = observer, closed_1 = _a.closed, destination = _a.destination, isStopped = _a.isStopped; if (closed_1 || isStopped) { return false; } else if (destination && destination instanceof Subscriber_Subscriber) { observer = destination; } else { observer = null; } } return true;
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/toSubscriber.js /** PURE_IMPORTS_START _Subscriber,_symbol_rxSubscriber,_Observer PURE_IMPORTS_END */
function toSubscriber(nextOrObserver, error, complete) {
if (nextOrObserver) { if (nextOrObserver instanceof Subscriber_Subscriber) { return nextOrObserver; } if (nextOrObserver[rxSubscriber]) { return nextOrObserver[rxSubscriber](); } } if (!nextOrObserver && !error && !complete) { return new Subscriber_Subscriber(empty); } return new Subscriber_Subscriber(nextOrObserver, error, complete);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/symbol/observable.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ var observable_observable = typeof Symbol === 'function' && Symbol.observable || '@@observable';
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/noop.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function noop() { }
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/pipe.js /** PURE_IMPORTS_START _noop PURE_IMPORTS_END */
function pipe() {
var fns = []; for (var _i = 0; _i < arguments.length; _i++) { fns[_i] = arguments[_i]; } return pipeFromArray(fns);
} function pipeFromArray(fns) {
if (!fns) { return noop; } if (fns.length === 1) { return fns[0]; } return function piped(input) { return fns.reduce(function (prev, fn) { return fn(prev); }, input); };
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/Observable.js /** PURE_IMPORTS_START _util_canReportError,_util_toSubscriber,_symbol_observable,_util_pipe,_config PURE_IMPORTS_END */
var Observable_Observable = /*@__PURE__*/ (function () {
function Observable(subscribe) { this._isScalar = false; if (subscribe) { this._subscribe = subscribe; } } Observable.prototype.lift = function (operator) { var observable = new Observable(); observable.source = this; observable.operator = operator; return observable; }; Observable.prototype.subscribe = function (observerOrNext, error, complete) { var operator = this.operator; var sink = toSubscriber(observerOrNext, error, complete); if (operator) { sink.add(operator.call(sink, this.source)); } else { sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ? this._subscribe(sink) : this._trySubscribe(sink)); } if (config.useDeprecatedSynchronousErrorHandling) { if (sink.syncErrorThrowable) { sink.syncErrorThrowable = false; if (sink.syncErrorThrown) { throw sink.syncErrorValue; } } } return sink; }; Observable.prototype._trySubscribe = function (sink) { try { return this._subscribe(sink); } catch (err) { if (config.useDeprecatedSynchronousErrorHandling) { sink.syncErrorThrown = true; sink.syncErrorValue = err; } if (canReportError(sink)) { sink.error(err); } else { console.warn(err); } } }; Observable.prototype.forEach = function (next, promiseCtor) { var _this = this; promiseCtor = getPromiseCtor(promiseCtor); return new promiseCtor(function (resolve, reject) { var subscription; subscription = _this.subscribe(function (value) { try { next(value); } catch (err) { reject(err); if (subscription) { subscription.unsubscribe(); } } }, reject, resolve); }); }; Observable.prototype._subscribe = function (subscriber) { var source = this.source; return source && source.subscribe(subscriber); }; Observable.prototype[observable_observable] = function () { return this; }; Observable.prototype.pipe = function () { var operations = []; for (var _i = 0; _i < arguments.length; _i++) { operations[_i] = arguments[_i]; } if (operations.length === 0) { return this; } return pipeFromArray(operations)(this); }; Observable.prototype.toPromise = function (promiseCtor) { var _this = this; promiseCtor = getPromiseCtor(promiseCtor); return new promiseCtor(function (resolve, reject) { var value; _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); }); }); }; Observable.create = function (subscribe) { return new Observable(subscribe); }; return Observable;
}());
function getPromiseCtor(promiseCtor) {
if (!promiseCtor) { promiseCtor = config.Promise || Promise; } if (!promiseCtor) { throw new Error('no Promise impl found'); } return promiseCtor;
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/ObjectUnsubscribedError.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function ObjectUnsubscribedErrorImpl() {
Error.call(this); this.message = 'object unsubscribed'; this.name = 'ObjectUnsubscribedError'; return this;
} ObjectUnsubscribedErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype); var ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/SubjectSubscription.js /** PURE_IMPORTS_START tslib,_Subscription PURE_IMPORTS_END */
var SubjectSubscription_SubjectSubscription = /*@__PURE__*/ (function (_super) {
__extends(SubjectSubscription, _super); function SubjectSubscription(subject, subscriber) { var _this = _super.call(this) || this; _this.subject = subject; _this.subscriber = subscriber; _this.closed = false; return _this; } SubjectSubscription.prototype.unsubscribe = function () { if (this.closed) { return; } this.closed = true; var subject = this.subject; var observers = subject.observers; this.subject = null; if (!observers || observers.length === 0 || subject.isStopped || subject.closed) { return; } var subscriberIndex = observers.indexOf(this.subscriber); if (subscriberIndex !== -1) { observers.splice(subscriberIndex, 1); } }; return SubjectSubscription;
}(Subscription_Subscription));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/Subject.js /** PURE_IMPORTS_START tslib,_Observable,_Subscriber,_Subscription,_util_ObjectUnsubscribedError,_SubjectSubscription,_internal_symbol_rxSubscriber PURE_IMPORTS_END */
var Subject_SubjectSubscriber = /*@__PURE__*/ (function (_super) {
__extends(SubjectSubscriber, _super); function SubjectSubscriber(destination) { var _this = _super.call(this, destination) || this; _this.destination = destination; return _this; } return SubjectSubscriber;
}(Subscriber_Subscriber));
var Subject_Subject = /*@__PURE__*/ (function (_super) {
__extends(Subject, _super); function Subject() { var _this = _super.call(this) || this; _this.observers = []; _this.closed = false; _this.isStopped = false; _this.hasError = false; _this.thrownError = null; return _this; } Subject.prototype[rxSubscriber] = function () { return new Subject_SubjectSubscriber(this); }; Subject.prototype.lift = function (operator) { var subject = new Subject_AnonymousSubject(this, this); subject.operator = operator; return subject; }; Subject.prototype.next = function (value) { if (this.closed) { throw new ObjectUnsubscribedError(); } if (!this.isStopped) { var observers = this.observers; var len = observers.length; var copy = observers.slice(); for (var i = 0; i < len; i++) { copy[i].next(value); } } }; Subject.prototype.error = function (err) { if (this.closed) { throw new ObjectUnsubscribedError(); } this.hasError = true; this.thrownError = err; this.isStopped = true; var observers = this.observers; var len = observers.length; var copy = observers.slice(); for (var i = 0; i < len; i++) { copy[i].error(err); } this.observers.length = 0; }; Subject.prototype.complete = function () { if (this.closed) { throw new ObjectUnsubscribedError(); } this.isStopped = true; var observers = this.observers; var len = observers.length; var copy = observers.slice(); for (var i = 0; i < len; i++) { copy[i].complete(); } this.observers.length = 0; }; Subject.prototype.unsubscribe = function () { this.isStopped = true; this.closed = true; this.observers = null; }; Subject.prototype._trySubscribe = function (subscriber) { if (this.closed) { throw new ObjectUnsubscribedError(); } else { return _super.prototype._trySubscribe.call(this, subscriber); } }; Subject.prototype._subscribe = function (subscriber) { if (this.closed) { throw new ObjectUnsubscribedError(); } else if (this.hasError) { subscriber.error(this.thrownError); return Subscription_Subscription.EMPTY; } else if (this.isStopped) { subscriber.complete(); return Subscription_Subscription.EMPTY; } else { this.observers.push(subscriber); return new SubjectSubscription_SubjectSubscription(this, subscriber); } }; Subject.prototype.asObservable = function () { var observable = new Observable_Observable(); observable.source = this; return observable; }; Subject.create = function (destination, source) { return new Subject_AnonymousSubject(destination, source); }; return Subject;
}(Observable_Observable));
var Subject_AnonymousSubject = /*@__PURE__*/ (function (_super) {
__extends(AnonymousSubject, _super); function AnonymousSubject(destination, source) { var _this = _super.call(this) || this; _this.destination = destination; _this.source = source; return _this; } AnonymousSubject.prototype.next = function (value) { var destination = this.destination; if (destination && destination.next) { destination.next(value); } }; AnonymousSubject.prototype.error = function (err) { var destination = this.destination; if (destination && destination.error) { this.destination.error(err); } }; AnonymousSubject.prototype.complete = function () { var destination = this.destination; if (destination && destination.complete) { this.destination.complete(); } }; AnonymousSubject.prototype._subscribe = function (subscriber) { var source = this.source; if (source) { return this.source.subscribe(subscriber); } else { return Subscription_Subscription.EMPTY; } }; return AnonymousSubject;
}(Subject_Subject));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/refCount.js /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
function refCount() {
return function refCountOperatorFunction(source) { return source.lift(new RefCountOperator(source)); };
} var RefCountOperator = /*@__PURE__*/ (function () {
function RefCountOperator(connectable) { this.connectable = connectable; } RefCountOperator.prototype.call = function (subscriber, source) { var connectable = this.connectable; connectable._refCount++; var refCounter = new refCount_RefCountSubscriber(subscriber, connectable); var subscription = source.subscribe(refCounter); if (!refCounter.closed) { refCounter.connection = connectable.connect(); } return subscription; }; return RefCountOperator;
}()); var refCount_RefCountSubscriber = /*@__PURE__*/ (function (_super) {
__extends(RefCountSubscriber, _super); function RefCountSubscriber(destination, connectable) { var _this = _super.call(this, destination) || this; _this.connectable = connectable; return _this; } RefCountSubscriber.prototype._unsubscribe = function () { var connectable = this.connectable; if (!connectable) { this.connection = null; return; } this.connectable = null; var refCount = connectable._refCount; if (refCount <= 0) { this.connection = null; return; } connectable._refCount = refCount - 1; if (refCount > 1) { this.connection = null; return; } var connection = this.connection; var sharedConnection = connectable._connection; this.connection = null; if (sharedConnection && (!connection || sharedConnection === connection)) { sharedConnection.unsubscribe(); } }; return RefCountSubscriber;
}(Subscriber_Subscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/ConnectableObservable.js /** PURE_IMPORTS_START tslib,_Subject,_Observable,_Subscriber,_Subscription,_operators_refCount PURE_IMPORTS_END */
var ConnectableObservable_ConnectableObservable = /*@__PURE__*/ (function (_super) {
__extends(ConnectableObservable, _super); function ConnectableObservable(source, subjectFactory) { var _this = _super.call(this) || this; _this.source = source; _this.subjectFactory = subjectFactory; _this._refCount = 0; _this._isComplete = false; return _this; } ConnectableObservable.prototype._subscribe = function (subscriber) { return this.getSubject().subscribe(subscriber); }; ConnectableObservable.prototype.getSubject = function () { var subject = this._subject; if (!subject || subject.isStopped) { this._subject = this.subjectFactory(); } return this._subject; }; ConnectableObservable.prototype.connect = function () { var connection = this._connection; if (!connection) { this._isComplete = false; connection = this._connection = new Subscription_Subscription(); connection.add(this.source .subscribe(new ConnectableObservable_ConnectableSubscriber(this.getSubject(), this))); if (connection.closed) { this._connection = null; connection = Subscription_Subscription.EMPTY; } } return connection; }; ConnectableObservable.prototype.refCount = function () { return refCount()(this); }; return ConnectableObservable;
}(Observable_Observable));
var connectableProto = ConnectableObservable_ConnectableObservable.prototype; var connectableObservableDescriptor = {
operator: { value: null }, _refCount: { value: 0, writable: true }, _subject: { value: null, writable: true }, _connection: { value: null, writable: true }, _subscribe: { value: connectableProto._subscribe }, _isComplete: { value: connectableProto._isComplete, writable: true }, getSubject: { value: connectableProto.getSubject }, connect: { value: connectableProto.connect }, refCount: { value: connectableProto.refCount }
}; var ConnectableObservable_ConnectableSubscriber = /*@__PURE__*/ (function (_super) {
__extends(ConnectableSubscriber, _super); function ConnectableSubscriber(destination, connectable) { var _this = _super.call(this, destination) || this; _this.connectable = connectable; return _this; } ConnectableSubscriber.prototype._error = function (err) { this._unsubscribe(); _super.prototype._error.call(this, err); }; ConnectableSubscriber.prototype._complete = function () { this.connectable._isComplete = true; this._unsubscribe(); _super.prototype._complete.call(this); }; ConnectableSubscriber.prototype._unsubscribe = function () { var connectable = this.connectable; if (connectable) { this.connectable = null; var connection = connectable._connection; connectable._refCount = 0; connectable._subject = null; connectable._connection = null; if (connection) { connection.unsubscribe(); } } }; return ConnectableSubscriber;
}(Subject_SubjectSubscriber)); var ConnectableObservable_RefCountOperator = /*@__PURE__*/ (function () {
function RefCountOperator(connectable) { this.connectable = connectable; } RefCountOperator.prototype.call = function (subscriber, source) { var connectable = this.connectable; connectable._refCount++; var refCounter = new ConnectableObservable_RefCountSubscriber(subscriber, connectable); var subscription = source.subscribe(refCounter); if (!refCounter.closed) { refCounter.connection = connectable.connect(); } return subscription; }; return RefCountOperator;
}()); var ConnectableObservable_RefCountSubscriber = /*@__PURE__*/ (function (_super) {
__extends(RefCountSubscriber, _super); function RefCountSubscriber(destination, connectable) { var _this = _super.call(this, destination) || this; _this.connectable = connectable; return _this; } RefCountSubscriber.prototype._unsubscribe = function () { var connectable = this.connectable; if (!connectable) { this.connection = null; return; } this.connectable = null; var refCount = connectable._refCount; if (refCount <= 0) { this.connection = null; return; } connectable._refCount = refCount - 1; if (refCount > 1) { this.connection = null; return; } var connection = this.connection; var sharedConnection = connectable._connection; this.connection = null; if (sharedConnection && (!connection || sharedConnection === connection)) { sharedConnection.unsubscribe(); } }; return RefCountSubscriber;
}(Subscriber_Subscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/groupBy.js /** PURE_IMPORTS_START tslib,_Subscriber,_Subscription,_Observable,_Subject PURE_IMPORTS_END */
function groupBy(keySelector, elementSelector, durationSelector, subjectSelector) {
return function (source) { return source.lift(new GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector)); };
} var GroupByOperator = /*@__PURE__*/ (function () {
function GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector) { this.keySelector = keySelector; this.elementSelector = elementSelector; this.durationSelector = durationSelector; this.subjectSelector = subjectSelector; } GroupByOperator.prototype.call = function (subscriber, source) { return source.subscribe(new groupBy_GroupBySubscriber(subscriber, this.keySelector, this.elementSelector, this.durationSelector, this.subjectSelector)); }; return GroupByOperator;
}()); var groupBy_GroupBySubscriber = /*@__PURE__*/ (function (_super) {
__extends(GroupBySubscriber, _super); function GroupBySubscriber(destination, keySelector, elementSelector, durationSelector, subjectSelector) { var _this = _super.call(this, destination) || this; _this.keySelector = keySelector; _this.elementSelector = elementSelector; _this.durationSelector = durationSelector; _this.subjectSelector = subjectSelector; _this.groups = null; _this.attemptedToUnsubscribe = false; _this.count = 0; return _this; } GroupBySubscriber.prototype._next = function (value) { var key; try { key = this.keySelector(value); } catch (err) { this.error(err); return; } this._group(value, key); }; GroupBySubscriber.prototype._group = function (value, key) { var groups = this.groups; if (!groups) { groups = this.groups = new Map(); } var group = groups.get(key); var element; if (this.elementSelector) { try { element = this.elementSelector(value); } catch (err) { this.error(err); } } else { element = value; } if (!group) { group = (this.subjectSelector ? this.subjectSelector() : new Subject_Subject()); groups.set(key, group); var groupedObservable = new groupBy_GroupedObservable(key, group, this); this.destination.next(groupedObservable); if (this.durationSelector) { var duration = void 0; try { duration = this.durationSelector(new groupBy_GroupedObservable(key, group)); } catch (err) { this.error(err); return; } this.add(duration.subscribe(new groupBy_GroupDurationSubscriber(key, group, this))); } } if (!group.closed) { group.next(element); } }; GroupBySubscriber.prototype._error = function (err) { var groups = this.groups; if (groups) { groups.forEach(function (group, key) { group.error(err); }); groups.clear(); } this.destination.error(err); }; GroupBySubscriber.prototype._complete = function () { var groups = this.groups; if (groups) { groups.forEach(function (group, key) { group.complete(); }); groups.clear(); } this.destination.complete(); }; GroupBySubscriber.prototype.removeGroup = function (key) { this.groups.delete(key); }; GroupBySubscriber.prototype.unsubscribe = function () { if (!this.closed) { this.attemptedToUnsubscribe = true; if (this.count === 0) { _super.prototype.unsubscribe.call(this); } } }; return GroupBySubscriber;
}(Subscriber_Subscriber)); var groupBy_GroupDurationSubscriber = /*@__PURE__*/ (function (_super) {
__extends(GroupDurationSubscriber, _super); function GroupDurationSubscriber(key, group, parent) { var _this = _super.call(this, group) || this; _this.key = key; _this.group = group; _this.parent = parent; return _this; } GroupDurationSubscriber.prototype._next = function (value) { this.complete(); }; GroupDurationSubscriber.prototype._unsubscribe = function () { var _a = this, parent = _a.parent, key = _a.key; this.key = this.parent = null; if (parent) { parent.removeGroup(key); } }; return GroupDurationSubscriber;
}(Subscriber_Subscriber)); var groupBy_GroupedObservable = /*@__PURE__*/ (function (_super) {
__extends(GroupedObservable, _super); function GroupedObservable(key, groupSubject, refCountSubscription) { var _this = _super.call(this) || this; _this.key = key; _this.groupSubject = groupSubject; _this.refCountSubscription = refCountSubscription; return _this; } GroupedObservable.prototype._subscribe = function (subscriber) { var subscription = new Subscription_Subscription(); var _a = this, refCountSubscription = _a.refCountSubscription, groupSubject = _a.groupSubject; if (refCountSubscription && !refCountSubscription.closed) { subscription.add(new groupBy_InnerRefCountSubscription(refCountSubscription)); } subscription.add(groupSubject.subscribe(subscriber)); return subscription; }; return GroupedObservable;
}(Observable_Observable));
var groupBy_InnerRefCountSubscription = /*@__PURE__*/ (function (_super) {
__extends(InnerRefCountSubscription, _super); function InnerRefCountSubscription(parent) { var _this = _super.call(this) || this; _this.parent = parent; parent.count++; return _this; } InnerRefCountSubscription.prototype.unsubscribe = function () { var parent = this.parent; if (!parent.closed && !this.closed) { _super.prototype.unsubscribe.call(this); parent.count -= 1; if (parent.count === 0 && parent.attemptedToUnsubscribe) { parent.unsubscribe(); } } }; return InnerRefCountSubscription;
}(Subscription_Subscription));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/BehaviorSubject.js /** PURE_IMPORTS_START tslib,_Subject,_util_ObjectUnsubscribedError PURE_IMPORTS_END */
var BehaviorSubject_BehaviorSubject = /*@__PURE__*/ (function (_super) {
__extends(BehaviorSubject, _super); function BehaviorSubject(_value) { var _this = _super.call(this) || this; _this._value = _value; return _this; } Object.defineProperty(BehaviorSubject.prototype, "value", { get: function () { return this.getValue(); }, enumerable: true, configurable: true }); BehaviorSubject.prototype._subscribe = function (subscriber) { var subscription = _super.prototype._subscribe.call(this, subscriber); if (subscription && !subscription.closed) { subscriber.next(this._value); } return subscription; }; BehaviorSubject.prototype.getValue = function () { if (this.hasError) { throw this.thrownError; } else if (this.closed) { throw new ObjectUnsubscribedError(); } else { return this._value; } }; BehaviorSubject.prototype.next = function (value) { _super.prototype.next.call(this, this._value = value); }; return BehaviorSubject;
}(Subject_Subject));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/Action.js /** PURE_IMPORTS_START tslib,_Subscription PURE_IMPORTS_END */
var Action_Action = /*@__PURE__*/ (function (_super) {
__extends(Action, _super); function Action(scheduler, work) { return _super.call(this) || this; } Action.prototype.schedule = function (state, delay) { if (delay === void 0) { delay = 0; } return this; }; return Action;
}(Subscription_Subscription));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/AsyncAction.js /** PURE_IMPORTS_START tslib,_Action PURE_IMPORTS_END */
var AsyncAction_AsyncAction = /*@__PURE__*/ (function (_super) {
__extends(AsyncAction, _super); function AsyncAction(scheduler, work) { var _this = _super.call(this, scheduler, work) || this; _this.scheduler = scheduler; _this.work = work; _this.pending = false; return _this; } AsyncAction.prototype.schedule = function (state, delay) { if (delay === void 0) { delay = 0; } if (this.closed) { return this; } this.state = state; var id = this.id; var scheduler = this.scheduler; if (id != null) { this.id = this.recycleAsyncId(scheduler, id, delay); } this.pending = true; this.delay = delay; this.id = this.id || this.requestAsyncId(scheduler, this.id, delay); return this; }; AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } return setInterval(scheduler.flush.bind(scheduler, this), delay); }; AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } if (delay !== null && this.delay === delay && this.pending === false) { return id; } clearInterval(id); return undefined; }; AsyncAction.prototype.execute = function (state, delay) { if (this.closed) { return new Error('executing a cancelled action'); } this.pending = false; var error = this._execute(state, delay); if (error) { return error; } else if (this.pending === false && this.id != null) { this.id = this.recycleAsyncId(this.scheduler, this.id, null); } }; AsyncAction.prototype._execute = function (state, delay) { var errored = false; var errorValue = undefined; try { this.work(state); } catch (e) { errored = true; errorValue = !!e && e || new Error(e); } if (errored) { this.unsubscribe(); return errorValue; } }; AsyncAction.prototype._unsubscribe = function () { var id = this.id; var scheduler = this.scheduler; var actions = scheduler.actions; var index = actions.indexOf(this); this.work = null; this.state = null; this.pending = false; this.scheduler = null; if (index !== -1) { actions.splice(index, 1); } if (id != null) { this.id = this.recycleAsyncId(scheduler, id, null); } this.delay = null; }; return AsyncAction;
}(Action_Action));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/QueueAction.js /** PURE_IMPORTS_START tslib,_AsyncAction PURE_IMPORTS_END */
var QueueAction_QueueAction = /*@__PURE__*/ (function (_super) {
__extends(QueueAction, _super); function QueueAction(scheduler, work) { var _this = _super.call(this, scheduler, work) || this; _this.scheduler = scheduler; _this.work = work; return _this; } QueueAction.prototype.schedule = function (state, delay) { if (delay === void 0) { delay = 0; } if (delay > 0) { return _super.prototype.schedule.call(this, state, delay); } this.delay = delay; this.state = state; this.scheduler.flush(this); return this; }; QueueAction.prototype.execute = function (state, delay) { return (delay > 0 || this.closed) ? _super.prototype.execute.call(this, state, delay) : this._execute(state, delay); }; QueueAction.prototype.requestAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) { return _super.prototype.requestAsyncId.call(this, scheduler, id, delay); } return scheduler.flush(this); }; return QueueAction;
}(AsyncAction_AsyncAction));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/Scheduler.js var Scheduler = /*@__PURE__*/ (function () {
function Scheduler(SchedulerAction, now) { if (now === void 0) { now = Scheduler.now; } this.SchedulerAction = SchedulerAction; this.now = now; } Scheduler.prototype.schedule = function (work, delay, state) { if (delay === void 0) { delay = 0; } return new this.SchedulerAction(this, work).schedule(state, delay); }; Scheduler.now = function () { return Date.now(); }; return Scheduler;
}());
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/AsyncScheduler.js /** PURE_IMPORTS_START tslib,_Scheduler PURE_IMPORTS_END */
var AsyncScheduler_AsyncScheduler = /*@__PURE__*/ (function (_super) {
__extends(AsyncScheduler, _super); function AsyncScheduler(SchedulerAction, now) { if (now === void 0) { now = Scheduler.now; } var _this = _super.call(this, SchedulerAction, function () { if (AsyncScheduler.delegate && AsyncScheduler.delegate !== _this) { return AsyncScheduler.delegate.now(); } else { return now(); } }) || this; _this.actions = []; _this.active = false; _this.scheduled = undefined; return _this; } AsyncScheduler.prototype.schedule = function (work, delay, state) { if (delay === void 0) { delay = 0; } if (AsyncScheduler.delegate && AsyncScheduler.delegate !== this) { return AsyncScheduler.delegate.schedule(work, delay, state); } else { return _super.prototype.schedule.call(this, work, delay, state); } }; AsyncScheduler.prototype.flush = function (action) { var actions = this.actions; if (this.active) { actions.push(action); return; } var error; this.active = true; do { if (error = action.execute(action.state, action.delay)) { break; } } while (action = actions.shift()); this.active = false; if (error) { while (action = actions.shift()) { action.unsubscribe(); } throw error; } }; return AsyncScheduler;
}(Scheduler));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/QueueScheduler.js /** PURE_IMPORTS_START tslib,_AsyncScheduler PURE_IMPORTS_END */
var QueueScheduler_QueueScheduler = /*@__PURE__*/ (function (_super) {
__extends(QueueScheduler, _super); function QueueScheduler() { return _super !== null && _super.apply(this, arguments) || this; } return QueueScheduler;
}(AsyncScheduler_AsyncScheduler));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/queue.js /** PURE_IMPORTS_START _QueueAction,_QueueScheduler PURE_IMPORTS_END */
var queue = /*@__PURE__*/ new QueueScheduler_QueueScheduler(QueueAction_QueueAction);
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/empty.js /** PURE_IMPORTS_START _Observable PURE_IMPORTS_END */
var EMPTY = /*@__PURE__*/ new Observable_Observable(function (subscriber) { return subscriber.complete(); }); function empty_empty(scheduler) {
return scheduler ? emptyScheduled(scheduler) : EMPTY;
} function emptyScheduled(scheduler) {
return new Observable_Observable(function (subscriber) { return scheduler.schedule(function () { return subscriber.complete(); }); });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isScheduler.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function isScheduler(value) {
return value && typeof value.schedule === 'function';
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/subscribeToArray.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ var subscribeToArray = function (array) {
return function (subscriber) { for (var i = 0, len = array.length; i < len && !subscriber.closed; i++) { subscriber.next(array[i]); } subscriber.complete(); };
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduled/scheduleArray.js /** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */
function scheduleArray(input, scheduler) {
return new Observable_Observable(function (subscriber) { var sub = new Subscription_Subscription(); var i = 0; sub.add(scheduler.schedule(function () { if (i === input.length) { subscriber.complete(); return; } subscriber.next(input[i++]); if (!subscriber.closed) { sub.add(this.schedule()); } })); return sub; });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/fromArray.js /** PURE_IMPORTS_START _Observable,_util_subscribeToArray,_scheduled_scheduleArray PURE_IMPORTS_END */
function fromArray(input, scheduler) {
if (!scheduler) { return new Observable_Observable(subscribeToArray(input)); } else { return scheduleArray(input, scheduler); }
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/of.js /** PURE_IMPORTS_START _util_isScheduler,_fromArray,_scheduled_scheduleArray PURE_IMPORTS_END */
function of() {
var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } var scheduler = args[args.length - 1]; if (isScheduler(scheduler)) { args.pop(); return scheduleArray(args, scheduler); } else { return fromArray(args); }
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/throwError.js /** PURE_IMPORTS_START _Observable PURE_IMPORTS_END */
function throwError(error, scheduler) {
if (!scheduler) { return new Observable_Observable(function (subscriber) { return subscriber.error(error); }); } else { return new Observable_Observable(function (subscriber) { return scheduler.schedule(dispatch, 0, { error: error, subscriber: subscriber }); }); }
} function dispatch(_a) {
var error = _a.error, subscriber = _a.subscriber; subscriber.error(error);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/Notification.js /** PURE_IMPORTS_START _observable_empty,_observable_of,_observable_throwError PURE_IMPORTS_END */
var NotificationKind; /*@__PURE__*/ (function (NotificationKind) {
NotificationKind["NEXT"] = "N"; NotificationKind["ERROR"] = "E"; NotificationKind["COMPLETE"] = "C";
})(NotificationKind || (NotificationKind = {})); var Notification_Notification = /*@__PURE__*/ (function () {
function Notification(kind, value, error) { this.kind = kind; this.value = value; this.error = error; this.hasValue = kind === 'N'; } Notification.prototype.observe = function (observer) { switch (this.kind) { case 'N': return observer.next && observer.next(this.value); case 'E': return observer.error && observer.error(this.error); case 'C': return observer.complete && observer.complete(); } }; Notification.prototype.do = function (next, error, complete) { var kind = this.kind; switch (kind) { case 'N': return next && next(this.value); case 'E': return error && error(this.error); case 'C': return complete && complete(); } }; Notification.prototype.accept = function (nextOrObserver, error, complete) { if (nextOrObserver && typeof nextOrObserver.next === 'function') { return this.observe(nextOrObserver); } else { return this.do(nextOrObserver, error, complete); } }; Notification.prototype.toObservable = function () { var kind = this.kind; switch (kind) { case 'N': return of(this.value); case 'E': return throwError(this.error); case 'C': return empty_empty(); } throw new Error('unexpected notification kind value'); }; Notification.createNext = function (value) { if (typeof value !== 'undefined') { return new Notification('N', value); } return Notification.undefinedValueNotification; }; Notification.createError = function (err) { return new Notification('E', undefined, err); }; Notification.createComplete = function () { return Notification.completeNotification; }; Notification.completeNotification = new Notification('C'); Notification.undefinedValueNotification = new Notification('N', undefined); return Notification;
}());
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/observeOn.js /** PURE_IMPORTS_START tslib,_Subscriber,_Notification PURE_IMPORTS_END */
function observeOn(scheduler, delay) {
if (delay === void 0) { delay = 0; } return function observeOnOperatorFunction(source) { return source.lift(new ObserveOnOperator(scheduler, delay)); };
} var ObserveOnOperator = /*@__PURE__*/ (function () {
function ObserveOnOperator(scheduler, delay) { if (delay === void 0) { delay = 0; } this.scheduler = scheduler; this.delay = delay; } ObserveOnOperator.prototype.call = function (subscriber, source) { return source.subscribe(new observeOn_ObserveOnSubscriber(subscriber, this.scheduler, this.delay)); }; return ObserveOnOperator;
}());
var observeOn_ObserveOnSubscriber = /*@__PURE__*/ (function (_super) {
__extends(ObserveOnSubscriber, _super); function ObserveOnSubscriber(destination, scheduler, delay) { if (delay === void 0) { delay = 0; } var _this = _super.call(this, destination) || this; _this.scheduler = scheduler; _this.delay = delay; return _this; } ObserveOnSubscriber.dispatch = function (arg) { var notification = arg.notification, destination = arg.destination; notification.observe(destination); this.unsubscribe(); }; ObserveOnSubscriber.prototype.scheduleMessage = function (notification) { var destination = this.destination; destination.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination))); }; ObserveOnSubscriber.prototype._next = function (value) { this.scheduleMessage(Notification_Notification.createNext(value)); }; ObserveOnSubscriber.prototype._error = function (err) { this.scheduleMessage(Notification_Notification.createError(err)); this.unsubscribe(); }; ObserveOnSubscriber.prototype._complete = function () { this.scheduleMessage(Notification_Notification.createComplete()); this.unsubscribe(); }; return ObserveOnSubscriber;
}(Subscriber_Subscriber));
var ObserveOnMessage = /*@__PURE__*/ (function () {
function ObserveOnMessage(notification, destination) { this.notification = notification; this.destination = destination; } return ObserveOnMessage;
}());
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/ReplaySubject.js /** PURE_IMPORTS_START tslib,_Subject,_scheduler_queue,_Subscription,_operators_observeOn,_util_ObjectUnsubscribedError,_SubjectSubscription PURE_IMPORTS_END */
var ReplaySubject_ReplaySubject = /*@__PURE__*/ (function (_super) {
__extends(ReplaySubject, _super); function ReplaySubject(bufferSize, windowTime, scheduler) { if (bufferSize === void 0) { bufferSize = Number.POSITIVE_INFINITY; } if (windowTime === void 0) { windowTime = Number.POSITIVE_INFINITY; } var _this = _super.call(this) || this; _this.scheduler = scheduler; _this._events = []; _this._infiniteTimeWindow = false; _this._bufferSize = bufferSize < 1 ? 1 : bufferSize; _this._windowTime = windowTime < 1 ? 1 : windowTime; if (windowTime === Number.POSITIVE_INFINITY) { _this._infiniteTimeWindow = true; _this.next = _this.nextInfiniteTimeWindow; } else { _this.next = _this.nextTimeWindow; } return _this; } ReplaySubject.prototype.nextInfiniteTimeWindow = function (value) { var _events = this._events; _events.push(value); if (_events.length > this._bufferSize) { _events.shift(); } _super.prototype.next.call(this, value); }; ReplaySubject.prototype.nextTimeWindow = function (value) { this._events.push(new ReplayEvent(this._getNow(), value)); this._trimBufferThenGetEvents(); _super.prototype.next.call(this, value); }; ReplaySubject.prototype._subscribe = function (subscriber) { var _infiniteTimeWindow = this._infiniteTimeWindow; var _events = _infiniteTimeWindow ? this._events : this._trimBufferThenGetEvents(); var scheduler = this.scheduler; var len = _events.length; var subscription; if (this.closed) { throw new ObjectUnsubscribedError(); } else if (this.isStopped || this.hasError) { subscription = Subscription_Subscription.EMPTY; } else { this.observers.push(subscriber); subscription = new SubjectSubscription_SubjectSubscription(this, subscriber); } if (scheduler) { subscriber.add(subscriber = new observeOn_ObserveOnSubscriber(subscriber, scheduler)); } if (_infiniteTimeWindow) { for (var i = 0; i < len && !subscriber.closed; i++) { subscriber.next(_events[i]); } } else { for (var i = 0; i < len && !subscriber.closed; i++) { subscriber.next(_events[i].value); } } if (this.hasError) { subscriber.error(this.thrownError); } else if (this.isStopped) { subscriber.complete(); } return subscription; }; ReplaySubject.prototype._getNow = function () { return (this.scheduler || queue).now(); }; ReplaySubject.prototype._trimBufferThenGetEvents = function () { var now = this._getNow(); var _bufferSize = this._bufferSize; var _windowTime = this._windowTime; var _events = this._events; var eventsCount = _events.length; var spliceCount = 0; while (spliceCount < eventsCount) { if ((now - _events[spliceCount].time) < _windowTime) { break; } spliceCount++; } if (eventsCount > _bufferSize) { spliceCount = Math.max(spliceCount, eventsCount - _bufferSize); } if (spliceCount > 0) { _events.splice(0, spliceCount); } return _events; }; return ReplaySubject;
}(Subject_Subject));
var ReplayEvent = /*@__PURE__*/ (function () {
function ReplayEvent(time, value) { this.time = time; this.value = value; } return ReplayEvent;
}());
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/AsyncSubject.js /** PURE_IMPORTS_START tslib,_Subject,_Subscription PURE_IMPORTS_END */
var AsyncSubject_AsyncSubject = /*@__PURE__*/ (function (_super) {
__extends(AsyncSubject, _super); function AsyncSubject() { var _this = _super !== null && _super.apply(this, arguments) || this; _this.value = null; _this.hasNext = false; _this.hasCompleted = false; return _this; } AsyncSubject.prototype._subscribe = function (subscriber) { if (this.hasError) { subscriber.error(this.thrownError); return Subscription_Subscription.EMPTY; } else if (this.hasCompleted && this.hasNext) { subscriber.next(this.value); subscriber.complete(); return Subscription_Subscription.EMPTY; } return _super.prototype._subscribe.call(this, subscriber); }; AsyncSubject.prototype.next = function (value) { if (!this.hasCompleted) { this.value = value; this.hasNext = true; } }; AsyncSubject.prototype.error = function (error) { if (!this.hasCompleted) { _super.prototype.error.call(this, error); } }; AsyncSubject.prototype.complete = function () { this.hasCompleted = true; if (this.hasNext) { _super.prototype.next.call(this, this.value); } _super.prototype.complete.call(this); }; return AsyncSubject;
}(Subject_Subject));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/Immediate.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ var nextHandle = 1; var tasksByHandle = {}; function runIfPresent(handle) {
var cb = tasksByHandle[handle]; if (cb) { cb(); }
} var Immediate = {
setImmediate: function (cb) { var handle = nextHandle++; tasksByHandle[handle] = cb; Promise.resolve().then(function () { return runIfPresent(handle); }); return handle; }, clearImmediate: function (handle) { delete tasksByHandle[handle]; },
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/AsapAction.js /** PURE_IMPORTS_START tslib,_util_Immediate,_AsyncAction PURE_IMPORTS_END */
var AsapAction_AsapAction = /*@__PURE__*/ (function (_super) {
__extends(AsapAction, _super); function AsapAction(scheduler, work) { var _this = _super.call(this, scheduler, work) || this; _this.scheduler = scheduler; _this.work = work; return _this; } AsapAction.prototype.requestAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } if (delay !== null && delay > 0) { return _super.prototype.requestAsyncId.call(this, scheduler, id, delay); } scheduler.actions.push(this); return scheduler.scheduled || (scheduler.scheduled = Immediate.setImmediate(scheduler.flush.bind(scheduler, null))); }; AsapAction.prototype.recycleAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) { return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay); } if (scheduler.actions.length === 0) { Immediate.clearImmediate(id); scheduler.scheduled = undefined; } return undefined; }; return AsapAction;
}(AsyncAction_AsyncAction));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/AsapScheduler.js /** PURE_IMPORTS_START tslib,_AsyncScheduler PURE_IMPORTS_END */
var AsapScheduler_AsapScheduler = /*@__PURE__*/ (function (_super) {
__extends(AsapScheduler, _super); function AsapScheduler() { return _super !== null && _super.apply(this, arguments) || this; } AsapScheduler.prototype.flush = function (action) { this.active = true; this.scheduled = undefined; var actions = this.actions; var error; var index = -1; var count = actions.length; action = action || actions.shift(); do { if (error = action.execute(action.state, action.delay)) { break; } } while (++index < count && (action = actions.shift())); this.active = false; if (error) { while (++index < count && (action = actions.shift())) { action.unsubscribe(); } throw error; } }; return AsapScheduler;
}(AsyncScheduler_AsyncScheduler));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/asap.js /** PURE_IMPORTS_START _AsapAction,_AsapScheduler PURE_IMPORTS_END */
var asap = /*@__PURE__*/ new AsapScheduler_AsapScheduler(AsapAction_AsapAction);
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/async.js /** PURE_IMPORTS_START _AsyncAction,_AsyncScheduler PURE_IMPORTS_END */
var async_async = /*@__PURE__*/ new AsyncScheduler_AsyncScheduler(AsyncAction_AsyncAction);
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/AnimationFrameAction.js /** PURE_IMPORTS_START tslib,_AsyncAction PURE_IMPORTS_END */
var AnimationFrameAction_AnimationFrameAction = /*@__PURE__*/ (function (_super) {
__extends(AnimationFrameAction, _super); function AnimationFrameAction(scheduler, work) { var _this = _super.call(this, scheduler, work) || this; _this.scheduler = scheduler; _this.work = work; return _this; } AnimationFrameAction.prototype.requestAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } if (delay !== null && delay > 0) { return _super.prototype.requestAsyncId.call(this, scheduler, id, delay); } scheduler.actions.push(this); return scheduler.scheduled || (scheduler.scheduled = requestAnimationFrame(function () { return scheduler.flush(null); })); }; AnimationFrameAction.prototype.recycleAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) { return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay); } if (scheduler.actions.length === 0) { cancelAnimationFrame(id); scheduler.scheduled = undefined; } return undefined; }; return AnimationFrameAction;
}(AsyncAction_AsyncAction));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/AnimationFrameScheduler.js /** PURE_IMPORTS_START tslib,_AsyncScheduler PURE_IMPORTS_END */
var AnimationFrameScheduler_AnimationFrameScheduler = /*@__PURE__*/ (function (_super) {
__extends(AnimationFrameScheduler, _super); function AnimationFrameScheduler() { return _super !== null && _super.apply(this, arguments) || this; } AnimationFrameScheduler.prototype.flush = function (action) { this.active = true; this.scheduled = undefined; var actions = this.actions; var error; var index = -1; var count = actions.length; action = action || actions.shift(); do { if (error = action.execute(action.state, action.delay)) { break; } } while (++index < count && (action = actions.shift())); this.active = false; if (error) { while (++index < count && (action = actions.shift())) { action.unsubscribe(); } throw error; } }; return AnimationFrameScheduler;
}(AsyncScheduler_AsyncScheduler));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/animationFrame.js /** PURE_IMPORTS_START _AnimationFrameAction,_AnimationFrameScheduler PURE_IMPORTS_END */
var animationFrame = /*@__PURE__*/ new AnimationFrameScheduler_AnimationFrameScheduler(AnimationFrameAction_AnimationFrameAction);
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduler/VirtualTimeScheduler.js /** PURE_IMPORTS_START tslib,_AsyncAction,_AsyncScheduler PURE_IMPORTS_END */
var VirtualTimeScheduler_VirtualTimeScheduler = /*@__PURE__*/ (function (_super) {
__extends(VirtualTimeScheduler, _super); function VirtualTimeScheduler(SchedulerAction, maxFrames) { if (SchedulerAction === void 0) { SchedulerAction = VirtualTimeScheduler_VirtualAction; } if (maxFrames === void 0) { maxFrames = Number.POSITIVE_INFINITY; } var _this = _super.call(this, SchedulerAction, function () { return _this.frame; }) || this; _this.maxFrames = maxFrames; _this.frame = 0; _this.index = -1; return _this; } VirtualTimeScheduler.prototype.flush = function () { var _a = this, actions = _a.actions, maxFrames = _a.maxFrames; var error, action; while ((action = actions[0]) && action.delay <= maxFrames) { actions.shift(); this.frame = action.delay; if (error = action.execute(action.state, action.delay)) { break; } } if (error) { while (action = actions.shift()) { action.unsubscribe(); } throw error; } }; VirtualTimeScheduler.frameTimeFactor = 10; return VirtualTimeScheduler;
}(AsyncScheduler_AsyncScheduler));
var VirtualTimeScheduler_VirtualAction = /*@__PURE__*/ (function (_super) {
__extends(VirtualAction, _super); function VirtualAction(scheduler, work, index) { if (index === void 0) { index = scheduler.index += 1; } var _this = _super.call(this, scheduler, work) || this; _this.scheduler = scheduler; _this.work = work; _this.index = index; _this.active = true; _this.index = scheduler.index = index; return _this; } VirtualAction.prototype.schedule = function (state, delay) { if (delay === void 0) { delay = 0; } if (!this.id) { return _super.prototype.schedule.call(this, state, delay); } this.active = false; var action = new VirtualAction(this.scheduler, this.work); this.add(action); return action.schedule(state, delay); }; VirtualAction.prototype.requestAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } this.delay = scheduler.frame + delay; var actions = scheduler.actions; actions.push(this); actions.sort(VirtualAction.sortActions); return true; }; VirtualAction.prototype.recycleAsyncId = function (scheduler, id, delay) { if (delay === void 0) { delay = 0; } return undefined; }; VirtualAction.prototype._execute = function (state, delay) { if (this.active === true) { return _super.prototype._execute.call(this, state, delay); } }; VirtualAction.sortActions = function (a, b) { if (a.delay === b.delay) { if (a.index === b.index) { return 0; } else if (a.index > b.index) { return 1; } else { return -1; } } else if (a.delay > b.delay) { return 1; } else { return -1; } }; return VirtualAction;
}(AsyncAction_AsyncAction));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/identity.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function identity(x) {
return x;
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isObservable.js /** PURE_IMPORTS_START _Observable PURE_IMPORTS_END */
function isObservable(obj) {
return !!obj && (obj instanceof Observable_Observable || (typeof obj.lift === 'function' && typeof obj.subscribe === 'function'));
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/ArgumentOutOfRangeError.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function ArgumentOutOfRangeErrorImpl() {
Error.call(this); this.message = 'argument out of range'; this.name = 'ArgumentOutOfRangeError'; return this;
} ArgumentOutOfRangeErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype); var ArgumentOutOfRangeError = ArgumentOutOfRangeErrorImpl;
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/EmptyError.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function EmptyErrorImpl() {
Error.call(this); this.message = 'no elements in sequence'; this.name = 'EmptyError'; return this;
} EmptyErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype); var EmptyError = EmptyErrorImpl;
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/TimeoutError.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function TimeoutErrorImpl() {
Error.call(this); this.message = 'Timeout has occurred'; this.name = 'TimeoutError'; return this;
} TimeoutErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype); var TimeoutError = TimeoutErrorImpl;
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/map.js /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
function map(project, thisArg) {
return function mapOperation(source) { if (typeof project !== 'function') { throw new TypeError('argument is not a function. Are you looking for `mapTo()`?'); } return source.lift(new MapOperator(project, thisArg)); };
} var MapOperator = /*@__PURE__*/ (function () {
function MapOperator(project, thisArg) { this.project = project; this.thisArg = thisArg; } MapOperator.prototype.call = function (subscriber, source) { return source.subscribe(new map_MapSubscriber(subscriber, this.project, this.thisArg)); }; return MapOperator;
}());
var map_MapSubscriber = /*@__PURE__*/ (function (_super) {
__extends(MapSubscriber, _super); function MapSubscriber(destination, project, thisArg) { var _this = _super.call(this, destination) || this; _this.project = project; _this.count = 0; _this.thisArg = thisArg || _this; return _this; } MapSubscriber.prototype._next = function (value) { var result; try { result = this.project.call(this.thisArg, value, this.count++); } catch (err) { this.destination.error(err); return; } this.destination.next(result); }; return MapSubscriber;
}(Subscriber_Subscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/bindCallback.js /** PURE_IMPORTS_START _Observable,_AsyncSubject,_operators_map,_util_canReportError,_util_isArray,_util_isScheduler PURE_IMPORTS_END */
function bindCallback(callbackFunc, resultSelector, scheduler) {
if (resultSelector) { if (isScheduler(resultSelector)) { scheduler = resultSelector; } else { return function () { var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } return bindCallback(callbackFunc, scheduler).apply(void 0, args).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); })); }; } } return function () { var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } var context = this; var subject; var params = { context: context, subject: subject, callbackFunc: callbackFunc, scheduler: scheduler, }; return new Observable_Observable(function (subscriber) { if (!scheduler) { if (!subject) { subject = new AsyncSubject_AsyncSubject(); var handler = function () { var innerArgs = []; for (var _i = 0; _i < arguments.length; _i++) { innerArgs[_i] = arguments[_i]; } subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs); subject.complete(); }; try { callbackFunc.apply(context, args.concat([handler])); } catch (err) { if (canReportError(subject)) { subject.error(err); } else { console.warn(err); } } } return subject.subscribe(subscriber); } else { var state = { args: args, subscriber: subscriber, params: params, }; return scheduler.schedule(bindCallback_dispatch, 0, state); } }); };
} function bindCallback_dispatch(state) {
var _this = this; var self = this; var args = state.args, subscriber = state.subscriber, params = state.params; var callbackFunc = params.callbackFunc, context = params.context, scheduler = params.scheduler; var subject = params.subject; if (!subject) { subject = params.subject = new AsyncSubject_AsyncSubject(); var handler = function () { var innerArgs = []; for (var _i = 0; _i < arguments.length; _i++) { innerArgs[_i] = arguments[_i]; } var value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs; _this.add(scheduler.schedule(dispatchNext, 0, { value: value, subject: subject })); }; try { callbackFunc.apply(context, args.concat([handler])); } catch (err) { subject.error(err); } } this.add(subject.subscribe(subscriber));
} function dispatchNext(state) {
var value = state.value, subject = state.subject; subject.next(value); subject.complete();
} function dispatchError(state) {
var err = state.err, subject = state.subject; subject.error(err);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/bindNodeCallback.js /** PURE_IMPORTS_START _Observable,_AsyncSubject,_operators_map,_util_canReportError,_util_isScheduler,_util_isArray PURE_IMPORTS_END */
function bindNodeCallback(callbackFunc, resultSelector, scheduler) {
if (resultSelector) { if (isScheduler(resultSelector)) { scheduler = resultSelector; } else { return function () { var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } return bindNodeCallback(callbackFunc, scheduler).apply(void 0, args).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); })); }; } } return function () { var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } var params = { subject: undefined, args: args, callbackFunc: callbackFunc, scheduler: scheduler, context: this, }; return new Observable_Observable(function (subscriber) { var context = params.context; var subject = params.subject; if (!scheduler) { if (!subject) { subject = params.subject = new AsyncSubject_AsyncSubject(); var handler = function () { var innerArgs = []; for (var _i = 0; _i < arguments.length; _i++) { innerArgs[_i] = arguments[_i]; } var err = innerArgs.shift(); if (err) { subject.error(err); return; } subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs); subject.complete(); }; try { callbackFunc.apply(context, args.concat([handler])); } catch (err) { if (canReportError(subject)) { subject.error(err); } else { console.warn(err); } } } return subject.subscribe(subscriber); } else { return scheduler.schedule(bindNodeCallback_dispatch, 0, { params: params, subscriber: subscriber, context: context }); } }); };
} function bindNodeCallback_dispatch(state) {
var _this = this; var params = state.params, subscriber = state.subscriber, context = state.context; var callbackFunc = params.callbackFunc, args = params.args, scheduler = params.scheduler; var subject = params.subject; if (!subject) { subject = params.subject = new AsyncSubject_AsyncSubject(); var handler = function () { var innerArgs = []; for (var _i = 0; _i < arguments.length; _i++) { innerArgs[_i] = arguments[_i]; } var err = innerArgs.shift(); if (err) { _this.add(scheduler.schedule(bindNodeCallback_dispatchError, 0, { err: err, subject: subject })); } else { var value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs; _this.add(scheduler.schedule(bindNodeCallback_dispatchNext, 0, { value: value, subject: subject })); } }; try { callbackFunc.apply(context, args.concat([handler])); } catch (err) { this.add(scheduler.schedule(bindNodeCallback_dispatchError, 0, { err: err, subject: subject })); } } this.add(subject.subscribe(subscriber));
} function bindNodeCallback_dispatchNext(arg) {
var value = arg.value, subject = arg.subject; subject.next(value); subject.complete();
} function bindNodeCallback_dispatchError(arg) {
var err = arg.err, subject = arg.subject; subject.error(err);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/OuterSubscriber.js /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
var OuterSubscriber_OuterSubscriber = /*@__PURE__*/ (function (_super) {
__extends(OuterSubscriber, _super); function OuterSubscriber() { return _super !== null && _super.apply(this, arguments) || this; } OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { this.destination.next(innerValue); }; OuterSubscriber.prototype.notifyError = function (error, innerSub) { this.destination.error(error); }; OuterSubscriber.prototype.notifyComplete = function (innerSub) { this.destination.complete(); }; return OuterSubscriber;
}(Subscriber_Subscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/InnerSubscriber.js /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
var InnerSubscriber_InnerSubscriber = /*@__PURE__*/ (function (_super) {
__extends(InnerSubscriber, _super); function InnerSubscriber(parent, outerValue, outerIndex) { var _this = _super.call(this) || this; _this.parent = parent; _this.outerValue = outerValue; _this.outerIndex = outerIndex; _this.index = 0; return _this; } InnerSubscriber.prototype._next = function (value) { this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this); }; InnerSubscriber.prototype._error = function (error) { this.parent.notifyError(error, this); this.unsubscribe(); }; InnerSubscriber.prototype._complete = function () { this.parent.notifyComplete(this); this.unsubscribe(); }; return InnerSubscriber;
}(Subscriber_Subscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/subscribeToPromise.js /** PURE_IMPORTS_START _hostReportError PURE_IMPORTS_END */
var subscribeToPromise = function (promise) {
return function (subscriber) { promise.then(function (value) { if (!subscriber.closed) { subscriber.next(value); subscriber.complete(); } }, function (err) { return subscriber.error(err); }) .then(null, hostReportError); return subscriber; };
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/symbol/iterator.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function getSymbolIterator() {
if (typeof Symbol !== 'function' || !Symbol.iterator) { return '@@iterator'; } return Symbol.iterator;
} var iterator_iterator = /*@__PURE__*/ getSymbolIterator(); var $$iterator = iterator_iterator;
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/subscribeToIterable.js /** PURE_IMPORTS_START _symbol_iterator PURE_IMPORTS_END */
var subscribeToIterable = function (iterable) {
return function (subscriber) { var iterator = iterable[iterator_iterator](); do { var item = iterator.next(); if (item.done) { subscriber.complete(); break; } subscriber.next(item.value); if (subscriber.closed) { break; } } while (true); if (typeof iterator.return === 'function') { subscriber.add(function () { if (iterator.return) { iterator.return(); } }); } return subscriber; };
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/subscribeToObservable.js /** PURE_IMPORTS_START _symbol_observable PURE_IMPORTS_END */
var subscribeToObservable = function (obj) {
return function (subscriber) { var obs = obj[observable_observable](); if (typeof obs.subscribe !== 'function') { throw new TypeError('Provided object does not correctly implement Symbol.observable'); } else { return obs.subscribe(subscriber); } };
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isArrayLike.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isPromise.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function isPromise(value) {
return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/subscribeTo.js /** PURE_IMPORTS_START _subscribeToArray,_subscribeToPromise,_subscribeToIterable,_subscribeToObservable,_isArrayLike,_isPromise,_isObject,_symbol_iterator,_symbol_observable PURE_IMPORTS_END */
var subscribeTo = function (result) {
if (!!result && typeof result[observable_observable] === 'function') { return subscribeToObservable(result); } else if (isArrayLike(result)) { return subscribeToArray(result); } else if (isPromise(result)) { return subscribeToPromise(result); } else if (!!result && typeof result[iterator_iterator] === 'function') { return subscribeToIterable(result); } else { var value = isObject(result) ? 'an invalid object' : "'" + result + "'"; var msg = "You provided " + value + " where a stream was expected." + ' You can provide an Observable, Promise, Array, or Iterable.'; throw new TypeError(msg); }
};
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/subscribeToResult.js /** PURE_IMPORTS_START _InnerSubscriber,_subscribeTo,_Observable PURE_IMPORTS_END */
function subscribeToResult(outerSubscriber, result, outerValue, outerIndex, destination) {
if (destination === void 0) { destination = new InnerSubscriber_InnerSubscriber(outerSubscriber, outerValue, outerIndex); } if (destination.closed) { return undefined; } if (result instanceof Observable_Observable) { return result.subscribe(destination); } return subscribeTo(result)(destination);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/combineLatest.js /** PURE_IMPORTS_START tslib,_util_isScheduler,_util_isArray,_OuterSubscriber,_util_subscribeToResult,_fromArray PURE_IMPORTS_END */
var NONE = {}; function combineLatest() {
var observables = []; for (var _i = 0; _i < arguments.length; _i++) { observables[_i] = arguments[_i]; } var resultSelector = null; var scheduler = null; if (isScheduler(observables[observables.length - 1])) { scheduler = observables.pop(); } if (typeof observables[observables.length - 1] === 'function') { resultSelector = observables.pop(); } if (observables.length === 1 && isArray(observables[0])) { observables = observables[0]; } return fromArray(observables, scheduler).lift(new CombineLatestOperator(resultSelector));
} var CombineLatestOperator = /*@__PURE__*/ (function () {
function CombineLatestOperator(resultSelector) { this.resultSelector = resultSelector; } CombineLatestOperator.prototype.call = function (subscriber, source) { return source.subscribe(new combineLatest_CombineLatestSubscriber(subscriber, this.resultSelector)); }; return CombineLatestOperator;
}());
var combineLatest_CombineLatestSubscriber = /*@__PURE__*/ (function (_super) {
__extends(CombineLatestSubscriber, _super); function CombineLatestSubscriber(destination, resultSelector) { var _this = _super.call(this, destination) || this; _this.resultSelector = resultSelector; _this.active = 0; _this.values = []; _this.observables = []; return _this; } CombineLatestSubscriber.prototype._next = function (observable) { this.values.push(NONE); this.observables.push(observable); }; CombineLatestSubscriber.prototype._complete = function () { var observables = this.observables; var len = observables.length; if (len === 0) { this.destination.complete(); } else { this.active = len; this.toRespond = len; for (var i = 0; i < len; i++) { var observable = observables[i]; this.add(subscribeToResult(this, observable, observable, i)); } } }; CombineLatestSubscriber.prototype.notifyComplete = function (unused) { if ((this.active -= 1) === 0) { this.destination.complete(); } }; CombineLatestSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { var values = this.values; var oldVal = values[outerIndex]; var toRespond = !this.toRespond ? 0 : oldVal === NONE ? --this.toRespond : this.toRespond; values[outerIndex] = innerValue; if (toRespond === 0) { if (this.resultSelector) { this._tryResultSelector(values); } else { this.destination.next(values.slice()); } } }; CombineLatestSubscriber.prototype._tryResultSelector = function (values) { var result; try { result = this.resultSelector.apply(this, values); } catch (err) { this.destination.error(err); return; } this.destination.next(result); }; return CombineLatestSubscriber;
}(OuterSubscriber_OuterSubscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduled/scheduleObservable.js /** PURE_IMPORTS_START _Observable,_Subscription,_symbol_observable PURE_IMPORTS_END */
function scheduleObservable(input, scheduler) {
return new Observable_Observable(function (subscriber) { var sub = new Subscription_Subscription(); sub.add(scheduler.schedule(function () { var observable = input[observable_observable](); sub.add(observable.subscribe({ next: function (value) { sub.add(scheduler.schedule(function () { return subscriber.next(value); })); }, error: function (err) { sub.add(scheduler.schedule(function () { return subscriber.error(err); })); }, complete: function () { sub.add(scheduler.schedule(function () { return subscriber.complete(); })); }, })); })); return sub; });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduled/schedulePromise.js /** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */
function schedulePromise(input, scheduler) {
return new Observable_Observable(function (subscriber) { var sub = new Subscription_Subscription(); sub.add(scheduler.schedule(function () { return input.then(function (value) { sub.add(scheduler.schedule(function () { subscriber.next(value); sub.add(scheduler.schedule(function () { return subscriber.complete(); })); })); }, function (err) { sub.add(scheduler.schedule(function () { return subscriber.error(err); })); }); })); return sub; });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduled/scheduleIterable.js /** PURE_IMPORTS_START _Observable,_Subscription,_symbol_iterator PURE_IMPORTS_END */
function scheduleIterable(input, scheduler) {
if (!input) { throw new Error('Iterable cannot be null'); } return new Observable_Observable(function (subscriber) { var sub = new Subscription_Subscription(); var iterator; sub.add(function () { if (iterator && typeof iterator.return === 'function') { iterator.return(); } }); sub.add(scheduler.schedule(function () { iterator = input[iterator_iterator](); sub.add(scheduler.schedule(function () { if (subscriber.closed) { return; } var value; var done; try { var result = iterator.next(); value = result.value; done = result.done; } catch (err) { subscriber.error(err); return; } if (done) { subscriber.complete(); } else { subscriber.next(value); this.schedule(); } })); })); return sub; });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isInteropObservable.js /** PURE_IMPORTS_START _symbol_observable PURE_IMPORTS_END */
function isInteropObservable(input) {
return input && typeof input[observable_observable] === 'function';
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isIterable.js /** PURE_IMPORTS_START _symbol_iterator PURE_IMPORTS_END */
function isIterable(input) {
return input && typeof input[iterator_iterator] === 'function';
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/scheduled/scheduled.js /** PURE_IMPORTS_START _scheduleObservable,_schedulePromise,_scheduleArray,_scheduleIterable,_util_isInteropObservable,_util_isPromise,_util_isArrayLike,_util_isIterable PURE_IMPORTS_END */
function scheduled(input, scheduler) {
if (input != null) { if (isInteropObservable(input)) { return scheduleObservable(input, scheduler); } else if (isPromise(input)) { return schedulePromise(input, scheduler); } else if (isArrayLike(input)) { return scheduleArray(input, scheduler); } else if (isIterable(input) || typeof input === 'string') { return scheduleIterable(input, scheduler); } } throw new TypeError((input !== null && typeof input || input) + ' is not observable');
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/from.js /** PURE_IMPORTS_START _Observable,_util_subscribeTo,_scheduled_scheduled PURE_IMPORTS_END */
function from(input, scheduler) {
if (!scheduler) { if (input instanceof Observable_Observable) { return input; } return new Observable_Observable(subscribeTo(input)); } else { return scheduled(input, scheduler); }
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/mergeMap.js /** PURE_IMPORTS_START tslib,_util_subscribeToResult,_OuterSubscriber,_InnerSubscriber,_map,_observable_from PURE_IMPORTS_END */
function mergeMap(project, resultSelector, concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } if (typeof resultSelector === 'function') { return function (source) { return source.pipe(mergeMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); }, concurrent)); }; } else if (typeof resultSelector === 'number') { concurrent = resultSelector; } return function (source) { return source.lift(new MergeMapOperator(project, concurrent)); };
} var MergeMapOperator = /*@__PURE__*/ (function () {
function MergeMapOperator(project, concurrent) { if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } this.project = project; this.concurrent = concurrent; } MergeMapOperator.prototype.call = function (observer, source) { return source.subscribe(new mergeMap_MergeMapSubscriber(observer, this.project, this.concurrent)); }; return MergeMapOperator;
}());
var mergeMap_MergeMapSubscriber = /*@__PURE__*/ (function (_super) {
__extends(MergeMapSubscriber, _super); function MergeMapSubscriber(destination, project, concurrent) { if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } var _this = _super.call(this, destination) || this; _this.project = project; _this.concurrent = concurrent; _this.hasCompleted = false; _this.buffer = []; _this.active = 0; _this.index = 0; return _this; } MergeMapSubscriber.prototype._next = function (value) { if (this.active < this.concurrent) { this._tryNext(value); } else { this.buffer.push(value); } }; MergeMapSubscriber.prototype._tryNext = function (value) { var result; var index = this.index++; try { result = this.project(value, index); } catch (err) { this.destination.error(err); return; } this.active++; this._innerSub(result, value, index); }; MergeMapSubscriber.prototype._innerSub = function (ish, value, index) { var innerSubscriber = new InnerSubscriber_InnerSubscriber(this, undefined, undefined); var destination = this.destination; destination.add(innerSubscriber); subscribeToResult(this, ish, value, index, innerSubscriber); }; MergeMapSubscriber.prototype._complete = function () { this.hasCompleted = true; if (this.active === 0 && this.buffer.length === 0) { this.destination.complete(); } this.unsubscribe(); }; MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { this.destination.next(innerValue); }; MergeMapSubscriber.prototype.notifyComplete = function (innerSub) { var buffer = this.buffer; this.remove(innerSub); this.active--; if (buffer.length > 0) { this._next(buffer.shift()); } else if (this.active === 0 && this.hasCompleted) { this.destination.complete(); } }; return MergeMapSubscriber;
}(OuterSubscriber_OuterSubscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/mergeAll.js /** PURE_IMPORTS_START _mergeMap,_util_identity PURE_IMPORTS_END */
function mergeAll(concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } return mergeMap(identity, concurrent);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/concatAll.js /** PURE_IMPORTS_START _mergeAll PURE_IMPORTS_END */
function concatAll() {
return mergeAll(1);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/concat.js /** PURE_IMPORTS_START _of,_operators_concatAll PURE_IMPORTS_END */
function concat() {
var observables = []; for (var _i = 0; _i < arguments.length; _i++) { observables[_i] = arguments[_i]; } return concatAll()(of.apply(void 0, observables));
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/defer.js /** PURE_IMPORTS_START _Observable,_from,_empty PURE_IMPORTS_END */
function defer(observableFactory) {
return new Observable_Observable(function (subscriber) { var input; try { input = observableFactory(); } catch (err) { subscriber.error(err); return undefined; } var source = input ? from(input) : empty_empty(); return source.subscribe(subscriber); });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/forkJoin.js /** PURE_IMPORTS_START _Observable,_util_isArray,_operators_map,_util_isObject,_from PURE_IMPORTS_END */
function forkJoin() {
var sources = []; for (var _i = 0; _i < arguments.length; _i++) { sources[_i] = arguments[_i]; } if (sources.length === 1) { var first_1 = sources[0]; if (isArray(first_1)) { return forkJoinInternal(first_1, null); } if (isObject(first_1) && Object.getPrototypeOf(first_1) === Object.prototype) { var keys = Object.keys(first_1); return forkJoinInternal(keys.map(function (key) { return first_1[key]; }), keys); } } if (typeof sources[sources.length - 1] === 'function') { var resultSelector_1 = sources.pop(); sources = (sources.length === 1 && isArray(sources[0])) ? sources[0] : sources; return forkJoinInternal(sources, null).pipe(map(function (args) { return resultSelector_1.apply(void 0, args); })); } return forkJoinInternal(sources, null);
} function forkJoinInternal(sources, keys) {
return new Observable_Observable(function (subscriber) { var len = sources.length; if (len === 0) { subscriber.complete(); return; } var values = new Array(len); var completed = 0; var emitted = 0; var _loop_1 = function (i) { var source = from(sources[i]); var hasValue = false; subscriber.add(source.subscribe({ next: function (value) { if (!hasValue) { hasValue = true; emitted++; } values[i] = value; }, error: function (err) { return subscriber.error(err); }, complete: function () { completed++; if (completed === len || !hasValue) { if (emitted === len) { subscriber.next(keys ? keys.reduce(function (result, key, i) { return (result[key] = values[i], result); }, {}) : values); } subscriber.complete(); } } })); }; for (var i = 0; i < len; i++) { _loop_1(i); } });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/fromEvent.js /** PURE_IMPORTS_START _Observable,_util_isArray,_util_isFunction,_operators_map PURE_IMPORTS_END */
var fromEvent_toString = Object.prototype.toString; function fromEvent(target, eventName, options, resultSelector) {
if (isFunction(options)) { resultSelector = options; options = undefined; } if (resultSelector) { return fromEvent(target, eventName, options).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); })); } return new Observable_Observable(function (subscriber) { function handler(e) { if (arguments.length > 1) { subscriber.next(Array.prototype.slice.call(arguments)); } else { subscriber.next(e); } } setupSubscription(target, eventName, handler, subscriber, options); });
} function setupSubscription(sourceObj, eventName, handler, subscriber, options) {
var unsubscribe; if (isEventTarget(sourceObj)) { var source_1 = sourceObj; sourceObj.addEventListener(eventName, handler, options); unsubscribe = function () { return source_1.removeEventListener(eventName, handler, options); }; } else if (isJQueryStyleEventEmitter(sourceObj)) { var source_2 = sourceObj; sourceObj.on(eventName, handler); unsubscribe = function () { return source_2.off(eventName, handler); }; } else if (isNodeStyleEventEmitter(sourceObj)) { var source_3 = sourceObj; sourceObj.addListener(eventName, handler); unsubscribe = function () { return source_3.removeListener(eventName, handler); }; } else if (sourceObj && sourceObj.length) { for (var i = 0, len = sourceObj.length; i < len; i++) { setupSubscription(sourceObj[i], eventName, handler, subscriber, options); } } else { throw new TypeError('Invalid event target'); } subscriber.add(unsubscribe);
} function isNodeStyleEventEmitter(sourceObj) {
return sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';
} function isJQueryStyleEventEmitter(sourceObj) {
return sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';
} function isEventTarget(sourceObj) {
return sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/fromEventPattern.js /** PURE_IMPORTS_START _Observable,_util_isArray,_util_isFunction,_operators_map PURE_IMPORTS_END */
function fromEventPattern(addHandler, removeHandler, resultSelector) {
if (resultSelector) { return fromEventPattern(addHandler, removeHandler).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); })); } return new Observable_Observable(function (subscriber) { var handler = function () { var e = []; for (var _i = 0; _i < arguments.length; _i++) { e[_i] = arguments[_i]; } return subscriber.next(e.length === 1 ? e[0] : e); }; var retValue; try { retValue = addHandler(handler); } catch (err) { subscriber.error(err); return undefined; } if (!isFunction(removeHandler)) { return undefined; } return function () { return removeHandler(handler, retValue); }; });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/generate.js /** PURE_IMPORTS_START _Observable,_util_identity,_util_isScheduler PURE_IMPORTS_END */
function generate(initialStateOrOptions, condition, iterate, resultSelectorOrObservable, scheduler) {
var resultSelector; var initialState; if (arguments.length == 1) { var options = initialStateOrOptions; initialState = options.initialState; condition = options.condition; iterate = options.iterate; resultSelector = options.resultSelector || identity; scheduler = options.scheduler; } else if (resultSelectorOrObservable === undefined || isScheduler(resultSelectorOrObservable)) { initialState = initialStateOrOptions; resultSelector = identity; scheduler = resultSelectorOrObservable; } else { initialState = initialStateOrOptions; resultSelector = resultSelectorOrObservable; } return new Observable_Observable(function (subscriber) { var state = initialState; if (scheduler) { return scheduler.schedule(generate_dispatch, 0, { subscriber: subscriber, iterate: iterate, condition: condition, resultSelector: resultSelector, state: state }); } do { if (condition) { var conditionResult = void 0; try { conditionResult = condition(state); } catch (err) { subscriber.error(err); return undefined; } if (!conditionResult) { subscriber.complete(); break; } } var value = void 0; try { value = resultSelector(state); } catch (err) { subscriber.error(err); return undefined; } subscriber.next(value); if (subscriber.closed) { break; } try { state = iterate(state); } catch (err) { subscriber.error(err); return undefined; } } while (true); return undefined; });
} function generate_dispatch(state) {
var subscriber = state.subscriber, condition = state.condition; if (subscriber.closed) { return undefined; } if (state.needIterate) { try { state.state = state.iterate(state.state); } catch (err) { subscriber.error(err); return undefined; } } else { state.needIterate = true; } if (condition) { var conditionResult = void 0; try { conditionResult = condition(state.state); } catch (err) { subscriber.error(err); return undefined; } if (!conditionResult) { subscriber.complete(); return undefined; } if (subscriber.closed) { return undefined; } } var value; try { value = state.resultSelector(state.state); } catch (err) { subscriber.error(err); return undefined; } if (subscriber.closed) { return undefined; } subscriber.next(value); if (subscriber.closed) { return undefined; } return this.schedule(state);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/iif.js /** PURE_IMPORTS_START _defer,_empty PURE_IMPORTS_END */
function iif(condition, trueResult, falseResult) {
if (trueResult === void 0) { trueResult = EMPTY; } if (falseResult === void 0) { falseResult = EMPTY; } return defer(function () { return condition() ? trueResult : falseResult; });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/isNumeric.js /** PURE_IMPORTS_START _isArray PURE_IMPORTS_END */
function isNumeric(val) {
return !isArray(val) && (val - parseFloat(val) + 1) >= 0;
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/interval.js /** PURE_IMPORTS_START _Observable,_scheduler_async,_util_isNumeric PURE_IMPORTS_END */
function interval(period, scheduler) {
if (period === void 0) { period = 0; } if (scheduler === void 0) { scheduler = async_async; } if (!isNumeric(period) || period < 0) { period = 0; } if (!scheduler || typeof scheduler.schedule !== 'function') { scheduler = async_async; } return new Observable_Observable(function (subscriber) { subscriber.add(scheduler.schedule(interval_dispatch, period, { subscriber: subscriber, counter: 0, period: period })); return subscriber; });
} function interval_dispatch(state) {
var subscriber = state.subscriber, counter = state.counter, period = state.period; subscriber.next(counter); this.schedule({ subscriber: subscriber, counter: counter + 1, period: period }, period);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/merge.js /** PURE_IMPORTS_START _Observable,_util_isScheduler,_operators_mergeAll,_fromArray PURE_IMPORTS_END */
function merge() {
var observables = []; for (var _i = 0; _i < arguments.length; _i++) { observables[_i] = arguments[_i]; } var concurrent = Number.POSITIVE_INFINITY; var scheduler = null; var last = observables[observables.length - 1]; if (isScheduler(last)) { scheduler = observables.pop(); if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') { concurrent = observables.pop(); } } else if (typeof last === 'number') { concurrent = observables.pop(); } if (scheduler === null && observables.length === 1 && observables[0] instanceof Observable_Observable) { return observables[0]; } return mergeAll(concurrent)(fromArray(observables, scheduler));
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/never.js /** PURE_IMPORTS_START _Observable,_util_noop PURE_IMPORTS_END */
var NEVER = /*@__PURE__*/ new Observable_Observable(noop); function never() {
return NEVER;
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/onErrorResumeNext.js /** PURE_IMPORTS_START _Observable,_from,_util_isArray,_empty PURE_IMPORTS_END */
function onErrorResumeNext() {
var sources = []; for (var _i = 0; _i < arguments.length; _i++) { sources[_i] = arguments[_i]; } if (sources.length === 0) { return EMPTY; } var first = sources[0], remainder = sources.slice(1); if (sources.length === 1 && isArray(first)) { return onErrorResumeNext.apply(void 0, first); } return new Observable_Observable(function (subscriber) { var subNext = function () { return subscriber.add(onErrorResumeNext.apply(void 0, remainder).subscribe(subscriber)); }; return from(first).subscribe({ next: function (value) { subscriber.next(value); }, error: subNext, complete: subNext, }); });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/pairs.js /** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */
function pairs(obj, scheduler) {
if (!scheduler) { return new Observable_Observable(function (subscriber) { var keys = Object.keys(obj); for (var i = 0; i < keys.length && !subscriber.closed; i++) { var key = keys[i]; if (obj.hasOwnProperty(key)) { subscriber.next([key, obj[key]]); } } subscriber.complete(); }); } else { return new Observable_Observable(function (subscriber) { var keys = Object.keys(obj); var subscription = new Subscription_Subscription(); subscription.add(scheduler.schedule(pairs_dispatch, 0, { keys: keys, index: 0, subscriber: subscriber, subscription: subscription, obj: obj })); return subscription; }); }
} function pairs_dispatch(state) {
var keys = state.keys, index = state.index, subscriber = state.subscriber, subscription = state.subscription, obj = state.obj; if (!subscriber.closed) { if (index < keys.length) { var key = keys[index]; subscriber.next([key, obj[key]]); subscription.add(this.schedule({ keys: keys, index: index + 1, subscriber: subscriber, subscription: subscription, obj: obj })); } else { subscriber.complete(); } }
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/util/not.js /** PURE_IMPORTS_START PURE_IMPORTS_END */ function not(pred, thisArg) {
function notPred() { return !(notPred.pred.apply(notPred.thisArg, arguments)); } notPred.pred = pred; notPred.thisArg = thisArg; return notPred;
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/operators/filter.js /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
function filter(predicate, thisArg) {
return function filterOperatorFunction(source) { return source.lift(new FilterOperator(predicate, thisArg)); };
} var FilterOperator = /*@__PURE__*/ (function () {
function FilterOperator(predicate, thisArg) { this.predicate = predicate; this.thisArg = thisArg; } FilterOperator.prototype.call = function (subscriber, source) { return source.subscribe(new filter_FilterSubscriber(subscriber, this.predicate, this.thisArg)); }; return FilterOperator;
}()); var filter_FilterSubscriber = /*@__PURE__*/ (function (_super) {
__extends(FilterSubscriber, _super); function FilterSubscriber(destination, predicate, thisArg) { var _this = _super.call(this, destination) || this; _this.predicate = predicate; _this.thisArg = thisArg; _this.count = 0; return _this; } FilterSubscriber.prototype._next = function (value) { var result; try { result = this.predicate.call(this.thisArg, value, this.count++); } catch (err) { this.destination.error(err); return; } if (result) { this.destination.next(value); } }; return FilterSubscriber;
}(Subscriber_Subscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/partition.js /** PURE_IMPORTS_START _util_not,_util_subscribeTo,_operators_filter,_Observable PURE_IMPORTS_END */
function partition(source, predicate, thisArg) {
return [ filter(predicate, thisArg)(new Observable_Observable(subscribeTo(source))), filter(not(predicate, thisArg))(new Observable_Observable(subscribeTo(source))) ];
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/race.js /** PURE_IMPORTS_START tslib,_util_isArray,_fromArray,_OuterSubscriber,_util_subscribeToResult PURE_IMPORTS_END */
function race() {
var observables = []; for (var _i = 0; _i < arguments.length; _i++) { observables[_i] = arguments[_i]; } if (observables.length === 1) { if (isArray(observables[0])) { observables = observables[0]; } else { return observables[0]; } } return fromArray(observables, undefined).lift(new RaceOperator());
} var RaceOperator = /*@__PURE__*/ (function () {
function RaceOperator() { } RaceOperator.prototype.call = function (subscriber, source) { return source.subscribe(new race_RaceSubscriber(subscriber)); }; return RaceOperator;
}());
var race_RaceSubscriber = /*@__PURE__*/ (function (_super) {
__extends(RaceSubscriber, _super); function RaceSubscriber(destination) { var _this = _super.call(this, destination) || this; _this.hasFirst = false; _this.observables = []; _this.subscriptions = []; return _this; } RaceSubscriber.prototype._next = function (observable) { this.observables.push(observable); }; RaceSubscriber.prototype._complete = function () { var observables = this.observables; var len = observables.length; if (len === 0) { this.destination.complete(); } else { for (var i = 0; i < len && !this.hasFirst; i++) { var observable = observables[i]; var subscription = subscribeToResult(this, observable, observable, i); if (this.subscriptions) { this.subscriptions.push(subscription); } this.add(subscription); } this.observables = null; } }; RaceSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { if (!this.hasFirst) { this.hasFirst = true; for (var i = 0; i < this.subscriptions.length; i++) { if (i !== outerIndex) { var subscription = this.subscriptions[i]; subscription.unsubscribe(); this.remove(subscription); } } this.subscriptions = null; } this.destination.next(innerValue); }; return RaceSubscriber;
}(OuterSubscriber_OuterSubscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/range.js /** PURE_IMPORTS_START _Observable PURE_IMPORTS_END */
function range(start, count, scheduler) {
if (start === void 0) { start = 0; } return new Observable_Observable(function (subscriber) { if (count === undefined) { count = start; start = 0; } var index = 0; var current = start; if (scheduler) { return scheduler.schedule(range_dispatch, 0, { index: index, count: count, start: start, subscriber: subscriber }); } else { do { if (index++ >= count) { subscriber.complete(); break; } subscriber.next(current++); if (subscriber.closed) { break; } } while (true); } return undefined; });
} function range_dispatch(state) {
var start = state.start, index = state.index, count = state.count, subscriber = state.subscriber; if (index >= count) { subscriber.complete(); return; } subscriber.next(start); if (subscriber.closed) { return; } state.index = index + 1; state.start = start + 1; this.schedule(state);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/timer.js /** PURE_IMPORTS_START _Observable,_scheduler_async,_util_isNumeric,_util_isScheduler PURE_IMPORTS_END */
function timer(dueTime, periodOrScheduler, scheduler) {
if (dueTime === void 0) { dueTime = 0; } var period = -1; if (isNumeric(periodOrScheduler)) { period = Number(periodOrScheduler) < 1 && 1 || Number(periodOrScheduler); } else if (isScheduler(periodOrScheduler)) { scheduler = periodOrScheduler; } if (!isScheduler(scheduler)) { scheduler = async_async; } return new Observable_Observable(function (subscriber) { var due = isNumeric(dueTime) ? dueTime : (+dueTime - scheduler.now()); return scheduler.schedule(timer_dispatch, due, { index: 0, period: period, subscriber: subscriber }); });
} function timer_dispatch(state) {
var index = state.index, period = state.period, subscriber = state.subscriber; subscriber.next(index); if (subscriber.closed) { return; } else if (period === -1) { return subscriber.complete(); } state.index = index + 1; this.schedule(state, period);
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/using.js /** PURE_IMPORTS_START _Observable,_from,_empty PURE_IMPORTS_END */
function using(resourceFactory, observableFactory) {
return new Observable_Observable(function (subscriber) { var resource; try { resource = resourceFactory(); } catch (err) { subscriber.error(err); return undefined; } var result; try { result = observableFactory(resource); } catch (err) { subscriber.error(err); return undefined; } var source = result ? from(result) : EMPTY; var subscription = source.subscribe(subscriber); return function () { subscription.unsubscribe(); if (resource) { resource.unsubscribe(); } }; });
}
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/internal/observable/zip.js /** PURE_IMPORTS_START tslib,_fromArray,_util_isArray,_Subscriber,_OuterSubscriber,util_subscribeToResult,.._internal_symbol_iterator PURE_IMPORTS_END */
function zip() {
var observables = []; for (var _i = 0; _i < arguments.length; _i++) { observables[_i] = arguments[_i]; } var resultSelector = observables[observables.length - 1]; if (typeof resultSelector === 'function') { observables.pop(); } return fromArray(observables, undefined).lift(new ZipOperator(resultSelector));
} var ZipOperator = /*@__PURE__*/ (function () {
function ZipOperator(resultSelector) { this.resultSelector = resultSelector; } ZipOperator.prototype.call = function (subscriber, source) { return source.subscribe(new zip_ZipSubscriber(subscriber, this.resultSelector)); }; return ZipOperator;
}());
var zip_ZipSubscriber = /*@__PURE__*/ (function (_super) {
__extends(ZipSubscriber, _super); function ZipSubscriber(destination, resultSelector, values) { if (values === void 0) { values = Object.create(null); } var _this = _super.call(this, destination) || this; _this.iterators = []; _this.active = 0; _this.resultSelector = (typeof resultSelector === 'function') ? resultSelector : null; _this.values = values; return _this; } ZipSubscriber.prototype._next = function (value) { var iterators = this.iterators; if (isArray(value)) { iterators.push(new zip_StaticArrayIterator(value)); } else if (typeof value[iterator_iterator] === 'function') { iterators.push(new StaticIterator(value[iterator_iterator]())); } else { iterators.push(new zip_ZipBufferIterator(this.destination, this, value)); } }; ZipSubscriber.prototype._complete = function () { var iterators = this.iterators; var len = iterators.length; this.unsubscribe(); if (len === 0) { this.destination.complete(); return; } this.active = len; for (var i = 0; i < len; i++) { var iterator = iterators[i]; if (iterator.stillUnsubscribed) { var destination = this.destination; destination.add(iterator.subscribe(iterator, i)); } else { this.active--; } } }; ZipSubscriber.prototype.notifyInactive = function () { this.active--; if (this.active === 0) { this.destination.complete(); } }; ZipSubscriber.prototype.checkIterators = function () { var iterators = this.iterators; var len = iterators.length; var destination = this.destination; for (var i = 0; i < len; i++) { var iterator = iterators[i]; if (typeof iterator.hasValue === 'function' && !iterator.hasValue()) { return; } } var shouldComplete = false; var args = []; for (var i = 0; i < len; i++) { var iterator = iterators[i]; var result = iterator.next(); if (iterator.hasCompleted()) { shouldComplete = true; } if (result.done) { destination.complete(); return; } args.push(result.value); } if (this.resultSelector) { this._tryresultSelector(args); } else { destination.next(args); } if (shouldComplete) { destination.complete(); } }; ZipSubscriber.prototype._tryresultSelector = function (args) { var result; try { result = this.resultSelector.apply(this, args); } catch (err) { this.destination.error(err); return; } this.destination.next(result); }; return ZipSubscriber;
}(Subscriber_Subscriber));
var StaticIterator = /*@__PURE__*/ (function () {
function StaticIterator(iterator) { this.iterator = iterator; this.nextResult = iterator.next(); } StaticIterator.prototype.hasValue = function () { return true; }; StaticIterator.prototype.next = function () { var result = this.nextResult; this.nextResult = this.iterator.next(); return result; }; StaticIterator.prototype.hasCompleted = function () { var nextResult = this.nextResult; return nextResult && nextResult.done; }; return StaticIterator;
}()); var zip_StaticArrayIterator = /*@__PURE__*/ (function () {
function StaticArrayIterator(array) { this.array = array; this.index = 0; this.length = 0; this.length = array.length; } StaticArrayIterator.prototype[iterator_iterator] = function () { return this; }; StaticArrayIterator.prototype.next = function (value) { var i = this.index++; var array = this.array; return i < this.length ? { value: array[i], done: false } : { value: null, done: true }; }; StaticArrayIterator.prototype.hasValue = function () { return this.array.length > this.index; }; StaticArrayIterator.prototype.hasCompleted = function () { return this.array.length === this.index; }; return StaticArrayIterator;
}()); var zip_ZipBufferIterator = /*@__PURE__*/ (function (_super) {
__extends(ZipBufferIterator, _super); function ZipBufferIterator(destination, parent, observable) { var _this = _super.call(this, destination) || this; _this.parent = parent; _this.observable = observable; _this.stillUnsubscribed = true; _this.buffer = []; _this.isComplete = false; return _this; } ZipBufferIterator.prototype[iterator_iterator] = function () { return this; }; ZipBufferIterator.prototype.next = function () { var buffer = this.buffer; if (buffer.length === 0 && this.isComplete) { return { value: null, done: true }; } else { return { value: buffer.shift(), done: false }; } }; ZipBufferIterator.prototype.hasValue = function () { return this.buffer.length > 0; }; ZipBufferIterator.prototype.hasCompleted = function () { return this.buffer.length === 0 && this.isComplete; }; ZipBufferIterator.prototype.notifyComplete = function () { if (this.buffer.length > 0) { this.isComplete = true; this.parent.notifyInactive(); } else { this.destination.complete(); } }; ZipBufferIterator.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { this.buffer.push(innerValue); this.parent.checkIterators(); }; ZipBufferIterator.prototype.subscribe = function (value, index) { return subscribeToResult(this, this.observable, this, index); }; return ZipBufferIterator;
}(OuterSubscriber_OuterSubscriber));
// CONCATENATED MODULE: ./node_modules/rxjs/_esm5/index.js /* concated harmony reexport Observable */webpack_require.d(webpack_exports, “Observable”, function() { return Observable_Observable; }); /* concated harmony reexport ConnectableObservable */webpack_require.d(webpack_exports, “ConnectableObservable”, function() { return ConnectableObservable_ConnectableObservable; }); /* concated harmony reexport GroupedObservable */webpack_require.d(webpack_exports, “GroupedObservable”, function() { return groupBy_GroupedObservable; }); /* concated harmony reexport observable */webpack_require.d(webpack_exports, “observable”, function() { return observable_observable; }); /* concated harmony reexport Subject */webpack_require.d(webpack_exports, “Subject”, function() { return Subject_Subject; }); /* concated harmony reexport BehaviorSubject */webpack_require.d(webpack_exports, “BehaviorSubject”, function() { return BehaviorSubject_BehaviorSubject; }); /* concated harmony reexport ReplaySubject */webpack_require.d(webpack_exports, “ReplaySubject”, function() { return ReplaySubject_ReplaySubject; }); /* concated harmony reexport AsyncSubject */webpack_require.d(webpack_exports, “AsyncSubject”, function() { return AsyncSubject_AsyncSubject; }); /* concated harmony reexport asapScheduler */webpack_require.d(webpack_exports, “asapScheduler”, function() { return asap; }); /* concated harmony reexport asyncScheduler */webpack_require.d(webpack_exports, “asyncScheduler”, function() { return async_async; }); /* concated harmony reexport queueScheduler */webpack_require.d(webpack_exports, “queueScheduler”, function() { return queue; }); /* concated harmony reexport animationFrameScheduler */webpack_require.d(webpack_exports, “animationFrameScheduler”, function() { return animationFrame; }); /* concated harmony reexport VirtualTimeScheduler */webpack_require.d(webpack_exports, “VirtualTimeScheduler”, function() { return VirtualTimeScheduler_VirtualTimeScheduler; }); /* concated harmony reexport VirtualAction */webpack_require.d(webpack_exports, “VirtualAction”, function() { return VirtualTimeScheduler_VirtualAction; }); /* concated harmony reexport Scheduler */webpack_require.d(webpack_exports, “Scheduler”, function() { return Scheduler; }); /* concated harmony reexport Subscription */webpack_require.d(webpack_exports, “Subscription”, function() { return Subscription_Subscription; }); /* concated harmony reexport Subscriber */webpack_require.d(webpack_exports, “Subscriber”, function() { return Subscriber_Subscriber; }); /* concated harmony reexport Notification */webpack_require.d(webpack_exports, “Notification”, function() { return Notification_Notification; }); /* concated harmony reexport NotificationKind */webpack_require.d(webpack_exports, “NotificationKind”, function() { return NotificationKind; }); /* concated harmony reexport pipe */webpack_require.d(webpack_exports, “pipe”, function() { return pipe; }); /* concated harmony reexport noop */webpack_require.d(webpack_exports, “noop”, function() { return noop; }); /* concated harmony reexport identity */webpack_require.d(webpack_exports, “identity”, function() { return identity; }); /* concated harmony reexport isObservable */webpack_require.d(webpack_exports, “isObservable”, function() { return isObservable; }); /* concated harmony reexport ArgumentOutOfRangeError */webpack_require.d(webpack_exports, “ArgumentOutOfRangeError”, function() { return ArgumentOutOfRangeError; }); /* concated harmony reexport EmptyError */webpack_require.d(webpack_exports, “EmptyError”, function() { return EmptyError; }); /* concated harmony reexport ObjectUnsubscribedError */webpack_require.d(webpack_exports, “ObjectUnsubscribedError”, function() { return ObjectUnsubscribedError; }); /* concated harmony reexport UnsubscriptionError */webpack_require.d(webpack_exports, “UnsubscriptionError”, function() { return UnsubscriptionError; }); /* concated harmony reexport TimeoutError */webpack_require.d(webpack_exports, “TimeoutError”, function() { return TimeoutError; }); /* concated harmony reexport bindCallback */webpack_require.d(webpack_exports, “bindCallback”, function() { return bindCallback; }); /* concated harmony reexport bindNodeCallback */webpack_require.d(webpack_exports, “bindNodeCallback”, function() { return bindNodeCallback; }); /* concated harmony reexport combineLatest */webpack_require.d(webpack_exports, “combineLatest”, function() { return combineLatest; }); /* concated harmony reexport concat */webpack_require.d(webpack_exports, “concat”, function() { return concat; }); /* concated harmony reexport defer */webpack_require.d(webpack_exports, “defer”, function() { return defer; }); /* concated harmony reexport empty */webpack_require.d(webpack_exports, “empty”, function() { return empty_empty; }); /* concated harmony reexport forkJoin */webpack_require.d(webpack_exports, “forkJoin”, function() { return forkJoin; }); /* concated harmony reexport from */webpack_require.d(webpack_exports, “from”, function() { return from; }); /* concated harmony reexport fromEvent */webpack_require.d(webpack_exports, “fromEvent”, function() { return fromEvent; }); /* concated harmony reexport fromEventPattern */webpack_require.d(webpack_exports, “fromEventPattern”, function() { return fromEventPattern; }); /* concated harmony reexport generate */webpack_require.d(webpack_exports, “generate”, function() { return generate; }); /* concated harmony reexport iif */webpack_require.d(webpack_exports, “iif”, function() { return iif; }); /* concated harmony reexport interval */webpack_require.d(webpack_exports, “interval”, function() { return interval; }); /* concated harmony reexport merge */webpack_require.d(webpack_exports, “merge”, function() { return merge; }); /* concated harmony reexport never */webpack_require.d(webpack_exports, “never”, function() { return never; }); /* concated harmony reexport of */webpack_require.d(webpack_exports, “of”, function() { return of; }); /* concated harmony reexport onErrorResumeNext */webpack_require.d(webpack_exports, “onErrorResumeNext”, function() { return onErrorResumeNext; }); /* concated harmony reexport pairs */webpack_require.d(webpack_exports, “pairs”, function() { return pairs; }); /* concated harmony reexport partition */webpack_require.d(webpack_exports, “partition”, function() { return partition; }); /* concated harmony reexport race */webpack_require.d(webpack_exports, “race”, function() { return race; }); /* concated harmony reexport range */webpack_require.d(webpack_exports, “range”, function() { return range; }); /* concated harmony reexport throwError */webpack_require.d(webpack_exports, “throwError”, function() { return throwError; }); /* concated harmony reexport timer */webpack_require.d(webpack_exports, “timer”, function() { return timer; }); /* concated harmony reexport using */webpack_require.d(webpack_exports, “using”, function() { return using; }); /* concated harmony reexport zip */webpack_require.d(webpack_exports, “zip”, function() { return zip; }); /* concated harmony reexport scheduled */webpack_require.d(webpack_exports, “scheduled”, function() { return scheduled; }); /* concated harmony reexport EMPTY */webpack_require.d(webpack_exports, “EMPTY”, function() { return EMPTY; }); /* concated harmony reexport NEVER */webpack_require.d(webpack_exports, “NEVER”, function() { return NEVER; }); /* concated harmony reexport config */webpack_require.d(webpack_exports, “config”, function() { return config; }); /** PURE_IMPORTS_START PURE_IMPORTS_END */
/***/ })
/******/ }); //# sourceMappingURL=app.js.map