/******/ (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