text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define([], factory);
  	else if(typeof exports === 'object')
  		exports["id_rights"] = factory();
  	else
  		root["VeLib"] = root["VeLib"] || {}, root["VeLib"]["id_rights"] = factory();
  })(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  /******/
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = 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;
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _actions = __webpack_require__(279);
  	
  	var _actions2 = _interopRequireDefault(_actions);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  	
  	var IDrights = function IDrights() {
  		_classCallCheck(this, IDrights);
  	
  		this.actions = _actions2.default;
  	};
  	
  	var idrights = new IDrights();
  	
  	Object.setPrototypeOf(idrights, _actions2.default);
  	
  	module.exports = idrights;
  
  /***/ }),
  
  /***/ 279:
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  	
  	var _Observable = __webpack_require__(280);
  	
  	__webpack_require__(294);
  	
  	__webpack_require__(300);
  	
  	__webpack_require__(303);
  	
  	__webpack_require__(312);
  	
  	__webpack_require__(320);
  	
  	__webpack_require__(322);
  	
  	__webpack_require__(327);
  	
  	var _configs = __webpack_require__(329);
  	
  	var _errors = __webpack_require__(330);
  	
  	var _errors2 = _interopRequireDefault(_errors);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  	
  	var callForData = VeLib.core.remote.callForData;
  	var state = VeLib.core.state;
  	
  	var pollIterationCount = 9;
  	var pollIntervalMs = 1000;
  	
  	var Actions = function () {
  		function Actions() {
  			_classCallCheck(this, Actions);
  		}
  	
  		_createClass(Actions, [{
  			key: 'getCompanyAuthorities',
  			value: function getCompanyAuthorities(regNumber) {
  				return new Promise(function (resolve, reject) {
  					_Observable.Observable.of("").delay(pollIntervalMs).flatMap(function () {
  						return _Observable.Observable.fromPromise(callForData({
  							method: "GET",
  							url: '' + _configs.configs.get().idrightsUrl + regNumber
  						}));
  					})
  					// Retry only if it doesn't throw a straight 404
  					.retryWhen(function (errors) {
  						return errors.scan(function (errorCount, err) {
  							if (err.response.status == 404 || err.response.status == 500) {
  								throw _errors2.default.notFound(err.msg);
  							} else if (errorCount >= pollIterationCount) {
  								throw _errors2.default.maxIterations(err.msg);
  							}
  							return errorCount + 1;
  						}, 0);
  					}).subscribe(
  					// If contains data data key we resolve
  					function (data) {
  						if (!Object.keys(data).length) {
  							reject(_errors2.default.emptyData());
  							state.addError(_errors2.default.emptyData());
  						} else resolve(data);
  					},
  					// We catch previously baked error in retryWhen and reject promise, and we add to state
  	
  					function (bakedError) {
  						reject(bakedError);
  						state.addError(bakedError);
  					});
  				});
  			}
  		}]);
  	
  		return Actions;
  	}();
  	
  	module.exports = new Actions();
  
  /***/ }),
  
  /***/ 280:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var root_1 = __webpack_require__(281);
  	var toSubscriber_1 = __webpack_require__(282);
  	var observable_1 = __webpack_require__(293);
  	/**
  	 * A representation of any set of values over any amount of time. This is the most basic building block
  	 * of RxJS.
  	 *
  	 * @class Observable<T>
  	 */
  	var Observable = (function () {
  	    /**
  	     * @constructor
  	     * @param {Function} subscribe the function that is called when the Observable is
  	     * initially subscribed to. This function is given a Subscriber, to which new values
  	     * can be `next`ed, or an `error` method can be called to raise an error, or
  	     * `complete` can be called to notify of a successful completion.
  	     */
  	    function Observable(subscribe) {
  	        this._isScalar = false;
  	        if (subscribe) {
  	            this._subscribe = subscribe;
  	        }
  	    }
  	    /**
  	     * Creates a new Observable, with this Observable as the source, and the passed
  	     * operator defined as the new observable's operator.
  	     * @method lift
  	     * @param {Operator} operator the operator defining the operation to take on the observable
  	     * @return {Observable} a new observable with the Operator applied
  	     */
  	    Observable.prototype.lift = function (operator) {
  	        var observable = new Observable();
  	        observable.source = this;
  	        observable.operator = operator;
  	        return observable;
  	    };
  	    /**
  	     * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.
  	     *
  	     * <span class="informal">Use it when you have all these Observables, but still nothing is happening.</span>
  	     *
  	     * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It
  	     * might be for example a function that you passed to a {@link create} static factory, but most of the time it is
  	     * a library implementation, which defines what and when will be emitted by an Observable. This means that calling
  	     * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often
  	     * thought.
  	     *
  	     * Apart from starting the execution of an Observable, this method allows you to listen for values
  	     * that an Observable emits, as well as for when it completes or errors. You can achieve this in two
  	     * following ways.
  	     *
  	     * The first way is creating an object that implements {@link Observer} interface. It should have methods
  	     * defined by that interface, but note that it should be just a regular JavaScript object, which you can create
  	     * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do
  	     * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also
  	     * that your object does not have to implement all methods. If you find yourself creating a method that doesn't
  	     * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will
  	     * be left uncaught.
  	     *
  	     * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.
  	     * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent
  	     * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,
  	     * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,
  	     * since `subscribe` recognizes these functions by where they were placed in function call. When it comes
  	     * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.
  	     *
  	     * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.
  	     * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean
  	     * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback
  	     * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.
  	     *
  	     * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.
  	     * It is an Observable itself that decides when these functions will be called. For example {@link of}
  	     * by default emits all its values synchronously. Always check documentation for how given Observable
  	     * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.
  	     *
  	     * @example <caption>Subscribe with an Observer</caption>
  	     * const sumObserver = {
  	     *   sum: 0,
  	     *   next(value) {
  	     *     console.log('Adding: ' + value);
  	     *     this.sum = this.sum + value;
  	     *   },
  	     *   error() { // We actually could just remove this method,
  	     *   },        // since we do not really care about errors right now.
  	     *   complete() {
  	     *     console.log('Sum equals: ' + this.sum);
  	     *   }
  	     * };
  	     *
  	     * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.
  	     * .subscribe(sumObserver);
  	     *
  	     * // Logs:
  	     * // "Adding: 1"
  	     * // "Adding: 2"
  	     * // "Adding: 3"
  	     * // "Sum equals: 6"
  	     *
  	     *
  	     * @example <caption>Subscribe with functions</caption>
  	     * let sum = 0;
  	     *
  	     * Rx.Observable.of(1, 2, 3)
  	     * .subscribe(
  	     *   function(value) {
  	     *     console.log('Adding: ' + value);
  	     *     sum = sum + value;
  	     *   },
  	     *   undefined,
  	     *   function() {
  	     *     console.log('Sum equals: ' + sum);
  	     *   }
  	     * );
  	     *
  	     * // Logs:
  	     * // "Adding: 1"
  	     * // "Adding: 2"
  	     * // "Adding: 3"
  	     * // "Sum equals: 6"
  	     *
  	     *
  	     * @example <caption>Cancel a subscription</caption>
  	     * const subscription = Rx.Observable.interval(1000).subscribe(
  	     *   num => console.log(num),
  	     *   undefined,
  	     *   () => console.log('completed!') // Will not be called, even
  	     * );                                // when cancelling subscription
  	     *
  	     *
  	     * setTimeout(() => {
  	     *   subscription.unsubscribe();
  	     *   console.log('unsubscribed!');
  	     * }, 2500);
  	     *
  	     * // Logs:
  	     * // 0 after 1s
  	     * // 1 after 2s
  	     * // "unsubscribed!" after 2.5s
  	     *
  	     *
  	     * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,
  	     *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed
  	     *  Observable.
  	     * @param {Function} error (optional) A handler for a terminal event resulting from an error. If no error handler is provided,
  	     *  the error will be thrown as unhandled.
  	     * @param {Function} complete (optional) A handler for a terminal event resulting from successful completion.
  	     * @return {ISubscription} a subscription reference to the registered handlers
  	     * @method subscribe
  	     */
  	    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
  	        var operator = this.operator;
  	        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);
  	        if (operator) {
  	            operator.call(sink, this.source);
  	        }
  	        else {
  	            sink.add(this.source ? this._subscribe(sink) : this._trySubscribe(sink));
  	        }
  	        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) {
  	            sink.syncErrorThrown = true;
  	            sink.syncErrorValue = err;
  	            sink.error(err);
  	        }
  	    };
  	    /**
  	     * @method forEach
  	     * @param {Function} next a handler for each value emitted by the observable
  	     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise
  	     * @return {Promise} a promise that either resolves on observable completion or
  	     *  rejects with the handled error
  	     */
  	    Observable.prototype.forEach = function (next, PromiseCtor) {
  	        var _this = this;
  	        if (!PromiseCtor) {
  	            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {
  	                PromiseCtor = root_1.root.Rx.config.Promise;
  	            }
  	            else if (root_1.root.Promise) {
  	                PromiseCtor = root_1.root.Promise;
  	            }
  	        }
  	        if (!PromiseCtor) {
  	            throw new Error('no Promise impl found');
  	        }
  	        return new PromiseCtor(function (resolve, reject) {
  	            // Must be declared in a separate statement to avoid a RefernceError when
  	            // accessing subscription below in the closure due to Temporal Dead Zone.
  	            var subscription;
  	            subscription = _this.subscribe(function (value) {
  	                if (subscription) {
  	                    // if there is a subscription, then we can surmise
  	                    // the next handling is asynchronous. Any errors thrown
  	                    // need to be rejected explicitly and unsubscribe must be
  	                    // called manually
  	                    try {
  	                        next(value);
  	                    }
  	                    catch (err) {
  	                        reject(err);
  	                        subscription.unsubscribe();
  	                    }
  	                }
  	                else {
  	                    // if there is NO subscription, then we're getting a nexted
  	                    // value synchronously during subscription. We can just call it.
  	                    // If it errors, Observable's `subscribe` will ensure the
  	                    // unsubscription logic is called, then synchronously rethrow the error.
  	                    // After that, Promise will trap the error and send it
  	                    // down the rejection path.
  	                    next(value);
  	                }
  	            }, reject, resolve);
  	        });
  	    };
  	    Observable.prototype._subscribe = function (subscriber) {
  	        return this.source.subscribe(subscriber);
  	    };
  	    /**
  	     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
  	     * @method Symbol.observable
  	     * @return {Observable} this instance of the observable
  	     */
  	    Observable.prototype[observable_1.observable] = function () {
  	        return this;
  	    };
  	    // HACK: Since TypeScript inherits static properties too, we have to
  	    // fight against TypeScript here so Subject can have a different static create signature
  	    /**
  	     * Creates a new cold Observable by calling the Observable constructor
  	     * @static true
  	     * @owner Observable
  	     * @method create
  	     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
  	     * @return {Observable} a new cold observable
  	     */
  	    Observable.create = function (subscribe) {
  	        return new Observable(subscribe);
  	    };
  	    return Observable;
  	}());
  	exports.Observable = Observable;
  	//# sourceMappingURL=Observable.js.map
  
  /***/ }),
  
  /***/ 281:
  /***/ (function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {"use strict";
  	// CommonJS / Node have global context exposed as "global" variable.
  	// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake
  	// the global "global" var for now.
  	var __window = typeof window !== 'undefined' && window;
  	var __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
  	    self instanceof WorkerGlobalScope && self;
  	var __global = typeof global !== 'undefined' && global;
  	var _root = __window || __global || __self;
  	exports.root = _root;
  	// Workaround Closure Compiler restriction: The body of a goog.module cannot use throw.
  	// This is needed when used with angular/tsickle which inserts a goog.module statement.
  	// Wrap in IIFE
  	(function () {
  	    if (!_root) {
  	        throw new Error('RxJS could not find any global context (window, self, global)');
  	    }
  	})();
  	//# sourceMappingURL=root.js.map
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ }),
  
  /***/ 282:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Subscriber_1 = __webpack_require__(283);
  	var rxSubscriber_1 = __webpack_require__(292);
  	var Observer_1 = __webpack_require__(291);
  	function toSubscriber(nextOrObserver, error, complete) {
  	    if (nextOrObserver) {
  	        if (nextOrObserver instanceof Subscriber_1.Subscriber) {
  	            return nextOrObserver;
  	        }
  	        if (nextOrObserver[rxSubscriber_1.rxSubscriber]) {
  	            return nextOrObserver[rxSubscriber_1.rxSubscriber]();
  	        }
  	    }
  	    if (!nextOrObserver && !error && !complete) {
  	        return new Subscriber_1.Subscriber(Observer_1.empty);
  	    }
  	    return new Subscriber_1.Subscriber(nextOrObserver, error, complete);
  	}
  	exports.toSubscriber = toSubscriber;
  	//# sourceMappingURL=toSubscriber.js.map
  
  /***/ }),
  
  /***/ 283:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var isFunction_1 = __webpack_require__(284);
  	var Subscription_1 = __webpack_require__(285);
  	var Observer_1 = __webpack_require__(291);
  	var rxSubscriber_1 = __webpack_require__(292);
  	/**
  	 * Implements the {@link Observer} interface and extends the
  	 * {@link Subscription} class. While the {@link Observer} is the public API for
  	 * consuming the values of an {@link Observable}, all Observers get converted to
  	 * a Subscriber, in order to provide Subscription-like capabilities such as
  	 * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
  	 * implementing operators, but it is rarely used as a public API.
  	 *
  	 * @class Subscriber<T>
  	 */
  	var Subscriber = (function (_super) {
  	    __extends(Subscriber, _super);
  	    /**
  	     * @param {Observer|function(value: T): void} [destinationOrNext] A partially
  	     * defined Observer or a `next` callback function.
  	     * @param {function(e: ?any): void} [error] The `error` callback of an
  	     * Observer.
  	     * @param {function(): void} [complete] The `complete` callback of an
  	     * Observer.
  	     */
  	    function Subscriber(destinationOrNext, error, complete) {
  	        _super.call(this);
  	        this.syncErrorValue = null;
  	        this.syncErrorThrown = false;
  	        this.syncErrorThrowable = false;
  	        this.isStopped = false;
  	        switch (arguments.length) {
  	            case 0:
  	                this.destination = Observer_1.empty;
  	                break;
  	            case 1:
  	                if (!destinationOrNext) {
  	                    this.destination = Observer_1.empty;
  	                    break;
  	                }
  	                if (typeof destinationOrNext === 'object') {
  	                    if (destinationOrNext instanceof Subscriber) {
  	                        this.destination = destinationOrNext;
  	                        this.destination.add(this);
  	                    }
  	                    else {
  	                        this.syncErrorThrowable = true;
  	                        this.destination = new SafeSubscriber(this, destinationOrNext);
  	                    }
  	                    break;
  	                }
  	            default:
  	                this.syncErrorThrowable = true;
  	                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);
  	                break;
  	        }
  	    }
  	    Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { return this; };
  	    /**
  	     * A static factory for a Subscriber, given a (potentially partial) definition
  	     * of an Observer.
  	     * @param {function(x: ?T): void} [next] The `next` callback of an Observer.
  	     * @param {function(e: ?any): void} [error] The `error` callback of an
  	     * Observer.
  	     * @param {function(): void} [complete] The `complete` callback of an
  	     * Observer.
  	     * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)
  	     * Observer represented by the given arguments.
  	     */
  	    Subscriber.create = function (next, error, complete) {
  	        var subscriber = new Subscriber(next, error, complete);
  	        subscriber.syncErrorThrowable = false;
  	        return subscriber;
  	    };
  	    /**
  	     * The {@link Observer} callback to receive notifications of type `next` from
  	     * the Observable, with a value. The Observable may call this method 0 or more
  	     * times.
  	     * @param {T} [value] The `next` value.
  	     * @return {void}
  	     */
  	    Subscriber.prototype.next = function (value) {
  	        if (!this.isStopped) {
  	            this._next(value);
  	        }
  	    };
  	    /**
  	     * The {@link Observer} callback to receive notifications of type `error` from
  	     * the Observable, with an attached {@link Error}. Notifies the Observer that
  	     * the Observable has experienced an error condition.
  	     * @param {any} [err] The `error` exception.
  	     * @return {void}
  	     */
  	    Subscriber.prototype.error = function (err) {
  	        if (!this.isStopped) {
  	            this.isStopped = true;
  	            this._error(err);
  	        }
  	    };
  	    /**
  	     * The {@link Observer} callback to receive a valueless notification of type
  	     * `complete` from the Observable. Notifies the Observer that the Observable
  	     * has finished sending push-based notifications.
  	     * @return {void}
  	     */
  	    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 _a = this, _parent = _a._parent, _parents = _a._parents;
  	        this._parent = null;
  	        this._parents = null;
  	        this.unsubscribe();
  	        this.closed = false;
  	        this.isStopped = false;
  	        this._parent = _parent;
  	        this._parents = _parents;
  	        return this;
  	    };
  	    return Subscriber;
  	}(Subscription_1.Subscription));
  	exports.Subscriber = Subscriber;
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var SafeSubscriber = (function (_super) {
  	    __extends(SafeSubscriber, _super);
  	    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {
  	        _super.call(this);
  	        this._parentSubscriber = _parentSubscriber;
  	        var next;
  	        var context = this;
  	        if (isFunction_1.isFunction(observerOrNext)) {
  	            next = observerOrNext;
  	        }
  	        else if (observerOrNext) {
  	            next = observerOrNext.next;
  	            error = observerOrNext.error;
  	            complete = observerOrNext.complete;
  	            if (observerOrNext !== Observer_1.empty) {
  	                context = Object.create(observerOrNext);
  	                if (isFunction_1.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;
  	    }
  	    SafeSubscriber.prototype.next = function (value) {
  	        if (!this.isStopped && this._next) {
  	            var _parentSubscriber = this._parentSubscriber;
  	            if (!_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;
  	            if (this._error) {
  	                if (!_parentSubscriber.syncErrorThrowable) {
  	                    this.__tryOrUnsub(this._error, err);
  	                    this.unsubscribe();
  	                }
  	                else {
  	                    this.__tryOrSetError(_parentSubscriber, this._error, err);
  	                    this.unsubscribe();
  	                }
  	            }
  	            else if (!_parentSubscriber.syncErrorThrowable) {
  	                this.unsubscribe();
  	                throw err;
  	            }
  	            else {
  	                _parentSubscriber.syncErrorValue = err;
  	                _parentSubscriber.syncErrorThrown = true;
  	                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 (!_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();
  	            throw err;
  	        }
  	    };
  	    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {
  	        try {
  	            fn.call(this._context, value);
  	        }
  	        catch (err) {
  	            parent.syncErrorValue = err;
  	            parent.syncErrorThrown = true;
  	            return true;
  	        }
  	        return false;
  	    };
  	    SafeSubscriber.prototype._unsubscribe = function () {
  	        var _parentSubscriber = this._parentSubscriber;
  	        this._context = null;
  	        this._parentSubscriber = null;
  	        _parentSubscriber.unsubscribe();
  	    };
  	    return SafeSubscriber;
  	}(Subscriber));
  	//# sourceMappingURL=Subscriber.js.map
  
  /***/ }),
  
  /***/ 284:
  /***/ (function(module, exports) {
  
  	"use strict";
  	function isFunction(x) {
  	    return typeof x === 'function';
  	}
  	exports.isFunction = isFunction;
  	//# sourceMappingURL=isFunction.js.map
  
  /***/ }),
  
  /***/ 285:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var isArray_1 = __webpack_require__(286);
  	var isObject_1 = __webpack_require__(287);
  	var isFunction_1 = __webpack_require__(284);
  	var tryCatch_1 = __webpack_require__(288);
  	var errorObject_1 = __webpack_require__(289);
  	var UnsubscriptionError_1 = __webpack_require__(290);
  	/**
  	 * Represents a disposable resource, such as the execution of an Observable. A
  	 * Subscription has one important method, `unsubscribe`, that takes no argument
  	 * and just disposes the resource held by the subscription.
  	 *
  	 * Additionally, subscriptions may be grouped together through the `add()`
  	 * method, which will attach a child Subscription to the current Subscription.
  	 * When a Subscription is unsubscribed, all its children (and its grandchildren)
  	 * will be unsubscribed as well.
  	 *
  	 * @class Subscription
  	 */
  	var Subscription = (function () {
  	    /**
  	     * @param {function(): void} [unsubscribe] A function describing how to
  	     * perform the disposal of resources when the `unsubscribe` method is called.
  	     */
  	    function Subscription(unsubscribe) {
  	        /**
  	         * A flag to indicate whether this Subscription has already been unsubscribed.
  	         * @type {boolean}
  	         */
  	        this.closed = false;
  	        this._parent = null;
  	        this._parents = null;
  	        this._subscriptions = null;
  	        if (unsubscribe) {
  	            this._unsubscribe = unsubscribe;
  	        }
  	    }
  	    /**
  	     * Disposes the resources held by the subscription. May, for instance, cancel
  	     * an ongoing Observable execution or cancel any other type of work that
  	     * started when the Subscription was created.
  	     * @return {void}
  	     */
  	    Subscription.prototype.unsubscribe = function () {
  	        var hasErrors = false;
  	        var errors;
  	        if (this.closed) {
  	            return;
  	        }
  	        var _a = this, _parent = _a._parent, _parents = _a._parents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;
  	        this.closed = true;
  	        this._parent = null;
  	        this._parents = null;
  	        // null out _subscriptions first so any child subscriptions that attempt
  	        // to remove themselves from this subscription will noop
  	        this._subscriptions = null;
  	        var index = -1;
  	        var len = _parents ? _parents.length : 0;
  	        // if this._parent is null, then so is this._parents, and we
  	        // don't have to remove ourselves from any parent subscriptions.
  	        while (_parent) {
  	            _parent.remove(this);
  	            // if this._parents is null or index >= len,
  	            // then _parent is set to null, and the loop exits
  	            _parent = ++index < len && _parents[index] || null;
  	        }
  	        if (isFunction_1.isFunction(_unsubscribe)) {
  	            var trial = tryCatch_1.tryCatch(_unsubscribe).call(this);
  	            if (trial === errorObject_1.errorObject) {
  	                hasErrors = true;
  	                errors = errors || (errorObject_1.errorObject.e instanceof UnsubscriptionError_1.UnsubscriptionError ?
  	                    flattenUnsubscriptionErrors(errorObject_1.errorObject.e.errors) : [errorObject_1.errorObject.e]);
  	            }
  	        }
  	        if (isArray_1.isArray(_subscriptions)) {
  	            index = -1;
  	            len = _subscriptions.length;
  	            while (++index < len) {
  	                var sub = _subscriptions[index];
  	                if (isObject_1.isObject(sub)) {
  	                    var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub);
  	                    if (trial === errorObject_1.errorObject) {
  	                        hasErrors = true;
  	                        errors = errors || [];
  	                        var err = errorObject_1.errorObject.e;
  	                        if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {
  	                            errors = errors.concat(flattenUnsubscriptionErrors(err.errors));
  	                        }
  	                        else {
  	                            errors.push(err);
  	                        }
  	                    }
  	                }
  	            }
  	        }
  	        if (hasErrors) {
  	            throw new UnsubscriptionError_1.UnsubscriptionError(errors);
  	        }
  	    };
  	    /**
  	     * Adds a tear down to be called during the unsubscribe() of this
  	     * Subscription.
  	     *
  	     * If the tear down being added is a subscription that is already
  	     * unsubscribed, is the same reference `add` is being called on, or is
  	     * `Subscription.EMPTY`, it will not be added.
  	     *
  	     * If this subscription is already in an `closed` state, the passed
  	     * tear down logic will be executed immediately.
  	     *
  	     * @param {TeardownLogic} teardown The additional logic to execute on
  	     * teardown.
  	     * @return {Subscription} Returns the Subscription used or created to be
  	     * added to the inner subscriptions list. This Subscription can be used with
  	     * `remove()` to remove the passed teardown logic from the inner subscriptions
  	     * list.
  	     */
  	    Subscription.prototype.add = function (teardown) {
  	        if (!teardown || (teardown === Subscription.EMPTY)) {
  	            return Subscription.EMPTY;
  	        }
  	        if (teardown === this) {
  	            return this;
  	        }
  	        var subscription = teardown;
  	        switch (typeof teardown) {
  	            case 'function':
  	                subscription = new Subscription(teardown);
  	            case 'object':
  	                if (subscription.closed || typeof subscription.unsubscribe !== 'function') {
  	                    return subscription;
  	                }
  	                else if (this.closed) {
  	                    subscription.unsubscribe();
  	                    return subscription;
  	                }
  	                else if (typeof subscription._addParent !== 'function' /* quack quack */) {
  	                    var tmp = subscription;
  	                    subscription = new Subscription();
  	                    subscription._subscriptions = [tmp];
  	                }
  	                break;
  	            default:
  	                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');
  	        }
  	        var subscriptions = this._subscriptions || (this._subscriptions = []);
  	        subscriptions.push(subscription);
  	        subscription._addParent(this);
  	        return subscription;
  	    };
  	    /**
  	     * Removes a Subscription from the internal list of subscriptions that will
  	     * unsubscribe during the unsubscribe process of this Subscription.
  	     * @param {Subscription} subscription The subscription to remove.
  	     * @return {void}
  	     */
  	    Subscription.prototype.remove = function (subscription) {
  	        var subscriptions = this._subscriptions;
  	        if (subscriptions) {
  	            var subscriptionIndex = subscriptions.indexOf(subscription);
  	            if (subscriptionIndex !== -1) {
  	                subscriptions.splice(subscriptionIndex, 1);
  	            }
  	        }
  	    };
  	    Subscription.prototype._addParent = function (parent) {
  	        var _a = this, _parent = _a._parent, _parents = _a._parents;
  	        if (!_parent || _parent === parent) {
  	            // If we don't have a parent, or the new parent is the same as the
  	            // current parent, then set this._parent to the new parent.
  	            this._parent = parent;
  	        }
  	        else if (!_parents) {
  	            // If there's already one parent, but not multiple, allocate an Array to
  	            // store the rest of the parent Subscriptions.
  	            this._parents = [parent];
  	        }
  	        else if (_parents.indexOf(parent) === -1) {
  	            // Only add the new parent to the _parents list if it's not already there.
  	            _parents.push(parent);
  	        }
  	    };
  	    Subscription.EMPTY = (function (empty) {
  	        empty.closed = true;
  	        return empty;
  	    }(new Subscription()));
  	    return Subscription;
  	}());
  	exports.Subscription = Subscription;
  	function flattenUnsubscriptionErrors(errors) {
  	    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError_1.UnsubscriptionError) ? err.errors : err); }, []);
  	}
  	//# sourceMappingURL=Subscription.js.map
  
  /***/ }),
  
  /***/ 286:
  /***/ (function(module, exports) {
  
  	"use strict";
  	exports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });
  	//# sourceMappingURL=isArray.js.map
  
  /***/ }),
  
  /***/ 287:
  /***/ (function(module, exports) {
  
  	"use strict";
  	function isObject(x) {
  	    return x != null && typeof x === 'object';
  	}
  	exports.isObject = isObject;
  	//# sourceMappingURL=isObject.js.map
  
  /***/ }),
  
  /***/ 288:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var errorObject_1 = __webpack_require__(289);
  	var tryCatchTarget;
  	function tryCatcher() {
  	    try {
  	        return tryCatchTarget.apply(this, arguments);
  	    }
  	    catch (e) {
  	        errorObject_1.errorObject.e = e;
  	        return errorObject_1.errorObject;
  	    }
  	}
  	function tryCatch(fn) {
  	    tryCatchTarget = fn;
  	    return tryCatcher;
  	}
  	exports.tryCatch = tryCatch;
  	;
  	//# sourceMappingURL=tryCatch.js.map
  
  /***/ }),
  
  /***/ 289:
  /***/ (function(module, exports) {
  
  	"use strict";
  	// typeof any so that it we don't have to cast when comparing a result to the error object
  	exports.errorObject = { e: {} };
  	//# sourceMappingURL=errorObject.js.map
  
  /***/ }),
  
  /***/ 290:
  /***/ (function(module, exports) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	/**
  	 * An error thrown when one or more errors have occurred during the
  	 * `unsubscribe` of a {@link Subscription}.
  	 */
  	var UnsubscriptionError = (function (_super) {
  	    __extends(UnsubscriptionError, _super);
  	    function UnsubscriptionError(errors) {
  	        _super.call(this);
  	        this.errors = errors;
  	        var err = Error.call(this, errors ?
  	            errors.length + " errors occurred during unsubscription:\n  " + errors.map(function (err, i) { return ((i + 1) + ") " + err.toString()); }).join('\n  ') : '');
  	        this.name = err.name = 'UnsubscriptionError';
  	        this.stack = err.stack;
  	        this.message = err.message;
  	    }
  	    return UnsubscriptionError;
  	}(Error));
  	exports.UnsubscriptionError = UnsubscriptionError;
  	//# sourceMappingURL=UnsubscriptionError.js.map
  
  /***/ }),
  
  /***/ 291:
  /***/ (function(module, exports) {
  
  	"use strict";
  	exports.empty = {
  	    closed: true,
  	    next: function (value) { },
  	    error: function (err) { throw err; },
  	    complete: function () { }
  	};
  	//# sourceMappingURL=Observer.js.map
  
  /***/ }),
  
  /***/ 292:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var root_1 = __webpack_require__(281);
  	var Symbol = root_1.root.Symbol;
  	exports.rxSubscriber = (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?
  	    Symbol.for('rxSubscriber') : '@@rxSubscriber';
  	/**
  	 * @deprecated use rxSubscriber instead
  	 */
  	exports.$$rxSubscriber = exports.rxSubscriber;
  	//# sourceMappingURL=rxSubscriber.js.map
  
  /***/ }),
  
  /***/ 293:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var root_1 = __webpack_require__(281);
  	function getSymbolObservable(context) {
  	    var $$observable;
  	    var Symbol = context.Symbol;
  	    if (typeof Symbol === 'function') {
  	        if (Symbol.observable) {
  	            $$observable = Symbol.observable;
  	        }
  	        else {
  	            $$observable = Symbol('observable');
  	            Symbol.observable = $$observable;
  	        }
  	    }
  	    else {
  	        $$observable = '@@observable';
  	    }
  	    return $$observable;
  	}
  	exports.getSymbolObservable = getSymbolObservable;
  	exports.observable = getSymbolObservable(root_1.root);
  	/**
  	 * @deprecated use observable instead
  	 */
  	exports.$$observable = exports.observable;
  	//# sourceMappingURL=observable.js.map
  
  /***/ }),
  
  /***/ 294:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	var of_1 = __webpack_require__(295);
  	Observable_1.Observable.of = of_1.of;
  	//# sourceMappingURL=of.js.map
  
  /***/ }),
  
  /***/ 295:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var ArrayObservable_1 = __webpack_require__(296);
  	exports.of = ArrayObservable_1.ArrayObservable.of;
  	//# sourceMappingURL=of.js.map
  
  /***/ }),
  
  /***/ 296:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Observable_1 = __webpack_require__(280);
  	var ScalarObservable_1 = __webpack_require__(297);
  	var EmptyObservable_1 = __webpack_require__(298);
  	var isScheduler_1 = __webpack_require__(299);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @extends {Ignored}
  	 * @hide true
  	 */
  	var ArrayObservable = (function (_super) {
  	    __extends(ArrayObservable, _super);
  	    function ArrayObservable(array, scheduler) {
  	        _super.call(this);
  	        this.array = array;
  	        this.scheduler = scheduler;
  	        if (!scheduler && array.length === 1) {
  	            this._isScalar = true;
  	            this.value = array[0];
  	        }
  	    }
  	    ArrayObservable.create = function (array, scheduler) {
  	        return new ArrayObservable(array, scheduler);
  	    };
  	    /**
  	     * Creates an Observable that emits some values you specify as arguments,
  	     * immediately one after the other, and then emits a complete notification.
  	     *
  	     * <span class="informal">Emits the arguments you provide, then completes.
  	     * </span>
  	     *
  	     * <img src="./img/of.png" width="100%">
  	     *
  	     * This static operator is useful for creating a simple Observable that only
  	     * emits the arguments given, and the complete notification thereafter. It can
  	     * be used for composing with other Observables, such as with {@link concat}.
  	     * By default, it uses a `null` IScheduler, which means the `next`
  	     * notifications are sent synchronously, although with a different IScheduler
  	     * it is possible to determine when those notifications will be delivered.
  	     *
  	     * @example <caption>Emit 10, 20, 30, then 'a', 'b', 'c', then start ticking every second.</caption>
  	     * var numbers = Rx.Observable.of(10, 20, 30);
  	     * var letters = Rx.Observable.of('a', 'b', 'c');
  	     * var interval = Rx.Observable.interval(1000);
  	     * var result = numbers.concat(letters).concat(interval);
  	     * result.subscribe(x => console.log(x));
  	     *
  	     * @see {@link create}
  	     * @see {@link empty}
  	     * @see {@link never}
  	     * @see {@link throw}
  	     *
  	     * @param {...T} values Arguments that represent `next` values to be emitted.
  	     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling
  	     * the emissions of the `next` notifications.
  	     * @return {Observable<T>} An Observable that emits each given input value.
  	     * @static true
  	     * @name of
  	     * @owner Observable
  	     */
  	    ArrayObservable.of = function () {
  	        var array = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            array[_i - 0] = arguments[_i];
  	        }
  	        var scheduler = array[array.length - 1];
  	        if (isScheduler_1.isScheduler(scheduler)) {
  	            array.pop();
  	        }
  	        else {
  	            scheduler = null;
  	        }
  	        var len = array.length;
  	        if (len > 1) {
  	            return new ArrayObservable(array, scheduler);
  	        }
  	        else if (len === 1) {
  	            return new ScalarObservable_1.ScalarObservable(array[0], scheduler);
  	        }
  	        else {
  	            return new EmptyObservable_1.EmptyObservable(scheduler);
  	        }
  	    };
  	    ArrayObservable.dispatch = function (state) {
  	        var array = state.array, index = state.index, count = state.count, subscriber = state.subscriber;
  	        if (index >= count) {
  	            subscriber.complete();
  	            return;
  	        }
  	        subscriber.next(array[index]);
  	        if (subscriber.closed) {
  	            return;
  	        }
  	        state.index = index + 1;
  	        this.schedule(state);
  	    };
  	    ArrayObservable.prototype._subscribe = function (subscriber) {
  	        var index = 0;
  	        var array = this.array;
  	        var count = array.length;
  	        var scheduler = this.scheduler;
  	        if (scheduler) {
  	            return scheduler.schedule(ArrayObservable.dispatch, 0, {
  	                array: array, index: index, count: count, subscriber: subscriber
  	            });
  	        }
  	        else {
  	            for (var i = 0; i < count && !subscriber.closed; i++) {
  	                subscriber.next(array[i]);
  	            }
  	            subscriber.complete();
  	        }
  	    };
  	    return ArrayObservable;
  	}(Observable_1.Observable));
  	exports.ArrayObservable = ArrayObservable;
  	//# sourceMappingURL=ArrayObservable.js.map
  
  /***/ }),
  
  /***/ 297:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Observable_1 = __webpack_require__(280);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @extends {Ignored}
  	 * @hide true
  	 */
  	var ScalarObservable = (function (_super) {
  	    __extends(ScalarObservable, _super);
  	    function ScalarObservable(value, scheduler) {
  	        _super.call(this);
  	        this.value = value;
  	        this.scheduler = scheduler;
  	        this._isScalar = true;
  	        if (scheduler) {
  	            this._isScalar = false;
  	        }
  	    }
  	    ScalarObservable.create = function (value, scheduler) {
  	        return new ScalarObservable(value, scheduler);
  	    };
  	    ScalarObservable.dispatch = function (state) {
  	        var done = state.done, value = state.value, subscriber = state.subscriber;
  	        if (done) {
  	            subscriber.complete();
  	            return;
  	        }
  	        subscriber.next(value);
  	        if (subscriber.closed) {
  	            return;
  	        }
  	        state.done = true;
  	        this.schedule(state);
  	    };
  	    ScalarObservable.prototype._subscribe = function (subscriber) {
  	        var value = this.value;
  	        var scheduler = this.scheduler;
  	        if (scheduler) {
  	            return scheduler.schedule(ScalarObservable.dispatch, 0, {
  	                done: false, value: value, subscriber: subscriber
  	            });
  	        }
  	        else {
  	            subscriber.next(value);
  	            if (!subscriber.closed) {
  	                subscriber.complete();
  	            }
  	        }
  	    };
  	    return ScalarObservable;
  	}(Observable_1.Observable));
  	exports.ScalarObservable = ScalarObservable;
  	//# sourceMappingURL=ScalarObservable.js.map
  
  /***/ }),
  
  /***/ 298:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Observable_1 = __webpack_require__(280);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @extends {Ignored}
  	 * @hide true
  	 */
  	var EmptyObservable = (function (_super) {
  	    __extends(EmptyObservable, _super);
  	    function EmptyObservable(scheduler) {
  	        _super.call(this);
  	        this.scheduler = scheduler;
  	    }
  	    /**
  	     * Creates an Observable that emits no items to the Observer and immediately
  	     * emits a complete notification.
  	     *
  	     * <span class="informal">Just emits 'complete', and nothing else.
  	     * </span>
  	     *
  	     * <img src="./img/empty.png" width="100%">
  	     *
  	     * This static operator is useful for creating a simple Observable that only
  	     * emits the complete notification. It can be used for composing with other
  	     * Observables, such as in a {@link mergeMap}.
  	     *
  	     * @example <caption>Emit the number 7, then complete.</caption>
  	     * var result = Rx.Observable.empty().startWith(7);
  	     * result.subscribe(x => console.log(x));
  	     *
  	     * @example <caption>Map and flatten only odd numbers to the sequence 'a', 'b', 'c'</caption>
  	     * var interval = Rx.Observable.interval(1000);
  	     * var result = interval.mergeMap(x =>
  	     *   x % 2 === 1 ? Rx.Observable.of('a', 'b', 'c') : Rx.Observable.empty()
  	     * );
  	     * result.subscribe(x => console.log(x));
  	     *
  	     * // Results in the following to the console:
  	     * // x is equal to the count on the interval eg(0,1,2,3,...)
  	     * // x will occur every 1000ms
  	     * // if x % 2 is equal to 1 print abc
  	     * // if x % 2 is not equal to 1 nothing will be output
  	     *
  	     * @see {@link create}
  	     * @see {@link never}
  	     * @see {@link of}
  	     * @see {@link throw}
  	     *
  	     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling
  	     * the emission of the complete notification.
  	     * @return {Observable} An "empty" Observable: emits only the complete
  	     * notification.
  	     * @static true
  	     * @name empty
  	     * @owner Observable
  	     */
  	    EmptyObservable.create = function (scheduler) {
  	        return new EmptyObservable(scheduler);
  	    };
  	    EmptyObservable.dispatch = function (arg) {
  	        var subscriber = arg.subscriber;
  	        subscriber.complete();
  	    };
  	    EmptyObservable.prototype._subscribe = function (subscriber) {
  	        var scheduler = this.scheduler;
  	        if (scheduler) {
  	            return scheduler.schedule(EmptyObservable.dispatch, 0, { subscriber: subscriber });
  	        }
  	        else {
  	            subscriber.complete();
  	        }
  	    };
  	    return EmptyObservable;
  	}(Observable_1.Observable));
  	exports.EmptyObservable = EmptyObservable;
  	//# sourceMappingURL=EmptyObservable.js.map
  
  /***/ }),
  
  /***/ 299:
  /***/ (function(module, exports) {
  
  	"use strict";
  	function isScheduler(value) {
  	    return value && typeof value.schedule === 'function';
  	}
  	exports.isScheduler = isScheduler;
  	//# sourceMappingURL=isScheduler.js.map
  
  /***/ }),
  
  /***/ 300:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	var fromPromise_1 = __webpack_require__(301);
  	Observable_1.Observable.fromPromise = fromPromise_1.fromPromise;
  	//# sourceMappingURL=fromPromise.js.map
  
  /***/ }),
  
  /***/ 301:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var PromiseObservable_1 = __webpack_require__(302);
  	exports.fromPromise = PromiseObservable_1.PromiseObservable.create;
  	//# sourceMappingURL=fromPromise.js.map
  
  /***/ }),
  
  /***/ 302:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var root_1 = __webpack_require__(281);
  	var Observable_1 = __webpack_require__(280);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @extends {Ignored}
  	 * @hide true
  	 */
  	var PromiseObservable = (function (_super) {
  	    __extends(PromiseObservable, _super);
  	    function PromiseObservable(promise, scheduler) {
  	        _super.call(this);
  	        this.promise = promise;
  	        this.scheduler = scheduler;
  	    }
  	    /**
  	     * Converts a Promise to an Observable.
  	     *
  	     * <span class="informal">Returns an Observable that just emits the Promise's
  	     * resolved value, then completes.</span>
  	     *
  	     * Converts an ES2015 Promise or a Promises/A+ spec compliant Promise to an
  	     * Observable. If the Promise resolves with a value, the output Observable
  	     * emits that resolved value as a `next`, and then completes. If the Promise
  	     * is rejected, then the output Observable emits the corresponding Error.
  	     *
  	     * @example <caption>Convert the Promise returned by Fetch to an Observable</caption>
  	     * var result = Rx.Observable.fromPromise(fetch('http://myserver.com/'));
  	     * result.subscribe(x => console.log(x), e => console.error(e));
  	     *
  	     * @see {@link bindCallback}
  	     * @see {@link from}
  	     *
  	     * @param {PromiseLike<T>} promise The promise to be converted.
  	     * @param {Scheduler} [scheduler] An optional IScheduler to use for scheduling
  	     * the delivery of the resolved value (or the rejection).
  	     * @return {Observable<T>} An Observable which wraps the Promise.
  	     * @static true
  	     * @name fromPromise
  	     * @owner Observable
  	     */
  	    PromiseObservable.create = function (promise, scheduler) {
  	        return new PromiseObservable(promise, scheduler);
  	    };
  	    PromiseObservable.prototype._subscribe = function (subscriber) {
  	        var _this = this;
  	        var promise = this.promise;
  	        var scheduler = this.scheduler;
  	        if (scheduler == null) {
  	            if (this._isScalar) {
  	                if (!subscriber.closed) {
  	                    subscriber.next(this.value);
  	                    subscriber.complete();
  	                }
  	            }
  	            else {
  	                promise.then(function (value) {
  	                    _this.value = value;
  	                    _this._isScalar = true;
  	                    if (!subscriber.closed) {
  	                        subscriber.next(value);
  	                        subscriber.complete();
  	                    }
  	                }, function (err) {
  	                    if (!subscriber.closed) {
  	                        subscriber.error(err);
  	                    }
  	                })
  	                    .then(null, function (err) {
  	                    // escape the promise trap, throw unhandled errors
  	                    root_1.root.setTimeout(function () { throw err; });
  	                });
  	            }
  	        }
  	        else {
  	            if (this._isScalar) {
  	                if (!subscriber.closed) {
  	                    return scheduler.schedule(dispatchNext, 0, { value: this.value, subscriber: subscriber });
  	                }
  	            }
  	            else {
  	                promise.then(function (value) {
  	                    _this.value = value;
  	                    _this._isScalar = true;
  	                    if (!subscriber.closed) {
  	                        subscriber.add(scheduler.schedule(dispatchNext, 0, { value: value, subscriber: subscriber }));
  	                    }
  	                }, function (err) {
  	                    if (!subscriber.closed) {
  	                        subscriber.add(scheduler.schedule(dispatchError, 0, { err: err, subscriber: subscriber }));
  	                    }
  	                })
  	                    .then(null, function (err) {
  	                    // escape the promise trap, throw unhandled errors
  	                    root_1.root.setTimeout(function () { throw err; });
  	                });
  	            }
  	        }
  	    };
  	    return PromiseObservable;
  	}(Observable_1.Observable));
  	exports.PromiseObservable = PromiseObservable;
  	function dispatchNext(arg) {
  	    var value = arg.value, subscriber = arg.subscriber;
  	    if (!subscriber.closed) {
  	        subscriber.next(value);
  	        subscriber.complete();
  	    }
  	}
  	function dispatchError(arg) {
  	    var err = arg.err, subscriber = arg.subscriber;
  	    if (!subscriber.closed) {
  	        subscriber.error(err);
  	    }
  	}
  	//# sourceMappingURL=PromiseObservable.js.map
  
  /***/ }),
  
  /***/ 303:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	var delay_1 = __webpack_require__(304);
  	Observable_1.Observable.prototype.delay = delay_1.delay;
  	//# sourceMappingURL=delay.js.map
  
  /***/ }),
  
  /***/ 304:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var async_1 = __webpack_require__(305);
  	var isDate_1 = __webpack_require__(310);
  	var Subscriber_1 = __webpack_require__(283);
  	var Notification_1 = __webpack_require__(311);
  	/**
  	 * Delays the emission of items from the source Observable by a given timeout or
  	 * until a given Date.
  	 *
  	 * <span class="informal">Time shifts each item by some specified amount of
  	 * milliseconds.</span>
  	 *
  	 * <img src="./img/delay.png" width="100%">
  	 *
  	 * If the delay argument is a Number, this operator time shifts the source
  	 * Observable by that amount of time expressed in milliseconds. The relative
  	 * time intervals between the values are preserved.
  	 *
  	 * If the delay argument is a Date, this operator time shifts the start of the
  	 * Observable execution until the given date occurs.
  	 *
  	 * @example <caption>Delay each click by one second</caption>
  	 * var clicks = Rx.Observable.fromEvent(document, 'click');
  	 * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second
  	 * delayedClicks.subscribe(x => console.log(x));
  	 *
  	 * @example <caption>Delay all clicks until a future date happens</caption>
  	 * var clicks = Rx.Observable.fromEvent(document, 'click');
  	 * var date = new Date('March 15, 2050 12:00:00'); // in the future
  	 * var delayedClicks = clicks.delay(date); // click emitted only after that date
  	 * delayedClicks.subscribe(x => console.log(x));
  	 *
  	 * @see {@link debounceTime}
  	 * @see {@link delayWhen}
  	 *
  	 * @param {number|Date} delay The delay duration in milliseconds (a `number`) or
  	 * a `Date` until which the emission of the source items is delayed.
  	 * @param {Scheduler} [scheduler=async] The IScheduler to use for
  	 * managing the timers that handle the time-shift for each item.
  	 * @return {Observable} An Observable that delays the emissions of the source
  	 * Observable by the specified timeout or Date.
  	 * @method delay
  	 * @owner Observable
  	 */
  	function delay(delay, scheduler) {
  	    if (scheduler === void 0) { scheduler = async_1.async; }
  	    var absoluteDelay = isDate_1.isDate(delay);
  	    var delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay);
  	    return this.lift(new DelayOperator(delayFor, scheduler));
  	}
  	exports.delay = delay;
  	var DelayOperator = (function () {
  	    function DelayOperator(delay, scheduler) {
  	        this.delay = delay;
  	        this.scheduler = scheduler;
  	    }
  	    DelayOperator.prototype.call = function (subscriber, source) {
  	        return source.subscribe(new DelaySubscriber(subscriber, this.delay, this.scheduler));
  	    };
  	    return DelayOperator;
  	}());
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var DelaySubscriber = (function (_super) {
  	    __extends(DelaySubscriber, _super);
  	    function DelaySubscriber(destination, delay, scheduler) {
  	        _super.call(this, destination);
  	        this.delay = delay;
  	        this.scheduler = scheduler;
  	        this.queue = [];
  	        this.active = false;
  	        this.errored = false;
  	    }
  	    DelaySubscriber.dispatch = function (state) {
  	        var source = state.source;
  	        var queue = source.queue;
  	        var scheduler = state.scheduler;
  	        var destination = state.destination;
  	        while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) {
  	            queue.shift().notification.observe(destination);
  	        }
  	        if (queue.length > 0) {
  	            var delay_1 = Math.max(0, queue[0].time - scheduler.now());
  	            this.schedule(state, delay_1);
  	        }
  	        else {
  	            source.active = false;
  	        }
  	    };
  	    DelaySubscriber.prototype._schedule = function (scheduler) {
  	        this.active = true;
  	        this.add(scheduler.schedule(DelaySubscriber.dispatch, this.delay, {
  	            source: this, destination: this.destination, scheduler: scheduler
  	        }));
  	    };
  	    DelaySubscriber.prototype.scheduleNotification = function (notification) {
  	        if (this.errored === true) {
  	            return;
  	        }
  	        var scheduler = this.scheduler;
  	        var message = new DelayMessage(scheduler.now() + this.delay, notification);
  	        this.queue.push(message);
  	        if (this.active === false) {
  	            this._schedule(scheduler);
  	        }
  	    };
  	    DelaySubscriber.prototype._next = function (value) {
  	        this.scheduleNotification(Notification_1.Notification.createNext(value));
  	    };
  	    DelaySubscriber.prototype._error = function (err) {
  	        this.errored = true;
  	        this.queue = [];
  	        this.destination.error(err);
  	    };
  	    DelaySubscriber.prototype._complete = function () {
  	        this.scheduleNotification(Notification_1.Notification.createComplete());
  	    };
  	    return DelaySubscriber;
  	}(Subscriber_1.Subscriber));
  	var DelayMessage = (function () {
  	    function DelayMessage(time, notification) {
  	        this.time = time;
  	        this.notification = notification;
  	    }
  	    return DelayMessage;
  	}());
  	//# sourceMappingURL=delay.js.map
  
  /***/ }),
  
  /***/ 305:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var AsyncAction_1 = __webpack_require__(306);
  	var AsyncScheduler_1 = __webpack_require__(308);
  	/**
  	 *
  	 * Async Scheduler
  	 *
  	 * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span>
  	 *
  	 * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript
  	 * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating
  	 * in intervals.
  	 *
  	 * If you just want to "defer" task, that is to perform it right after currently
  	 * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),
  	 * better choice will be the {@link asap} scheduler.
  	 *
  	 * @example <caption>Use async scheduler to delay task</caption>
  	 * const task = () => console.log('it works!');
  	 *
  	 * Rx.Scheduler.async.schedule(task, 2000);
  	 *
  	 * // After 2 seconds logs:
  	 * // "it works!"
  	 *
  	 *
  	 * @example <caption>Use async scheduler to repeat task in intervals</caption>
  	 * function task(state) {
  	 *   console.log(state);
  	 *   this.schedule(state + 1, 1000); // `this` references currently executing Action,
  	 *                                   // which we reschedule with new state and delay
  	 * }
  	 *
  	 * Rx.Scheduler.async.schedule(task, 3000, 0);
  	 *
  	 * // Logs:
  	 * // 0 after 3s
  	 * // 1 after 4s
  	 * // 2 after 5s
  	 * // 3 after 6s
  	 *
  	 * @static true
  	 * @name async
  	 * @owner Scheduler
  	 */
  	exports.async = new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);
  	//# sourceMappingURL=async.js.map
  
  /***/ }),
  
  /***/ 306:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var root_1 = __webpack_require__(281);
  	var Action_1 = __webpack_require__(307);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var AsyncAction = (function (_super) {
  	    __extends(AsyncAction, _super);
  	    function AsyncAction(scheduler, work) {
  	        _super.call(this, scheduler, work);
  	        this.scheduler = scheduler;
  	        this.work = work;
  	        this.pending = false;
  	    }
  	    AsyncAction.prototype.schedule = function (state, delay) {
  	        if (delay === void 0) { delay = 0; }
  	        if (this.closed) {
  	            return this;
  	        }
  	        // Always replace the current state with the new state.
  	        this.state = state;
  	        // Set the pending flag indicating that this action has been scheduled, or
  	        // has recursively rescheduled itself.
  	        this.pending = true;
  	        var id = this.id;
  	        var scheduler = this.scheduler;
  	        //
  	        // Important implementation note:
  	        //
  	        // Actions only execute once by default, unless rescheduled from within the
  	        // scheduled callback. This allows us to implement single and repeat
  	        // actions via the same code path, without adding API surface area, as well
  	        // as mimic traditional recursion but across asynchronous boundaries.
  	        //
  	        // However, JS runtimes and timers distinguish between intervals achieved by
  	        // serial `setTimeout` calls vs. a single `setInterval` call. An interval of
  	        // serial `setTimeout` calls can be individually delayed, which delays
  	        // scheduling the next `setTimeout`, and so on. `setInterval` attempts to
  	        // guarantee the interval callback will be invoked more precisely to the
  	        // interval period, regardless of load.
  	        //
  	        // Therefore, we use `setInterval` to schedule single and repeat actions.
  	        // If the action reschedules itself with the same delay, the interval is not
  	        // canceled. If the action doesn't reschedule, or reschedules with a
  	        // different delay, the interval will be canceled after scheduled callback
  	        // execution.
  	        //
  	        if (id != null) {
  	            this.id = this.recycleAsyncId(scheduler, id, delay);
  	        }
  	        this.delay = delay;
  	        // If this action has already an async Id, don't request a new one.
  	        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 root_1.root.setInterval(scheduler.flush.bind(scheduler, this), delay);
  	    };
  	    AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
  	        if (delay === void 0) { delay = 0; }
  	        // If this action is rescheduled with the same delay time, don't clear the interval id.
  	        if (delay !== null && this.delay === delay && this.pending === false) {
  	            return id;
  	        }
  	        // Otherwise, if the action's delay time is different from the current delay,
  	        // or the action has been rescheduled before it's executed, clear the interval id
  	        return root_1.root.clearInterval(id) && undefined || undefined;
  	    };
  	    /**
  	     * Immediately executes this action and the `work` it contains.
  	     * @return {any}
  	     */
  	    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) {
  	            // Dequeue if the action didn't reschedule itself. Don't call
  	            // unsubscribe(), because the action could reschedule later.
  	            // For example:
  	            // ```
  	            // scheduler.schedule(function doWork(counter) {
  	            //   /* ... I'm a busy worker bee ... */
  	            //   var originalAction = this;
  	            //   /* wait 100ms before rescheduling the action */
  	            //   setTimeout(function () {
  	            //     originalAction.schedule(counter + 1);
  	            //   }, 100);
  	            // }, 1000);
  	            // ```
  	            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_1.Action));
  	exports.AsyncAction = AsyncAction;
  	//# sourceMappingURL=AsyncAction.js.map
  
  /***/ }),
  
  /***/ 307:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Subscription_1 = __webpack_require__(285);
  	/**
  	 * A unit of work to be executed in a {@link Scheduler}. An action is typically
  	 * created from within a Scheduler and an RxJS user does not need to concern
  	 * themselves about creating and manipulating an Action.
  	 *
  	 * ```ts
  	 * class Action<T> extends Subscription {
  	 *   new (scheduler: Scheduler, work: (state?: T) => void);
  	 *   schedule(state?: T, delay: number = 0): Subscription;
  	 * }
  	 * ```
  	 *
  	 * @class Action<T>
  	 */
  	var Action = (function (_super) {
  	    __extends(Action, _super);
  	    function Action(scheduler, work) {
  	        _super.call(this);
  	    }
  	    /**
  	     * Schedules this action on its parent Scheduler for execution. May be passed
  	     * some context object, `state`. May happen at some point in the future,
  	     * according to the `delay` parameter, if specified.
  	     * @param {T} [state] Some contextual data that the `work` function uses when
  	     * called by the Scheduler.
  	     * @param {number} [delay] Time to wait before executing the work, where the
  	     * time unit is implicit and defined by the Scheduler.
  	     * @return {void}
  	     */
  	    Action.prototype.schedule = function (state, delay) {
  	        if (delay === void 0) { delay = 0; }
  	        return this;
  	    };
  	    return Action;
  	}(Subscription_1.Subscription));
  	exports.Action = Action;
  	//# sourceMappingURL=Action.js.map
  
  /***/ }),
  
  /***/ 308:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Scheduler_1 = __webpack_require__(309);
  	var AsyncScheduler = (function (_super) {
  	    __extends(AsyncScheduler, _super);
  	    function AsyncScheduler() {
  	        _super.apply(this, arguments);
  	        this.actions = [];
  	        /**
  	         * A flag to indicate whether the Scheduler is currently executing a batch of
  	         * queued actions.
  	         * @type {boolean}
  	         */
  	        this.active = false;
  	        /**
  	         * An internal ID used to track the latest asynchronous task such as those
  	         * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and
  	         * others.
  	         * @type {any}
  	         */
  	        this.scheduled = undefined;
  	    }
  	    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()); // exhaust the scheduler queue
  	        this.active = false;
  	        if (error) {
  	            while (action = actions.shift()) {
  	                action.unsubscribe();
  	            }
  	            throw error;
  	        }
  	    };
  	    return AsyncScheduler;
  	}(Scheduler_1.Scheduler));
  	exports.AsyncScheduler = AsyncScheduler;
  	//# sourceMappingURL=AsyncScheduler.js.map
  
  /***/ }),
  
  /***/ 309:
  /***/ (function(module, exports) {
  
  	"use strict";
  	/**
  	 * An execution context and a data structure to order tasks and schedule their
  	 * execution. Provides a notion of (potentially virtual) time, through the
  	 * `now()` getter method.
  	 *
  	 * Each unit of work in a Scheduler is called an {@link Action}.
  	 *
  	 * ```ts
  	 * class Scheduler {
  	 *   now(): number;
  	 *   schedule(work, delay?, state?): Subscription;
  	 * }
  	 * ```
  	 *
  	 * @class Scheduler
  	 */
  	var Scheduler = (function () {
  	    function Scheduler(SchedulerAction, now) {
  	        if (now === void 0) { now = Scheduler.now; }
  	        this.SchedulerAction = SchedulerAction;
  	        this.now = now;
  	    }
  	    /**
  	     * Schedules a function, `work`, for execution. May happen at some point in
  	     * the future, according to the `delay` parameter, if specified. May be passed
  	     * some context object, `state`, which will be passed to the `work` function.
  	     *
  	     * The given arguments will be processed an stored as an Action object in a
  	     * queue of actions.
  	     *
  	     * @param {function(state: ?T): ?Subscription} work A function representing a
  	     * task, or some unit of work to be executed by the Scheduler.
  	     * @param {number} [delay] Time to wait before executing the work, where the
  	     * time unit is implicit and defined by the Scheduler itself.
  	     * @param {T} [state] Some contextual data that the `work` function uses when
  	     * called by the Scheduler.
  	     * @return {Subscription} A subscription in order to be able to unsubscribe
  	     * the scheduled work.
  	     */
  	    Scheduler.prototype.schedule = function (work, delay, state) {
  	        if (delay === void 0) { delay = 0; }
  	        return new this.SchedulerAction(this, work).schedule(state, delay);
  	    };
  	    Scheduler.now = Date.now ? Date.now : function () { return +new Date(); };
  	    return Scheduler;
  	}());
  	exports.Scheduler = Scheduler;
  	//# sourceMappingURL=Scheduler.js.map
  
  /***/ }),
  
  /***/ 310:
  /***/ (function(module, exports) {
  
  	"use strict";
  	function isDate(value) {
  	    return value instanceof Date && !isNaN(+value);
  	}
  	exports.isDate = isDate;
  	//# sourceMappingURL=isDate.js.map
  
  /***/ }),
  
  /***/ 311:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	/**
  	 * Represents a push-based event or value that an {@link Observable} can emit.
  	 * This class is particularly useful for operators that manage notifications,
  	 * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and
  	 * others. Besides wrapping the actual delivered value, it also annotates it
  	 * with metadata of, for instance, what type of push message it is (`next`,
  	 * `error`, or `complete`).
  	 *
  	 * @see {@link materialize}
  	 * @see {@link dematerialize}
  	 * @see {@link observeOn}
  	 *
  	 * @class Notification<T>
  	 */
  	var Notification = (function () {
  	    function Notification(kind, value, error) {
  	        this.kind = kind;
  	        this.value = value;
  	        this.error = error;
  	        this.hasValue = kind === 'N';
  	    }
  	    /**
  	     * Delivers to the given `observer` the value wrapped by this Notification.
  	     * @param {Observer} observer
  	     * @return
  	     */
  	    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();
  	        }
  	    };
  	    /**
  	     * Given some {@link Observer} callbacks, deliver the value represented by the
  	     * current Notification to the correctly corresponding callback.
  	     * @param {function(value: T): void} next An Observer `next` callback.
  	     * @param {function(err: any): void} [error] An Observer `error` callback.
  	     * @param {function(): void} [complete] An Observer `complete` callback.
  	     * @return {any}
  	     */
  	    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();
  	        }
  	    };
  	    /**
  	     * Takes an Observer or its individual callback functions, and calls `observe`
  	     * or `do` methods accordingly.
  	     * @param {Observer|function(value: T): void} nextOrObserver An Observer or
  	     * the `next` callback.
  	     * @param {function(err: any): void} [error] An Observer `error` callback.
  	     * @param {function(): void} [complete] An Observer `complete` callback.
  	     * @return {any}
  	     */
  	    Notification.prototype.accept = function (nextOrObserver, error, complete) {
  	        if (nextOrObserver && typeof nextOrObserver.next === 'function') {
  	            return this.observe(nextOrObserver);
  	        }
  	        else {
  	            return this.do(nextOrObserver, error, complete);
  	        }
  	    };
  	    /**
  	     * Returns a simple Observable that just delivers the notification represented
  	     * by this Notification instance.
  	     * @return {any}
  	     */
  	    Notification.prototype.toObservable = function () {
  	        var kind = this.kind;
  	        switch (kind) {
  	            case 'N':
  	                return Observable_1.Observable.of(this.value);
  	            case 'E':
  	                return Observable_1.Observable.throw(this.error);
  	            case 'C':
  	                return Observable_1.Observable.empty();
  	        }
  	        throw new Error('unexpected notification kind value');
  	    };
  	    /**
  	     * A shortcut to create a Notification instance of the type `next` from a
  	     * given value.
  	     * @param {T} value The `next` value.
  	     * @return {Notification<T>} The "next" Notification representing the
  	     * argument.
  	     */
  	    Notification.createNext = function (value) {
  	        if (typeof value !== 'undefined') {
  	            return new Notification('N', value);
  	        }
  	        return Notification.undefinedValueNotification;
  	    };
  	    /**
  	     * A shortcut to create a Notification instance of the type `error` from a
  	     * given error.
  	     * @param {any} [err] The `error` error.
  	     * @return {Notification<T>} The "error" Notification representing the
  	     * argument.
  	     */
  	    Notification.createError = function (err) {
  	        return new Notification('E', undefined, err);
  	    };
  	    /**
  	     * A shortcut to create a Notification instance of the type `complete`.
  	     * @return {Notification<any>} The valueless "complete" Notification.
  	     */
  	    Notification.createComplete = function () {
  	        return Notification.completeNotification;
  	    };
  	    Notification.completeNotification = new Notification('C');
  	    Notification.undefinedValueNotification = new Notification('N', undefined);
  	    return Notification;
  	}());
  	exports.Notification = Notification;
  	//# sourceMappingURL=Notification.js.map
  
  /***/ }),
  
  /***/ 312:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	var mergeMap_1 = __webpack_require__(313);
  	Observable_1.Observable.prototype.mergeMap = mergeMap_1.mergeMap;
  	Observable_1.Observable.prototype.flatMap = mergeMap_1.mergeMap;
  	//# sourceMappingURL=mergeMap.js.map
  
  /***/ }),
  
  /***/ 313:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var subscribeToResult_1 = __webpack_require__(314);
  	var OuterSubscriber_1 = __webpack_require__(319);
  	/* tslint:enable:max-line-length */
  	/**
  	 * Projects each source value to an Observable which is merged in the output
  	 * Observable.
  	 *
  	 * <span class="informal">Maps each value to an Observable, then flattens all of
  	 * these inner Observables using {@link mergeAll}.</span>
  	 *
  	 * <img src="./img/mergeMap.png" width="100%">
  	 *
  	 * Returns an Observable that emits items based on applying a function that you
  	 * supply to each item emitted by the source Observable, where that function
  	 * returns an Observable, and then merging those resulting Observables and
  	 * emitting the results of this merger.
  	 *
  	 * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>
  	 * var letters = Rx.Observable.of('a', 'b', 'c');
  	 * var result = letters.mergeMap(x =>
  	 *   Rx.Observable.interval(1000).map(i => x+i)
  	 * );
  	 * result.subscribe(x => console.log(x));
  	 *
  	 * // Results in the following:
  	 * // a0
  	 * // b0
  	 * // c0
  	 * // a1
  	 * // b1
  	 * // c1
  	 * // continues to list a,b,c with respective ascending integers
  	 *
  	 * @see {@link concatMap}
  	 * @see {@link exhaustMap}
  	 * @see {@link merge}
  	 * @see {@link mergeAll}
  	 * @see {@link mergeMapTo}
  	 * @see {@link mergeScan}
  	 * @see {@link switchMap}
  	 *
  	 * @param {function(value: T, ?index: number): ObservableInput} project A function
  	 * that, when applied to an item emitted by the source Observable, returns an
  	 * Observable.
  	 * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
  	 * A function to produce the value on the output Observable based on the values
  	 * and the indices of the source (outer) emission and the inner Observable
  	 * emission. The arguments passed to this function are:
  	 * - `outerValue`: the value that came from the source
  	 * - `innerValue`: the value that came from the projected Observable
  	 * - `outerIndex`: the "index" of the value that came from the source
  	 * - `innerIndex`: the "index" of the value from the projected Observable
  	 * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
  	 * Observables being subscribed to concurrently.
  	 * @return {Observable} An Observable that emits the result of applying the
  	 * projection function (and the optional `resultSelector`) to each item emitted
  	 * by the source Observable and merging the results of the Observables obtained
  	 * from this transformation.
  	 * @method mergeMap
  	 * @owner Observable
  	 */
  	function mergeMap(project, resultSelector, concurrent) {
  	    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
  	    if (typeof resultSelector === 'number') {
  	        concurrent = resultSelector;
  	        resultSelector = null;
  	    }
  	    return this.lift(new MergeMapOperator(project, resultSelector, concurrent));
  	}
  	exports.mergeMap = mergeMap;
  	var MergeMapOperator = (function () {
  	    function MergeMapOperator(project, resultSelector, concurrent) {
  	        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
  	        this.project = project;
  	        this.resultSelector = resultSelector;
  	        this.concurrent = concurrent;
  	    }
  	    MergeMapOperator.prototype.call = function (observer, source) {
  	        return source.subscribe(new MergeMapSubscriber(observer, this.project, this.resultSelector, this.concurrent));
  	    };
  	    return MergeMapOperator;
  	}());
  	exports.MergeMapOperator = MergeMapOperator;
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var MergeMapSubscriber = (function (_super) {
  	    __extends(MergeMapSubscriber, _super);
  	    function MergeMapSubscriber(destination, project, resultSelector, concurrent) {
  	        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
  	        _super.call(this, destination);
  	        this.project = project;
  	        this.resultSelector = resultSelector;
  	        this.concurrent = concurrent;
  	        this.hasCompleted = false;
  	        this.buffer = [];
  	        this.active = 0;
  	        this.index = 0;
  	    }
  	    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) {
  	        this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index));
  	    };
  	    MergeMapSubscriber.prototype._complete = function () {
  	        this.hasCompleted = true;
  	        if (this.active === 0 && this.buffer.length === 0) {
  	            this.destination.complete();
  	        }
  	    };
  	    MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
  	        if (this.resultSelector) {
  	            this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex);
  	        }
  	        else {
  	            this.destination.next(innerValue);
  	        }
  	    };
  	    MergeMapSubscriber.prototype._notifyResultSelector = function (outerValue, innerValue, outerIndex, innerIndex) {
  	        var result;
  	        try {
  	            result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);
  	        }
  	        catch (err) {
  	            this.destination.error(err);
  	            return;
  	        }
  	        this.destination.next(result);
  	    };
  	    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_1.OuterSubscriber));
  	exports.MergeMapSubscriber = MergeMapSubscriber;
  	//# sourceMappingURL=mergeMap.js.map
  
  /***/ }),
  
  /***/ 314:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var root_1 = __webpack_require__(281);
  	var isArrayLike_1 = __webpack_require__(315);
  	var isPromise_1 = __webpack_require__(316);
  	var isObject_1 = __webpack_require__(287);
  	var Observable_1 = __webpack_require__(280);
  	var iterator_1 = __webpack_require__(317);
  	var InnerSubscriber_1 = __webpack_require__(318);
  	var observable_1 = __webpack_require__(293);
  	function subscribeToResult(outerSubscriber, result, outerValue, outerIndex) {
  	    var destination = new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex);
  	    if (destination.closed) {
  	        return null;
  	    }
  	    if (result instanceof Observable_1.Observable) {
  	        if (result._isScalar) {
  	            destination.next(result.value);
  	            destination.complete();
  	            return null;
  	        }
  	        else {
  	            return result.subscribe(destination);
  	        }
  	    }
  	    else if (isArrayLike_1.isArrayLike(result)) {
  	        for (var i = 0, len = result.length; i < len && !destination.closed; i++) {
  	            destination.next(result[i]);
  	        }
  	        if (!destination.closed) {
  	            destination.complete();
  	        }
  	    }
  	    else if (isPromise_1.isPromise(result)) {
  	        result.then(function (value) {
  	            if (!destination.closed) {
  	                destination.next(value);
  	                destination.complete();
  	            }
  	        }, function (err) { return destination.error(err); })
  	            .then(null, function (err) {
  	            // Escaping the Promise trap: globally throw unhandled errors
  	            root_1.root.setTimeout(function () { throw err; });
  	        });
  	        return destination;
  	    }
  	    else if (result && typeof result[iterator_1.iterator] === 'function') {
  	        var iterator = result[iterator_1.iterator]();
  	        do {
  	            var item = iterator.next();
  	            if (item.done) {
  	                destination.complete();
  	                break;
  	            }
  	            destination.next(item.value);
  	            if (destination.closed) {
  	                break;
  	            }
  	        } while (true);
  	    }
  	    else if (result && typeof result[observable_1.observable] === 'function') {
  	        var obs = result[observable_1.observable]();
  	        if (typeof obs.subscribe !== 'function') {
  	            destination.error(new TypeError('Provided object does not correctly implement Symbol.observable'));
  	        }
  	        else {
  	            return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex));
  	        }
  	    }
  	    else {
  	        var value = isObject_1.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.';
  	        destination.error(new TypeError(msg));
  	    }
  	    return null;
  	}
  	exports.subscribeToResult = subscribeToResult;
  	//# sourceMappingURL=subscribeToResult.js.map
  
  /***/ }),
  
  /***/ 315:
  /***/ (function(module, exports) {
  
  	"use strict";
  	exports.isArrayLike = (function (x) { return x && typeof x.length === 'number'; });
  	//# sourceMappingURL=isArrayLike.js.map
  
  /***/ }),
  
  /***/ 316:
  /***/ (function(module, exports) {
  
  	"use strict";
  	function isPromise(value) {
  	    return value && typeof value.subscribe !== 'function' && typeof value.then === 'function';
  	}
  	exports.isPromise = isPromise;
  	//# sourceMappingURL=isPromise.js.map
  
  /***/ }),
  
  /***/ 317:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var root_1 = __webpack_require__(281);
  	function symbolIteratorPonyfill(root) {
  	    var Symbol = root.Symbol;
  	    if (typeof Symbol === 'function') {
  	        if (!Symbol.iterator) {
  	            Symbol.iterator = Symbol('iterator polyfill');
  	        }
  	        return Symbol.iterator;
  	    }
  	    else {
  	        // [for Mozilla Gecko 27-35:](https://mzl.la/2ewE1zC)
  	        var Set_1 = root.Set;
  	        if (Set_1 && typeof new Set_1()['@@iterator'] === 'function') {
  	            return '@@iterator';
  	        }
  	        var Map_1 = root.Map;
  	        // required for compatability with es6-shim
  	        if (Map_1) {
  	            var keys = Object.getOwnPropertyNames(Map_1.prototype);
  	            for (var i = 0; i < keys.length; ++i) {
  	                var key = keys[i];
  	                // according to spec, Map.prototype[@@iterator] and Map.orototype.entries must be equal.
  	                if (key !== 'entries' && key !== 'size' && Map_1.prototype[key] === Map_1.prototype['entries']) {
  	                    return key;
  	                }
  	            }
  	        }
  	        return '@@iterator';
  	    }
  	}
  	exports.symbolIteratorPonyfill = symbolIteratorPonyfill;
  	exports.iterator = symbolIteratorPonyfill(root_1.root);
  	/**
  	 * @deprecated use iterator instead
  	 */
  	exports.$$iterator = exports.iterator;
  	//# sourceMappingURL=iterator.js.map
  
  /***/ }),
  
  /***/ 318:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Subscriber_1 = __webpack_require__(283);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var InnerSubscriber = (function (_super) {
  	    __extends(InnerSubscriber, _super);
  	    function InnerSubscriber(parent, outerValue, outerIndex) {
  	        _super.call(this);
  	        this.parent = parent;
  	        this.outerValue = outerValue;
  	        this.outerIndex = outerIndex;
  	        this.index = 0;
  	    }
  	    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_1.Subscriber));
  	exports.InnerSubscriber = InnerSubscriber;
  	//# sourceMappingURL=InnerSubscriber.js.map
  
  /***/ }),
  
  /***/ 319:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Subscriber_1 = __webpack_require__(283);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var OuterSubscriber = (function (_super) {
  	    __extends(OuterSubscriber, _super);
  	    function OuterSubscriber() {
  	        _super.apply(this, arguments);
  	    }
  	    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_1.Subscriber));
  	exports.OuterSubscriber = OuterSubscriber;
  	//# sourceMappingURL=OuterSubscriber.js.map
  
  /***/ }),
  
  /***/ 320:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	var map_1 = __webpack_require__(321);
  	Observable_1.Observable.prototype.map = map_1.map;
  	//# sourceMappingURL=map.js.map
  
  /***/ }),
  
  /***/ 321:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Subscriber_1 = __webpack_require__(283);
  	/**
  	 * Applies a given `project` function to each value emitted by the source
  	 * Observable, and emits the resulting values as an Observable.
  	 *
  	 * <span class="informal">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),
  	 * it passes each source value through a transformation function to get
  	 * corresponding output values.</span>
  	 *
  	 * <img src="./img/map.png" width="100%">
  	 *
  	 * Similar to the well known `Array.prototype.map` function, this operator
  	 * applies a projection to each value and emits that projection in the output
  	 * Observable.
  	 *
  	 * @example <caption>Map every click to the clientX position of that click</caption>
  	 * var clicks = Rx.Observable.fromEvent(document, 'click');
  	 * var positions = clicks.map(ev => ev.clientX);
  	 * positions.subscribe(x => console.log(x));
  	 *
  	 * @see {@link mapTo}
  	 * @see {@link pluck}
  	 *
  	 * @param {function(value: T, index: number): R} project The function to apply
  	 * to each `value` emitted by the source Observable. The `index` parameter is
  	 * the number `i` for the i-th emission that has happened since the
  	 * subscription, starting from the number `0`.
  	 * @param {any} [thisArg] An optional argument to define what `this` is in the
  	 * `project` function.
  	 * @return {Observable<R>} An Observable that emits the values from the source
  	 * Observable transformed by the given `project` function.
  	 * @method map
  	 * @owner Observable
  	 */
  	function map(project, thisArg) {
  	    if (typeof project !== 'function') {
  	        throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
  	    }
  	    return this.lift(new MapOperator(project, thisArg));
  	}
  	exports.map = map;
  	var MapOperator = (function () {
  	    function MapOperator(project, thisArg) {
  	        this.project = project;
  	        this.thisArg = thisArg;
  	    }
  	    MapOperator.prototype.call = function (subscriber, source) {
  	        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
  	    };
  	    return MapOperator;
  	}());
  	exports.MapOperator = MapOperator;
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var MapSubscriber = (function (_super) {
  	    __extends(MapSubscriber, _super);
  	    function MapSubscriber(destination, project, thisArg) {
  	        _super.call(this, destination);
  	        this.project = project;
  	        this.count = 0;
  	        this.thisArg = thisArg || this;
  	    }
  	    // NOTE: This looks unoptimized, but it's actually purposefully NOT
  	    // using try/catch optimizations.
  	    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_1.Subscriber));
  	//# sourceMappingURL=map.js.map
  
  /***/ }),
  
  /***/ 322:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	var retryWhen_1 = __webpack_require__(323);
  	Observable_1.Observable.prototype.retryWhen = retryWhen_1.retryWhen;
  	//# sourceMappingURL=retryWhen.js.map
  
  /***/ }),
  
  /***/ 323:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Subject_1 = __webpack_require__(324);
  	var tryCatch_1 = __webpack_require__(288);
  	var errorObject_1 = __webpack_require__(289);
  	var OuterSubscriber_1 = __webpack_require__(319);
  	var subscribeToResult_1 = __webpack_require__(314);
  	/**
  	 * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
  	 * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.
  	 * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
  	 * subscription. Otherwise this method will resubscribe to the source Observable.
  	 *
  	 * <img src="./img/retryWhen.png" width="100%">
  	 *
  	 * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a
  	 * user can `complete` or `error`, aborting the retry.
  	 * @return {Observable} The source Observable modified with retry logic.
  	 * @method retryWhen
  	 * @owner Observable
  	 */
  	function retryWhen(notifier) {
  	    return this.lift(new RetryWhenOperator(notifier, this));
  	}
  	exports.retryWhen = retryWhen;
  	var RetryWhenOperator = (function () {
  	    function RetryWhenOperator(notifier, source) {
  	        this.notifier = notifier;
  	        this.source = source;
  	    }
  	    RetryWhenOperator.prototype.call = function (subscriber, source) {
  	        return source.subscribe(new RetryWhenSubscriber(subscriber, this.notifier, this.source));
  	    };
  	    return RetryWhenOperator;
  	}());
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var RetryWhenSubscriber = (function (_super) {
  	    __extends(RetryWhenSubscriber, _super);
  	    function RetryWhenSubscriber(destination, notifier, source) {
  	        _super.call(this, destination);
  	        this.notifier = notifier;
  	        this.source = source;
  	    }
  	    RetryWhenSubscriber.prototype.error = function (err) {
  	        if (!this.isStopped) {
  	            var errors = this.errors;
  	            var retries = this.retries;
  	            var retriesSubscription = this.retriesSubscription;
  	            if (!retries) {
  	                errors = new Subject_1.Subject();
  	                retries = tryCatch_1.tryCatch(this.notifier)(errors);
  	                if (retries === errorObject_1.errorObject) {
  	                    return _super.prototype.error.call(this, errorObject_1.errorObject.e);
  	                }
  	                retriesSubscription = subscribeToResult_1.subscribeToResult(this, retries);
  	            }
  	            else {
  	                this.errors = null;
  	                this.retriesSubscription = null;
  	            }
  	            this._unsubscribeAndRecycle();
  	            this.errors = errors;
  	            this.retries = retries;
  	            this.retriesSubscription = retriesSubscription;
  	            errors.next(err);
  	        }
  	    };
  	    RetryWhenSubscriber.prototype._unsubscribe = function () {
  	        var _a = this, errors = _a.errors, retriesSubscription = _a.retriesSubscription;
  	        if (errors) {
  	            errors.unsubscribe();
  	            this.errors = null;
  	        }
  	        if (retriesSubscription) {
  	            retriesSubscription.unsubscribe();
  	            this.retriesSubscription = null;
  	        }
  	        this.retries = null;
  	    };
  	    RetryWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
  	        var _a = this, errors = _a.errors, retries = _a.retries, retriesSubscription = _a.retriesSubscription;
  	        this.errors = null;
  	        this.retries = null;
  	        this.retriesSubscription = null;
  	        this._unsubscribeAndRecycle();
  	        this.errors = errors;
  	        this.retries = retries;
  	        this.retriesSubscription = retriesSubscription;
  	        this.source.subscribe(this);
  	    };
  	    return RetryWhenSubscriber;
  	}(OuterSubscriber_1.OuterSubscriber));
  	//# sourceMappingURL=retryWhen.js.map
  
  /***/ }),
  
  /***/ 324:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Observable_1 = __webpack_require__(280);
  	var Subscriber_1 = __webpack_require__(283);
  	var Subscription_1 = __webpack_require__(285);
  	var ObjectUnsubscribedError_1 = __webpack_require__(325);
  	var SubjectSubscription_1 = __webpack_require__(326);
  	var rxSubscriber_1 = __webpack_require__(292);
  	/**
  	 * @class SubjectSubscriber<T>
  	 */
  	var SubjectSubscriber = (function (_super) {
  	    __extends(SubjectSubscriber, _super);
  	    function SubjectSubscriber(destination) {
  	        _super.call(this, destination);
  	        this.destination = destination;
  	    }
  	    return SubjectSubscriber;
  	}(Subscriber_1.Subscriber));
  	exports.SubjectSubscriber = SubjectSubscriber;
  	/**
  	 * @class Subject<T>
  	 */
  	var Subject = (function (_super) {
  	    __extends(Subject, _super);
  	    function Subject() {
  	        _super.call(this);
  	        this.observers = [];
  	        this.closed = false;
  	        this.isStopped = false;
  	        this.hasError = false;
  	        this.thrownError = null;
  	    }
  	    Subject.prototype[rxSubscriber_1.rxSubscriber] = function () {
  	        return new SubjectSubscriber(this);
  	    };
  	    Subject.prototype.lift = function (operator) {
  	        var subject = new AnonymousSubject(this, this);
  	        subject.operator = operator;
  	        return subject;
  	    };
  	    Subject.prototype.next = function (value) {
  	        if (this.closed) {
  	            throw new ObjectUnsubscribedError_1.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_1.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_1.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_1.ObjectUnsubscribedError();
  	        }
  	        else {
  	            return _super.prototype._trySubscribe.call(this, subscriber);
  	        }
  	    };
  	    Subject.prototype._subscribe = function (subscriber) {
  	        if (this.closed) {
  	            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();
  	        }
  	        else if (this.hasError) {
  	            subscriber.error(this.thrownError);
  	            return Subscription_1.Subscription.EMPTY;
  	        }
  	        else if (this.isStopped) {
  	            subscriber.complete();
  	            return Subscription_1.Subscription.EMPTY;
  	        }
  	        else {
  	            this.observers.push(subscriber);
  	            return new SubjectSubscription_1.SubjectSubscription(this, subscriber);
  	        }
  	    };
  	    Subject.prototype.asObservable = function () {
  	        var observable = new Observable_1.Observable();
  	        observable.source = this;
  	        return observable;
  	    };
  	    Subject.create = function (destination, source) {
  	        return new AnonymousSubject(destination, source);
  	    };
  	    return Subject;
  	}(Observable_1.Observable));
  	exports.Subject = Subject;
  	/**
  	 * @class AnonymousSubject<T>
  	 */
  	var AnonymousSubject = (function (_super) {
  	    __extends(AnonymousSubject, _super);
  	    function AnonymousSubject(destination, source) {
  	        _super.call(this);
  	        this.destination = destination;
  	        this.source = source;
  	    }
  	    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_1.Subscription.EMPTY;
  	        }
  	    };
  	    return AnonymousSubject;
  	}(Subject));
  	exports.AnonymousSubject = AnonymousSubject;
  	//# sourceMappingURL=Subject.js.map
  
  /***/ }),
  
  /***/ 325:
  /***/ (function(module, exports) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	/**
  	 * An error thrown when an action is invalid because the object has been
  	 * unsubscribed.
  	 *
  	 * @see {@link Subject}
  	 * @see {@link BehaviorSubject}
  	 *
  	 * @class ObjectUnsubscribedError
  	 */
  	var ObjectUnsubscribedError = (function (_super) {
  	    __extends(ObjectUnsubscribedError, _super);
  	    function ObjectUnsubscribedError() {
  	        var err = _super.call(this, 'object unsubscribed');
  	        this.name = err.name = 'ObjectUnsubscribedError';
  	        this.stack = err.stack;
  	        this.message = err.message;
  	    }
  	    return ObjectUnsubscribedError;
  	}(Error));
  	exports.ObjectUnsubscribedError = ObjectUnsubscribedError;
  	//# sourceMappingURL=ObjectUnsubscribedError.js.map
  
  /***/ }),
  
  /***/ 326:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Subscription_1 = __webpack_require__(285);
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var SubjectSubscription = (function (_super) {
  	    __extends(SubjectSubscription, _super);
  	    function SubjectSubscription(subject, subscriber) {
  	        _super.call(this);
  	        this.subject = subject;
  	        this.subscriber = subscriber;
  	        this.closed = false;
  	    }
  	    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_1.Subscription));
  	exports.SubjectSubscription = SubjectSubscription;
  	//# sourceMappingURL=SubjectSubscription.js.map
  
  /***/ }),
  
  /***/ 327:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var Observable_1 = __webpack_require__(280);
  	var scan_1 = __webpack_require__(328);
  	Observable_1.Observable.prototype.scan = scan_1.scan;
  	//# sourceMappingURL=scan.js.map
  
  /***/ }),
  
  /***/ 328:
  /***/ (function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var Subscriber_1 = __webpack_require__(283);
  	/* tslint:enable:max-line-length */
  	/**
  	 * Applies an accumulator function over the source Observable, and returns each
  	 * intermediate result, with an optional seed value.
  	 *
  	 * <span class="informal">It's like {@link reduce}, but emits the current
  	 * accumulation whenever the source emits a value.</span>
  	 *
  	 * <img src="./img/scan.png" width="100%">
  	 *
  	 * Combines together all values emitted on the source, using an accumulator
  	 * function that knows how to join a new source value into the accumulation from
  	 * the past. Is similar to {@link reduce}, but emits the intermediate
  	 * accumulations.
  	 *
  	 * Returns an Observable that applies a specified `accumulator` function to each
  	 * item emitted by the source Observable. If a `seed` value is specified, then
  	 * that value will be used as the initial value for the accumulator. If no seed
  	 * value is specified, the first item of the source is used as the seed.
  	 *
  	 * @example <caption>Count the number of click events</caption>
  	 * var clicks = Rx.Observable.fromEvent(document, 'click');
  	 * var ones = clicks.mapTo(1);
  	 * var seed = 0;
  	 * var count = ones.scan((acc, one) => acc + one, seed);
  	 * count.subscribe(x => console.log(x));
  	 *
  	 * @see {@link expand}
  	 * @see {@link mergeScan}
  	 * @see {@link reduce}
  	 *
  	 * @param {function(acc: R, value: T, index: number): R} accumulator
  	 * The accumulator function called on each source value.
  	 * @param {T|R} [seed] The initial accumulation value.
  	 * @return {Observable<R>} An observable of the accumulated values.
  	 * @method scan
  	 * @owner Observable
  	 */
  	function scan(accumulator, seed) {
  	    var hasSeed = false;
  	    // providing a seed of `undefined` *should* be valid and trigger
  	    // hasSeed! so don't use `seed !== undefined` checks!
  	    // For this reason, we have to check it here at the original call site
  	    // otherwise inside Operator/Subscriber we won't know if `undefined`
  	    // means they didn't provide anything or if they literally provided `undefined`
  	    if (arguments.length >= 2) {
  	        hasSeed = true;
  	    }
  	    return this.lift(new ScanOperator(accumulator, seed, hasSeed));
  	}
  	exports.scan = scan;
  	var ScanOperator = (function () {
  	    function ScanOperator(accumulator, seed, hasSeed) {
  	        if (hasSeed === void 0) { hasSeed = false; }
  	        this.accumulator = accumulator;
  	        this.seed = seed;
  	        this.hasSeed = hasSeed;
  	    }
  	    ScanOperator.prototype.call = function (subscriber, source) {
  	        return source.subscribe(new ScanSubscriber(subscriber, this.accumulator, this.seed, this.hasSeed));
  	    };
  	    return ScanOperator;
  	}());
  	/**
  	 * We need this JSDoc comment for affecting ESDoc.
  	 * @ignore
  	 * @extends {Ignored}
  	 */
  	var ScanSubscriber = (function (_super) {
  	    __extends(ScanSubscriber, _super);
  	    function ScanSubscriber(destination, accumulator, _seed, hasSeed) {
  	        _super.call(this, destination);
  	        this.accumulator = accumulator;
  	        this._seed = _seed;
  	        this.hasSeed = hasSeed;
  	        this.index = 0;
  	    }
  	    Object.defineProperty(ScanSubscriber.prototype, "seed", {
  	        get: function () {
  	            return this._seed;
  	        },
  	        set: function (value) {
  	            this.hasSeed = true;
  	            this._seed = value;
  	        },
  	        enumerable: true,
  	        configurable: true
  	    });
  	    ScanSubscriber.prototype._next = function (value) {
  	        if (!this.hasSeed) {
  	            this.seed = value;
  	            this.destination.next(value);
  	        }
  	        else {
  	            return this._tryNext(value);
  	        }
  	    };
  	    ScanSubscriber.prototype._tryNext = function (value) {
  	        var index = this.index++;
  	        var result;
  	        try {
  	            result = this.accumulator(this.seed, value, index);
  	        }
  	        catch (err) {
  	            this.destination.error(err);
  	        }
  	        this.seed = result;
  	        this.destination.next(result);
  	    };
  	    return ScanSubscriber;
  	}(Subscriber_1.Subscriber));
  	//# sourceMappingURL=scan.js.map
  
  /***/ }),
  
  /***/ 329:
  /***/ (function(module, exports) {
  
  	"use strict";
  	
  	Object.defineProperty(exports, "__esModule", {
  		value: true
  	});
  	
  	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  	
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  	
  	var Configs = exports.Configs = function () {
  		function Configs() {
  			_classCallCheck(this, Configs);
  		}
  	
  		_createClass(Configs, [{
  			key: "get",
  			value: function get() {
  				return {
  					// TODO need to update this after i know the url
  					// companySuffix: '/company',
  					idrightsUrl: "/id-rights/public/signing-procuration/"
  				};
  			}
  		}]);
  	
  		return Configs;
  	}();
  	
  	var configs = exports.configs = new Configs();
  
  /***/ }),
  
  /***/ 330:
  /***/ (function(module, exports) {
  
  	"use strict";
  	
  	module.exports = {
  		notFound: function notFound() {
  			var serverMessage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
  	
  			return {
  				msg: "company not found",
  				context: "Fetching id-rights entities",
  				serverMsg: serverMessage,
  				fatal: true,
  				code: "7fbf51fc-cfa7-40df-9cdf-5b48e790231e"
  			};
  		},
  		maxIterations: function maxIterations() {
  			var serverMessage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
  	
  			return {
  				msg: "max iterations reached",
  				context: "Fetching id-rights entities",
  				serverMsg: serverMessage,
  				fatal: true,
  				code: "1f02b648-532b-4a27-b7ad-c8498460dbd9"
  	
  			};
  		},
  		emptyData: function emptyData() {
  			var serverMessage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
  	
  			return {
  				msg: "server returned empty data",
  				context: "Fetching id-rights entities",
  				serverMsg: serverMessage,
  				fatal: true,
  				code: "a5c29c55-f64c-4838-ba1d-c119862c4fe3"
  			};
  		}
  	};
  
  /***/ })
  
  /******/ })
  });
  ;
  //# sourceMappingURL=ve.id_rights.js.map