/home/blackyak/www/wordpress/wp-content/plugins/wp-travel-engine/assets/lib/rxjs.umd.js
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define('rxjs', ['exports'], factory) :
(factory((global.rxjs = {})));
}(this, (function (exports) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
t[p[i]] = s[p[i]];
return t;
}
function isFunction(x) {
return typeof x === 'function';
}
var _enable_super_gross_mode_that_will_cause_bad_things = false;
var config = {
Promise: undefined,
set useDeprecatedSynchronousErrorHandling(value) {
if (value) {
var error = new Error();
console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n' + error.stack);
}
else if (_enable_super_gross_mode_that_will_cause_bad_things) {
console.log('RxJS: Back to a better error behavior. Thank you. <3');
}
_enable_super_gross_mode_that_will_cause_bad_things = value;
},
get useDeprecatedSynchronousErrorHandling() {
return _enable_super_gross_mode_that_will_cause_bad_things;
},
};
function hostReportError(err) {
setTimeout(function () { throw err; }, 0);
}
var empty = {
closed: true,
next: function (value) { },
error: function (err) {
if (config.useDeprecatedSynchronousErrorHandling) {
throw err;
}
else {
hostReportError(err);
}
},
complete: function () { }
};
var isArray = (function () { return Array.isArray || (function (x) { return x && typeof x.length === 'number'; }); })();
function isObject(x) {
return x !== null && typeof x === 'object';
}
var UnsubscriptionErrorImpl = (function () {
function UnsubscriptionErrorImpl(errors) {
Error.call(this);
this.message = errors ?
errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n ') : '';
this.name = 'UnsubscriptionError';
this.errors = errors;
return this;
}
UnsubscriptionErrorImpl.prototype = Object.create(Error.prototype);
return UnsubscriptionErrorImpl;
})();
var UnsubscriptionError = UnsubscriptionErrorImpl;
var Subscription = (function () {
function Subscription(unsubscribe) {
this.closed = false;
this._parentOrParents = null;
this._subscriptions = null;
if (unsubscribe) {
this._ctorUnsubscribe = true;
this._unsubscribe = unsubscribe;
}
}
Subscription.prototype.unsubscribe = function () {
var errors;
if (this.closed) {
return;
}
var _a = this, _parentOrParents = _a._parentOrParents, _ctorUnsubscribe = _a._ctorUnsubscribe, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;
this.closed = true;
this._parentOrParents = null;
this._subscriptions = null;
if (_parentOrParents instanceof Subscription) {
_parentOrParents.remove(this);
}
else if (_parentOrParents !== null) {
for (var index = 0; index < _parentOrParents.length; ++index) {
var parent_1 = _parentOrParents[index];
parent_1.remove(this);
}
}
if (isFunction(_unsubscribe)) {
if (_ctorUnsubscribe) {
this._unsubscribe = undefined;
}
try {
_unsubscribe.call(this);
}
catch (e) {
errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
}
}
if (isArray(_subscriptions)) {
var index = -1;
var len = _subscriptions.length;
while (++index < len) {
var sub = _subscriptions[index];
if (isObject(sub)) {
try {
sub.unsubscribe();
}
catch (e) {
errors = errors || [];
if (e instanceof UnsubscriptionError) {
errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
}
else {
errors.push(e);
}
}
}
}
}
if (errors) {
throw new UnsubscriptionError(errors);
}
};
Subscription.prototype.add = function (teardown) {
var subscription = teardown;
if (!teardown) {
return Subscription.EMPTY;
}
switch (typeof teardown) {
case 'function':
subscription = new Subscription(teardown);
case 'object':
if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {
return subscription;
}
else if (this.closed) {
subscription.unsubscribe();
return subscription;
}
else if (!(subscription instanceof Subscription)) {
var tmp = subscription;
subscription = new Subscription();
subscription._subscriptions = [tmp];
}
break;
default: {
throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');
}
}
var _parentOrParents = subscription._parentOrParents;
if (_parentOrParents === null) {
subscription._parentOrParents = this;
}
else if (_parentOrParents instanceof Subscription) {
if (_parentOrParents === this) {
return subscription;
}
subscription._parentOrParents = [_parentOrParents, this];
}
else if (_parentOrParents.indexOf(this) === -1) {
_parentOrParents.push(this);
}
else {
return subscription;
}
var subscriptions = this._subscriptions;
if (subscriptions === null) {
this._subscriptions = [subscription];
}
else {
subscriptions.push(subscription);
}
return subscription;
};
Subscription.prototype.remove = function (subscription) {
var subscriptions = this._subscriptions;
if (subscriptions) {
var subscriptionIndex = subscriptions.indexOf(subscription);
if (subscriptionIndex !== -1) {
subscriptions.splice(subscriptionIndex, 1);
}
}
};
Subscription.EMPTY = (function (empty) {
empty.closed = true;
return empty;
}(new Subscription()));
return Subscription;
}());
function flattenUnsubscriptionErrors(errors) {
return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError) ? err.errors : err); }, []);
}
var rxSubscriber = (function () {
return typeof Symbol === 'function'
? Symbol('rxSubscriber')
: '@@rxSubscriber_' + Math.random();
})();
var Subscriber = (function (_super) {
__extends(Subscriber, _super);
function Subscriber(destinationOrNext, error, complete) {
var _this = _super.call(this) || this;
_this.syncErrorValue = null;
_this.syncErrorThrown = false;
_this.syncErrorThrowable = false;
_this.isStopped = false;
switch (arguments.length) {
case 0:
_this.destination = empty;
break;
case 1:
if (!destinationOrNext) {
_this.destination = empty;
break;
}
if (typeof destinationOrNext === 'object') {
if (destinationOrNext instanceof Subscriber) {
_this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;
_this.destination = destinationOrNext;
destinationOrNext.add(_this);
}
else {
_this.syncErrorThrowable = true;
_this.destination = new SafeSubscriber(_this, destinationOrNext);
}
break;
}
default:
_this.syncErrorThrowable = true;
_this.destination = new SafeSubscriber(_this, destinationOrNext, error, complete);
break;
}
return _this;
}
Subscriber.prototype[rxSubscriber] = function () { return this; };
Subscriber.create = function (next, error, complete) {
var subscriber = new Subscriber(next, error, complete);
subscriber.syncErrorThrowable = false;
return subscriber;
};
Subscriber.prototype.next = function (value) {
if (!this.isStopped) {
this._next(value);
}
};
Subscriber.prototype.error = function (err) {
if (!this.isStopped) {
this.isStopped = true;
this._error(err);
}
};
Subscriber.prototype.complete = function () {
if (!this.isStopped) {
this.isStopped = true;
this._complete();
}
};
Subscriber.prototype.unsubscribe = function () {
if (this.closed) {
return;
}
this.isStopped = true;
_super.prototype.unsubscribe.call(this);
};
Subscriber.prototype._next = function (value) {
this.destination.next(value);
};
Subscriber.prototype._error = function (err) {
this.destination.error(err);
this.unsubscribe();
};
Subscriber.prototype._complete = function () {
this.destination.complete();
this.unsubscribe();
};
Subscriber.prototype._unsubscribeAndRecycle = function () {
var _parentOrParents = this._parentOrParents;
this._parentOrParents = null;
this.unsubscribe();
this.closed = false;
this.isStopped = false;
this._parentOrParents = _parentOrParents;
return this;
};
return Subscriber;
}(Subscription));
var SafeSubscriber = (function (_super) {
__extends(SafeSubscriber, _super);
function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {
var _this = _super.call(this) || this;
_this._parentSubscriber = _parentSubscriber;
var next;
var context = _this;
if (isFunction(observerOrNext)) {
next = observerOrNext;
}
else if (observerOrNext) {
next = observerOrNext.next;
error = observerOrNext.error;
complete = observerOrNext.complete;
if (observerOrNext !== empty) {
context = Object.create(observerOrNext);
if (isFunction(context.unsubscribe)) {
_this.add(context.unsubscribe.bind(context));
}
context.unsubscribe = _this.unsubscribe.bind(_this);
}
}
_this._context = context;
_this._next = next;
_this._error = error;
_this._complete = complete;
return _this;
}
SafeSubscriber.prototype.next = function (value) {
if (!this.isStopped && this._next) {
var _parentSubscriber = this._parentSubscriber;
if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
this.__tryOrUnsub(this._next, value);
}
else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
this.unsubscribe();
}
}
};
SafeSubscriber.prototype.error = function (err) {
if (!this.isStopped) {
var _parentSubscriber = this._parentSubscriber;
var useDeprecatedSynchronousErrorHandling = config.useDeprecatedSynchronousErrorHandling;
if (this._error) {
if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
this.__tryOrUnsub(this._error, err);
this.unsubscribe();
}
else {
this.__tryOrSetError(_parentSubscriber, this._error, err);
this.unsubscribe();
}
}
else if (!_parentSubscriber.syncErrorThrowable) {
this.unsubscribe();
if (useDeprecatedSynchronousErrorHandling) {
throw err;
}
hostReportError(err);
}
else {
if (useDeprecatedSynchronousErrorHandling) {
_parentSubscriber.syncErrorValue = err;
_parentSubscriber.syncErrorThrown = true;
}
else {
hostReportError(err);
}
this.unsubscribe();
}
}
};
SafeSubscriber.prototype.complete = function () {
var _this = this;
if (!this.isStopped) {
var _parentSubscriber = this._parentSubscriber;
if (this._complete) {
var wrappedComplete = function () { return _this._complete.call(_this._context); };
if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
this.__tryOrUnsub(wrappedComplete);
this.unsubscribe();
}
else {
this.__tryOrSetError(_parentSubscriber, wrappedComplete);
this.unsubscribe();
}
}
else {
this.unsubscribe();
}
}
};
SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {
try {
fn.call(this._context, value);
}
catch (err) {
this.unsubscribe();
if (config.useDeprecatedSynchronousErrorHandling) {
throw err;
}
else {
hostReportError(err);
}
}
};
SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {
if (!config.useDeprecatedSynchronousErrorHandling) {
throw new Error('bad call');
}
try {
fn.call(this._context, value);
}
catch (err) {
if (config.useDeprecatedSynchronousErrorHandling) {
parent.syncErrorValue = err;
parent.syncErrorThrown = true;
return true;
}
else {
hostReportError(err);
return true;
}
}
return false;
};
SafeSubscriber.prototype._unsubscribe = function () {
var _parentSubscriber = this._parentSubscriber;
this._context = null;
this._parentSubscriber = null;
_parentSubscriber.unsubscribe();
};
return SafeSubscriber;
}(Subscriber));
function canReportError(observer) {
while (observer) {
var _a = observer, closed_1 = _a.closed, destination = _a.destination, isStopped = _a.isStopped;
if (closed_1 || isStopped) {
return false;
}
else if (destination && destination instanceof Subscriber) {
observer = destination;
}
else {
observer = null;
}
}
return true;
}
function toSubscriber(nextOrObserver, error, complete) {
if (nextOrObserver) {
if (nextOrObserver instanceof Subscriber) {
return nextOrObserver;
}
if (nextOrObserver[rxSubscriber]) {
return nextOrObserver[rxSubscriber]();
}
}
if (!nextOrObserver && !error && !complete) {
return new Subscriber(empty);
}
return new Subscriber(nextOrObserver, error, complete);
}
var observable = (function () { return typeof Symbol === 'function' && Symbol.observable || '@@observable'; })();
function identity(x) {
return x;
}
function pipe() {
var fns = [];
for (var _i = 0; _i < arguments.length; _i++) {
fns[_i] = arguments[_i];
}
return pipeFromArray(fns);
}
function pipeFromArray(fns) {
if (fns.length === 0) {
return identity;
}
if (fns.length === 1) {
return fns[0];
}
return function piped(input) {
return fns.reduce(function (prev, fn) { return fn(prev); }, input);
};
}
var Observable = (function () {
function Observable(subscribe) {
this._isScalar = false;
if (subscribe) {
this._subscribe = subscribe;
}
}
Observable.prototype.lift = function (operator) {
var observable$$1 = new Observable();
observable$$1.source = this;
observable$$1.operator = operator;
return observable$$1;
};
Observable.prototype.subscribe = function (observerOrNext, error, complete) {
var operator = this.operator;
var sink = toSubscriber(observerOrNext, error, complete);
if (operator) {
sink.add(operator.call(sink, this.source));
}
else {
sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?
this._subscribe(sink) :
this._trySubscribe(sink));
}
if (config.useDeprecatedSynchronousErrorHandling) {
if (sink.syncErrorThrowable) {
sink.syncErrorThrowable = false;
if (sink.syncErrorThrown) {
throw sink.syncErrorValue;
}
}
}
return sink;
};
Observable.prototype._trySubscribe = function (sink) {
try {
return this._subscribe(sink);
}
catch (err) {
if (config.useDeprecatedSynchronousErrorHandling) {
sink.syncErrorThrown = true;
sink.syncErrorValue = err;
}
if (canReportError(sink)) {
sink.error(err);
}
else {
console.warn(err);
}
}
};
Observable.prototype.forEach = function (next, promiseCtor) {
var _this = this;
promiseCtor = getPromiseCtor(promiseCtor);
return new promiseCtor(function (resolve, reject) {
var subscription;
subscription = _this.subscribe(function (value) {
try {
next(value);
}
catch (err) {
reject(err);
if (subscription) {
subscription.unsubscribe();
}
}
}, reject, resolve);
});
};
Observable.prototype._subscribe = function (subscriber) {
var source = this.source;
return source && source.subscribe(subscriber);
};
Observable.prototype[observable] = function () {
return this;
};
Observable.prototype.pipe = function () {
var operations = [];
for (var _i = 0; _i < arguments.length; _i++) {
operations[_i] = arguments[_i];
}
if (operations.length === 0) {
return this;
}
return pipeFromArray(operations)(this);
};
Observable.prototype.toPromise = function (promiseCtor) {
var _this = this;
promiseCtor = getPromiseCtor(promiseCtor);
return new promiseCtor(function (resolve, reject) {
var value;
_this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });
});
};
Observable.create = function (subscribe) {
return new Observable(subscribe);
};
return Observable;
}());
function getPromiseCtor(promiseCtor) {
if (!promiseCtor) {
promiseCtor = config.Promise || Promise;
}
if (!promiseCtor) {
throw new Error('no Promise impl found');
}
return promiseCtor;
}
var ObjectUnsubscribedErrorImpl = (function () {
function ObjectUnsubscribedErrorImpl() {
Error.call(this);
this.message = 'object unsubscribed';
this.name = 'ObjectUnsubscribedError';
return this;
}
ObjectUnsubscribedErrorImpl.prototype = Object.create(Error.prototype);
return ObjectUnsubscribedErrorImpl;
})();
var ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;
var SubjectSubscription = (function (_super) {
__extends(SubjectSubscription, _super);
function SubjectSubscription(subject, subscriber) {
var _this = _super.call(this) || this;
_this.subject = subject;
_this.subscriber = subscriber;
_this.closed = false;
return _this;
}
SubjectSubscription.prototype.unsubscribe = function () {
if (this.closed) {
return;
}
this.closed = true;
var subject = this.subject;
var observers = subject.observers;
this.subject = null;
if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {
return;
}
var subscriberIndex = observers.indexOf(this.subscriber);
if (subscriberIndex !== -1) {
observers.splice(subscriberIndex, 1);
}
};
return SubjectSubscription;
}(Subscription));
var SubjectSubscriber = (function (_super) {
__extends(SubjectSubscriber, _super);
function SubjectSubscriber(destination) {
var _this = _super.call(this, destination) || this;
_this.destination = destination;
return _this;
}
return SubjectSubscriber;
}(Subscriber));
var Subject = (function (_super) {
__extends(Subject, _super);
function Subject() {
var _this = _super.call(this) || this;
_this.observers = [];
_this.closed = false;
_this.isStopped = false;
_this.hasError = false;
_this.thrownError = null;
return _this;
}
Subject.prototype[rxSubscriber] = function () {
return new 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();
}
if (!this.isStopped) {
var observers = this.observers;
var len = observers.length;
var copy = observers.slice();
for (var i = 0; i < len; i++) {
copy[i].next(value);
}
}
};
Subject.prototype.error = function (err) {
if (this.closed) {
throw new ObjectUnsubscribedError();
}
this.hasError = true;
this.thrownError = err;
this.isStopped = true;
var observers = this.observers;
var len = observers.length;
var copy = observers.slice();
for (var i = 0; i < len; i++) {
copy[i].error(err);
}
this.observers.length = 0;
};
Subject.prototype.complete = function () {
if (this.closed) {
throw new ObjectUnsubscribedError();
}
this.isStopped = true;
var observers = this.observers;
var len = observers.length;
var copy = observers.slice();
for (var i = 0; i < len; i++) {
copy[i].complete();
}
this.observers.length = 0;
};
Subject.prototype.unsubscribe = function () {
this.isStopped = true;
this.closed = true;
this.observers = null;
};
Subject.prototype._trySubscribe = function (subscriber) {
if (this.closed) {
throw new ObjectUnsubscribedError();
}
else {
return _super.prototype._trySubscribe.call(this, subscriber);
}
};
Subject.prototype._subscribe = function (subscriber) {
if (this.closed) {
throw new ObjectUnsubscribedError();
}
else if (this.hasError) {
subscriber.error(this.thrownError);
return Subscription.EMPTY;
}
else if (this.isStopped) {
subscriber.complete();
return Subscription.EMPTY;
}
else {
this.observers.push(subscriber);
return new SubjectSubscription(this, subscriber);
}
};
Subject.prototype.asObservable = function () {
var observable = new Observable();
observable.source = this;
return observable;
};
Subject.create = function (destination, source) {
return new AnonymousSubject(destination, source);
};
return Subject;
}(Observable));
var AnonymousSubject = (function (_super) {
__extends(AnonymousSubject, _super);
function AnonymousSubject(destination, source) {
var _this = _super.call(this) || this;
_this.destination = destination;
_this.source = source;
return _this;
}
AnonymousSubject.prototype.next = function (value) {
var destination = this.destination;
if (destination && destination.next) {
destination.next(value);
}
};
AnonymousSubject.prototype.error = function (err) {
var destination = this.destination;
if (destination && destination.error) {
this.destination.error(err);
}
};
AnonymousSubject.prototype.complete = function () {
var destination = this.destination;
if (destination && destination.complete) {
this.destination.complete();
}
};
AnonymousSubject.prototype._subscribe = function (subscriber) {
var source = this.source;
if (source) {
return this.source.subscribe(subscriber);
}
else {
return Subscription.EMPTY;
}
};
return AnonymousSubject;
}(Subject));
function refCount() {
return function refCountOperatorFunction(source) {
return source.lift(new RefCountOperator(source));
};
}
var RefCountOperator = (function () {
function RefCountOperator(connectable) {
this.connectable = connectable;
}
RefCountOperator.prototype.call = function (subscriber, source) {
var connectable = this.connectable;
connectable._refCount++;
var refCounter = new RefCountSubscriber(subscriber, connectable);
var subscription = source.subscribe(refCounter);
if (!refCounter.closed) {
refCounter.connection = connectable.connect();
}
return subscription;
};
return RefCountOperator;
}());
var RefCountSubscriber = (function (_super) {
__extends(RefCountSubscriber, _super);
function RefCountSubscriber(destination, connectable) {
var _this = _super.call(this, destination) || this;
_this.connectable = connectable;
return _this;
}
RefCountSubscriber.prototype._unsubscribe = function () {
var connectable = this.connectable;
if (!connectable) {
this.connection = null;
return;
}
this.connectable = null;
var refCount = connectable._refCount;
if (refCount <= 0) {
this.connection = null;
return;
}
connectable._refCount = refCount - 1;
if (refCount > 1) {
this.connection = null;
return;
}
var connection = this.connection;
var sharedConnection = connectable._connection;
this.connection = null;
if (sharedConnection && (!connection || sharedConnection === connection)) {
sharedConnection.unsubscribe();
}
};
return RefCountSubscriber;
}(Subscriber));
var ConnectableObservable = (function (_super) {
__extends(ConnectableObservable, _super);
function ConnectableObservable(source, subjectFactory) {
var _this = _super.call(this) || this;
_this.source = source;
_this.subjectFactory = subjectFactory;
_this._refCount = 0;
_this._isComplete = false;
return _this;
}
ConnectableObservable.prototype._subscribe = function (subscriber) {
return this.getSubject().subscribe(subscriber);
};
ConnectableObservable.prototype.getSubject = function () {
var subject = this._subject;
if (!subject || subject.isStopped) {
this._subject = this.subjectFactory();
}
return this._subject;
};
ConnectableObservable.prototype.connect = function () {
var connection = this._connection;
if (!connection) {
this._isComplete = false;
connection = this._connection = new Subscription();
connection.add(this.source
.subscribe(new ConnectableSubscriber(this.getSubject(), this)));
if (connection.closed) {
this._connection = null;
connection = Subscription.EMPTY;
}
}
return connection;
};
ConnectableObservable.prototype.refCount = function () {
return refCount()(this);
};
return ConnectableObservable;
}(Observable));
var connectableObservableDescriptor = (function () {
var connectableProto = ConnectableObservable.prototype;
return {
operator: { value: null },
_refCount: { value: 0, writable: true },
_subject: { value: null, writable: true },
_connection: { value: null, writable: true },
_subscribe: { value: connectableProto._subscribe },
_isComplete: { value: connectableProto._isComplete, writable: true },
getSubject: { value: connectableProto.getSubject },
connect: { value: connectableProto.connect },
refCount: { value: connectableProto.refCount }
};
})();
var ConnectableSubscriber = (function (_super) {
__extends(ConnectableSubscriber, _super);
function ConnectableSubscriber(destination, connectable) {
var _this = _super.call(this, destination) || this;
_this.connectable = connectable;
return _this;
}
ConnectableSubscriber.prototype._error = function (err) {
this._unsubscribe();
_super.prototype._error.call(this, err);
};
ConnectableSubscriber.prototype._complete = function () {
this.connectable._isComplete = true;
this._unsubscribe();
_super.prototype._complete.call(this);
};
ConnectableSubscriber.prototype._unsubscribe = function () {
var connectable = this.connectable;
if (connectable) {
this.connectable = null;
var connection = connectable._connection;
connectable._refCount = 0;
connectable._subject = null;
connectable._connection = null;
if (connection) {
connection.unsubscribe();
}
}
};
return ConnectableSubscriber;
}(SubjectSubscriber));
var RefCountSubscriber$1 = (function (_super) {
__extends(RefCountSubscriber, _super);
function RefCountSubscriber(destination, connectable) {
var _this = _super.call(this, destination) || this;
_this.connectable = connectable;
return _this;
}
RefCountSubscriber.prototype._unsubscribe = function () {
var connectable = this.connectable;
if (!connectable) {
this.connection = null;
return;
}
this.connectable = null;
var refCount$$1 = connectable._refCount;
if (refCount$$1 <= 0) {
this.connection = null;
return;
}
connectable._refCount = refCount$$1 - 1;
if (refCount$$1 > 1) {
this.connection = null;
return;
}
var connection = this.connection;
var sharedConnection = connectable._connection;
this.connection = null;
if (sharedConnection && (!connection || sharedConnection === connection)) {
sharedConnection.unsubscribe();
}
};
return RefCountSubscriber;
}(Subscriber));
function groupBy(keySelector, elementSelector, durationSelector, subjectSelector) {
return function (source) {
return source.lift(new GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector));
};
}
var GroupByOperator = (function () {
function GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector) {
this.keySelector = keySelector;
this.elementSelector = elementSelector;
this.durationSelector = durationSelector;
this.subjectSelector = subjectSelector;
}
GroupByOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new GroupBySubscriber(subscriber, this.keySelector, this.elementSelector, this.durationSelector, this.subjectSelector));
};
return GroupByOperator;
}());
var GroupBySubscriber = (function (_super) {
__extends(GroupBySubscriber, _super);
function GroupBySubscriber(destination, keySelector, elementSelector, durationSelector, subjectSelector) {
var _this = _super.call(this, destination) || this;
_this.keySelector = keySelector;
_this.elementSelector = elementSelector;
_this.durationSelector = durationSelector;
_this.subjectSelector = subjectSelector;
_this.groups = null;
_this.attemptedToUnsubscribe = false;
_this.count = 0;
return _this;
}
GroupBySubscriber.prototype._next = function (value) {
var key;
try {
key = this.keySelector(value);
}
catch (err) {
this.error(err);
return;
}
this._group(value, key);
};
GroupBySubscriber.prototype._group = function (value, key) {
var groups = this.groups;
if (!groups) {
groups = this.groups = new Map();
}
var group = groups.get(key);
var element;
if (this.elementSelector) {
try {
element = this.elementSelector(value);
}
catch (err) {
this.error(err);
}
}
else {
element = value;
}
if (!group) {
group = (this.subjectSelector ? this.subjectSelector() : new Subject());
groups.set(key, group);
var groupedObservable = new GroupedObservable(key, group, this);
this.destination.next(groupedObservable);
if (this.durationSelector) {
var duration = void 0;
try {
duration = this.durationSelector(new GroupedObservable(key, group));
}
catch (err) {
this.error(err);
return;
}
this.add(duration.subscribe(new GroupDurationSubscriber(key, group, this)));
}
}
if (!group.closed) {
group.next(element);
}
};
GroupBySubscriber.prototype._error = function (err) {
var groups = this.groups;
if (groups) {
groups.forEach(function (group, key) {
group.error(err);
});
groups.clear();
}
this.destination.error(err);
};
GroupBySubscriber.prototype._complete = function () {
var groups = this.groups;
if (groups) {
groups.forEach(function (group, key) {
group.complete();
});
groups.clear();
}
this.destination.complete();
};
GroupBySubscriber.prototype.removeGroup = function (key) {
this.groups.delete(key);
};
GroupBySubscriber.prototype.unsubscribe = function () {
if (!this.closed) {
this.attemptedToUnsubscribe = true;
if (this.count === 0) {
_super.prototype.unsubscribe.call(this);
}
}
};
return GroupBySubscriber;
}(Subscriber));
var GroupDurationSubscriber = (function (_super) {
__extends(GroupDurationSubscriber, _super);
function GroupDurationSubscriber(key, group, parent) {
var _this = _super.call(this, group) || this;
_this.key = key;
_this.group = group;
_this.parent = parent;
return _this;
}
GroupDurationSubscriber.prototype._next = function (value) {
this.complete();
};
GroupDurationSubscriber.prototype._unsubscribe = function () {
var _a = this, parent = _a.parent, key = _a.key;
this.key = this.parent = null;
if (parent) {
parent.removeGroup(key);
}
};
return GroupDurationSubscriber;
}(Subscriber));
var GroupedObservable = (function (_super) {
__extends(GroupedObservable, _super);
function GroupedObservable(key, groupSubject, refCountSubscription) {
var _this = _super.call(this) || this;
_this.key = key;
_this.groupSubject = groupSubject;
_this.refCountSubscription = refCountSubscription;
return _this;
}
GroupedObservable.prototype._subscribe = function (subscriber) {
var subscription = new Subscription();
var _a = this, refCountSubscription = _a.refCountSubscription, groupSubject = _a.groupSubject;
if (refCountSubscription && !refCountSubscription.closed) {
subscription.add(new InnerRefCountSubscription(refCountSubscription));
}
subscription.add(groupSubject.subscribe(subscriber));
return subscription;
};
return GroupedObservable;
}(Observable));
var InnerRefCountSubscription = (function (_super) {
__extends(InnerRefCountSubscription, _super);
function InnerRefCountSubscription(parent) {
var _this = _super.call(this) || this;
_this.parent = parent;
parent.count++;
return _this;
}
InnerRefCountSubscription.prototype.unsubscribe = function () {
var parent = this.parent;
if (!parent.closed && !this.closed) {
_super.prototype.unsubscribe.call(this);
parent.count -= 1;
if (parent.count === 0 && parent.attemptedToUnsubscribe) {
parent.unsubscribe();
}
}
};
return InnerRefCountSubscription;
}(Subscription));
var BehaviorSubject = (function (_super) {
__extends(BehaviorSubject, _super);
function BehaviorSubject(_value) {
var _this = _super.call(this) || this;
_this._value = _value;
return _this;
}
Object.defineProperty(BehaviorSubject.prototype, "value", {
get: function () {
return this.getValue();
},
enumerable: true,
configurable: true
});
BehaviorSubject.prototype._subscribe = function (subscriber) {
var subscription = _super.prototype._subscribe.call(this, subscriber);
if (subscription && !subscription.closed) {
subscriber.next(this._value);
}
return subscription;
};
BehaviorSubject.prototype.getValue = function () {
if (this.hasError) {
throw this.thrownError;
}
else if (this.closed) {
throw new ObjectUnsubscribedError();
}
else {
return this._value;
}
};
BehaviorSubject.prototype.next = function (value) {
_super.prototype.next.call(this, this._value = value);
};
return BehaviorSubject;
}(Subject));
var Action = (function (_super) {
__extends(Action, _super);
function Action(scheduler, work) {
return _super.call(this) || this;
}
Action.prototype.schedule = function (state, delay) {
if (delay === void 0) { delay = 0; }
return this;
};
return Action;
}(Subscription));
var AsyncAction = (function (_super) {
__extends(AsyncAction, _super);
function AsyncAction(scheduler, work) {
var _this = _super.call(this, scheduler, work) || this;
_this.scheduler = scheduler;
_this.work = work;
_this.pending = false;
return _this;
}
AsyncAction.prototype.schedule = function (state, delay) {
if (delay === void 0) { delay = 0; }
if (this.closed) {
return this;
}
this.state = state;
var id = this.id;
var scheduler = this.scheduler;
if (id != null) {
this.id = this.recycleAsyncId(scheduler, id, delay);
}
this.pending = true;
this.delay = delay;
this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);
return this;
};
AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
return setInterval(scheduler.flush.bind(scheduler, this), delay);
};
AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
if (delay !== null && this.delay === delay && this.pending === false) {
return id;
}
clearInterval(id);
return undefined;
};
AsyncAction.prototype.execute = function (state, delay) {
if (this.closed) {
return new Error('executing a cancelled action');
}
this.pending = false;
var error = this._execute(state, delay);
if (error) {
return error;
}
else if (this.pending === false && this.id != null) {
this.id = this.recycleAsyncId(this.scheduler, this.id, null);
}
};
AsyncAction.prototype._execute = function (state, delay) {
var errored = false;
var errorValue = undefined;
try {
this.work(state);
}
catch (e) {
errored = true;
errorValue = !!e && e || new Error(e);
}
if (errored) {
this.unsubscribe();
return errorValue;
}
};
AsyncAction.prototype._unsubscribe = function () {
var id = this.id;
var scheduler = this.scheduler;
var actions = scheduler.actions;
var index = actions.indexOf(this);
this.work = null;
this.state = null;
this.pending = false;
this.scheduler = null;
if (index !== -1) {
actions.splice(index, 1);
}
if (id != null) {
this.id = this.recycleAsyncId(scheduler, id, null);
}
this.delay = null;
};
return AsyncAction;
}(Action));
var QueueAction = (function (_super) {
__extends(QueueAction, _super);
function QueueAction(scheduler, work) {
var _this = _super.call(this, scheduler, work) || this;
_this.scheduler = scheduler;
_this.work = work;
return _this;
}
QueueAction.prototype.schedule = function (state, delay) {
if (delay === void 0) { delay = 0; }
if (delay > 0) {
return _super.prototype.schedule.call(this, state, delay);
}
this.delay = delay;
this.state = state;
this.scheduler.flush(this);
return this;
};
QueueAction.prototype.execute = function (state, delay) {
return (delay > 0 || this.closed) ?
_super.prototype.execute.call(this, state, delay) :
this._execute(state, delay);
};
QueueAction.prototype.requestAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {
return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
}
return scheduler.flush(this);
};
return QueueAction;
}(AsyncAction));
var Scheduler = (function () {
function Scheduler(SchedulerAction, now) {
if (now === void 0) { now = Scheduler.now; }
this.SchedulerAction = SchedulerAction;
this.now = now;
}
Scheduler.prototype.schedule = function (work, delay, state) {
if (delay === void 0) { delay = 0; }
return new this.SchedulerAction(this, work).schedule(state, delay);
};
Scheduler.now = function () { return Date.now(); };
return Scheduler;
}());
var AsyncScheduler = (function (_super) {
__extends(AsyncScheduler, _super);
function AsyncScheduler(SchedulerAction, now) {
if (now === void 0) { now = Scheduler.now; }
var _this = _super.call(this, SchedulerAction, function () {
if (AsyncScheduler.delegate && AsyncScheduler.delegate !== _this) {
return AsyncScheduler.delegate.now();
}
else {
return now();
}
}) || this;
_this.actions = [];
_this.active = false;
_this.scheduled = undefined;
return _this;
}
AsyncScheduler.prototype.schedule = function (work, delay, state) {
if (delay === void 0) { delay = 0; }
if (AsyncScheduler.delegate && AsyncScheduler.delegate !== this) {
return AsyncScheduler.delegate.schedule(work, delay, state);
}
else {
return _super.prototype.schedule.call(this, work, delay, state);
}
};
AsyncScheduler.prototype.flush = function (action) {
var actions = this.actions;
if (this.active) {
actions.push(action);
return;
}
var error;
this.active = true;
do {
if (error = action.execute(action.state, action.delay)) {
break;
}
} while (action = actions.shift());
this.active = false;
if (error) {
while (action = actions.shift()) {
action.unsubscribe();
}
throw error;
}
};
return AsyncScheduler;
}(Scheduler));
var QueueScheduler = (function (_super) {
__extends(QueueScheduler, _super);
function QueueScheduler() {
return _super !== null && _super.apply(this, arguments) || this;
}
return QueueScheduler;
}(AsyncScheduler));
var queueScheduler = new QueueScheduler(QueueAction);
var queue = queueScheduler;
var EMPTY = new Observable(function (subscriber) { return subscriber.complete(); });
function empty$1(scheduler) {
return scheduler ? emptyScheduled(scheduler) : EMPTY;
}
function emptyScheduled(scheduler) {
return new Observable(function (subscriber) { return scheduler.schedule(function () { return subscriber.complete(); }); });
}
function isScheduler(value) {
return value && typeof value.schedule === 'function';
}
var subscribeToArray = function (array) { return function (subscriber) {
for (var i = 0, len = array.length; i < len && !subscriber.closed; i++) {
subscriber.next(array[i]);
}
subscriber.complete();
}; };
function scheduleArray(input, scheduler) {
return new Observable(function (subscriber) {
var sub = new Subscription();
var i = 0;
sub.add(scheduler.schedule(function () {
if (i === input.length) {
subscriber.complete();
return;
}
subscriber.next(input[i++]);
if (!subscriber.closed) {
sub.add(this.schedule());
}
}));
return sub;
});
}
function fromArray(input, scheduler) {
if (!scheduler) {
return new Observable(subscribeToArray(input));
}
else {
return scheduleArray(input, scheduler);
}
}
function of() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var scheduler = args[args.length - 1];
if (isScheduler(scheduler)) {
args.pop();
return scheduleArray(args, scheduler);
}
else {
return fromArray(args);
}
}
function throwError(error, scheduler) {
if (!scheduler) {
return new Observable(function (subscriber) { return subscriber.error(error); });
}
else {
return new Observable(function (subscriber) { return scheduler.schedule(dispatch, 0, { error: error, subscriber: subscriber }); });
}
}
function dispatch(_a) {
var error = _a.error, subscriber = _a.subscriber;
subscriber.error(error);
}
(function (NotificationKind) {
NotificationKind["NEXT"] = "N";
NotificationKind["ERROR"] = "E";
NotificationKind["COMPLETE"] = "C";
})(exports.NotificationKind || (exports.NotificationKind = {}));
var Notification = (function () {
function Notification(kind, value, error) {
this.kind = kind;
this.value = value;
this.error = error;
this.hasValue = kind === 'N';
}
Notification.prototype.observe = function (observer) {
switch (this.kind) {
case 'N':
return observer.next && observer.next(this.value);
case 'E':
return observer.error && observer.error(this.error);
case 'C':
return observer.complete && observer.complete();
}
};
Notification.prototype.do = function (next, error, complete) {
var kind = this.kind;
switch (kind) {
case 'N':
return next && next(this.value);
case 'E':
return error && error(this.error);
case 'C':
return complete && complete();
}
};
Notification.prototype.accept = function (nextOrObserver, error, complete) {
if (nextOrObserver && typeof nextOrObserver.next === 'function') {
return this.observe(nextOrObserver);
}
else {
return this.do(nextOrObserver, error, complete);
}
};
Notification.prototype.toObservable = function () {
var kind = this.kind;
switch (kind) {
case 'N':
return of(this.value);
case 'E':
return throwError(this.error);
case 'C':
return empty$1();
}
throw new Error('unexpected notification kind value');
};
Notification.createNext = function (value) {
if (typeof value !== 'undefined') {
return new Notification('N', value);
}
return Notification.undefinedValueNotification;
};
Notification.createError = function (err) {
return new Notification('E', undefined, err);
};
Notification.createComplete = function () {
return Notification.completeNotification;
};
Notification.completeNotification = new Notification('C');
Notification.undefinedValueNotification = new Notification('N', undefined);
return Notification;
}());
function observeOn(scheduler, delay) {
if (delay === void 0) { delay = 0; }
return function observeOnOperatorFunction(source) {
return source.lift(new ObserveOnOperator(scheduler, delay));
};
}
var ObserveOnOperator = (function () {
function ObserveOnOperator(scheduler, delay) {
if (delay === void 0) { delay = 0; }
this.scheduler = scheduler;
this.delay = delay;
}
ObserveOnOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new ObserveOnSubscriber(subscriber, this.scheduler, this.delay));
};
return ObserveOnOperator;
}());
var ObserveOnSubscriber = (function (_super) {
__extends(ObserveOnSubscriber, _super);
function ObserveOnSubscriber(destination, scheduler, delay) {
if (delay === void 0) { delay = 0; }
var _this = _super.call(this, destination) || this;
_this.scheduler = scheduler;
_this.delay = delay;
return _this;
}
ObserveOnSubscriber.dispatch = function (arg) {
var notification = arg.notification, destination = arg.destination;
notification.observe(destination);
this.unsubscribe();
};
ObserveOnSubscriber.prototype.scheduleMessage = function (notification) {
var destination = this.destination;
destination.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));
};
ObserveOnSubscriber.prototype._next = function (value) {
this.scheduleMessage(Notification.createNext(value));
};
ObserveOnSubscriber.prototype._error = function (err) {
this.scheduleMessage(Notification.createError(err));
this.unsubscribe();
};
ObserveOnSubscriber.prototype._complete = function () {
this.scheduleMessage(Notification.createComplete());
this.unsubscribe();
};
return ObserveOnSubscriber;
}(Subscriber));
var ObserveOnMessage = (function () {
function ObserveOnMessage(notification, destination) {
this.notification = notification;
this.destination = destination;
}
return ObserveOnMessage;
}());
var ReplaySubject = (function (_super) {
__extends(ReplaySubject, _super);
function ReplaySubject(bufferSize, windowTime, scheduler) {
if (bufferSize === void 0) { bufferSize = Number.POSITIVE_INFINITY; }
if (windowTime === void 0) { windowTime = Number.POSITIVE_INFINITY; }
var _this = _super.call(this) || this;
_this.scheduler = scheduler;
_this._events = [];
_this._infiniteTimeWindow = false;
_this._bufferSize = bufferSize < 1 ? 1 : bufferSize;
_this._windowTime = windowTime < 1 ? 1 : windowTime;
if (windowTime === Number.POSITIVE_INFINITY) {
_this._infiniteTimeWindow = true;
_this.next = _this.nextInfiniteTimeWindow;
}
else {
_this.next = _this.nextTimeWindow;
}
return _this;
}
ReplaySubject.prototype.nextInfiniteTimeWindow = function (value) {
if (!this.isStopped) {
var _events = this._events;
_events.push(value);
if (_events.length > this._bufferSize) {
_events.shift();
}
}
_super.prototype.next.call(this, value);
};
ReplaySubject.prototype.nextTimeWindow = function (value) {
if (!this.isStopped) {
this._events.push(new ReplayEvent(this._getNow(), value));
this._trimBufferThenGetEvents();
}
_super.prototype.next.call(this, value);
};
ReplaySubject.prototype._subscribe = function (subscriber) {
var _infiniteTimeWindow = this._infiniteTimeWindow;
var _events = _infiniteTimeWindow ? this._events : this._trimBufferThenGetEvents();
var scheduler = this.scheduler;
var len = _events.length;
var subscription;
if (this.closed) {
throw new ObjectUnsubscribedError();
}
else if (this.isStopped || this.hasError) {
subscription = Subscription.EMPTY;
}
else {
this.observers.push(subscriber);
subscription = new SubjectSubscription(this, subscriber);
}
if (scheduler) {
subscriber.add(subscriber = new ObserveOnSubscriber(subscriber, scheduler));
}
if (_infiniteTimeWindow) {
for (var i = 0; i < len && !subscriber.closed; i++) {
subscriber.next(_events[i]);
}
}
else {
for (var i = 0; i < len && !subscriber.closed; i++) {
subscriber.next(_events[i].value);
}
}
if (this.hasError) {
subscriber.error(this.thrownError);
}
else if (this.isStopped) {
subscriber.complete();
}
return subscription;
};
ReplaySubject.prototype._getNow = function () {
return (this.scheduler || queue).now();
};
ReplaySubject.prototype._trimBufferThenGetEvents = function () {
var now = this._getNow();
var _bufferSize = this._bufferSize;
var _windowTime = this._windowTime;
var _events = this._events;
var eventsCount = _events.length;
var spliceCount = 0;
while (spliceCount < eventsCount) {
if ((now - _events[spliceCount].time) < _windowTime) {
break;
}
spliceCount++;
}
if (eventsCount > _bufferSize) {
spliceCount = Math.max(spliceCount, eventsCount - _bufferSize);
}
if (spliceCount > 0) {
_events.splice(0, spliceCount);
}
return _events;
};
return ReplaySubject;
}(Subject));
var ReplayEvent = (function () {
function ReplayEvent(time, value) {
this.time = time;
this.value = value;
}
return ReplayEvent;
}());
var AsyncSubject = (function (_super) {
__extends(AsyncSubject, _super);
function AsyncSubject() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.value = null;
_this.hasNext = false;
_this.hasCompleted = false;
return _this;
}
AsyncSubject.prototype._subscribe = function (subscriber) {
if (this.hasError) {
subscriber.error(this.thrownError);
return Subscription.EMPTY;
}
else if (this.hasCompleted && this.hasNext) {
subscriber.next(this.value);
subscriber.complete();
return Subscription.EMPTY;
}
return _super.prototype._subscribe.call(this, subscriber);
};
AsyncSubject.prototype.next = function (value) {
if (!this.hasCompleted) {
this.value = value;
this.hasNext = true;
}
};
AsyncSubject.prototype.error = function (error) {
if (!this.hasCompleted) {
_super.prototype.error.call(this, error);
}
};
AsyncSubject.prototype.complete = function () {
this.hasCompleted = true;
if (this.hasNext) {
_super.prototype.next.call(this, this.value);
}
_super.prototype.complete.call(this);
};
return AsyncSubject;
}(Subject));
var nextHandle = 1;
var RESOLVED = (function () { return Promise.resolve(); })();
var activeHandles = {};
function findAndClearHandle(handle) {
if (handle in activeHandles) {
delete activeHandles[handle];
return true;
}
return false;
}
var Immediate = {
setImmediate: function (cb) {
var handle = nextHandle++;
activeHandles[handle] = true;
RESOLVED.then(function () { return findAndClearHandle(handle) && cb(); });
return handle;
},
clearImmediate: function (handle) {
findAndClearHandle(handle);
},
};
var AsapAction = (function (_super) {
__extends(AsapAction, _super);
function AsapAction(scheduler, work) {
var _this = _super.call(this, scheduler, work) || this;
_this.scheduler = scheduler;
_this.work = work;
return _this;
}
AsapAction.prototype.requestAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
if (delay !== null && delay > 0) {
return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
}
scheduler.actions.push(this);
return scheduler.scheduled || (scheduler.scheduled = Immediate.setImmediate(scheduler.flush.bind(scheduler, null)));
};
AsapAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {
return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
}
if (scheduler.actions.length === 0) {
Immediate.clearImmediate(id);
scheduler.scheduled = undefined;
}
return undefined;
};
return AsapAction;
}(AsyncAction));
var AsapScheduler = (function (_super) {
__extends(AsapScheduler, _super);
function AsapScheduler() {
return _super !== null && _super.apply(this, arguments) || this;
}
AsapScheduler.prototype.flush = function (action) {
this.active = true;
this.scheduled = undefined;
var actions = this.actions;
var error;
var index = -1;
var count = actions.length;
action = action || actions.shift();
do {
if (error = action.execute(action.state, action.delay)) {
break;
}
} while (++index < count && (action = actions.shift()));
this.active = false;
if (error) {
while (++index < count && (action = actions.shift())) {
action.unsubscribe();
}
throw error;
}
};
return AsapScheduler;
}(AsyncScheduler));
var asapScheduler = new AsapScheduler(AsapAction);
var asap = asapScheduler;
var asyncScheduler = new AsyncScheduler(AsyncAction);
var async = asyncScheduler;
var AnimationFrameAction = (function (_super) {
__extends(AnimationFrameAction, _super);
function AnimationFrameAction(scheduler, work) {
var _this = _super.call(this, scheduler, work) || this;
_this.scheduler = scheduler;
_this.work = work;
return _this;
}
AnimationFrameAction.prototype.requestAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
if (delay !== null && delay > 0) {
return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
}
scheduler.actions.push(this);
return scheduler.scheduled || (scheduler.scheduled = requestAnimationFrame(function () { return scheduler.flush(null); }));
};
AnimationFrameAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {
return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
}
if (scheduler.actions.length === 0) {
cancelAnimationFrame(id);
scheduler.scheduled = undefined;
}
return undefined;
};
return AnimationFrameAction;
}(AsyncAction));
var AnimationFrameScheduler = (function (_super) {
__extends(AnimationFrameScheduler, _super);
function AnimationFrameScheduler() {
return _super !== null && _super.apply(this, arguments) || this;
}
AnimationFrameScheduler.prototype.flush = function (action) {
this.active = true;
this.scheduled = undefined;
var actions = this.actions;
var error;
var index = -1;
var count = actions.length;
action = action || actions.shift();
do {
if (error = action.execute(action.state, action.delay)) {
break;
}
} while (++index < count && (action = actions.shift()));
this.active = false;
if (error) {
while (++index < count && (action = actions.shift())) {
action.unsubscribe();
}
throw error;
}
};
return AnimationFrameScheduler;
}(AsyncScheduler));
var animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction);
var animationFrame = animationFrameScheduler;
var VirtualTimeScheduler = (function (_super) {
__extends(VirtualTimeScheduler, _super);
function VirtualTimeScheduler(SchedulerAction, maxFrames) {
if (SchedulerAction === void 0) { SchedulerAction = VirtualAction; }
if (maxFrames === void 0) { maxFrames = Number.POSITIVE_INFINITY; }
var _this = _super.call(this, SchedulerAction, function () { return _this.frame; }) || this;
_this.maxFrames = maxFrames;
_this.frame = 0;
_this.index = -1;
return _this;
}
VirtualTimeScheduler.prototype.flush = function () {
var _a = this, actions = _a.actions, maxFrames = _a.maxFrames;
var error, action;
while ((action = actions[0]) && action.delay <= maxFrames) {
actions.shift();
this.frame = action.delay;
if (error = action.execute(action.state, action.delay)) {
break;
}
}
if (error) {
while (action = actions.shift()) {
action.unsubscribe();
}
throw error;
}
};
VirtualTimeScheduler.frameTimeFactor = 10;
return VirtualTimeScheduler;
}(AsyncScheduler));
var VirtualAction = (function (_super) {
__extends(VirtualAction, _super);
function VirtualAction(scheduler, work, index) {
if (index === void 0) { index = scheduler.index += 1; }
var _this = _super.call(this, scheduler, work) || this;
_this.scheduler = scheduler;
_this.work = work;
_this.index = index;
_this.active = true;
_this.index = scheduler.index = index;
return _this;
}
VirtualAction.prototype.schedule = function (state, delay) {
if (delay === void 0) { delay = 0; }
if (!this.id) {
return _super.prototype.schedule.call(this, state, delay);
}
this.active = false;
var action = new VirtualAction(this.scheduler, this.work);
this.add(action);
return action.schedule(state, delay);
};
VirtualAction.prototype.requestAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
this.delay = scheduler.frame + delay;
var actions = scheduler.actions;
actions.push(this);
actions.sort(VirtualAction.sortActions);
return true;
};
VirtualAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
if (delay === void 0) { delay = 0; }
return undefined;
};
VirtualAction.prototype._execute = function (state, delay) {
if (this.active === true) {
return _super.prototype._execute.call(this, state, delay);
}
};
VirtualAction.sortActions = function (a, b) {
if (a.delay === b.delay) {
if (a.index === b.index) {
return 0;
}
else if (a.index > b.index) {
return 1;
}
else {
return -1;
}
}
else if (a.delay > b.delay) {
return 1;
}
else {
return -1;
}
};
return VirtualAction;
}(AsyncAction));
function noop() { }
function isObservable(obj) {
return !!obj && (obj instanceof Observable || (typeof obj.lift === 'function' && typeof obj.subscribe === 'function'));
}
var ArgumentOutOfRangeErrorImpl = (function () {
function ArgumentOutOfRangeErrorImpl() {
Error.call(this);
this.message = 'argument out of range';
this.name = 'ArgumentOutOfRangeError';
return this;
}
ArgumentOutOfRangeErrorImpl.prototype = Object.create(Error.prototype);
return ArgumentOutOfRangeErrorImpl;
})();
var ArgumentOutOfRangeError = ArgumentOutOfRangeErrorImpl;
var EmptyErrorImpl = (function () {
function EmptyErrorImpl() {
Error.call(this);
this.message = 'no elements in sequence';
this.name = 'EmptyError';
return this;
}
EmptyErrorImpl.prototype = Object.create(Error.prototype);
return EmptyErrorImpl;
})();
var EmptyError = EmptyErrorImpl;
var TimeoutErrorImpl = (function () {
function TimeoutErrorImpl() {
Error.call(this);
this.message = 'Timeout has occurred';
this.name = 'TimeoutError';
return this;
}
TimeoutErrorImpl.prototype = Object.create(Error.prototype);
return TimeoutErrorImpl;
})();
var TimeoutError = TimeoutErrorImpl;
function map(project, thisArg) {
return function mapOperation(source) {
if (typeof project !== 'function') {
throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
}
return source.lift(new MapOperator(project, thisArg));
};
}
var MapOperator = (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;
}());
var MapSubscriber = (function (_super) {
__extends(MapSubscriber, _super);
function MapSubscriber(destination, project, thisArg) {
var _this = _super.call(this, destination) || this;
_this.project = project;
_this.count = 0;
_this.thisArg = thisArg || _this;
return _this;
}
MapSubscriber.prototype._next = function (value) {
var result;
try {
result = this.project.call(this.thisArg, value, this.count++);
}
catch (err) {
this.destination.error(err);
return;
}
this.destination.next(result);
};
return MapSubscriber;
}(Subscriber));
function bindCallback(callbackFunc, resultSelector, scheduler) {
if (resultSelector) {
if (isScheduler(resultSelector)) {
scheduler = resultSelector;
}
else {
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return bindCallback(callbackFunc, scheduler).apply(void 0, args).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); }));
};
}
}
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var context = this;
var subject;
var params = {
context: context,
subject: subject,
callbackFunc: callbackFunc,
scheduler: scheduler,
};
return new Observable(function (subscriber) {
if (!scheduler) {
if (!subject) {
subject = new AsyncSubject();
var handler = function () {
var innerArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
innerArgs[_i] = arguments[_i];
}
subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs);
subject.complete();
};
try {
callbackFunc.apply(context, args.concat([handler]));
}
catch (err) {
if (canReportError(subject)) {
subject.error(err);
}
else {
console.warn(err);
}
}
}
return subject.subscribe(subscriber);
}
else {
var state = {
args: args, subscriber: subscriber, params: params,
};
return scheduler.schedule(dispatch$1, 0, state);
}
});
};
}
function dispatch$1(state) {
var _this = this;
var args = state.args, subscriber = state.subscriber, params = state.params;
var callbackFunc = params.callbackFunc, context = params.context, scheduler = params.scheduler;
var subject = params.subject;
if (!subject) {
subject = params.subject = new AsyncSubject();
var handler = function () {
var innerArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
innerArgs[_i] = arguments[_i];
}
var value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs;
_this.add(scheduler.schedule(dispatchNext, 0, { value: value, subject: subject }));
};
try {
callbackFunc.apply(context, args.concat([handler]));
}
catch (err) {
subject.error(err);
}
}
this.add(subject.subscribe(subscriber));
}
function dispatchNext(state) {
var value = state.value, subject = state.subject;
subject.next(value);
subject.complete();
}
function bindNodeCallback(callbackFunc, resultSelector, scheduler) {
if (resultSelector) {
if (isScheduler(resultSelector)) {
scheduler = resultSelector;
}
else {
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return bindNodeCallback(callbackFunc, scheduler).apply(void 0, args).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); }));
};
}
}
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var params = {
subject: undefined,
args: args,
callbackFunc: callbackFunc,
scheduler: scheduler,
context: this,
};
return new Observable(function (subscriber) {
var context = params.context;
var subject = params.subject;
if (!scheduler) {
if (!subject) {
subject = params.subject = new AsyncSubject();
var handler = function () {
var innerArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
innerArgs[_i] = arguments[_i];
}
var err = innerArgs.shift();
if (err) {
subject.error(err);
return;
}
subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs);
subject.complete();
};
try {
callbackFunc.apply(context, args.concat([handler]));
}
catch (err) {
if (canReportError(subject)) {
subject.error(err);
}
else {
console.warn(err);
}
}
}
return subject.subscribe(subscriber);
}
else {
return scheduler.schedule(dispatch$2, 0, { params: params, subscriber: subscriber, context: context });
}
});
};
}
function dispatch$2(state) {
var _this = this;
var params = state.params, subscriber = state.subscriber, context = state.context;
var callbackFunc = params.callbackFunc, args = params.args, scheduler = params.scheduler;
var subject = params.subject;
if (!subject) {
subject = params.subject = new AsyncSubject();
var handler = function () {
var innerArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
innerArgs[_i] = arguments[_i];
}
var err = innerArgs.shift();
if (err) {
_this.add(scheduler.schedule(dispatchError$1, 0, { err: err, subject: subject }));
}
else {
var value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs;
_this.add(scheduler.schedule(dispatchNext$1, 0, { value: value, subject: subject }));
}
};
try {
callbackFunc.apply(context, args.concat([handler]));
}
catch (err) {
this.add(scheduler.schedule(dispatchError$1, 0, { err: err, subject: subject }));
}
}
this.add(subject.subscribe(subscriber));
}
function dispatchNext$1(arg) {
var value = arg.value, subject = arg.subject;
subject.next(value);
subject.complete();
}
function dispatchError$1(arg) {
var err = arg.err, subject = arg.subject;
subject.error(err);
}
var OuterSubscriber = (function (_super) {
__extends(OuterSubscriber, _super);
function OuterSubscriber() {
return _super !== null && _super.apply(this, arguments) || this;
}
OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
this.destination.next(innerValue);
};
OuterSubscriber.prototype.notifyError = function (error, innerSub) {
this.destination.error(error);
};
OuterSubscriber.prototype.notifyComplete = function (innerSub) {
this.destination.complete();
};
return OuterSubscriber;
}(Subscriber));
var InnerSubscriber = (function (_super) {
__extends(InnerSubscriber, _super);
function InnerSubscriber(parent, outerValue, outerIndex) {
var _this = _super.call(this) || this;
_this.parent = parent;
_this.outerValue = outerValue;
_this.outerIndex = outerIndex;
_this.index = 0;
return _this;
}
InnerSubscriber.prototype._next = function (value) {
this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);
};
InnerSubscriber.prototype._error = function (error) {
this.parent.notifyError(error, this);
this.unsubscribe();
};
InnerSubscriber.prototype._complete = function () {
this.parent.notifyComplete(this);
this.unsubscribe();
};
return InnerSubscriber;
}(Subscriber));
var subscribeToPromise = function (promise) { return function (subscriber) {
promise.then(function (value) {
if (!subscriber.closed) {
subscriber.next(value);
subscriber.complete();
}
}, function (err) { return subscriber.error(err); })
.then(null, hostReportError);
return subscriber;
}; };
function getSymbolIterator() {
if (typeof Symbol !== 'function' || !Symbol.iterator) {
return '@@iterator';
}
return Symbol.iterator;
}
var iterator = getSymbolIterator();
var subscribeToIterable = function (iterable) { return function (subscriber) {
var iterator$$1 = iterable[iterator]();
do {
var item = void 0;
try {
item = iterator$$1.next();
}
catch (err) {
subscriber.error(err);
return subscriber;
}
if (item.done) {
subscriber.complete();
break;
}
subscriber.next(item.value);
if (subscriber.closed) {
break;
}
} while (true);
if (typeof iterator$$1.return === 'function') {
subscriber.add(function () {
if (iterator$$1.return) {
iterator$$1.return();
}
});
}
return subscriber;
}; };
var subscribeToObservable = function (obj) { return function (subscriber) {
var obs = obj[observable]();
if (typeof obs.subscribe !== 'function') {
throw new TypeError('Provided object does not correctly implement Symbol.observable');
}
else {
return obs.subscribe(subscriber);
}
}; };
var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
function isPromise(value) {
return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';
}
var subscribeTo = function (result) {
if (!!result && typeof result[observable] === 'function') {
return subscribeToObservable(result);
}
else if (isArrayLike(result)) {
return subscribeToArray(result);
}
else if (isPromise(result)) {
return subscribeToPromise(result);
}
else if (!!result && typeof result[iterator] === 'function') {
return subscribeToIterable(result);
}
else {
var value = isObject(result) ? 'an invalid object' : "'" + result + "'";
var msg = "You provided " + value + " where a stream was expected."
+ ' You can provide an Observable, Promise, Array, or Iterable.';
throw new TypeError(msg);
}
};
function subscribeToResult(outerSubscriber, result, outerValue, outerIndex, innerSubscriber) {
if (innerSubscriber === void 0) { innerSubscriber = new InnerSubscriber(outerSubscriber, outerValue, outerIndex); }
if (innerSubscriber.closed) {
return undefined;
}
if (result instanceof Observable) {
return result.subscribe(innerSubscriber);
}
return subscribeTo(result)(innerSubscriber);
}
var NONE = {};
function combineLatest() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
var resultSelector = undefined;
var scheduler = undefined;
if (isScheduler(observables[observables.length - 1])) {
scheduler = observables.pop();
}
if (typeof observables[observables.length - 1] === 'function') {
resultSelector = observables.pop();
}
if (observables.length === 1 && isArray(observables[0])) {
observables = observables[0];
}
return fromArray(observables, scheduler).lift(new CombineLatestOperator(resultSelector));
}
var CombineLatestOperator = (function () {
function CombineLatestOperator(resultSelector) {
this.resultSelector = resultSelector;
}
CombineLatestOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new CombineLatestSubscriber(subscriber, this.resultSelector));
};
return CombineLatestOperator;
}());
var CombineLatestSubscriber = (function (_super) {
__extends(CombineLatestSubscriber, _super);
function CombineLatestSubscriber(destination, resultSelector) {
var _this = _super.call(this, destination) || this;
_this.resultSelector = resultSelector;
_this.active = 0;
_this.values = [];
_this.observables = [];
return _this;
}
CombineLatestSubscriber.prototype._next = function (observable) {
this.values.push(NONE);
this.observables.push(observable);
};
CombineLatestSubscriber.prototype._complete = function () {
var observables = this.observables;
var len = observables.length;
if (len === 0) {
this.destination.complete();
}
else {
this.active = len;
this.toRespond = len;
for (var i = 0; i < len; i++) {
var observable = observables[i];
this.add(subscribeToResult(this, observable, undefined, i));
}
}
};
CombineLatestSubscriber.prototype.notifyComplete = function (unused) {
if ((this.active -= 1) === 0) {
this.destination.complete();
}
};
CombineLatestSubscriber.prototype.notifyNext = function (_outerValue, innerValue, outerIndex) {
var values = this.values;
var oldVal = values[outerIndex];
var toRespond = !this.toRespond
? 0
: oldVal === NONE ? --this.toRespond : this.toRespond;
values[outerIndex] = innerValue;
if (toRespond === 0) {
if (this.resultSelector) {
this._tryResultSelector(values);
}
else {
this.destination.next(values.slice());
}
}
};
CombineLatestSubscriber.prototype._tryResultSelector = function (values) {
var result;
try {
result = this.resultSelector.apply(this, values);
}
catch (err) {
this.destination.error(err);
return;
}
this.destination.next(result);
};
return CombineLatestSubscriber;
}(OuterSubscriber));
function scheduleObservable(input, scheduler) {
return new Observable(function (subscriber) {
var sub = new Subscription();
sub.add(scheduler.schedule(function () {
var observable$$1 = input[observable]();
sub.add(observable$$1.subscribe({
next: function (value) { sub.add(scheduler.schedule(function () { return subscriber.next(value); })); },
error: function (err) { sub.add(scheduler.schedule(function () { return subscriber.error(err); })); },
complete: function () { sub.add(scheduler.schedule(function () { return subscriber.complete(); })); },
}));
}));
return sub;
});
}
function schedulePromise(input, scheduler) {
return new Observable(function (subscriber) {
var sub = new Subscription();
sub.add(scheduler.schedule(function () { return input.then(function (value) {
sub.add(scheduler.schedule(function () {
subscriber.next(value);
sub.add(scheduler.schedule(function () { return subscriber.complete(); }));
}));
}, function (err) {
sub.add(scheduler.schedule(function () { return subscriber.error(err); }));
}); }));
return sub;
});
}
function scheduleIterable(input, scheduler) {
if (!input) {
throw new Error('Iterable cannot be null');
}
return new Observable(function (subscriber) {
var sub = new Subscription();
var iterator$$1;
sub.add(function () {
if (iterator$$1 && typeof iterator$$1.return === 'function') {
iterator$$1.return();
}
});
sub.add(scheduler.schedule(function () {
iterator$$1 = input[iterator]();
sub.add(scheduler.schedule(function () {
if (subscriber.closed) {
return;
}
var value;
var done;
try {
var result = iterator$$1.next();
value = result.value;
done = result.done;
}
catch (err) {
subscriber.error(err);
return;
}
if (done) {
subscriber.complete();
}
else {
subscriber.next(value);
this.schedule();
}
}));
}));
return sub;
});
}
function isInteropObservable(input) {
return input && typeof input[observable] === 'function';
}
function isIterable(input) {
return input && typeof input[iterator] === 'function';
}
function scheduled(input, scheduler) {
if (input != null) {
if (isInteropObservable(input)) {
return scheduleObservable(input, scheduler);
}
else if (isPromise(input)) {
return schedulePromise(input, scheduler);
}
else if (isArrayLike(input)) {
return scheduleArray(input, scheduler);
}
else if (isIterable(input) || typeof input === 'string') {
return scheduleIterable(input, scheduler);
}
}
throw new TypeError((input !== null && typeof input || input) + ' is not observable');
}
function from(input, scheduler) {
if (!scheduler) {
if (input instanceof Observable) {
return input;
}
return new Observable(subscribeTo(input));
}
else {
return scheduled(input, scheduler);
}
}
var SimpleInnerSubscriber = (function (_super) {
__extends(SimpleInnerSubscriber, _super);
function SimpleInnerSubscriber(parent) {
var _this = _super.call(this) || this;
_this.parent = parent;
return _this;
}
SimpleInnerSubscriber.prototype._next = function (value) {
this.parent.notifyNext(value);
};
SimpleInnerSubscriber.prototype._error = function (error) {
this.parent.notifyError(error);
this.unsubscribe();
};
SimpleInnerSubscriber.prototype._complete = function () {
this.parent.notifyComplete();
this.unsubscribe();
};
return SimpleInnerSubscriber;
}(Subscriber));
var ComplexInnerSubscriber = (function (_super) {
__extends(ComplexInnerSubscriber, _super);
function ComplexInnerSubscriber(parent, outerValue, outerIndex) {
var _this = _super.call(this) || this;
_this.parent = parent;
_this.outerValue = outerValue;
_this.outerIndex = outerIndex;
return _this;
}
ComplexInnerSubscriber.prototype._next = function (value) {
this.parent.notifyNext(this.outerValue, value, this.outerIndex, this);
};
ComplexInnerSubscriber.prototype._error = function (error) {
this.parent.notifyError(error);
this.unsubscribe();
};
ComplexInnerSubscriber.prototype._complete = function () {
this.parent.notifyComplete(this);
this.unsubscribe();
};
return ComplexInnerSubscriber;
}(Subscriber));
var SimpleOuterSubscriber = (function (_super) {
__extends(SimpleOuterSubscriber, _super);
function SimpleOuterSubscriber() {
return _super !== null && _super.apply(this, arguments) || this;
}
SimpleOuterSubscriber.prototype.notifyNext = function (innerValue) {
this.destination.next(innerValue);
};
SimpleOuterSubscriber.prototype.notifyError = function (err) {
this.destination.error(err);
};
SimpleOuterSubscriber.prototype.notifyComplete = function () {
this.destination.complete();
};
return SimpleOuterSubscriber;
}(Subscriber));
var ComplexOuterSubscriber = (function (_super) {
__extends(ComplexOuterSubscriber, _super);
function ComplexOuterSubscriber() {
return _super !== null && _super.apply(this, arguments) || this;
}
ComplexOuterSubscriber.prototype.notifyNext = function (_outerValue, innerValue, _outerIndex, _innerSub) {
this.destination.next(innerValue);
};
ComplexOuterSubscriber.prototype.notifyError = function (error) {
this.destination.error(error);
};
ComplexOuterSubscriber.prototype.notifyComplete = function (_innerSub) {
this.destination.complete();
};
return ComplexOuterSubscriber;
}(Subscriber));
function innerSubscribe(result, innerSubscriber) {
if (innerSubscriber.closed) {
return undefined;
}
if (result instanceof Observable) {
return result.subscribe(innerSubscriber);
}
return subscribeTo(result)(innerSubscriber);
}
function mergeMap(project, resultSelector, concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
if (typeof resultSelector === 'function') {
return function (source) { return source.pipe(mergeMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); }, concurrent)); };
}
else if (typeof resultSelector === 'number') {
concurrent = resultSelector;
}
return function (source) { return source.lift(new MergeMapOperator(project, concurrent)); };
}
var MergeMapOperator = (function () {
function MergeMapOperator(project, concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
this.project = project;
this.concurrent = concurrent;
}
MergeMapOperator.prototype.call = function (observer, source) {
return source.subscribe(new MergeMapSubscriber(observer, this.project, this.concurrent));
};
return MergeMapOperator;
}());
var MergeMapSubscriber = (function (_super) {
__extends(MergeMapSubscriber, _super);
function MergeMapSubscriber(destination, project, concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
var _this = _super.call(this, destination) || this;
_this.project = project;
_this.concurrent = concurrent;
_this.hasCompleted = false;
_this.buffer = [];
_this.active = 0;
_this.index = 0;
return _this;
}
MergeMapSubscriber.prototype._next = function (value) {
if (this.active < this.concurrent) {
this._tryNext(value);
}
else {
this.buffer.push(value);
}
};
MergeMapSubscriber.prototype._tryNext = function (value) {
var result;
var index = this.index++;
try {
result = this.project(value, index);
}
catch (err) {
this.destination.error(err);
return;
}
this.active++;
this._innerSub(result);
};
MergeMapSubscriber.prototype._innerSub = function (ish) {
var innerSubscriber = new SimpleInnerSubscriber(this);
var destination = this.destination;
destination.add(innerSubscriber);
var innerSubscription = innerSubscribe(ish, innerSubscriber);
if (innerSubscription !== innerSubscriber) {
destination.add(innerSubscription);
}
};
MergeMapSubscriber.prototype._complete = function () {
this.hasCompleted = true;
if (this.active === 0 && this.buffer.length === 0) {
this.destination.complete();
}
this.unsubscribe();
};
MergeMapSubscriber.prototype.notifyNext = function (innerValue) {
this.destination.next(innerValue);
};
MergeMapSubscriber.prototype.notifyComplete = function () {
var buffer = this.buffer;
this.active--;
if (buffer.length > 0) {
this._next(buffer.shift());
}
else if (this.active === 0 && this.hasCompleted) {
this.destination.complete();
}
};
return MergeMapSubscriber;
}(SimpleOuterSubscriber));
var flatMap = mergeMap;
function mergeAll(concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
return mergeMap(identity, concurrent);
}
function concatAll() {
return mergeAll(1);
}
function concat() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
return concatAll()(of.apply(void 0, observables));
}
function defer(observableFactory) {
return new Observable(function (subscriber) {
var input;
try {
input = observableFactory();
}
catch (err) {
subscriber.error(err);
return undefined;
}
var source = input ? from(input) : empty$1();
return source.subscribe(subscriber);
});
}
function forkJoin() {
var sources = [];
for (var _i = 0; _i < arguments.length; _i++) {
sources[_i] = arguments[_i];
}
if (sources.length === 1) {
var first_1 = sources[0];
if (isArray(first_1)) {
return forkJoinInternal(first_1, null);
}
if (isObject(first_1) && Object.getPrototypeOf(first_1) === Object.prototype) {
var keys = Object.keys(first_1);
return forkJoinInternal(keys.map(function (key) { return first_1[key]; }), keys);
}
}
if (typeof sources[sources.length - 1] === 'function') {
var resultSelector_1 = sources.pop();
sources = (sources.length === 1 && isArray(sources[0])) ? sources[0] : sources;
return forkJoinInternal(sources, null).pipe(map(function (args) { return resultSelector_1.apply(void 0, args); }));
}
return forkJoinInternal(sources, null);
}
function forkJoinInternal(sources, keys) {
return new Observable(function (subscriber) {
var len = sources.length;
if (len === 0) {
subscriber.complete();
return;
}
var values = new Array(len);
var completed = 0;
var emitted = 0;
var _loop_1 = function (i) {
var source = from(sources[i]);
var hasValue = false;
subscriber.add(source.subscribe({
next: function (value) {
if (!hasValue) {
hasValue = true;
emitted++;
}
values[i] = value;
},
error: function (err) { return subscriber.error(err); },
complete: function () {
completed++;
if (completed === len || !hasValue) {
if (emitted === len) {
subscriber.next(keys ?
keys.reduce(function (result, key, i) { return (result[key] = values[i], result); }, {}) :
values);
}
subscriber.complete();
}
}
}));
};
for (var i = 0; i < len; i++) {
_loop_1(i);
}
});
}
function fromEvent(target, eventName, options, resultSelector) {
if (isFunction(options)) {
resultSelector = options;
options = undefined;
}
if (resultSelector) {
return fromEvent(target, eventName, options).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); }));
}
return new Observable(function (subscriber) {
function handler(e) {
if (arguments.length > 1) {
subscriber.next(Array.prototype.slice.call(arguments));
}
else {
subscriber.next(e);
}
}
setupSubscription(target, eventName, handler, subscriber, options);
});
}
function setupSubscription(sourceObj, eventName, handler, subscriber, options) {
var unsubscribe;
if (isEventTarget(sourceObj)) {
var source_1 = sourceObj;
sourceObj.addEventListener(eventName, handler, options);
unsubscribe = function () { return source_1.removeEventListener(eventName, handler, options); };
}
else if (isJQueryStyleEventEmitter(sourceObj)) {
var source_2 = sourceObj;
sourceObj.on(eventName, handler);
unsubscribe = function () { return source_2.off(eventName, handler); };
}
else if (isNodeStyleEventEmitter(sourceObj)) {
var source_3 = sourceObj;
sourceObj.addListener(eventName, handler);
unsubscribe = function () { return source_3.removeListener(eventName, handler); };
}
else if (sourceObj && sourceObj.length) {
for (var i = 0, len = sourceObj.length; i < len; i++) {
setupSubscription(sourceObj[i], eventName, handler, subscriber, options);
}
}
else {
throw new TypeError('Invalid event target');
}
subscriber.add(unsubscribe);
}
function isNodeStyleEventEmitter(sourceObj) {
return sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';
}
function isJQueryStyleEventEmitter(sourceObj) {
return sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';
}
function isEventTarget(sourceObj) {
return sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';
}
function fromEventPattern(addHandler, removeHandler, resultSelector) {
if (resultSelector) {
return fromEventPattern(addHandler, removeHandler).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); }));
}
return new Observable(function (subscriber) {
var handler = function () {
var e = [];
for (var _i = 0; _i < arguments.length; _i++) {
e[_i] = arguments[_i];
}
return subscriber.next(e.length === 1 ? e[0] : e);
};
var retValue;
try {
retValue = addHandler(handler);
}
catch (err) {
subscriber.error(err);
return undefined;
}
if (!isFunction(removeHandler)) {
return undefined;
}
return function () { return removeHandler(handler, retValue); };
});
}
function generate(initialStateOrOptions, condition, iterate, resultSelectorOrObservable, scheduler) {
var resultSelector;
var initialState;
if (arguments.length == 1) {
var options = initialStateOrOptions;
initialState = options.initialState;
condition = options.condition;
iterate = options.iterate;
resultSelector = options.resultSelector || identity;
scheduler = options.scheduler;
}
else if (resultSelectorOrObservable === undefined || isScheduler(resultSelectorOrObservable)) {
initialState = initialStateOrOptions;
resultSelector = identity;
scheduler = resultSelectorOrObservable;
}
else {
initialState = initialStateOrOptions;
resultSelector = resultSelectorOrObservable;
}
return new Observable(function (subscriber) {
var state = initialState;
if (scheduler) {
return scheduler.schedule(dispatch$3, 0, {
subscriber: subscriber,
iterate: iterate,
condition: condition,
resultSelector: resultSelector,
state: state
});
}
do {
if (condition) {
var conditionResult = void 0;
try {
conditionResult = condition(state);
}
catch (err) {
subscriber.error(err);
return undefined;
}
if (!conditionResult) {
subscriber.complete();
break;
}
}
var value = void 0;
try {
value = resultSelector(state);
}
catch (err) {
subscriber.error(err);
return undefined;
}
subscriber.next(value);
if (subscriber.closed) {
break;
}
try {
state = iterate(state);
}
catch (err) {
subscriber.error(err);
return undefined;
}
} while (true);
return undefined;
});
}
function dispatch$3(state) {
var subscriber = state.subscriber, condition = state.condition;
if (subscriber.closed) {
return undefined;
}
if (state.needIterate) {
try {
state.state = state.iterate(state.state);
}
catch (err) {
subscriber.error(err);
return undefined;
}
}
else {
state.needIterate = true;
}
if (condition) {
var conditionResult = void 0;
try {
conditionResult = condition(state.state);
}
catch (err) {
subscriber.error(err);
return undefined;
}
if (!conditionResult) {
subscriber.complete();
return undefined;
}
if (subscriber.closed) {
return undefined;
}
}
var value;
try {
value = state.resultSelector(state.state);
}
catch (err) {
subscriber.error(err);
return undefined;
}
if (subscriber.closed) {
return undefined;
}
subscriber.next(value);
if (subscriber.closed) {
return undefined;
}
return this.schedule(state);
}
function iif(condition, trueResult, falseResult) {
if (trueResult === void 0) { trueResult = EMPTY; }
if (falseResult === void 0) { falseResult = EMPTY; }
return defer(function () { return condition() ? trueResult : falseResult; });
}
function isNumeric(val) {
return !isArray(val) && (val - parseFloat(val) + 1) >= 0;
}
function interval(period, scheduler) {
if (period === void 0) { period = 0; }
if (scheduler === void 0) { scheduler = async; }
if (!isNumeric(period) || period < 0) {
period = 0;
}
if (!scheduler || typeof scheduler.schedule !== 'function') {
scheduler = async;
}
return new Observable(function (subscriber) {
subscriber.add(scheduler.schedule(dispatch$4, period, { subscriber: subscriber, counter: 0, period: period }));
return subscriber;
});
}
function dispatch$4(state) {
var subscriber = state.subscriber, counter = state.counter, period = state.period;
subscriber.next(counter);
this.schedule({ subscriber: subscriber, counter: counter + 1, period: period }, period);
}
function merge() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
var concurrent = Number.POSITIVE_INFINITY;
var scheduler = null;
var last = observables[observables.length - 1];
if (isScheduler(last)) {
scheduler = observables.pop();
if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') {
concurrent = observables.pop();
}
}
else if (typeof last === 'number') {
concurrent = observables.pop();
}
if (scheduler === null && observables.length === 1 && observables[0] instanceof Observable) {
return observables[0];
}
return mergeAll(concurrent)(fromArray(observables, scheduler));
}
var NEVER = new Observable(noop);
function never() {
return NEVER;
}
function onErrorResumeNext() {
var sources = [];
for (var _i = 0; _i < arguments.length; _i++) {
sources[_i] = arguments[_i];
}
if (sources.length === 0) {
return EMPTY;
}
var first = sources[0], remainder = sources.slice(1);
if (sources.length === 1 && isArray(first)) {
return onErrorResumeNext.apply(void 0, first);
}
return new Observable(function (subscriber) {
var subNext = function () { return subscriber.add(onErrorResumeNext.apply(void 0, remainder).subscribe(subscriber)); };
return from(first).subscribe({
next: function (value) { subscriber.next(value); },
error: subNext,
complete: subNext,
});
});
}
function pairs(obj, scheduler) {
if (!scheduler) {
return new Observable(function (subscriber) {
var keys = Object.keys(obj);
for (var i = 0; i < keys.length && !subscriber.closed; i++) {
var key = keys[i];
if (obj.hasOwnProperty(key)) {
subscriber.next([key, obj[key]]);
}
}
subscriber.complete();
});
}
else {
return new Observable(function (subscriber) {
var keys = Object.keys(obj);
var subscription = new Subscription();
subscription.add(scheduler.schedule(dispatch$5, 0, { keys: keys, index: 0, subscriber: subscriber, subscription: subscription, obj: obj }));
return subscription;
});
}
}
function dispatch$5(state) {
var keys = state.keys, index = state.index, subscriber = state.subscriber, subscription = state.subscription, obj = state.obj;
if (!subscriber.closed) {
if (index < keys.length) {
var key = keys[index];
subscriber.next([key, obj[key]]);
subscription.add(this.schedule({ keys: keys, index: index + 1, subscriber: subscriber, subscription: subscription, obj: obj }));
}
else {
subscriber.complete();
}
}
}
function not(pred, thisArg) {
function notPred() {
return !(notPred.pred.apply(notPred.thisArg, arguments));
}
notPred.pred = pred;
notPred.thisArg = thisArg;
return notPred;
}
function filter(predicate, thisArg) {
return function filterOperatorFunction(source) {
return source.lift(new FilterOperator(predicate, thisArg));
};
}
var FilterOperator = (function () {
function FilterOperator(predicate, thisArg) {
this.predicate = predicate;
this.thisArg = thisArg;
}
FilterOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
};
return FilterOperator;
}());
var FilterSubscriber = (function (_super) {
__extends(FilterSubscriber, _super);
function FilterSubscriber(destination, predicate, thisArg) {
var _this = _super.call(this, destination) || this;
_this.predicate = predicate;
_this.thisArg = thisArg;
_this.count = 0;
return _this;
}
FilterSubscriber.prototype._next = function (value) {
var result;
try {
result = this.predicate.call(this.thisArg, value, this.count++);
}
catch (err) {
this.destination.error(err);
return;
}
if (result) {
this.destination.next(value);
}
};
return FilterSubscriber;
}(Subscriber));
function partition(source, predicate, thisArg) {
return [
filter(predicate, thisArg)(new Observable(subscribeTo(source))),
filter(not(predicate, thisArg))(new Observable(subscribeTo(source)))
];
}
function race() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
if (observables.length === 1) {
if (isArray(observables[0])) {
observables = observables[0];
}
else {
return observables[0];
}
}
return fromArray(observables, undefined).lift(new RaceOperator());
}
var RaceOperator = (function () {
function RaceOperator() {
}
RaceOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new RaceSubscriber(subscriber));
};
return RaceOperator;
}());
var RaceSubscriber = (function (_super) {
__extends(RaceSubscriber, _super);
function RaceSubscriber(destination) {
var _this = _super.call(this, destination) || this;
_this.hasFirst = false;
_this.observables = [];
_this.subscriptions = [];
return _this;
}
RaceSubscriber.prototype._next = function (observable) {
this.observables.push(observable);
};
RaceSubscriber.prototype._complete = function () {
var observables = this.observables;
var len = observables.length;
if (len === 0) {
this.destination.complete();
}
else {
for (var i = 0; i < len && !this.hasFirst; i++) {
var observable = observables[i];
var subscription = subscribeToResult(this, observable, undefined, i);
if (this.subscriptions) {
this.subscriptions.push(subscription);
}
this.add(subscription);
}
this.observables = null;
}
};
RaceSubscriber.prototype.notifyNext = function (_outerValue, innerValue, outerIndex) {
if (!this.hasFirst) {
this.hasFirst = true;
for (var i = 0; i < this.subscriptions.length; i++) {
if (i !== outerIndex) {
var subscription = this.subscriptions[i];
subscription.unsubscribe();
this.remove(subscription);
}
}
this.subscriptions = null;
}
this.destination.next(innerValue);
};
return RaceSubscriber;
}(OuterSubscriber));
function range(start, count, scheduler) {
if (start === void 0) { start = 0; }
return new Observable(function (subscriber) {
if (count === undefined) {
count = start;
start = 0;
}
var index = 0;
var current = start;
if (scheduler) {
return scheduler.schedule(dispatch$6, 0, {
index: index, count: count, start: start, subscriber: subscriber
});
}
else {
do {
if (index++ >= count) {
subscriber.complete();
break;
}
subscriber.next(current++);
if (subscriber.closed) {
break;
}
} while (true);
}
return undefined;
});
}
function dispatch$6(state) {
var start = state.start, index = state.index, count = state.count, subscriber = state.subscriber;
if (index >= count) {
subscriber.complete();
return;
}
subscriber.next(start);
if (subscriber.closed) {
return;
}
state.index = index + 1;
state.start = start + 1;
this.schedule(state);
}
function timer(dueTime, periodOrScheduler, scheduler) {
if (dueTime === void 0) { dueTime = 0; }
var period = -1;
if (isNumeric(periodOrScheduler)) {
period = Number(periodOrScheduler) < 1 && 1 || Number(periodOrScheduler);
}
else if (isScheduler(periodOrScheduler)) {
scheduler = periodOrScheduler;
}
if (!isScheduler(scheduler)) {
scheduler = async;
}
return new Observable(function (subscriber) {
var due = isNumeric(dueTime)
? dueTime
: (+dueTime - scheduler.now());
return scheduler.schedule(dispatch$7, due, {
index: 0, period: period, subscriber: subscriber
});
});
}
function dispatch$7(state) {
var index = state.index, period = state.period, subscriber = state.subscriber;
subscriber.next(index);
if (subscriber.closed) {
return;
}
else if (period === -1) {
return subscriber.complete();
}
state.index = index + 1;
this.schedule(state, period);
}
function using(resourceFactory, observableFactory) {
return new Observable(function (subscriber) {
var resource;
try {
resource = resourceFactory();
}
catch (err) {
subscriber.error(err);
return undefined;
}
var result;
try {
result = observableFactory(resource);
}
catch (err) {
subscriber.error(err);
return undefined;
}
var source = result ? from(result) : EMPTY;
var subscription = source.subscribe(subscriber);
return function () {
subscription.unsubscribe();
if (resource) {
resource.unsubscribe();
}
};
});
}
function zip() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
var resultSelector = observables[observables.length - 1];
if (typeof resultSelector === 'function') {
observables.pop();
}
return fromArray(observables, undefined).lift(new ZipOperator(resultSelector));
}
var ZipOperator = (function () {
function ZipOperator(resultSelector) {
this.resultSelector = resultSelector;
}
ZipOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new ZipSubscriber(subscriber, this.resultSelector));
};
return ZipOperator;
}());
var ZipSubscriber = (function (_super) {
__extends(ZipSubscriber, _super);
function ZipSubscriber(destination, resultSelector, values) {
if (values === void 0) { values = Object.create(null); }
var _this = _super.call(this, destination) || this;
_this.resultSelector = resultSelector;
_this.iterators = [];
_this.active = 0;
_this.resultSelector = (typeof resultSelector === 'function') ? resultSelector : undefined;
return _this;
}
ZipSubscriber.prototype._next = function (value) {
var iterators = this.iterators;
if (isArray(value)) {
iterators.push(new StaticArrayIterator(value));
}
else if (typeof value[iterator] === 'function') {
iterators.push(new StaticIterator(value[iterator]()));
}
else {
iterators.push(new ZipBufferIterator(this.destination, this, value));
}
};
ZipSubscriber.prototype._complete = function () {
var iterators = this.iterators;
var len = iterators.length;
this.unsubscribe();
if (len === 0) {
this.destination.complete();
return;
}
this.active = len;
for (var i = 0; i < len; i++) {
var iterator$$1 = iterators[i];
if (iterator$$1.stillUnsubscribed) {
var destination = this.destination;
destination.add(iterator$$1.subscribe());
}
else {
this.active--;
}
}
};
ZipSubscriber.prototype.notifyInactive = function () {
this.active--;
if (this.active === 0) {
this.destination.complete();
}
};
ZipSubscriber.prototype.checkIterators = function () {
var iterators = this.iterators;
var len = iterators.length;
var destination = this.destination;
for (var i = 0; i < len; i++) {
var iterator$$1 = iterators[i];
if (typeof iterator$$1.hasValue === 'function' && !iterator$$1.hasValue()) {
return;
}
}
var shouldComplete = false;
var args = [];
for (var i = 0; i < len; i++) {
var iterator$$1 = iterators[i];
var result = iterator$$1.next();
if (iterator$$1.hasCompleted()) {
shouldComplete = true;
}
if (result.done) {
destination.complete();
return;
}
args.push(result.value);
}
if (this.resultSelector) {
this._tryresultSelector(args);
}
else {
destination.next(args);
}
if (shouldComplete) {
destination.complete();
}
};
ZipSubscriber.prototype._tryresultSelector = function (args) {
var result;
try {
result = this.resultSelector.apply(this, args);
}
catch (err) {
this.destination.error(err);
return;
}
this.destination.next(result);
};
return ZipSubscriber;
}(Subscriber));
var StaticIterator = (function () {
function StaticIterator(iterator$$1) {
this.iterator = iterator$$1;
this.nextResult = iterator$$1.next();
}
StaticIterator.prototype.hasValue = function () {
return true;
};
StaticIterator.prototype.next = function () {
var result = this.nextResult;
this.nextResult = this.iterator.next();
return result;
};
StaticIterator.prototype.hasCompleted = function () {
var nextResult = this.nextResult;
return Boolean(nextResult && nextResult.done);
};
return StaticIterator;
}());
var StaticArrayIterator = (function () {
function StaticArrayIterator(array) {
this.array = array;
this.index = 0;
this.length = 0;
this.length = array.length;
}
StaticArrayIterator.prototype[iterator] = function () {
return this;
};
StaticArrayIterator.prototype.next = function (value) {
var i = this.index++;
var array = this.array;
return i < this.length ? { value: array[i], done: false } : { value: null, done: true };
};
StaticArrayIterator.prototype.hasValue = function () {
return this.array.length > this.index;
};
StaticArrayIterator.prototype.hasCompleted = function () {
return this.array.length === this.index;
};
return StaticArrayIterator;
}());
var ZipBufferIterator = (function (_super) {
__extends(ZipBufferIterator, _super);
function ZipBufferIterator(destination, parent, observable) {
var _this = _super.call(this, destination) || this;
_this.parent = parent;
_this.observable = observable;
_this.stillUnsubscribed = true;
_this.buffer = [];
_this.isComplete = false;
return _this;
}
ZipBufferIterator.prototype[iterator] = function () {
return this;
};
ZipBufferIterator.prototype.next = function () {
var buffer = this.buffer;
if (buffer.length === 0 && this.isComplete) {
return { value: null, done: true };
}
else {
return { value: buffer.shift(), done: false };
}
};
ZipBufferIterator.prototype.hasValue = function () {
return this.buffer.length > 0;
};
ZipBufferIterator.prototype.hasCompleted = function () {
return this.buffer.length === 0 && this.isComplete;
};
ZipBufferIterator.prototype.notifyComplete = function () {
if (this.buffer.length > 0) {
this.isComplete = true;
this.parent.notifyInactive();
}
else {
this.destination.complete();
}
};
ZipBufferIterator.prototype.notifyNext = function (innerValue) {
this.buffer.push(innerValue);
this.parent.checkIterators();
};
ZipBufferIterator.prototype.subscribe = function () {
return innerSubscribe(this.observable, new SimpleInnerSubscriber(this));
};
return ZipBufferIterator;
}(SimpleOuterSubscriber));
function audit(durationSelector) {
return function auditOperatorFunction(source) {
return source.lift(new AuditOperator(durationSelector));
};
}
var AuditOperator = (function () {
function AuditOperator(durationSelector) {
this.durationSelector = durationSelector;
}
AuditOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new AuditSubscriber(subscriber, this.durationSelector));
};
return AuditOperator;
}());
var AuditSubscriber = (function (_super) {
__extends(AuditSubscriber, _super);
function AuditSubscriber(destination, durationSelector) {
var _this = _super.call(this, destination) || this;
_this.durationSelector = durationSelector;
_this.hasValue = false;
return _this;
}
AuditSubscriber.prototype._next = function (value) {
this.value = value;
this.hasValue = true;
if (!this.throttled) {
var duration = void 0;
try {
var durationSelector = this.durationSelector;
duration = durationSelector(value);
}
catch (err) {
return this.destination.error(err);
}
var innerSubscription = innerSubscribe(duration, new SimpleInnerSubscriber(this));
if (!innerSubscription || innerSubscription.closed) {
this.clearThrottle();
}
else {
this.add(this.throttled = innerSubscription);
}
}
};
AuditSubscriber.prototype.clearThrottle = function () {
var _a = this, value = _a.value, hasValue = _a.hasValue, throttled = _a.throttled;
if (throttled) {
this.remove(throttled);
this.throttled = undefined;
throttled.unsubscribe();
}
if (hasValue) {
this.value = undefined;
this.hasValue = false;
this.destination.next(value);
}
};
AuditSubscriber.prototype.notifyNext = function () {
this.clearThrottle();
};
AuditSubscriber.prototype.notifyComplete = function () {
this.clearThrottle();
};
return AuditSubscriber;
}(SimpleOuterSubscriber));
function auditTime(duration, scheduler) {
if (scheduler === void 0) { scheduler = async; }
return audit(function () { return timer(duration, scheduler); });
}
function buffer(closingNotifier) {
return function bufferOperatorFunction(source) {
return source.lift(new BufferOperator(closingNotifier));
};
}
var BufferOperator = (function () {
function BufferOperator(closingNotifier) {
this.closingNotifier = closingNotifier;
}
BufferOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new BufferSubscriber(subscriber, this.closingNotifier));
};
return BufferOperator;
}());
var BufferSubscriber = (function (_super) {
__extends(BufferSubscriber, _super);
function BufferSubscriber(destination, closingNotifier) {
var _this = _super.call(this, destination) || this;
_this.buffer = [];
_this.add(innerSubscribe(closingNotifier, new SimpleInnerSubscriber(_this)));
return _this;
}
BufferSubscriber.prototype._next = function (value) {
this.buffer.push(value);
};
BufferSubscriber.prototype.notifyNext = function () {
var buffer = this.buffer;
this.buffer = [];
this.destination.next(buffer);
};
return BufferSubscriber;
}(SimpleOuterSubscriber));
function bufferCount(bufferSize, startBufferEvery) {
if (startBufferEvery === void 0) { startBufferEvery = null; }
return function bufferCountOperatorFunction(source) {
return source.lift(new BufferCountOperator(bufferSize, startBufferEvery));
};
}
var BufferCountOperator = (function () {
function BufferCountOperator(bufferSize, startBufferEvery) {
this.bufferSize = bufferSize;
this.startBufferEvery = startBufferEvery;
if (!startBufferEvery || bufferSize === startBufferEvery) {
this.subscriberClass = BufferCountSubscriber;
}
else {
this.subscriberClass = BufferSkipCountSubscriber;
}
}
BufferCountOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new this.subscriberClass(subscriber, this.bufferSize, this.startBufferEvery));
};
return BufferCountOperator;
}());
var BufferCountSubscriber = (function (_super) {
__extends(BufferCountSubscriber, _super);
function BufferCountSubscriber(destination, bufferSize) {
var _this = _super.call(this, destination) || this;
_this.bufferSize = bufferSize;
_this.buffer = [];
return _this;
}
BufferCountSubscriber.prototype._next = function (value) {
var buffer = this.buffer;
buffer.push(value);
if (buffer.length == this.bufferSize) {
this.destination.next(buffer);
this.buffer = [];
}
};
BufferCountSubscriber.prototype._complete = function () {
var buffer = this.buffer;
if (buffer.length > 0) {
this.destination.next(buffer);
}
_super.prototype._complete.call(this);
};
return BufferCountSubscriber;
}(Subscriber));
var BufferSkipCountSubscriber = (function (_super) {
__extends(BufferSkipCountSubscriber, _super);
function BufferSkipCountSubscriber(destination, bufferSize, startBufferEvery) {
var _this = _super.call(this, destination) || this;
_this.bufferSize = bufferSize;
_this.startBufferEvery = startBufferEvery;
_this.buffers = [];
_this.count = 0;
return _this;
}
BufferSkipCountSubscriber.prototype._next = function (value) {
var _a = this, bufferSize = _a.bufferSize, startBufferEvery = _a.startBufferEvery, buffers = _a.buffers, count = _a.count;
this.count++;
if (count % startBufferEvery === 0) {
buffers.push([]);
}
for (var i = buffers.length; i--;) {
var buffer = buffers[i];
buffer.push(value);
if (buffer.length === bufferSize) {
buffers.splice(i, 1);
this.destination.next(buffer);
}
}
};
BufferSkipCountSubscriber.prototype._complete = function () {
var _a = this, buffers = _a.buffers, destination = _a.destination;
while (buffers.length > 0) {
var buffer = buffers.shift();
if (buffer.length > 0) {
destination.next(buffer);
}
}
_super.prototype._complete.call(this);
};
return BufferSkipCountSubscriber;
}(Subscriber));
function bufferTime(bufferTimeSpan) {
var length = arguments.length;
var scheduler = async;
if (isScheduler(arguments[arguments.length - 1])) {
scheduler = arguments[arguments.length - 1];
length--;
}
var bufferCreationInterval = null;
if (length >= 2) {
bufferCreationInterval = arguments[1];
}
var maxBufferSize = Number.POSITIVE_INFINITY;
if (length >= 3) {
maxBufferSize = arguments[2];
}
return function bufferTimeOperatorFunction(source) {
return source.lift(new BufferTimeOperator(bufferTimeSpan, bufferCreationInterval, maxBufferSize, scheduler));
};
}
var BufferTimeOperator = (function () {
function BufferTimeOperator(bufferTimeSpan, bufferCreationInterval, maxBufferSize, scheduler) {
this.bufferTimeSpan = bufferTimeSpan;
this.bufferCreationInterval = bufferCreationInterval;
this.maxBufferSize = maxBufferSize;
this.scheduler = scheduler;
}
BufferTimeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new BufferTimeSubscriber(subscriber, this.bufferTimeSpan, this.bufferCreationInterval, this.maxBufferSize, this.scheduler));
};
return BufferTimeOperator;
}());
var Context = (function () {
function Context() {
this.buffer = [];
}
return Context;
}());
var BufferTimeSubscriber = (function (_super) {
__extends(BufferTimeSubscriber, _super);
function BufferTimeSubscriber(destination, bufferTimeSpan, bufferCreationInterval, maxBufferSize, scheduler) {
var _this = _super.call(this, destination) || this;
_this.bufferTimeSpan = bufferTimeSpan;
_this.bufferCreationInterval = bufferCreationInterval;
_this.maxBufferSize = maxBufferSize;
_this.scheduler = scheduler;
_this.contexts = [];
var context = _this.openContext();
_this.timespanOnly = bufferCreationInterval == null || bufferCreationInterval < 0;
if (_this.timespanOnly) {
var timeSpanOnlyState = { subscriber: _this, context: context, bufferTimeSpan: bufferTimeSpan };
_this.add(context.closeAction = scheduler.schedule(dispatchBufferTimeSpanOnly, bufferTimeSpan, timeSpanOnlyState));
}
else {
var closeState = { subscriber: _this, context: context };
var creationState = { bufferTimeSpan: bufferTimeSpan, bufferCreationInterval: bufferCreationInterval, subscriber: _this, scheduler: scheduler };
_this.add(context.closeAction = scheduler.schedule(dispatchBufferClose, bufferTimeSpan, closeState));
_this.add(scheduler.schedule(dispatchBufferCreation, bufferCreationInterval, creationState));
}
return _this;
}
BufferTimeSubscriber.prototype._next = function (value) {
var contexts = this.contexts;
var len = contexts.length;
var filledBufferContext;
for (var i = 0; i < len; i++) {
var context_1 = contexts[i];
var buffer = context_1.buffer;
buffer.push(value);
if (buffer.length == this.maxBufferSize) {
filledBufferContext = context_1;
}
}
if (filledBufferContext) {
this.onBufferFull(filledBufferContext);
}
};
BufferTimeSubscriber.prototype._error = function (err) {
this.contexts.length = 0;
_super.prototype._error.call(this, err);
};
BufferTimeSubscriber.prototype._complete = function () {
var _a = this, contexts = _a.contexts, destination = _a.destination;
while (contexts.length > 0) {
var context_2 = contexts.shift();
destination.next(context_2.buffer);
}
_super.prototype._complete.call(this);
};
BufferTimeSubscriber.prototype._unsubscribe = function () {
this.contexts = null;
};
BufferTimeSubscriber.prototype.onBufferFull = function (context) {
this.closeContext(context);
var closeAction = context.closeAction;
closeAction.unsubscribe();
this.remove(closeAction);
if (!this.closed && this.timespanOnly) {
context = this.openContext();
var bufferTimeSpan = this.bufferTimeSpan;
var timeSpanOnlyState = { subscriber: this, context: context, bufferTimeSpan: bufferTimeSpan };
this.add(context.closeAction = this.scheduler.schedule(dispatchBufferTimeSpanOnly, bufferTimeSpan, timeSpanOnlyState));
}
};
BufferTimeSubscriber.prototype.openContext = function () {
var context = new Context();
this.contexts.push(context);
return context;
};
BufferTimeSubscriber.prototype.closeContext = function (context) {
this.destination.next(context.buffer);
var contexts = this.contexts;
var spliceIndex = contexts ? contexts.indexOf(context) : -1;
if (spliceIndex >= 0) {
contexts.splice(contexts.indexOf(context), 1);
}
};
return BufferTimeSubscriber;
}(Subscriber));
function dispatchBufferTimeSpanOnly(state) {
var subscriber = state.subscriber;
var prevContext = state.context;
if (prevContext) {
subscriber.closeContext(prevContext);
}
if (!subscriber.closed) {
state.context = subscriber.openContext();
state.context.closeAction = this.schedule(state, state.bufferTimeSpan);
}
}
function dispatchBufferCreation(state) {
var bufferCreationInterval = state.bufferCreationInterval, bufferTimeSpan = state.bufferTimeSpan, subscriber = state.subscriber, scheduler = state.scheduler;
var context = subscriber.openContext();
var action = this;
if (!subscriber.closed) {
subscriber.add(context.closeAction = scheduler.schedule(dispatchBufferClose, bufferTimeSpan, { subscriber: subscriber, context: context }));
action.schedule(state, bufferCreationInterval);
}
}
function dispatchBufferClose(arg) {
var subscriber = arg.subscriber, context = arg.context;
subscriber.closeContext(context);
}
function bufferToggle(openings, closingSelector) {
return function bufferToggleOperatorFunction(source) {
return source.lift(new BufferToggleOperator(openings, closingSelector));
};
}
var BufferToggleOperator = (function () {
function BufferToggleOperator(openings, closingSelector) {
this.openings = openings;
this.closingSelector = closingSelector;
}
BufferToggleOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new BufferToggleSubscriber(subscriber, this.openings, this.closingSelector));
};
return BufferToggleOperator;
}());
var BufferToggleSubscriber = (function (_super) {
__extends(BufferToggleSubscriber, _super);
function BufferToggleSubscriber(destination, openings, closingSelector) {
var _this = _super.call(this, destination) || this;
_this.closingSelector = closingSelector;
_this.contexts = [];
_this.add(subscribeToResult(_this, openings));
return _this;
}
BufferToggleSubscriber.prototype._next = function (value) {
var contexts = this.contexts;
var len = contexts.length;
for (var i = 0; i < len; i++) {
contexts[i].buffer.push(value);
}
};
BufferToggleSubscriber.prototype._error = function (err) {
var contexts = this.contexts;
while (contexts.length > 0) {
var context_1 = contexts.shift();
context_1.subscription.unsubscribe();
context_1.buffer = null;
context_1.subscription = null;
}
this.contexts = null;
_super.prototype._error.call(this, err);
};
BufferToggleSubscriber.prototype._complete = function () {
var contexts = this.contexts;
while (contexts.length > 0) {
var context_2 = contexts.shift();
this.destination.next(context_2.buffer);
context_2.subscription.unsubscribe();
context_2.buffer = null;
context_2.subscription = null;
}
this.contexts = null;
_super.prototype._complete.call(this);
};
BufferToggleSubscriber.prototype.notifyNext = function (outerValue, innerValue) {
outerValue ? this.closeBuffer(outerValue) : this.openBuffer(innerValue);
};
BufferToggleSubscriber.prototype.notifyComplete = function (innerSub) {
this.closeBuffer(innerSub.context);
};
BufferToggleSubscriber.prototype.openBuffer = function (value) {
try {
var closingSelector = this.closingSelector;
var closingNotifier = closingSelector.call(this, value);
if (closingNotifier) {
this.trySubscribe(closingNotifier);
}
}
catch (err) {
this._error(err);
}
};
BufferToggleSubscriber.prototype.closeBuffer = function (context) {
var contexts = this.contexts;
if (contexts && context) {
var buffer = context.buffer, subscription = context.subscription;
this.destination.next(buffer);
contexts.splice(contexts.indexOf(context), 1);
this.remove(subscription);
subscription.unsubscribe();
}
};
BufferToggleSubscriber.prototype.trySubscribe = function (closingNotifier) {
var contexts = this.contexts;
var buffer = [];
var subscription = new Subscription();
var context = { buffer: buffer, subscription: subscription };
contexts.push(context);
var innerSubscription = subscribeToResult(this, closingNotifier, context);
if (!innerSubscription || innerSubscription.closed) {
this.closeBuffer(context);
}
else {
innerSubscription.context = context;
this.add(innerSubscription);
subscription.add(innerSubscription);
}
};
return BufferToggleSubscriber;
}(OuterSubscriber));
function bufferWhen(closingSelector) {
return function (source) {
return source.lift(new BufferWhenOperator(closingSelector));
};
}
var BufferWhenOperator = (function () {
function BufferWhenOperator(closingSelector) {
this.closingSelector = closingSelector;
}
BufferWhenOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new BufferWhenSubscriber(subscriber, this.closingSelector));
};
return BufferWhenOperator;
}());
var BufferWhenSubscriber = (function (_super) {
__extends(BufferWhenSubscriber, _super);
function BufferWhenSubscriber(destination, closingSelector) {
var _this = _super.call(this, destination) || this;
_this.closingSelector = closingSelector;
_this.subscribing = false;
_this.openBuffer();
return _this;
}
BufferWhenSubscriber.prototype._next = function (value) {
this.buffer.push(value);
};
BufferWhenSubscriber.prototype._complete = function () {
var buffer = this.buffer;
if (buffer) {
this.destination.next(buffer);
}
_super.prototype._complete.call(this);
};
BufferWhenSubscriber.prototype._unsubscribe = function () {
this.buffer = undefined;
this.subscribing = false;
};
BufferWhenSubscriber.prototype.notifyNext = function () {
this.openBuffer();
};
BufferWhenSubscriber.prototype.notifyComplete = function () {
if (this.subscribing) {
this.complete();
}
else {
this.openBuffer();
}
};
BufferWhenSubscriber.prototype.openBuffer = function () {
var closingSubscription = this.closingSubscription;
if (closingSubscription) {
this.remove(closingSubscription);
closingSubscription.unsubscribe();
}
var buffer = this.buffer;
if (this.buffer) {
this.destination.next(buffer);
}
this.buffer = [];
var closingNotifier;
try {
var closingSelector = this.closingSelector;
closingNotifier = closingSelector();
}
catch (err) {
return this.error(err);
}
closingSubscription = new Subscription();
this.closingSubscription = closingSubscription;
this.add(closingSubscription);
this.subscribing = true;
closingSubscription.add(innerSubscribe(closingNotifier, new SimpleInnerSubscriber(this)));
this.subscribing = false;
};
return BufferWhenSubscriber;
}(SimpleOuterSubscriber));
function catchError(selector) {
return function catchErrorOperatorFunction(source) {
var operator = new CatchOperator(selector);
var caught = source.lift(operator);
return (operator.caught = caught);
};
}
var CatchOperator = (function () {
function CatchOperator(selector) {
this.selector = selector;
}
CatchOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new CatchSubscriber(subscriber, this.selector, this.caught));
};
return CatchOperator;
}());
var CatchSubscriber = (function (_super) {
__extends(CatchSubscriber, _super);
function CatchSubscriber(destination, selector, caught) {
var _this = _super.call(this, destination) || this;
_this.selector = selector;
_this.caught = caught;
return _this;
}
CatchSubscriber.prototype.error = function (err) {
if (!this.isStopped) {
var result = void 0;
try {
result = this.selector(err, this.caught);
}
catch (err2) {
_super.prototype.error.call(this, err2);
return;
}
this._unsubscribeAndRecycle();
var innerSubscriber = new SimpleInnerSubscriber(this);
this.add(innerSubscriber);
var innerSubscription = innerSubscribe(result, innerSubscriber);
if (innerSubscription !== innerSubscriber) {
this.add(innerSubscription);
}
}
};
return CatchSubscriber;
}(SimpleOuterSubscriber));
function combineAll(project) {
return function (source) { return source.lift(new CombineLatestOperator(project)); };
}
function combineLatest$1() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
var project = null;
if (typeof observables[observables.length - 1] === 'function') {
project = observables.pop();
}
if (observables.length === 1 && isArray(observables[0])) {
observables = observables[0].slice();
}
return function (source) { return source.lift.call(from([source].concat(observables)), new CombineLatestOperator(project)); };
}
function concat$1() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
return function (source) { return source.lift.call(concat.apply(void 0, [source].concat(observables))); };
}
function concatMap(project, resultSelector) {
return mergeMap(project, resultSelector, 1);
}
function concatMapTo(innerObservable, resultSelector) {
return concatMap(function () { return innerObservable; }, resultSelector);
}
function count(predicate) {
return function (source) { return source.lift(new CountOperator(predicate, source)); };
}
var CountOperator = (function () {
function CountOperator(predicate, source) {
this.predicate = predicate;
this.source = source;
}
CountOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new CountSubscriber(subscriber, this.predicate, this.source));
};
return CountOperator;
}());
var CountSubscriber = (function (_super) {
__extends(CountSubscriber, _super);
function CountSubscriber(destination, predicate, source) {
var _this = _super.call(this, destination) || this;
_this.predicate = predicate;
_this.source = source;
_this.count = 0;
_this.index = 0;
return _this;
}
CountSubscriber.prototype._next = function (value) {
if (this.predicate) {
this._tryPredicate(value);
}
else {
this.count++;
}
};
CountSubscriber.prototype._tryPredicate = function (value) {
var result;
try {
result = this.predicate(value, this.index++, this.source);
}
catch (err) {
this.destination.error(err);
return;
}
if (result) {
this.count++;
}
};
CountSubscriber.prototype._complete = function () {
this.destination.next(this.count);
this.destination.complete();
};
return CountSubscriber;
}(Subscriber));
function debounce(durationSelector) {
return function (source) { return source.lift(new DebounceOperator(durationSelector)); };
}
var DebounceOperator = (function () {
function DebounceOperator(durationSelector) {
this.durationSelector = durationSelector;
}
DebounceOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DebounceSubscriber(subscriber, this.durationSelector));
};
return DebounceOperator;
}());
var DebounceSubscriber = (function (_super) {
__extends(DebounceSubscriber, _super);
function DebounceSubscriber(destination, durationSelector) {
var _this = _super.call(this, destination) || this;
_this.durationSelector = durationSelector;
_this.hasValue = false;
return _this;
}
DebounceSubscriber.prototype._next = function (value) {
try {
var result = this.durationSelector.call(this, value);
if (result) {
this._tryNext(value, result);
}
}
catch (err) {
this.destination.error(err);
}
};
DebounceSubscriber.prototype._complete = function () {
this.emitValue();
this.destination.complete();
};
DebounceSubscriber.prototype._tryNext = function (value, duration) {
var subscription = this.durationSubscription;
this.value = value;
this.hasValue = true;
if (subscription) {
subscription.unsubscribe();
this.remove(subscription);
}
subscription = innerSubscribe(duration, new SimpleInnerSubscriber(this));
if (subscription && !subscription.closed) {
this.add(this.durationSubscription = subscription);
}
};
DebounceSubscriber.prototype.notifyNext = function () {
this.emitValue();
};
DebounceSubscriber.prototype.notifyComplete = function () {
this.emitValue();
};
DebounceSubscriber.prototype.emitValue = function () {
if (this.hasValue) {
var value = this.value;
var subscription = this.durationSubscription;
if (subscription) {
this.durationSubscription = undefined;
subscription.unsubscribe();
this.remove(subscription);
}
this.value = undefined;
this.hasValue = false;
_super.prototype._next.call(this, value);
}
};
return DebounceSubscriber;
}(SimpleOuterSubscriber));
function debounceTime(dueTime, scheduler) {
if (scheduler === void 0) { scheduler = async; }
return function (source) { return source.lift(new DebounceTimeOperator(dueTime, scheduler)); };
}
var DebounceTimeOperator = (function () {
function DebounceTimeOperator(dueTime, scheduler) {
this.dueTime = dueTime;
this.scheduler = scheduler;
}
DebounceTimeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DebounceTimeSubscriber(subscriber, this.dueTime, this.scheduler));
};
return DebounceTimeOperator;
}());
var DebounceTimeSubscriber = (function (_super) {
__extends(DebounceTimeSubscriber, _super);
function DebounceTimeSubscriber(destination, dueTime, scheduler) {
var _this = _super.call(this, destination) || this;
_this.dueTime = dueTime;
_this.scheduler = scheduler;
_this.debouncedSubscription = null;
_this.lastValue = null;
_this.hasValue = false;
return _this;
}
DebounceTimeSubscriber.prototype._next = function (value) {
this.clearDebounce();
this.lastValue = value;
this.hasValue = true;
this.add(this.debouncedSubscription = this.scheduler.schedule(dispatchNext$2, this.dueTime, this));
};
DebounceTimeSubscriber.prototype._complete = function () {
this.debouncedNext();
this.destination.complete();
};
DebounceTimeSubscriber.prototype.debouncedNext = function () {
this.clearDebounce();
if (this.hasValue) {
var lastValue = this.lastValue;
this.lastValue = null;
this.hasValue = false;
this.destination.next(lastValue);
}
};
DebounceTimeSubscriber.prototype.clearDebounce = function () {
var debouncedSubscription = this.debouncedSubscription;
if (debouncedSubscription !== null) {
this.remove(debouncedSubscription);
debouncedSubscription.unsubscribe();
this.debouncedSubscription = null;
}
};
return DebounceTimeSubscriber;
}(Subscriber));
function dispatchNext$2(subscriber) {
subscriber.debouncedNext();
}
function defaultIfEmpty(defaultValue) {
if (defaultValue === void 0) { defaultValue = null; }
return function (source) { return source.lift(new DefaultIfEmptyOperator(defaultValue)); };
}
var DefaultIfEmptyOperator = (function () {
function DefaultIfEmptyOperator(defaultValue) {
this.defaultValue = defaultValue;
}
DefaultIfEmptyOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DefaultIfEmptySubscriber(subscriber, this.defaultValue));
};
return DefaultIfEmptyOperator;
}());
var DefaultIfEmptySubscriber = (function (_super) {
__extends(DefaultIfEmptySubscriber, _super);
function DefaultIfEmptySubscriber(destination, defaultValue) {
var _this = _super.call(this, destination) || this;
_this.defaultValue = defaultValue;
_this.isEmpty = true;
return _this;
}
DefaultIfEmptySubscriber.prototype._next = function (value) {
this.isEmpty = false;
this.destination.next(value);
};
DefaultIfEmptySubscriber.prototype._complete = function () {
if (this.isEmpty) {
this.destination.next(this.defaultValue);
}
this.destination.complete();
};
return DefaultIfEmptySubscriber;
}(Subscriber));
function isDate(value) {
return value instanceof Date && !isNaN(+value);
}
function delay(delay, scheduler) {
if (scheduler === void 0) { scheduler = async; }
var absoluteDelay = isDate(delay);
var delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay);
return function (source) { return source.lift(new DelayOperator(delayFor, scheduler)); };
}
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;
}());
var DelaySubscriber = (function (_super) {
__extends(DelaySubscriber, _super);
function DelaySubscriber(destination, delay, scheduler) {
var _this = _super.call(this, destination) || this;
_this.delay = delay;
_this.scheduler = scheduler;
_this.queue = [];
_this.active = false;
_this.errored = false;
return _this;
}
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 {
this.unsubscribe();
source.active = false;
}
};
DelaySubscriber.prototype._schedule = function (scheduler) {
this.active = true;
var destination = this.destination;
destination.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.createNext(value));
};
DelaySubscriber.prototype._error = function (err) {
this.errored = true;
this.queue = [];
this.destination.error(err);
this.unsubscribe();
};
DelaySubscriber.prototype._complete = function () {
this.scheduleNotification(Notification.createComplete());
this.unsubscribe();
};
return DelaySubscriber;
}(Subscriber));
var DelayMessage = (function () {
function DelayMessage(time, notification) {
this.time = time;
this.notification = notification;
}
return DelayMessage;
}());
function delayWhen(delayDurationSelector, subscriptionDelay) {
if (subscriptionDelay) {
return function (source) {
return new SubscriptionDelayObservable(source, subscriptionDelay)
.lift(new DelayWhenOperator(delayDurationSelector));
};
}
return function (source) { return source.lift(new DelayWhenOperator(delayDurationSelector)); };
}
var DelayWhenOperator = (function () {
function DelayWhenOperator(delayDurationSelector) {
this.delayDurationSelector = delayDurationSelector;
}
DelayWhenOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DelayWhenSubscriber(subscriber, this.delayDurationSelector));
};
return DelayWhenOperator;
}());
var DelayWhenSubscriber = (function (_super) {
__extends(DelayWhenSubscriber, _super);
function DelayWhenSubscriber(destination, delayDurationSelector) {
var _this = _super.call(this, destination) || this;
_this.delayDurationSelector = delayDurationSelector;
_this.completed = false;
_this.delayNotifierSubscriptions = [];
_this.index = 0;
return _this;
}
DelayWhenSubscriber.prototype.notifyNext = function (outerValue, _innerValue, _outerIndex, _innerIndex, innerSub) {
this.destination.next(outerValue);
this.removeSubscription(innerSub);
this.tryComplete();
};
DelayWhenSubscriber.prototype.notifyError = function (error, innerSub) {
this._error(error);
};
DelayWhenSubscriber.prototype.notifyComplete = function (innerSub) {
var value = this.removeSubscription(innerSub);
if (value) {
this.destination.next(value);
}
this.tryComplete();
};
DelayWhenSubscriber.prototype._next = function (value) {
var index = this.index++;
try {
var delayNotifier = this.delayDurationSelector(value, index);
if (delayNotifier) {
this.tryDelay(delayNotifier, value);
}
}
catch (err) {
this.destination.error(err);
}
};
DelayWhenSubscriber.prototype._complete = function () {
this.completed = true;
this.tryComplete();
this.unsubscribe();
};
DelayWhenSubscriber.prototype.removeSubscription = function (subscription) {
subscription.unsubscribe();
var subscriptionIdx = this.delayNotifierSubscriptions.indexOf(subscription);
if (subscriptionIdx !== -1) {
this.delayNotifierSubscriptions.splice(subscriptionIdx, 1);
}
return subscription.outerValue;
};
DelayWhenSubscriber.prototype.tryDelay = function (delayNotifier, value) {
var notifierSubscription = subscribeToResult(this, delayNotifier, value);
if (notifierSubscription && !notifierSubscription.closed) {
var destination = this.destination;
destination.add(notifierSubscription);
this.delayNotifierSubscriptions.push(notifierSubscription);
}
};
DelayWhenSubscriber.prototype.tryComplete = function () {
if (this.completed && this.delayNotifierSubscriptions.length === 0) {
this.destination.complete();
}
};
return DelayWhenSubscriber;
}(OuterSubscriber));
var SubscriptionDelayObservable = (function (_super) {
__extends(SubscriptionDelayObservable, _super);
function SubscriptionDelayObservable(source, subscriptionDelay) {
var _this = _super.call(this) || this;
_this.source = source;
_this.subscriptionDelay = subscriptionDelay;
return _this;
}
SubscriptionDelayObservable.prototype._subscribe = function (subscriber) {
this.subscriptionDelay.subscribe(new SubscriptionDelaySubscriber(subscriber, this.source));
};
return SubscriptionDelayObservable;
}(Observable));
var SubscriptionDelaySubscriber = (function (_super) {
__extends(SubscriptionDelaySubscriber, _super);
function SubscriptionDelaySubscriber(parent, source) {
var _this = _super.call(this) || this;
_this.parent = parent;
_this.source = source;
_this.sourceSubscribed = false;
return _this;
}
SubscriptionDelaySubscriber.prototype._next = function (unused) {
this.subscribeToSource();
};
SubscriptionDelaySubscriber.prototype._error = function (err) {
this.unsubscribe();
this.parent.error(err);
};
SubscriptionDelaySubscriber.prototype._complete = function () {
this.unsubscribe();
this.subscribeToSource();
};
SubscriptionDelaySubscriber.prototype.subscribeToSource = function () {
if (!this.sourceSubscribed) {
this.sourceSubscribed = true;
this.unsubscribe();
this.source.subscribe(this.parent);
}
};
return SubscriptionDelaySubscriber;
}(Subscriber));
function dematerialize() {
return function dematerializeOperatorFunction(source) {
return source.lift(new DeMaterializeOperator());
};
}
var DeMaterializeOperator = (function () {
function DeMaterializeOperator() {
}
DeMaterializeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DeMaterializeSubscriber(subscriber));
};
return DeMaterializeOperator;
}());
var DeMaterializeSubscriber = (function (_super) {
__extends(DeMaterializeSubscriber, _super);
function DeMaterializeSubscriber(destination) {
return _super.call(this, destination) || this;
}
DeMaterializeSubscriber.prototype._next = function (value) {
value.observe(this.destination);
};
return DeMaterializeSubscriber;
}(Subscriber));
function distinct(keySelector, flushes) {
return function (source) { return source.lift(new DistinctOperator(keySelector, flushes)); };
}
var DistinctOperator = (function () {
function DistinctOperator(keySelector, flushes) {
this.keySelector = keySelector;
this.flushes = flushes;
}
DistinctOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DistinctSubscriber(subscriber, this.keySelector, this.flushes));
};
return DistinctOperator;
}());
var DistinctSubscriber = (function (_super) {
__extends(DistinctSubscriber, _super);
function DistinctSubscriber(destination, keySelector, flushes) {
var _this = _super.call(this, destination) || this;
_this.keySelector = keySelector;
_this.values = new Set();
if (flushes) {
_this.add(innerSubscribe(flushes, new SimpleInnerSubscriber(_this)));
}
return _this;
}
DistinctSubscriber.prototype.notifyNext = function () {
this.values.clear();
};
DistinctSubscriber.prototype.notifyError = function (error) {
this._error(error);
};
DistinctSubscriber.prototype._next = function (value) {
if (this.keySelector) {
this._useKeySelector(value);
}
else {
this._finalizeNext(value, value);
}
};
DistinctSubscriber.prototype._useKeySelector = function (value) {
var key;
var destination = this.destination;
try {
key = this.keySelector(value);
}
catch (err) {
destination.error(err);
return;
}
this._finalizeNext(key, value);
};
DistinctSubscriber.prototype._finalizeNext = function (key, value) {
var values = this.values;
if (!values.has(key)) {
values.add(key);
this.destination.next(value);
}
};
return DistinctSubscriber;
}(SimpleOuterSubscriber));
function distinctUntilChanged(compare, keySelector) {
return function (source) { return source.lift(new DistinctUntilChangedOperator(compare, keySelector)); };
}
var DistinctUntilChangedOperator = (function () {
function DistinctUntilChangedOperator(compare, keySelector) {
this.compare = compare;
this.keySelector = keySelector;
}
DistinctUntilChangedOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));
};
return DistinctUntilChangedOperator;
}());
var DistinctUntilChangedSubscriber = (function (_super) {
__extends(DistinctUntilChangedSubscriber, _super);
function DistinctUntilChangedSubscriber(destination, compare, keySelector) {
var _this = _super.call(this, destination) || this;
_this.keySelector = keySelector;
_this.hasKey = false;
if (typeof compare === 'function') {
_this.compare = compare;
}
return _this;
}
DistinctUntilChangedSubscriber.prototype.compare = function (x, y) {
return x === y;
};
DistinctUntilChangedSubscriber.prototype._next = function (value) {
var key;
try {
var keySelector = this.keySelector;
key = keySelector ? keySelector(value) : value;
}
catch (err) {
return this.destination.error(err);
}
var result = false;
if (this.hasKey) {
try {
var compare = this.compare;
result = compare(this.key, key);
}
catch (err) {
return this.destination.error(err);
}
}
else {
this.hasKey = true;
}
if (!result) {
this.key = key;
this.destination.next(value);
}
};
return DistinctUntilChangedSubscriber;
}(Subscriber));
function distinctUntilKeyChanged(key, compare) {
return distinctUntilChanged(function (x, y) { return compare ? compare(x[key], y[key]) : x[key] === y[key]; });
}
function throwIfEmpty(errorFactory) {
if (errorFactory === void 0) { errorFactory = defaultErrorFactory; }
return function (source) {
return source.lift(new ThrowIfEmptyOperator(errorFactory));
};
}
var ThrowIfEmptyOperator = (function () {
function ThrowIfEmptyOperator(errorFactory) {
this.errorFactory = errorFactory;
}
ThrowIfEmptyOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new ThrowIfEmptySubscriber(subscriber, this.errorFactory));
};
return ThrowIfEmptyOperator;
}());
var ThrowIfEmptySubscriber = (function (_super) {
__extends(ThrowIfEmptySubscriber, _super);
function ThrowIfEmptySubscriber(destination, errorFactory) {
var _this = _super.call(this, destination) || this;
_this.errorFactory = errorFactory;
_this.hasValue = false;
return _this;
}
ThrowIfEmptySubscriber.prototype._next = function (value) {
this.hasValue = true;
this.destination.next(value);
};
ThrowIfEmptySubscriber.prototype._complete = function () {
if (!this.hasValue) {
var err = void 0;
try {
err = this.errorFactory();
}
catch (e) {
err = e;
}
this.destination.error(err);
}
else {
return this.destination.complete();
}
};
return ThrowIfEmptySubscriber;
}(Subscriber));
function defaultErrorFactory() {
return new EmptyError();
}
function take(count) {
return function (source) {
if (count === 0) {
return empty$1();
}
else {
return source.lift(new TakeOperator(count));
}
};
}
var TakeOperator = (function () {
function TakeOperator(total) {
this.total = total;
if (this.total < 0) {
throw new ArgumentOutOfRangeError;
}
}
TakeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new TakeSubscriber(subscriber, this.total));
};
return TakeOperator;
}());
var TakeSubscriber = (function (_super) {
__extends(TakeSubscriber, _super);
function TakeSubscriber(destination, total) {
var _this = _super.call(this, destination) || this;
_this.total = total;
_this.count = 0;
return _this;
}
TakeSubscriber.prototype._next = function (value) {
var total = this.total;
var count = ++this.count;
if (count <= total) {
this.destination.next(value);
if (count === total) {
this.destination.complete();
this.unsubscribe();
}
}
};
return TakeSubscriber;
}(Subscriber));
function elementAt(index, defaultValue) {
if (index < 0) {
throw new ArgumentOutOfRangeError();
}
var hasDefaultValue = arguments.length >= 2;
return function (source) { return source.pipe(filter(function (v, i) { return i === index; }), take(1), hasDefaultValue
? defaultIfEmpty(defaultValue)
: throwIfEmpty(function () { return new ArgumentOutOfRangeError(); })); };
}
function endWith() {
var array = [];
for (var _i = 0; _i < arguments.length; _i++) {
array[_i] = arguments[_i];
}
return function (source) { return concat(source, of.apply(void 0, array)); };
}
function every(predicate, thisArg) {
return function (source) { return source.lift(new EveryOperator(predicate, thisArg, source)); };
}
var EveryOperator = (function () {
function EveryOperator(predicate, thisArg, source) {
this.predicate = predicate;
this.thisArg = thisArg;
this.source = source;
}
EveryOperator.prototype.call = function (observer, source) {
return source.subscribe(new EverySubscriber(observer, this.predicate, this.thisArg, this.source));
};
return EveryOperator;
}());
var EverySubscriber = (function (_super) {
__extends(EverySubscriber, _super);
function EverySubscriber(destination, predicate, thisArg, source) {
var _this = _super.call(this, destination) || this;
_this.predicate = predicate;
_this.thisArg = thisArg;
_this.source = source;
_this.index = 0;
_this.thisArg = thisArg || _this;
return _this;
}
EverySubscriber.prototype.notifyComplete = function (everyValueMatch) {
this.destination.next(everyValueMatch);
this.destination.complete();
};
EverySubscriber.prototype._next = function (value) {
var result = false;
try {
result = this.predicate.call(this.thisArg, value, this.index++, this.source);
}
catch (err) {
this.destination.error(err);
return;
}
if (!result) {
this.notifyComplete(false);
}
};
EverySubscriber.prototype._complete = function () {
this.notifyComplete(true);
};
return EverySubscriber;
}(Subscriber));
function exhaust() {
return function (source) { return source.lift(new SwitchFirstOperator()); };
}
var SwitchFirstOperator = (function () {
function SwitchFirstOperator() {
}
SwitchFirstOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new SwitchFirstSubscriber(subscriber));
};
return SwitchFirstOperator;
}());
var SwitchFirstSubscriber = (function (_super) {
__extends(SwitchFirstSubscriber, _super);
function SwitchFirstSubscriber(destination) {
var _this = _super.call(this, destination) || this;
_this.hasCompleted = false;
_this.hasSubscription = false;
return _this;
}
SwitchFirstSubscriber.prototype._next = function (value) {
if (!this.hasSubscription) {
this.hasSubscription = true;
this.add(innerSubscribe(value, new SimpleInnerSubscriber(this)));
}
};
SwitchFirstSubscriber.prototype._complete = function () {
this.hasCompleted = true;
if (!this.hasSubscription) {
this.destination.complete();
}
};
SwitchFirstSubscriber.prototype.notifyComplete = function () {
this.hasSubscription = false;
if (this.hasCompleted) {
this.destination.complete();
}
};
return SwitchFirstSubscriber;
}(SimpleOuterSubscriber));
function exhaustMap(project, resultSelector) {
if (resultSelector) {
return function (source) { return source.pipe(exhaustMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); })); };
}
return function (source) {
return source.lift(new ExhaustMapOperator(project));
};
}
var ExhaustMapOperator = (function () {
function ExhaustMapOperator(project) {
this.project = project;
}
ExhaustMapOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new ExhaustMapSubscriber(subscriber, this.project));
};
return ExhaustMapOperator;
}());
var ExhaustMapSubscriber = (function (_super) {
__extends(ExhaustMapSubscriber, _super);
function ExhaustMapSubscriber(destination, project) {
var _this = _super.call(this, destination) || this;
_this.project = project;
_this.hasSubscription = false;
_this.hasCompleted = false;
_this.index = 0;
return _this;
}
ExhaustMapSubscriber.prototype._next = function (value) {
if (!this.hasSubscription) {
this.tryNext(value);
}
};
ExhaustMapSubscriber.prototype.tryNext = function (value) {
var result;
var index = this.index++;
try {
result = this.project(value, index);
}
catch (err) {
this.destination.error(err);
return;
}
this.hasSubscription = true;
this._innerSub(result);
};
ExhaustMapSubscriber.prototype._innerSub = function (result) {
var innerSubscriber = new SimpleInnerSubscriber(this);
var destination = this.destination;
destination.add(innerSubscriber);
var innerSubscription = innerSubscribe(result, innerSubscriber);
if (innerSubscription !== innerSubscriber) {
destination.add(innerSubscription);
}
};
ExhaustMapSubscriber.prototype._complete = function () {
this.hasCompleted = true;
if (!this.hasSubscription) {
this.destination.complete();
}
this.unsubscribe();
};
ExhaustMapSubscriber.prototype.notifyNext = function (innerValue) {
this.destination.next(innerValue);
};
ExhaustMapSubscriber.prototype.notifyError = function (err) {
this.destination.error(err);
};
ExhaustMapSubscriber.prototype.notifyComplete = function () {
this.hasSubscription = false;
if (this.hasCompleted) {
this.destination.complete();
}
};
return ExhaustMapSubscriber;
}(SimpleOuterSubscriber));
function expand(project, concurrent, scheduler) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
concurrent = (concurrent || 0) < 1 ? Number.POSITIVE_INFINITY : concurrent;
return function (source) { return source.lift(new ExpandOperator(project, concurrent, scheduler)); };
}
var ExpandOperator = (function () {
function ExpandOperator(project, concurrent, scheduler) {
this.project = project;
this.concurrent = concurrent;
this.scheduler = scheduler;
}
ExpandOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new ExpandSubscriber(subscriber, this.project, this.concurrent, this.scheduler));
};
return ExpandOperator;
}());
var ExpandSubscriber = (function (_super) {
__extends(ExpandSubscriber, _super);
function ExpandSubscriber(destination, project, concurrent, scheduler) {
var _this = _super.call(this, destination) || this;
_this.project = project;
_this.concurrent = concurrent;
_this.scheduler = scheduler;
_this.index = 0;
_this.active = 0;
_this.hasCompleted = false;
if (concurrent < Number.POSITIVE_INFINITY) {
_this.buffer = [];
}
return _this;
}
ExpandSubscriber.dispatch = function (arg) {
var subscriber = arg.subscriber, result = arg.result, value = arg.value, index = arg.index;
subscriber.subscribeToProjection(result, value, index);
};
ExpandSubscriber.prototype._next = function (value) {
var destination = this.destination;
if (destination.closed) {
this._complete();
return;
}
var index = this.index++;
if (this.active < this.concurrent) {
destination.next(value);
try {
var project = this.project;
var result = project(value, index);
if (!this.scheduler) {
this.subscribeToProjection(result, value, index);
}
else {
var state = { subscriber: this, result: result, value: value, index: index };
var destination_1 = this.destination;
destination_1.add(this.scheduler.schedule(ExpandSubscriber.dispatch, 0, state));
}
}
catch (e) {
destination.error(e);
}
}
else {
this.buffer.push(value);
}
};
ExpandSubscriber.prototype.subscribeToProjection = function (result, value, index) {
this.active++;
var destination = this.destination;
destination.add(innerSubscribe(result, new SimpleInnerSubscriber(this)));
};
ExpandSubscriber.prototype._complete = function () {
this.hasCompleted = true;
if (this.hasCompleted && this.active === 0) {
this.destination.complete();
}
this.unsubscribe();
};
ExpandSubscriber.prototype.notifyNext = function (innerValue) {
this._next(innerValue);
};
ExpandSubscriber.prototype.notifyComplete = function () {
var buffer = this.buffer;
this.active--;
if (buffer && buffer.length > 0) {
this._next(buffer.shift());
}
if (this.hasCompleted && this.active === 0) {
this.destination.complete();
}
};
return ExpandSubscriber;
}(SimpleOuterSubscriber));
function finalize(callback) {
return function (source) { return source.lift(new FinallyOperator(callback)); };
}
var FinallyOperator = (function () {
function FinallyOperator(callback) {
this.callback = callback;
}
FinallyOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new FinallySubscriber(subscriber, this.callback));
};
return FinallyOperator;
}());
var FinallySubscriber = (function (_super) {
__extends(FinallySubscriber, _super);
function FinallySubscriber(destination, callback) {
var _this = _super.call(this, destination) || this;
_this.add(new Subscription(callback));
return _this;
}
return FinallySubscriber;
}(Subscriber));
function find(predicate, thisArg) {
if (typeof predicate !== 'function') {
throw new TypeError('predicate is not a function');
}
return function (source) { return source.lift(new FindValueOperator(predicate, source, false, thisArg)); };
}
var FindValueOperator = (function () {
function FindValueOperator(predicate, source, yieldIndex, thisArg) {
this.predicate = predicate;
this.source = source;
this.yieldIndex = yieldIndex;
this.thisArg = thisArg;
}
FindValueOperator.prototype.call = function (observer, source) {
return source.subscribe(new FindValueSubscriber(observer, this.predicate, this.source, this.yieldIndex, this.thisArg));
};
return FindValueOperator;
}());
var FindValueSubscriber = (function (_super) {
__extends(FindValueSubscriber, _super);
function FindValueSubscriber(destination, predicate, source, yieldIndex, thisArg) {
var _this = _super.call(this, destination) || this;
_this.predicate = predicate;
_this.source = source;
_this.yieldIndex = yieldIndex;
_this.thisArg = thisArg;
_this.index = 0;
return _this;
}
FindValueSubscriber.prototype.notifyComplete = function (value) {
var destination = this.destination;
destination.next(value);
destination.complete();
this.unsubscribe();
};
FindValueSubscriber.prototype._next = function (value) {
var _a = this, predicate = _a.predicate, thisArg = _a.thisArg;
var index = this.index++;
try {
var result = predicate.call(thisArg || this, value, index, this.source);
if (result) {
this.notifyComplete(this.yieldIndex ? index : value);
}
}
catch (err) {
this.destination.error(err);
}
};
FindValueSubscriber.prototype._complete = function () {
this.notifyComplete(this.yieldIndex ? -1 : undefined);
};
return FindValueSubscriber;
}(Subscriber));
function findIndex(predicate, thisArg) {
return function (source) { return source.lift(new FindValueOperator(predicate, source, true, thisArg)); };
}
function first(predicate, defaultValue) {
var hasDefaultValue = arguments.length >= 2;
return function (source) { return source.pipe(predicate ? filter(function (v, i) { return predicate(v, i, source); }) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function () { return new EmptyError(); })); };
}
function ignoreElements() {
return function ignoreElementsOperatorFunction(source) {
return source.lift(new IgnoreElementsOperator());
};
}
var IgnoreElementsOperator = (function () {
function IgnoreElementsOperator() {
}
IgnoreElementsOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new IgnoreElementsSubscriber(subscriber));
};
return IgnoreElementsOperator;
}());
var IgnoreElementsSubscriber = (function (_super) {
__extends(IgnoreElementsSubscriber, _super);
function IgnoreElementsSubscriber() {
return _super !== null && _super.apply(this, arguments) || this;
}
IgnoreElementsSubscriber.prototype._next = function (unused) {
};
return IgnoreElementsSubscriber;
}(Subscriber));
function isEmpty() {
return function (source) { return source.lift(new IsEmptyOperator()); };
}
var IsEmptyOperator = (function () {
function IsEmptyOperator() {
}
IsEmptyOperator.prototype.call = function (observer, source) {
return source.subscribe(new IsEmptySubscriber(observer));
};
return IsEmptyOperator;
}());
var IsEmptySubscriber = (function (_super) {
__extends(IsEmptySubscriber, _super);
function IsEmptySubscriber(destination) {
return _super.call(this, destination) || this;
}
IsEmptySubscriber.prototype.notifyComplete = function (isEmpty) {
var destination = this.destination;
destination.next(isEmpty);
destination.complete();
};
IsEmptySubscriber.prototype._next = function (value) {
this.notifyComplete(false);
};
IsEmptySubscriber.prototype._complete = function () {
this.notifyComplete(true);
};
return IsEmptySubscriber;
}(Subscriber));
function takeLast(count) {
return function takeLastOperatorFunction(source) {
if (count === 0) {
return empty$1();
}
else {
return source.lift(new TakeLastOperator(count));
}
};
}
var TakeLastOperator = (function () {
function TakeLastOperator(total) {
this.total = total;
if (this.total < 0) {
throw new ArgumentOutOfRangeError;
}
}
TakeLastOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new TakeLastSubscriber(subscriber, this.total));
};
return TakeLastOperator;
}());
var TakeLastSubscriber = (function (_super) {
__extends(TakeLastSubscriber, _super);
function TakeLastSubscriber(destination, total) {
var _this = _super.call(this, destination) || this;
_this.total = total;
_this.ring = new Array();
_this.count = 0;
return _this;
}
TakeLastSubscriber.prototype._next = function (value) {
var ring = this.ring;
var total = this.total;
var count = this.count++;
if (ring.length < total) {
ring.push(value);
}
else {
var index = count % total;
ring[index] = value;
}
};
TakeLastSubscriber.prototype._complete = function () {
var destination = this.destination;
var count = this.count;
if (count > 0) {
var total = this.count >= this.total ? this.total : this.count;
var ring = this.ring;
for (var i = 0; i < total; i++) {
var idx = (count++) % total;
destination.next(ring[idx]);
}
}
destination.complete();
};
return TakeLastSubscriber;
}(Subscriber));
function last(predicate, defaultValue) {
var hasDefaultValue = arguments.length >= 2;
return function (source) { return source.pipe(predicate ? filter(function (v, i) { return predicate(v, i, source); }) : identity, takeLast(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function () { return new EmptyError(); })); };
}
function mapTo(value) {
return function (source) { return source.lift(new MapToOperator(value)); };
}
var MapToOperator = (function () {
function MapToOperator(value) {
this.value = value;
}
MapToOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new MapToSubscriber(subscriber, this.value));
};
return MapToOperator;
}());
var MapToSubscriber = (function (_super) {
__extends(MapToSubscriber, _super);
function MapToSubscriber(destination, value) {
var _this = _super.call(this, destination) || this;
_this.value = value;
return _this;
}
MapToSubscriber.prototype._next = function (x) {
this.destination.next(this.value);
};
return MapToSubscriber;
}(Subscriber));
function materialize() {
return function materializeOperatorFunction(source) {
return source.lift(new MaterializeOperator());
};
}
var MaterializeOperator = (function () {
function MaterializeOperator() {
}
MaterializeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new MaterializeSubscriber(subscriber));
};
return MaterializeOperator;
}());
var MaterializeSubscriber = (function (_super) {
__extends(MaterializeSubscriber, _super);
function MaterializeSubscriber(destination) {
return _super.call(this, destination) || this;
}
MaterializeSubscriber.prototype._next = function (value) {
this.destination.next(Notification.createNext(value));
};
MaterializeSubscriber.prototype._error = function (err) {
var destination = this.destination;
destination.next(Notification.createError(err));
destination.complete();
};
MaterializeSubscriber.prototype._complete = function () {
var destination = this.destination;
destination.next(Notification.createComplete());
destination.complete();
};
return MaterializeSubscriber;
}(Subscriber));
function scan(accumulator, seed) {
var hasSeed = false;
if (arguments.length >= 2) {
hasSeed = true;
}
return function scanOperatorFunction(source) {
return source.lift(new ScanOperator(accumulator, seed, hasSeed));
};
}
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;
}());
var ScanSubscriber = (function (_super) {
__extends(ScanSubscriber, _super);
function ScanSubscriber(destination, accumulator, _seed, hasSeed) {
var _this = _super.call(this, destination) || this;
_this.accumulator = accumulator;
_this._seed = _seed;
_this.hasSeed = hasSeed;
_this.index = 0;
return _this;
}
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));
function reduce(accumulator, seed) {
if (arguments.length >= 2) {
return function reduceOperatorFunctionWithSeed(source) {
return pipe(scan(accumulator, seed), takeLast(1), defaultIfEmpty(seed))(source);
};
}
return function reduceOperatorFunction(source) {
return pipe(scan(function (acc, value, index) { return accumulator(acc, value, index + 1); }), takeLast(1))(source);
};
}
function max(comparer) {
var max = (typeof comparer === 'function')
? function (x, y) { return comparer(x, y) > 0 ? x : y; }
: function (x, y) { return x > y ? x : y; };
return reduce(max);
}
function merge$1() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
return function (source) { return source.lift.call(merge.apply(void 0, [source].concat(observables))); };
}
function mergeMapTo(innerObservable, resultSelector, concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
if (typeof resultSelector === 'function') {
return mergeMap(function () { return innerObservable; }, resultSelector, concurrent);
}
if (typeof resultSelector === 'number') {
concurrent = resultSelector;
}
return mergeMap(function () { return innerObservable; }, concurrent);
}
function mergeScan(accumulator, seed, concurrent) {
if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }
return function (source) { return source.lift(new MergeScanOperator(accumulator, seed, concurrent)); };
}
var MergeScanOperator = (function () {
function MergeScanOperator(accumulator, seed, concurrent) {
this.accumulator = accumulator;
this.seed = seed;
this.concurrent = concurrent;
}
MergeScanOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new MergeScanSubscriber(subscriber, this.accumulator, this.seed, this.concurrent));
};
return MergeScanOperator;
}());
var MergeScanSubscriber = (function (_super) {
__extends(MergeScanSubscriber, _super);
function MergeScanSubscriber(destination, accumulator, acc, concurrent) {
var _this = _super.call(this, destination) || this;
_this.accumulator = accumulator;
_this.acc = acc;
_this.concurrent = concurrent;
_this.hasValue = false;
_this.hasCompleted = false;
_this.buffer = [];
_this.active = 0;
_this.index = 0;
return _this;
}
MergeScanSubscriber.prototype._next = function (value) {
if (this.active < this.concurrent) {
var index = this.index++;
var destination = this.destination;
var ish = void 0;
try {
var accumulator = this.accumulator;
ish = accumulator(this.acc, value, index);
}
catch (e) {
return destination.error(e);
}
this.active++;
this._innerSub(ish);
}
else {
this.buffer.push(value);
}
};
MergeScanSubscriber.prototype._innerSub = function (ish) {
var innerSubscriber = new SimpleInnerSubscriber(this);
var destination = this.destination;
destination.add(innerSubscriber);
var innerSubscription = innerSubscribe(ish, innerSubscriber);
if (innerSubscription !== innerSubscriber) {
destination.add(innerSubscription);
}
};
MergeScanSubscriber.prototype._complete = function () {
this.hasCompleted = true;
if (this.active === 0 && this.buffer.length === 0) {
if (this.hasValue === false) {
this.destination.next(this.acc);
}
this.destination.complete();
}
this.unsubscribe();
};
MergeScanSubscriber.prototype.notifyNext = function (innerValue) {
var destination = this.destination;
this.acc = innerValue;
this.hasValue = true;
destination.next(innerValue);
};
MergeScanSubscriber.prototype.notifyComplete = function () {
var buffer = this.buffer;
this.active--;
if (buffer.length > 0) {
this._next(buffer.shift());
}
else if (this.active === 0 && this.hasCompleted) {
if (this.hasValue === false) {
this.destination.next(this.acc);
}
this.destination.complete();
}
};
return MergeScanSubscriber;
}(SimpleOuterSubscriber));
function min(comparer) {
var min = (typeof comparer === 'function')
? function (x, y) { return comparer(x, y) < 0 ? x : y; }
: function (x, y) { return x < y ? x : y; };
return reduce(min);
}
function multicast(subjectOrSubjectFactory, selector) {
return function multicastOperatorFunction(source) {
var subjectFactory;
if (typeof subjectOrSubjectFactory === 'function') {
subjectFactory = subjectOrSubjectFactory;
}
else {
subjectFactory = function subjectFactory() {
return subjectOrSubjectFactory;
};
}
if (typeof selector === 'function') {
return source.lift(new MulticastOperator(subjectFactory, selector));
}
var connectable = Object.create(source, connectableObservableDescriptor);
connectable.source = source;
connectable.subjectFactory = subjectFactory;
return connectable;
};
}
var MulticastOperator = (function () {
function MulticastOperator(subjectFactory, selector) {
this.subjectFactory = subjectFactory;
this.selector = selector;
}
MulticastOperator.prototype.call = function (subscriber, source) {
var selector = this.selector;
var subject = this.subjectFactory();
var subscription = selector(subject).subscribe(subscriber);
subscription.add(source.subscribe(subject));
return subscription;
};
return MulticastOperator;
}());
function onErrorResumeNext$1() {
var nextSources = [];
for (var _i = 0; _i < arguments.length; _i++) {
nextSources[_i] = arguments[_i];
}
if (nextSources.length === 1 && isArray(nextSources[0])) {
nextSources = nextSources[0];
}
return function (source) { return source.lift(new OnErrorResumeNextOperator(nextSources)); };
}
var OnErrorResumeNextOperator = (function () {
function OnErrorResumeNextOperator(nextSources) {
this.nextSources = nextSources;
}
OnErrorResumeNextOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new OnErrorResumeNextSubscriber(subscriber, this.nextSources));
};
return OnErrorResumeNextOperator;
}());
var OnErrorResumeNextSubscriber = (function (_super) {
__extends(OnErrorResumeNextSubscriber, _super);
function OnErrorResumeNextSubscriber(destination, nextSources) {
var _this = _super.call(this, destination) || this;
_this.destination = destination;
_this.nextSources = nextSources;
return _this;
}
OnErrorResumeNextSubscriber.prototype.notifyError = function () {
this.subscribeToNextSource();
};
OnErrorResumeNextSubscriber.prototype.notifyComplete = function () {
this.subscribeToNextSource();
};
OnErrorResumeNextSubscriber.prototype._error = function (err) {
this.subscribeToNextSource();
this.unsubscribe();
};
OnErrorResumeNextSubscriber.prototype._complete = function () {
this.subscribeToNextSource();
this.unsubscribe();
};
OnErrorResumeNextSubscriber.prototype.subscribeToNextSource = function () {
var next = this.nextSources.shift();
if (!!next) {
var innerSubscriber = new SimpleInnerSubscriber(this);
var destination = this.destination;
destination.add(innerSubscriber);
var innerSubscription = innerSubscribe(next, innerSubscriber);
if (innerSubscription !== innerSubscriber) {
destination.add(innerSubscription);
}
}
else {
this.destination.complete();
}
};
return OnErrorResumeNextSubscriber;
}(SimpleOuterSubscriber));
function pairwise() {
return function (source) { return source.lift(new PairwiseOperator()); };
}
var PairwiseOperator = (function () {
function PairwiseOperator() {
}
PairwiseOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new PairwiseSubscriber(subscriber));
};
return PairwiseOperator;
}());
var PairwiseSubscriber = (function (_super) {
__extends(PairwiseSubscriber, _super);
function PairwiseSubscriber(destination) {
var _this = _super.call(this, destination) || this;
_this.hasPrev = false;
return _this;
}
PairwiseSubscriber.prototype._next = function (value) {
var pair;
if (this.hasPrev) {
pair = [this.prev, value];
}
else {
this.hasPrev = true;
}
this.prev = value;
if (pair) {
this.destination.next(pair);
}
};
return PairwiseSubscriber;
}(Subscriber));
function partition$1(predicate, thisArg) {
return function (source) { return [
filter(predicate, thisArg)(source),
filter(not(predicate, thisArg))(source)
]; };
}
function pluck() {
var properties = [];
for (var _i = 0; _i < arguments.length; _i++) {
properties[_i] = arguments[_i];
}
var length = properties.length;
if (length === 0) {
throw new Error('list of properties cannot be empty.');
}
return function (source) { return map(plucker(properties, length))(source); };
}
function plucker(props, length) {
var mapper = function (x) {
var currentProp = x;
for (var i = 0; i < length; i++) {
var p = currentProp != null ? currentProp[props[i]] : undefined;
if (p !== void 0) {
currentProp = p;
}
else {
return undefined;
}
}
return currentProp;
};
return mapper;
}
function publish(selector) {
return selector ?
multicast(function () { return new Subject(); }, selector) :
multicast(new Subject());
}
function publishBehavior(value) {
return function (source) { return multicast(new BehaviorSubject(value))(source); };
}
function publishLast() {
return function (source) { return multicast(new AsyncSubject())(source); };
}
function publishReplay(bufferSize, windowTime, selectorOrScheduler, scheduler) {
if (selectorOrScheduler && typeof selectorOrScheduler !== 'function') {
scheduler = selectorOrScheduler;
}
var selector = typeof selectorOrScheduler === 'function' ? selectorOrScheduler : undefined;
var subject = new ReplaySubject(bufferSize, windowTime, scheduler);
return function (source) { return multicast(function () { return subject; }, selector)(source); };
}
function race$1() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
return function raceOperatorFunction(source) {
if (observables.length === 1 && isArray(observables[0])) {
observables = observables[0];
}
return source.lift.call(race.apply(void 0, [source].concat(observables)));
};
}
function repeat(count) {
if (count === void 0) { count = -1; }
return function (source) {
if (count === 0) {
return empty$1();
}
else if (count < 0) {
return source.lift(new RepeatOperator(-1, source));
}
else {
return source.lift(new RepeatOperator(count - 1, source));
}
};
}
var RepeatOperator = (function () {
function RepeatOperator(count, source) {
this.count = count;
this.source = source;
}
RepeatOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new RepeatSubscriber(subscriber, this.count, this.source));
};
return RepeatOperator;
}());
var RepeatSubscriber = (function (_super) {
__extends(RepeatSubscriber, _super);
function RepeatSubscriber(destination, count, source) {
var _this = _super.call(this, destination) || this;
_this.count = count;
_this.source = source;
return _this;
}
RepeatSubscriber.prototype.complete = function () {
if (!this.isStopped) {
var _a = this, source = _a.source, count = _a.count;
if (count === 0) {
return _super.prototype.complete.call(this);
}
else if (count > -1) {
this.count = count - 1;
}
source.subscribe(this._unsubscribeAndRecycle());
}
};
return RepeatSubscriber;
}(Subscriber));
function repeatWhen(notifier) {
return function (source) { return source.lift(new RepeatWhenOperator(notifier)); };
}
var RepeatWhenOperator = (function () {
function RepeatWhenOperator(notifier) {
this.notifier = notifier;
}
RepeatWhenOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new RepeatWhenSubscriber(subscriber, this.notifier, source));
};
return RepeatWhenOperator;
}());
var RepeatWhenSubscriber = (function (_super) {
__extends(RepeatWhenSubscriber, _super);
function RepeatWhenSubscriber(destination, notifier, source) {
var _this = _super.call(this, destination) || this;
_this.notifier = notifier;
_this.source = source;
_this.sourceIsBeingSubscribedTo = true;
return _this;
}
RepeatWhenSubscriber.prototype.notifyNext = function () {
this.sourceIsBeingSubscribedTo = true;
this.source.subscribe(this);
};
RepeatWhenSubscriber.prototype.notifyComplete = function () {
if (this.sourceIsBeingSubscribedTo === false) {
return _super.prototype.complete.call(this);
}
};
RepeatWhenSubscriber.prototype.complete = function () {
this.sourceIsBeingSubscribedTo = false;
if (!this.isStopped) {
if (!this.retries) {
this.subscribeToRetries();
}
if (!this.retriesSubscription || this.retriesSubscription.closed) {
return _super.prototype.complete.call(this);
}
this._unsubscribeAndRecycle();
this.notifications.next(undefined);
}
};
RepeatWhenSubscriber.prototype._unsubscribe = function () {
var _a = this, notifications = _a.notifications, retriesSubscription = _a.retriesSubscription;
if (notifications) {
notifications.unsubscribe();
this.notifications = undefined;
}
if (retriesSubscription) {
retriesSubscription.unsubscribe();
this.retriesSubscription = undefined;
}
this.retries = undefined;
};
RepeatWhenSubscriber.prototype._unsubscribeAndRecycle = function () {
var _unsubscribe = this._unsubscribe;
this._unsubscribe = null;
_super.prototype._unsubscribeAndRecycle.call(this);
this._unsubscribe = _unsubscribe;
return this;
};
RepeatWhenSubscriber.prototype.subscribeToRetries = function () {
this.notifications = new Subject();
var retries;
try {
var notifier = this.notifier;
retries = notifier(this.notifications);
}
catch (e) {
return _super.prototype.complete.call(this);
}
this.retries = retries;
this.retriesSubscription = innerSubscribe(retries, new SimpleInnerSubscriber(this));
};
return RepeatWhenSubscriber;
}(SimpleOuterSubscriber));
function retry(count) {
if (count === void 0) { count = -1; }
return function (source) { return source.lift(new RetryOperator(count, source)); };
}
var RetryOperator = (function () {
function RetryOperator(count, source) {
this.count = count;
this.source = source;
}
RetryOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new RetrySubscriber(subscriber, this.count, this.source));
};
return RetryOperator;
}());
var RetrySubscriber = (function (_super) {
__extends(RetrySubscriber, _super);
function RetrySubscriber(destination, count, source) {
var _this = _super.call(this, destination) || this;
_this.count = count;
_this.source = source;
return _this;
}
RetrySubscriber.prototype.error = function (err) {
if (!this.isStopped) {
var _a = this, source = _a.source, count = _a.count;
if (count === 0) {
return _super.prototype.error.call(this, err);
}
else if (count > -1) {
this.count = count - 1;
}
source.subscribe(this._unsubscribeAndRecycle());
}
};
return RetrySubscriber;
}(Subscriber));
function retryWhen(notifier) {
return function (source) { return source.lift(new RetryWhenOperator(notifier, source)); };
}
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;
}());
var RetryWhenSubscriber = (function (_super) {
__extends(RetryWhenSubscriber, _super);
function RetryWhenSubscriber(destination, notifier, source) {
var _this = _super.call(this, destination) || this;
_this.notifier = notifier;
_this.source = source;
return _this;
}
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();
try {
var notifier = this.notifier;
retries = notifier(errors);
}
catch (e) {
return _super.prototype.error.call(this, e);
}
retriesSubscription = innerSubscribe(retries, new SimpleInnerSubscriber(this));
}
else {
this.errors = undefined;
this.retriesSubscription = undefined;
}
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 = undefined;
}
if (retriesSubscription) {
retriesSubscription.unsubscribe();
this.retriesSubscription = undefined;
}
this.retries = undefined;
};
RetryWhenSubscriber.prototype.notifyNext = function () {
var _unsubscribe = this._unsubscribe;
this._unsubscribe = null;
this._unsubscribeAndRecycle();
this._unsubscribe = _unsubscribe;
this.source.subscribe(this);
};
return RetryWhenSubscriber;
}(SimpleOuterSubscriber));
function sample(notifier) {
return function (source) { return source.lift(new SampleOperator(notifier)); };
}
var SampleOperator = (function () {
function SampleOperator(notifier) {
this.notifier = notifier;
}
SampleOperator.prototype.call = function (subscriber, source) {
var sampleSubscriber = new SampleSubscriber(subscriber);
var subscription = source.subscribe(sampleSubscriber);
subscription.add(innerSubscribe(this.notifier, new SimpleInnerSubscriber(sampleSubscriber)));
return subscription;
};
return SampleOperator;
}());
var SampleSubscriber = (function (_super) {
__extends(SampleSubscriber, _super);
function SampleSubscriber() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.hasValue = false;
return _this;
}
SampleSubscriber.prototype._next = function (value) {
this.value = value;
this.hasValue = true;
};
SampleSubscriber.prototype.notifyNext = function () {
this.emitValue();
};
SampleSubscriber.prototype.notifyComplete = function () {
this.emitValue();
};
SampleSubscriber.prototype.emitValue = function () {
if (this.hasValue) {
this.hasValue = false;
this.destination.next(this.value);
}
};
return SampleSubscriber;
}(SimpleOuterSubscriber));
function sampleTime(period, scheduler) {
if (scheduler === void 0) { scheduler = async; }
return function (source) { return source.lift(new SampleTimeOperator(period, scheduler)); };
}
var SampleTimeOperator = (function () {
function SampleTimeOperator(period, scheduler) {
this.period = period;
this.scheduler = scheduler;
}
SampleTimeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new SampleTimeSubscriber(subscriber, this.period, this.scheduler));
};
return SampleTimeOperator;
}());
var SampleTimeSubscriber = (function (_super) {
__extends(SampleTimeSubscriber, _super);
function SampleTimeSubscriber(destination, period, scheduler) {
var _this = _super.call(this, destination) || this;
_this.period = period;
_this.scheduler = scheduler;
_this.hasValue = false;
_this.add(scheduler.schedule(dispatchNotification, period, { subscriber: _this, period: period }));
return _this;
}
SampleTimeSubscriber.prototype._next = function (value) {
this.lastValue = value;
this.hasValue = true;
};
SampleTimeSubscriber.prototype.notifyNext = function () {
if (this.hasValue) {
this.hasValue = false;
this.destination.next(this.lastValue);
}
};
return SampleTimeSubscriber;
}(Subscriber));
function dispatchNotification(state) {
var subscriber = state.subscriber, period = state.period;
subscriber.notifyNext();
this.schedule(state, period);
}
function sequenceEqual(compareTo, comparator) {
return function (source) { return source.lift(new SequenceEqualOperator(compareTo, comparator)); };
}
var SequenceEqualOperator = (function () {
function SequenceEqualOperator(compareTo, comparator) {
this.compareTo = compareTo;
this.comparator = comparator;
}
SequenceEqualOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new SequenceEqualSubscriber(subscriber, this.compareTo, this.comparator));
};
return SequenceEqualOperator;
}());
var SequenceEqualSubscriber = (function (_super) {
__extends(SequenceEqualSubscriber, _super);
function SequenceEqualSubscriber(destination, compareTo, comparator) {
var _this = _super.call(this, destination) || this;
_this.compareTo = compareTo;
_this.comparator = comparator;
_this._a = [];
_this._b = [];
_this._oneComplete = false;
_this.destination.add(compareTo.subscribe(new SequenceEqualCompareToSubscriber(destination, _this)));
return _this;
}
SequenceEqualSubscriber.prototype._next = function (value) {
if (this._oneComplete && this._b.length === 0) {
this.emit(false);
}
else {
this._a.push(value);
this.checkValues();
}
};
SequenceEqualSubscriber.prototype._complete = function () {
if (this._oneComplete) {
this.emit(this._a.length === 0 && this._b.length === 0);
}
else {
this._oneComplete = true;
}
this.unsubscribe();
};
SequenceEqualSubscriber.prototype.checkValues = function () {
var _c = this, _a = _c._a, _b = _c._b, comparator = _c.comparator;
while (_a.length > 0 && _b.length > 0) {
var a = _a.shift();
var b = _b.shift();
var areEqual = false;
try {
areEqual = comparator ? comparator(a, b) : a === b;
}
catch (e) {
this.destination.error(e);
}
if (!areEqual) {
this.emit(false);
}
}
};
SequenceEqualSubscriber.prototype.emit = function (value) {
var destination = this.destination;
destination.next(value);
destination.complete();
};
SequenceEqualSubscriber.prototype.nextB = function (value) {
if (this._oneComplete && this._a.length === 0) {
this.emit(false);
}
else {
this._b.push(value);
this.checkValues();
}
};
SequenceEqualSubscriber.prototype.completeB = function () {
if (this._oneComplete) {
this.emit(this._a.length === 0 && this._b.length === 0);
}
else {
this._oneComplete = true;
}
};
return SequenceEqualSubscriber;
}(Subscriber));
var SequenceEqualCompareToSubscriber = (function (_super) {
__extends(SequenceEqualCompareToSubscriber, _super);
function SequenceEqualCompareToSubscriber(destination, parent) {
var _this = _super.call(this, destination) || this;
_this.parent = parent;
return _this;
}
SequenceEqualCompareToSubscriber.prototype._next = function (value) {
this.parent.nextB(value);
};
SequenceEqualCompareToSubscriber.prototype._error = function (err) {
this.parent.error(err);
this.unsubscribe();
};
SequenceEqualCompareToSubscriber.prototype._complete = function () {
this.parent.completeB();
this.unsubscribe();
};
return SequenceEqualCompareToSubscriber;
}(Subscriber));
function shareSubjectFactory() {
return new Subject();
}
function share() {
return function (source) { return refCount()(multicast(shareSubjectFactory)(source)); };
}
function shareReplay(configOrBufferSize, windowTime, scheduler) {
var config;
if (configOrBufferSize && typeof configOrBufferSize === 'object') {
config = configOrBufferSize;
}
else {
config = {
bufferSize: configOrBufferSize,
windowTime: windowTime,
refCount: false,
scheduler: scheduler,
};
}
return function (source) { return source.lift(shareReplayOperator(config)); };
}
function shareReplayOperator(_a) {
var _b = _a.bufferSize, bufferSize = _b === void 0 ? Number.POSITIVE_INFINITY : _b, _c = _a.windowTime, windowTime = _c === void 0 ? Number.POSITIVE_INFINITY : _c, useRefCount = _a.refCount, scheduler = _a.scheduler;
var subject;
var refCount = 0;
var subscription;
var hasError = false;
var isComplete = false;
return function shareReplayOperation(source) {
refCount++;
var innerSub;
if (!subject || hasError) {
hasError = false;
subject = new ReplaySubject(bufferSize, windowTime, scheduler);
innerSub = subject.subscribe(this);
subscription = source.subscribe({
next: function (value) {
subject.next(value);
},
error: function (err) {
hasError = true;
subject.error(err);
},
complete: function () {
isComplete = true;
subscription = undefined;
subject.complete();
},
});
if (isComplete) {
subscription = undefined;
}
}
else {
innerSub = subject.subscribe(this);
}
this.add(function () {
refCount--;
innerSub.unsubscribe();
innerSub = undefined;
if (subscription && !isComplete && useRefCount && refCount === 0) {
subscription.unsubscribe();
subscription = undefined;
subject = undefined;
}
});
};
}
function single(predicate) {
return function (source) { return source.lift(new SingleOperator(predicate, source)); };
}
var SingleOperator = (function () {
function SingleOperator(predicate, source) {
this.predicate = predicate;
this.source = source;
}
SingleOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new SingleSubscriber(subscriber, this.predicate, this.source));
};
return SingleOperator;
}());
var SingleSubscriber = (function (_super) {
__extends(SingleSubscriber, _super);
function SingleSubscriber(destination, predicate, source) {
var _this = _super.call(this, destination) || this;
_this.predicate = predicate;
_this.source = source;
_this.seenValue = false;
_this.index = 0;
return _this;
}
SingleSubscriber.prototype.applySingleValue = function (value) {
if (this.seenValue) {
this.destination.error('Sequence contains more than one element');
}
else {
this.seenValue = true;
this.singleValue = value;
}
};
SingleSubscriber.prototype._next = function (value) {
var index = this.index++;
if (this.predicate) {
this.tryNext(value, index);
}
else {
this.applySingleValue(value);
}
};
SingleSubscriber.prototype.tryNext = function (value, index) {
try {
if (this.predicate(value, index, this.source)) {
this.applySingleValue(value);
}
}
catch (err) {
this.destination.error(err);
}
};
SingleSubscriber.prototype._complete = function () {
var destination = this.destination;
if (this.index > 0) {
destination.next(this.seenValue ? this.singleValue : undefined);
destination.complete();
}
else {
destination.error(new EmptyError);
}
};
return SingleSubscriber;
}(Subscriber));
function skip(count) {
return function (source) { return source.lift(new SkipOperator(count)); };
}
var SkipOperator = (function () {
function SkipOperator(total) {
this.total = total;
}
SkipOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new SkipSubscriber(subscriber, this.total));
};
return SkipOperator;
}());
var SkipSubscriber = (function (_super) {
__extends(SkipSubscriber, _super);
function SkipSubscriber(destination, total) {
var _this = _super.call(this, destination) || this;
_this.total = total;
_this.count = 0;
return _this;
}
SkipSubscriber.prototype._next = function (x) {
if (++this.count > this.total) {
this.destination.next(x);
}
};
return SkipSubscriber;
}(Subscriber));
function skipLast(count) {
return function (source) { return source.lift(new SkipLastOperator(count)); };
}
var SkipLastOperator = (function () {
function SkipLastOperator(_skipCount) {
this._skipCount = _skipCount;
if (this._skipCount < 0) {
throw new ArgumentOutOfRangeError;
}
}
SkipLastOperator.prototype.call = function (subscriber, source) {
if (this._skipCount === 0) {
return source.subscribe(new Subscriber(subscriber));
}
else {
return source.subscribe(new SkipLastSubscriber(subscriber, this._skipCount));
}
};
return SkipLastOperator;
}());
var SkipLastSubscriber = (function (_super) {
__extends(SkipLastSubscriber, _super);
function SkipLastSubscriber(destination, _skipCount) {
var _this = _super.call(this, destination) || this;
_this._skipCount = _skipCount;
_this._count = 0;
_this._ring = new Array(_skipCount);
return _this;
}
SkipLastSubscriber.prototype._next = function (value) {
var skipCount = this._skipCount;
var count = this._count++;
if (count < skipCount) {
this._ring[count] = value;
}
else {
var currentIndex = count % skipCount;
var ring = this._ring;
var oldValue = ring[currentIndex];
ring[currentIndex] = value;
this.destination.next(oldValue);
}
};
return SkipLastSubscriber;
}(Subscriber));
function skipUntil(notifier) {
return function (source) { return source.lift(new SkipUntilOperator(notifier)); };
}
var SkipUntilOperator = (function () {
function SkipUntilOperator(notifier) {
this.notifier = notifier;
}
SkipUntilOperator.prototype.call = function (destination, source) {
return source.subscribe(new SkipUntilSubscriber(destination, this.notifier));
};
return SkipUntilOperator;
}());
var SkipUntilSubscriber = (function (_super) {
__extends(SkipUntilSubscriber, _super);
function SkipUntilSubscriber(destination, notifier) {
var _this = _super.call(this, destination) || this;
_this.hasValue = false;
var innerSubscriber = new SimpleInnerSubscriber(_this);
_this.add(innerSubscriber);
_this.innerSubscription = innerSubscriber;
var innerSubscription = innerSubscribe(notifier, innerSubscriber);
if (innerSubscription !== innerSubscriber) {
_this.add(innerSubscription);
_this.innerSubscription = innerSubscription;
}
return _this;
}
SkipUntilSubscriber.prototype._next = function (value) {
if (this.hasValue) {
_super.prototype._next.call(this, value);
}
};
SkipUntilSubscriber.prototype.notifyNext = function () {
this.hasValue = true;
if (this.innerSubscription) {
this.innerSubscription.unsubscribe();
}
};
SkipUntilSubscriber.prototype.notifyComplete = function () {
};
return SkipUntilSubscriber;
}(SimpleOuterSubscriber));
function skipWhile(predicate) {
return function (source) { return source.lift(new SkipWhileOperator(predicate)); };
}
var SkipWhileOperator = (function () {
function SkipWhileOperator(predicate) {
this.predicate = predicate;
}
SkipWhileOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new SkipWhileSubscriber(subscriber, this.predicate));
};
return SkipWhileOperator;
}());
var SkipWhileSubscriber = (function (_super) {
__extends(SkipWhileSubscriber, _super);
function SkipWhileSubscriber(destination, predicate) {
var _this = _super.call(this, destination) || this;
_this.predicate = predicate;
_this.skipping = true;
_this.index = 0;
return _this;
}
SkipWhileSubscriber.prototype._next = function (value) {
var destination = this.destination;
if (this.skipping) {
this.tryCallPredicate(value);
}
if (!this.skipping) {
destination.next(value);
}
};
SkipWhileSubscriber.prototype.tryCallPredicate = function (value) {
try {
var result = this.predicate(value, this.index++);
this.skipping = Boolean(result);
}
catch (err) {
this.destination.error(err);
}
};
return SkipWhileSubscriber;
}(Subscriber));
function startWith() {
var array = [];
for (var _i = 0; _i < arguments.length; _i++) {
array[_i] = arguments[_i];
}
var scheduler = array[array.length - 1];
if (isScheduler(scheduler)) {
array.pop();
return function (source) { return concat(array, source, scheduler); };
}
else {
return function (source) { return concat(array, source); };
}
}
var SubscribeOnObservable = (function (_super) {
__extends(SubscribeOnObservable, _super);
function SubscribeOnObservable(source, delayTime, scheduler) {
if (delayTime === void 0) { delayTime = 0; }
if (scheduler === void 0) { scheduler = asap; }
var _this = _super.call(this) || this;
_this.source = source;
_this.delayTime = delayTime;
_this.scheduler = scheduler;
if (!isNumeric(delayTime) || delayTime < 0) {
_this.delayTime = 0;
}
if (!scheduler || typeof scheduler.schedule !== 'function') {
_this.scheduler = asap;
}
return _this;
}
SubscribeOnObservable.create = function (source, delay, scheduler) {
if (delay === void 0) { delay = 0; }
if (scheduler === void 0) { scheduler = asap; }
return new SubscribeOnObservable(source, delay, scheduler);
};
SubscribeOnObservable.dispatch = function (arg) {
var source = arg.source, subscriber = arg.subscriber;
return this.add(source.subscribe(subscriber));
};
SubscribeOnObservable.prototype._subscribe = function (subscriber) {
var delay = this.delayTime;
var source = this.source;
var scheduler = this.scheduler;
return scheduler.schedule(SubscribeOnObservable.dispatch, delay, {
source: source, subscriber: subscriber
});
};
return SubscribeOnObservable;
}(Observable));
function subscribeOn(scheduler, delay) {
if (delay === void 0) { delay = 0; }
return function subscribeOnOperatorFunction(source) {
return source.lift(new SubscribeOnOperator(scheduler, delay));
};
}
var SubscribeOnOperator = (function () {
function SubscribeOnOperator(scheduler, delay) {
this.scheduler = scheduler;
this.delay = delay;
}
SubscribeOnOperator.prototype.call = function (subscriber, source) {
return new SubscribeOnObservable(source, this.delay, this.scheduler).subscribe(subscriber);
};
return SubscribeOnOperator;
}());
function switchMap(project, resultSelector) {
if (typeof resultSelector === 'function') {
return function (source) { return source.pipe(switchMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); })); };
}
return function (source) { return source.lift(new SwitchMapOperator(project)); };
}
var SwitchMapOperator = (function () {
function SwitchMapOperator(project) {
this.project = project;
}
SwitchMapOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new SwitchMapSubscriber(subscriber, this.project));
};
return SwitchMapOperator;
}());
var SwitchMapSubscriber = (function (_super) {
__extends(SwitchMapSubscriber, _super);
function SwitchMapSubscriber(destination, project) {
var _this = _super.call(this, destination) || this;
_this.project = project;
_this.index = 0;
return _this;
}
SwitchMapSubscriber.prototype._next = function (value) {
var result;
var index = this.index++;
try {
result = this.project(value, index);
}
catch (error) {
this.destination.error(error);
return;
}
this._innerSub(result);
};
SwitchMapSubscriber.prototype._innerSub = function (result) {
var innerSubscription = this.innerSubscription;
if (innerSubscription) {
innerSubscription.unsubscribe();
}
var innerSubscriber = new SimpleInnerSubscriber(this);
var destination = this.destination;
destination.add(innerSubscriber);
this.innerSubscription = innerSubscribe(result, innerSubscriber);
if (this.innerSubscription !== innerSubscriber) {
destination.add(this.innerSubscription);
}
};
SwitchMapSubscriber.prototype._complete = function () {
var innerSubscription = this.innerSubscription;
if (!innerSubscription || innerSubscription.closed) {
_super.prototype._complete.call(this);
}
this.unsubscribe();
};
SwitchMapSubscriber.prototype._unsubscribe = function () {
this.innerSubscription = undefined;
};
SwitchMapSubscriber.prototype.notifyComplete = function () {
this.innerSubscription = undefined;
if (this.isStopped) {
_super.prototype._complete.call(this);
}
};
SwitchMapSubscriber.prototype.notifyNext = function (innerValue) {
this.destination.next(innerValue);
};
return SwitchMapSubscriber;
}(SimpleOuterSubscriber));
function switchAll() {
return switchMap(identity);
}
function switchMapTo(innerObservable, resultSelector) {
return resultSelector ? switchMap(function () { return innerObservable; }, resultSelector) : switchMap(function () { return innerObservable; });
}
function takeUntil(notifier) {
return function (source) { return source.lift(new TakeUntilOperator(notifier)); };
}
var TakeUntilOperator = (function () {
function TakeUntilOperator(notifier) {
this.notifier = notifier;
}
TakeUntilOperator.prototype.call = function (subscriber, source) {
var takeUntilSubscriber = new TakeUntilSubscriber(subscriber);
var notifierSubscription = innerSubscribe(this.notifier, new SimpleInnerSubscriber(takeUntilSubscriber));
if (notifierSubscription && !takeUntilSubscriber.seenValue) {
takeUntilSubscriber.add(notifierSubscription);
return source.subscribe(takeUntilSubscriber);
}
return takeUntilSubscriber;
};
return TakeUntilOperator;
}());
var TakeUntilSubscriber = (function (_super) {
__extends(TakeUntilSubscriber, _super);
function TakeUntilSubscriber(destination) {
var _this = _super.call(this, destination) || this;
_this.seenValue = false;
return _this;
}
TakeUntilSubscriber.prototype.notifyNext = function () {
this.seenValue = true;
this.complete();
};
TakeUntilSubscriber.prototype.notifyComplete = function () {
};
return TakeUntilSubscriber;
}(SimpleOuterSubscriber));
function takeWhile(predicate, inclusive) {
if (inclusive === void 0) { inclusive = false; }
return function (source) {
return source.lift(new TakeWhileOperator(predicate, inclusive));
};
}
var TakeWhileOperator = (function () {
function TakeWhileOperator(predicate, inclusive) {
this.predicate = predicate;
this.inclusive = inclusive;
}
TakeWhileOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new TakeWhileSubscriber(subscriber, this.predicate, this.inclusive));
};
return TakeWhileOperator;
}());
var TakeWhileSubscriber = (function (_super) {
__extends(TakeWhileSubscriber, _super);
function TakeWhileSubscriber(destination, predicate, inclusive) {
var _this = _super.call(this, destination) || this;
_this.predicate = predicate;
_this.inclusive = inclusive;
_this.index = 0;
return _this;
}
TakeWhileSubscriber.prototype._next = function (value) {
var destination = this.destination;
var result;
try {
result = this.predicate(value, this.index++);
}
catch (err) {
destination.error(err);
return;
}
this.nextOrComplete(value, result);
};
TakeWhileSubscriber.prototype.nextOrComplete = function (value, predicateResult) {
var destination = this.destination;
if (Boolean(predicateResult)) {
destination.next(value);
}
else {
if (this.inclusive) {
destination.next(value);
}
destination.complete();
}
};
return TakeWhileSubscriber;
}(Subscriber));
function tap(nextOrObserver, error, complete) {
return function tapOperatorFunction(source) {
return source.lift(new DoOperator(nextOrObserver, error, complete));
};
}
var DoOperator = (function () {
function DoOperator(nextOrObserver, error, complete) {
this.nextOrObserver = nextOrObserver;
this.error = error;
this.complete = complete;
}
DoOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new TapSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));
};
return DoOperator;
}());
var TapSubscriber = (function (_super) {
__extends(TapSubscriber, _super);
function TapSubscriber(destination, observerOrNext, error, complete) {
var _this = _super.call(this, destination) || this;
_this._tapNext = noop;
_this._tapError = noop;
_this._tapComplete = noop;
_this._tapError = error || noop;
_this._tapComplete = complete || noop;
if (isFunction(observerOrNext)) {
_this._context = _this;
_this._tapNext = observerOrNext;
}
else if (observerOrNext) {
_this._context = observerOrNext;
_this._tapNext = observerOrNext.next || noop;
_this._tapError = observerOrNext.error || noop;
_this._tapComplete = observerOrNext.complete || noop;
}
return _this;
}
TapSubscriber.prototype._next = function (value) {
try {
this._tapNext.call(this._context, value);
}
catch (err) {
this.destination.error(err);
return;
}
this.destination.next(value);
};
TapSubscriber.prototype._error = function (err) {
try {
this._tapError.call(this._context, err);
}
catch (err) {
this.destination.error(err);
return;
}
this.destination.error(err);
};
TapSubscriber.prototype._complete = function () {
try {
this._tapComplete.call(this._context);
}
catch (err) {
this.destination.error(err);
return;
}
return this.destination.complete();
};
return TapSubscriber;
}(Subscriber));
var defaultThrottleConfig = {
leading: true,
trailing: false
};
function throttle(durationSelector, config) {
if (config === void 0) { config = defaultThrottleConfig; }
return function (source) { return source.lift(new ThrottleOperator(durationSelector, !!config.leading, !!config.trailing)); };
}
var ThrottleOperator = (function () {
function ThrottleOperator(durationSelector, leading, trailing) {
this.durationSelector = durationSelector;
this.leading = leading;
this.trailing = trailing;
}
ThrottleOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new ThrottleSubscriber(subscriber, this.durationSelector, this.leading, this.trailing));
};
return ThrottleOperator;
}());
var ThrottleSubscriber = (function (_super) {
__extends(ThrottleSubscriber, _super);
function ThrottleSubscriber(destination, durationSelector, _leading, _trailing) {
var _this = _super.call(this, destination) || this;
_this.destination = destination;
_this.durationSelector = durationSelector;
_this._leading = _leading;
_this._trailing = _trailing;
_this._hasValue = false;
return _this;
}
ThrottleSubscriber.prototype._next = function (value) {
this._hasValue = true;
this._sendValue = value;
if (!this._throttled) {
if (this._leading) {
this.send();
}
else {
this.throttle(value);
}
}
};
ThrottleSubscriber.prototype.send = function () {
var _a = this, _hasValue = _a._hasValue, _sendValue = _a._sendValue;
if (_hasValue) {
this.destination.next(_sendValue);
this.throttle(_sendValue);
}
this._hasValue = false;
this._sendValue = undefined;
};
ThrottleSubscriber.prototype.throttle = function (value) {
var duration = this.tryDurationSelector(value);
if (!!duration) {
this.add(this._throttled = innerSubscribe(duration, new SimpleInnerSubscriber(this)));
}
};
ThrottleSubscriber.prototype.tryDurationSelector = function (value) {
try {
return this.durationSelector(value);
}
catch (err) {
this.destination.error(err);
return null;
}
};
ThrottleSubscriber.prototype.throttlingDone = function () {
var _a = this, _throttled = _a._throttled, _trailing = _a._trailing;
if (_throttled) {
_throttled.unsubscribe();
}
this._throttled = undefined;
if (_trailing) {
this.send();
}
};
ThrottleSubscriber.prototype.notifyNext = function () {
this.throttlingDone();
};
ThrottleSubscriber.prototype.notifyComplete = function () {
this.throttlingDone();
};
return ThrottleSubscriber;
}(SimpleOuterSubscriber));
function throttleTime(duration, scheduler, config) {
if (scheduler === void 0) { scheduler = async; }
if (config === void 0) { config = defaultThrottleConfig; }
return function (source) { return source.lift(new ThrottleTimeOperator(duration, scheduler, config.leading, config.trailing)); };
}
var ThrottleTimeOperator = (function () {
function ThrottleTimeOperator(duration, scheduler, leading, trailing) {
this.duration = duration;
this.scheduler = scheduler;
this.leading = leading;
this.trailing = trailing;
}
ThrottleTimeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new ThrottleTimeSubscriber(subscriber, this.duration, this.scheduler, this.leading, this.trailing));
};
return ThrottleTimeOperator;
}());
var ThrottleTimeSubscriber = (function (_super) {
__extends(ThrottleTimeSubscriber, _super);
function ThrottleTimeSubscriber(destination, duration, scheduler, leading, trailing) {
var _this = _super.call(this, destination) || this;
_this.duration = duration;
_this.scheduler = scheduler;
_this.leading = leading;
_this.trailing = trailing;
_this._hasTrailingValue = false;
_this._trailingValue = null;
return _this;
}
ThrottleTimeSubscriber.prototype._next = function (value) {
if (this.throttled) {
if (this.trailing) {
this._trailingValue = value;
this._hasTrailingValue = true;
}
}
else {
this.add(this.throttled = this.scheduler.schedule(dispatchNext$3, this.duration, { subscriber: this }));
if (this.leading) {
this.destination.next(value);
}
else if (this.trailing) {
this._trailingValue = value;
this._hasTrailingValue = true;
}
}
};
ThrottleTimeSubscriber.prototype._complete = function () {
if (this._hasTrailingValue) {
this.destination.next(this._trailingValue);
this.destination.complete();
}
else {
this.destination.complete();
}
};
ThrottleTimeSubscriber.prototype.clearThrottle = function () {
var throttled = this.throttled;
if (throttled) {
if (this.trailing && this._hasTrailingValue) {
this.destination.next(this._trailingValue);
this._trailingValue = null;
this._hasTrailingValue = false;
}
throttled.unsubscribe();
this.remove(throttled);
this.throttled = null;
}
};
return ThrottleTimeSubscriber;
}(Subscriber));
function dispatchNext$3(arg) {
var subscriber = arg.subscriber;
subscriber.clearThrottle();
}
function timeInterval(scheduler) {
if (scheduler === void 0) { scheduler = async; }
return function (source) { return defer(function () {
return source.pipe(scan(function (_a, value) {
var current = _a.current;
return ({ value: value, current: scheduler.now(), last: current });
}, { current: scheduler.now(), value: undefined, last: undefined }), map(function (_a) {
var current = _a.current, last = _a.last, value = _a.value;
return new TimeInterval(value, current - last);
}));
}); };
}
var TimeInterval = (function () {
function TimeInterval(value, interval) {
this.value = value;
this.interval = interval;
}
return TimeInterval;
}());
function timeoutWith(due, withObservable, scheduler) {
if (scheduler === void 0) { scheduler = async; }
return function (source) {
var absoluteTimeout = isDate(due);
var waitFor = absoluteTimeout ? (+due - scheduler.now()) : Math.abs(due);
return source.lift(new TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler));
};
}
var TimeoutWithOperator = (function () {
function TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler) {
this.waitFor = waitFor;
this.absoluteTimeout = absoluteTimeout;
this.withObservable = withObservable;
this.scheduler = scheduler;
}
TimeoutWithOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new TimeoutWithSubscriber(subscriber, this.absoluteTimeout, this.waitFor, this.withObservable, this.scheduler));
};
return TimeoutWithOperator;
}());
var TimeoutWithSubscriber = (function (_super) {
__extends(TimeoutWithSubscriber, _super);
function TimeoutWithSubscriber(destination, absoluteTimeout, waitFor, withObservable, scheduler) {
var _this = _super.call(this, destination) || this;
_this.absoluteTimeout = absoluteTimeout;
_this.waitFor = waitFor;
_this.withObservable = withObservable;
_this.scheduler = scheduler;
_this.scheduleTimeout();
return _this;
}
TimeoutWithSubscriber.dispatchTimeout = function (subscriber) {
var withObservable = subscriber.withObservable;
subscriber._unsubscribeAndRecycle();
subscriber.add(innerSubscribe(withObservable, new SimpleInnerSubscriber(subscriber)));
};
TimeoutWithSubscriber.prototype.scheduleTimeout = function () {
var action = this.action;
if (action) {
this.action = action.schedule(this, this.waitFor);
}
else {
this.add(this.action = this.scheduler.schedule(TimeoutWithSubscriber.dispatchTimeout, this.waitFor, this));
}
};
TimeoutWithSubscriber.prototype._next = function (value) {
if (!this.absoluteTimeout) {
this.scheduleTimeout();
}
_super.prototype._next.call(this, value);
};
TimeoutWithSubscriber.prototype._unsubscribe = function () {
this.action = undefined;
this.scheduler = null;
this.withObservable = null;
};
return TimeoutWithSubscriber;
}(SimpleOuterSubscriber));
function timeout(due, scheduler) {
if (scheduler === void 0) { scheduler = async; }
return timeoutWith(due, throwError(new TimeoutError()), scheduler);
}
function timestamp(scheduler) {
if (scheduler === void 0) { scheduler = async; }
return map(function (value) { return new Timestamp(value, scheduler.now()); });
}
var Timestamp = (function () {
function Timestamp(value, timestamp) {
this.value = value;
this.timestamp = timestamp;
}
return Timestamp;
}());
function toArrayReducer(arr, item, index) {
if (index === 0) {
return [item];
}
arr.push(item);
return arr;
}
function toArray() {
return reduce(toArrayReducer, []);
}
function window$1(windowBoundaries) {
return function windowOperatorFunction(source) {
return source.lift(new WindowOperator(windowBoundaries));
};
}
var WindowOperator = (function () {
function WindowOperator(windowBoundaries) {
this.windowBoundaries = windowBoundaries;
}
WindowOperator.prototype.call = function (subscriber, source) {
var windowSubscriber = new WindowSubscriber(subscriber);
var sourceSubscription = source.subscribe(windowSubscriber);
if (!sourceSubscription.closed) {
windowSubscriber.add(innerSubscribe(this.windowBoundaries, new SimpleInnerSubscriber(windowSubscriber)));
}
return sourceSubscription;
};
return WindowOperator;
}());
var WindowSubscriber = (function (_super) {
__extends(WindowSubscriber, _super);
function WindowSubscriber(destination) {
var _this = _super.call(this, destination) || this;
_this.window = new Subject();
destination.next(_this.window);
return _this;
}
WindowSubscriber.prototype.notifyNext = function () {
this.openWindow();
};
WindowSubscriber.prototype.notifyError = function (error) {
this._error(error);
};
WindowSubscriber.prototype.notifyComplete = function () {
this._complete();
};
WindowSubscriber.prototype._next = function (value) {
this.window.next(value);
};
WindowSubscriber.prototype._error = function (err) {
this.window.error(err);
this.destination.error(err);
};
WindowSubscriber.prototype._complete = function () {
this.window.complete();
this.destination.complete();
};
WindowSubscriber.prototype._unsubscribe = function () {
this.window = null;
};
WindowSubscriber.prototype.openWindow = function () {
var prevWindow = this.window;
if (prevWindow) {
prevWindow.complete();
}
var destination = this.destination;
var newWindow = this.window = new Subject();
destination.next(newWindow);
};
return WindowSubscriber;
}(SimpleOuterSubscriber));
function windowCount(windowSize, startWindowEvery) {
if (startWindowEvery === void 0) { startWindowEvery = 0; }
return function windowCountOperatorFunction(source) {
return source.lift(new WindowCountOperator(windowSize, startWindowEvery));
};
}
var WindowCountOperator = (function () {
function WindowCountOperator(windowSize, startWindowEvery) {
this.windowSize = windowSize;
this.startWindowEvery = startWindowEvery;
}
WindowCountOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new WindowCountSubscriber(subscriber, this.windowSize, this.startWindowEvery));
};
return WindowCountOperator;
}());
var WindowCountSubscriber = (function (_super) {
__extends(WindowCountSubscriber, _super);
function WindowCountSubscriber(destination, windowSize, startWindowEvery) {
var _this = _super.call(this, destination) || this;
_this.destination = destination;
_this.windowSize = windowSize;
_this.startWindowEvery = startWindowEvery;
_this.windows = [new Subject()];
_this.count = 0;
destination.next(_this.windows[0]);
return _this;
}
WindowCountSubscriber.prototype._next = function (value) {
var startWindowEvery = (this.startWindowEvery > 0) ? this.startWindowEvery : this.windowSize;
var destination = this.destination;
var windowSize = this.windowSize;
var windows = this.windows;
var len = windows.length;
for (var i = 0; i < len && !this.closed; i++) {
windows[i].next(value);
}
var c = this.count - windowSize + 1;
if (c >= 0 && c % startWindowEvery === 0 && !this.closed) {
windows.shift().complete();
}
if (++this.count % startWindowEvery === 0 && !this.closed) {
var window_1 = new Subject();
windows.push(window_1);
destination.next(window_1);
}
};
WindowCountSubscriber.prototype._error = function (err) {
var windows = this.windows;
if (windows) {
while (windows.length > 0 && !this.closed) {
windows.shift().error(err);
}
}
this.destination.error(err);
};
WindowCountSubscriber.prototype._complete = function () {
var windows = this.windows;
if (windows) {
while (windows.length > 0 && !this.closed) {
windows.shift().complete();
}
}
this.destination.complete();
};
WindowCountSubscriber.prototype._unsubscribe = function () {
this.count = 0;
this.windows = null;
};
return WindowCountSubscriber;
}(Subscriber));
function windowTime(windowTimeSpan) {
var scheduler = async;
var windowCreationInterval = null;
var maxWindowSize = Number.POSITIVE_INFINITY;
if (isScheduler(arguments[3])) {
scheduler = arguments[3];
}
if (isScheduler(arguments[2])) {
scheduler = arguments[2];
}
else if (isNumeric(arguments[2])) {
maxWindowSize = Number(arguments[2]);
}
if (isScheduler(arguments[1])) {
scheduler = arguments[1];
}
else if (isNumeric(arguments[1])) {
windowCreationInterval = Number(arguments[1]);
}
return function windowTimeOperatorFunction(source) {
return source.lift(new WindowTimeOperator(windowTimeSpan, windowCreationInterval, maxWindowSize, scheduler));
};
}
var WindowTimeOperator = (function () {
function WindowTimeOperator(windowTimeSpan, windowCreationInterval, maxWindowSize, scheduler) {
this.windowTimeSpan = windowTimeSpan;
this.windowCreationInterval = windowCreationInterval;
this.maxWindowSize = maxWindowSize;
this.scheduler = scheduler;
}
WindowTimeOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new WindowTimeSubscriber(subscriber, this.windowTimeSpan, this.windowCreationInterval, this.maxWindowSize, this.scheduler));
};
return WindowTimeOperator;
}());
var CountedSubject = (function (_super) {
__extends(CountedSubject, _super);
function CountedSubject() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this._numberOfNextedValues = 0;
return _this;
}
CountedSubject.prototype.next = function (value) {
this._numberOfNextedValues++;
_super.prototype.next.call(this, value);
};
Object.defineProperty(CountedSubject.prototype, "numberOfNextedValues", {
get: function () {
return this._numberOfNextedValues;
},
enumerable: true,
configurable: true
});
return CountedSubject;
}(Subject));
var WindowTimeSubscriber = (function (_super) {
__extends(WindowTimeSubscriber, _super);
function WindowTimeSubscriber(destination, windowTimeSpan, windowCreationInterval, maxWindowSize, scheduler) {
var _this = _super.call(this, destination) || this;
_this.destination = destination;
_this.windowTimeSpan = windowTimeSpan;
_this.windowCreationInterval = windowCreationInterval;
_this.maxWindowSize = maxWindowSize;
_this.scheduler = scheduler;
_this.windows = [];
var window = _this.openWindow();
if (windowCreationInterval !== null && windowCreationInterval >= 0) {
var closeState = { subscriber: _this, window: window, context: null };
var creationState = { windowTimeSpan: windowTimeSpan, windowCreationInterval: windowCreationInterval, subscriber: _this, scheduler: scheduler };
_this.add(scheduler.schedule(dispatchWindowClose, windowTimeSpan, closeState));
_this.add(scheduler.schedule(dispatchWindowCreation, windowCreationInterval, creationState));
}
else {
var timeSpanOnlyState = { subscriber: _this, window: window, windowTimeSpan: windowTimeSpan };
_this.add(scheduler.schedule(dispatchWindowTimeSpanOnly, windowTimeSpan, timeSpanOnlyState));
}
return _this;
}
WindowTimeSubscriber.prototype._next = function (value) {
var windows = this.windows;
var len = windows.length;
for (var i = 0; i < len; i++) {
var window_1 = windows[i];
if (!window_1.closed) {
window_1.next(value);
if (window_1.numberOfNextedValues >= this.maxWindowSize) {
this.closeWindow(window_1);
}
}
}
};
WindowTimeSubscriber.prototype._error = function (err) {
var windows = this.windows;
while (windows.length > 0) {
windows.shift().error(err);
}
this.destination.error(err);
};
WindowTimeSubscriber.prototype._complete = function () {
var windows = this.windows;
while (windows.length > 0) {
var window_2 = windows.shift();
if (!window_2.closed) {
window_2.complete();
}
}
this.destination.complete();
};
WindowTimeSubscriber.prototype.openWindow = function () {
var window = new CountedSubject();
this.windows.push(window);
var destination = this.destination;
destination.next(window);
return window;
};
WindowTimeSubscriber.prototype.closeWindow = function (window) {
window.complete();
var windows = this.windows;
windows.splice(windows.indexOf(window), 1);
};
return WindowTimeSubscriber;
}(Subscriber));
function dispatchWindowTimeSpanOnly(state) {
var subscriber = state.subscriber, windowTimeSpan = state.windowTimeSpan, window = state.window;
if (window) {
subscriber.closeWindow(window);
}
state.window = subscriber.openWindow();
this.schedule(state, windowTimeSpan);
}
function dispatchWindowCreation(state) {
var windowTimeSpan = state.windowTimeSpan, subscriber = state.subscriber, scheduler = state.scheduler, windowCreationInterval = state.windowCreationInterval;
var window = subscriber.openWindow();
var action = this;
var context = { action: action, subscription: null };
var timeSpanState = { subscriber: subscriber, window: window, context: context };
context.subscription = scheduler.schedule(dispatchWindowClose, windowTimeSpan, timeSpanState);
action.add(context.subscription);
action.schedule(state, windowCreationInterval);
}
function dispatchWindowClose(state) {
var subscriber = state.subscriber, window = state.window, context = state.context;
if (context && context.action && context.subscription) {
context.action.remove(context.subscription);
}
subscriber.closeWindow(window);
}
function windowToggle(openings, closingSelector) {
return function (source) { return source.lift(new WindowToggleOperator(openings, closingSelector)); };
}
var WindowToggleOperator = (function () {
function WindowToggleOperator(openings, closingSelector) {
this.openings = openings;
this.closingSelector = closingSelector;
}
WindowToggleOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new WindowToggleSubscriber(subscriber, this.openings, this.closingSelector));
};
return WindowToggleOperator;
}());
var WindowToggleSubscriber = (function (_super) {
__extends(WindowToggleSubscriber, _super);
function WindowToggleSubscriber(destination, openings, closingSelector) {
var _this = _super.call(this, destination) || this;
_this.openings = openings;
_this.closingSelector = closingSelector;
_this.contexts = [];
_this.add(_this.openSubscription = subscribeToResult(_this, openings, openings));
return _this;
}
WindowToggleSubscriber.prototype._next = function (value) {
var contexts = this.contexts;
if (contexts) {
var len = contexts.length;
for (var i = 0; i < len; i++) {
contexts[i].window.next(value);
}
}
};
WindowToggleSubscriber.prototype._error = function (err) {
var contexts = this.contexts;
this.contexts = null;
if (contexts) {
var len = contexts.length;
var index = -1;
while (++index < len) {
var context_1 = contexts[index];
context_1.window.error(err);
context_1.subscription.unsubscribe();
}
}
_super.prototype._error.call(this, err);
};
WindowToggleSubscriber.prototype._complete = function () {
var contexts = this.contexts;
this.contexts = null;
if (contexts) {
var len = contexts.length;
var index = -1;
while (++index < len) {
var context_2 = contexts[index];
context_2.window.complete();
context_2.subscription.unsubscribe();
}
}
_super.prototype._complete.call(this);
};
WindowToggleSubscriber.prototype._unsubscribe = function () {
var contexts = this.contexts;
this.contexts = null;
if (contexts) {
var len = contexts.length;
var index = -1;
while (++index < len) {
var context_3 = contexts[index];
context_3.window.unsubscribe();
context_3.subscription.unsubscribe();
}
}
};
WindowToggleSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
if (outerValue === this.openings) {
var closingNotifier = void 0;
try {
var closingSelector = this.closingSelector;
closingNotifier = closingSelector(innerValue);
}
catch (e) {
return this.error(e);
}
var window_1 = new Subject();
var subscription = new Subscription();
var context_4 = { window: window_1, subscription: subscription };
this.contexts.push(context_4);
var innerSubscription = subscribeToResult(this, closingNotifier, context_4);
if (innerSubscription.closed) {
this.closeWindow(this.contexts.length - 1);
}
else {
innerSubscription.context = context_4;
subscription.add(innerSubscription);
}
this.destination.next(window_1);
}
else {
this.closeWindow(this.contexts.indexOf(outerValue));
}
};
WindowToggleSubscriber.prototype.notifyError = function (err) {
this.error(err);
};
WindowToggleSubscriber.prototype.notifyComplete = function (inner) {
if (inner !== this.openSubscription) {
this.closeWindow(this.contexts.indexOf(inner.context));
}
};
WindowToggleSubscriber.prototype.closeWindow = function (index) {
if (index === -1) {
return;
}
var contexts = this.contexts;
var context = contexts[index];
var window = context.window, subscription = context.subscription;
contexts.splice(index, 1);
window.complete();
subscription.unsubscribe();
};
return WindowToggleSubscriber;
}(OuterSubscriber));
function windowWhen(closingSelector) {
return function windowWhenOperatorFunction(source) {
return source.lift(new WindowOperator$1(closingSelector));
};
}
var WindowOperator$1 = (function () {
function WindowOperator(closingSelector) {
this.closingSelector = closingSelector;
}
WindowOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new WindowSubscriber$1(subscriber, this.closingSelector));
};
return WindowOperator;
}());
var WindowSubscriber$1 = (function (_super) {
__extends(WindowSubscriber, _super);
function WindowSubscriber(destination, closingSelector) {
var _this = _super.call(this, destination) || this;
_this.destination = destination;
_this.closingSelector = closingSelector;
_this.openWindow();
return _this;
}
WindowSubscriber.prototype.notifyNext = function (_outerValue, _innerValue, _outerIndex, _innerIndex, innerSub) {
this.openWindow(innerSub);
};
WindowSubscriber.prototype.notifyError = function (error) {
this._error(error);
};
WindowSubscriber.prototype.notifyComplete = function (innerSub) {
this.openWindow(innerSub);
};
WindowSubscriber.prototype._next = function (value) {
this.window.next(value);
};
WindowSubscriber.prototype._error = function (err) {
this.window.error(err);
this.destination.error(err);
this.unsubscribeClosingNotification();
};
WindowSubscriber.prototype._complete = function () {
this.window.complete();
this.destination.complete();
this.unsubscribeClosingNotification();
};
WindowSubscriber.prototype.unsubscribeClosingNotification = function () {
if (this.closingNotification) {
this.closingNotification.unsubscribe();
}
};
WindowSubscriber.prototype.openWindow = function (innerSub) {
if (innerSub === void 0) { innerSub = null; }
if (innerSub) {
this.remove(innerSub);
innerSub.unsubscribe();
}
var prevWindow = this.window;
if (prevWindow) {
prevWindow.complete();
}
var window = this.window = new Subject();
this.destination.next(window);
var closingNotifier;
try {
var closingSelector = this.closingSelector;
closingNotifier = closingSelector();
}
catch (e) {
this.destination.error(e);
this.window.error(e);
return;
}
this.add(this.closingNotification = subscribeToResult(this, closingNotifier));
};
return WindowSubscriber;
}(OuterSubscriber));
function withLatestFrom() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return function (source) {
var project;
if (typeof args[args.length - 1] === 'function') {
project = args.pop();
}
var observables = args;
return source.lift(new WithLatestFromOperator(observables, project));
};
}
var WithLatestFromOperator = (function () {
function WithLatestFromOperator(observables, project) {
this.observables = observables;
this.project = project;
}
WithLatestFromOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));
};
return WithLatestFromOperator;
}());
var WithLatestFromSubscriber = (function (_super) {
__extends(WithLatestFromSubscriber, _super);
function WithLatestFromSubscriber(destination, observables, project) {
var _this = _super.call(this, destination) || this;
_this.observables = observables;
_this.project = project;
_this.toRespond = [];
var len = observables.length;
_this.values = new Array(len);
for (var i = 0; i < len; i++) {
_this.toRespond.push(i);
}
for (var i = 0; i < len; i++) {
var observable = observables[i];
_this.add(subscribeToResult(_this, observable, undefined, i));
}
return _this;
}
WithLatestFromSubscriber.prototype.notifyNext = function (_outerValue, innerValue, outerIndex) {
this.values[outerIndex] = innerValue;
var toRespond = this.toRespond;
if (toRespond.length > 0) {
var found = toRespond.indexOf(outerIndex);
if (found !== -1) {
toRespond.splice(found, 1);
}
}
};
WithLatestFromSubscriber.prototype.notifyComplete = function () {
};
WithLatestFromSubscriber.prototype._next = function (value) {
if (this.toRespond.length === 0) {
var args = [value].concat(this.values);
if (this.project) {
this._tryProject(args);
}
else {
this.destination.next(args);
}
}
};
WithLatestFromSubscriber.prototype._tryProject = function (args) {
var result;
try {
result = this.project.apply(this, args);
}
catch (err) {
this.destination.error(err);
return;
}
this.destination.next(result);
};
return WithLatestFromSubscriber;
}(OuterSubscriber));
function zip$1() {
var observables = [];
for (var _i = 0; _i < arguments.length; _i++) {
observables[_i] = arguments[_i];
}
return function zipOperatorFunction(source) {
return source.lift.call(zip.apply(void 0, [source].concat(observables)));
};
}
function zipAll(project) {
return function (source) { return source.lift(new ZipOperator(project)); };
}
var _operators = /*#__PURE__*/Object.freeze({
audit: audit,
auditTime: auditTime,
buffer: buffer,
bufferCount: bufferCount,
bufferTime: bufferTime,
bufferToggle: bufferToggle,
bufferWhen: bufferWhen,
catchError: catchError,
combineAll: combineAll,
combineLatest: combineLatest$1,
concat: concat$1,
concatAll: concatAll,
concatMap: concatMap,
concatMapTo: concatMapTo,
count: count,
debounce: debounce,
debounceTime: debounceTime,
defaultIfEmpty: defaultIfEmpty,
delay: delay,
delayWhen: delayWhen,
dematerialize: dematerialize,
distinct: distinct,
distinctUntilChanged: distinctUntilChanged,
distinctUntilKeyChanged: distinctUntilKeyChanged,
elementAt: elementAt,
endWith: endWith,
every: every,
exhaust: exhaust,
exhaustMap: exhaustMap,
expand: expand,
filter: filter,
finalize: finalize,
find: find,
findIndex: findIndex,
first: first,
groupBy: groupBy,
ignoreElements: ignoreElements,
isEmpty: isEmpty,
last: last,
map: map,
mapTo: mapTo,
materialize: materialize,
max: max,
merge: merge$1,
mergeAll: mergeAll,
mergeMap: mergeMap,
flatMap: flatMap,
mergeMapTo: mergeMapTo,
mergeScan: mergeScan,
min: min,
multicast: multicast,
observeOn: observeOn,
onErrorResumeNext: onErrorResumeNext$1,
pairwise: pairwise,
partition: partition$1,
pluck: pluck,
publish: publish,
publishBehavior: publishBehavior,
publishLast: publishLast,
publishReplay: publishReplay,
race: race$1,
reduce: reduce,
repeat: repeat,
repeatWhen: repeatWhen,
retry: retry,
retryWhen: retryWhen,
refCount: refCount,
sample: sample,
sampleTime: sampleTime,
scan: scan,
sequenceEqual: sequenceEqual,
share: share,
shareReplay: shareReplay,
single: single,
skip: skip,
skipLast: skipLast,
skipUntil: skipUntil,
skipWhile: skipWhile,
startWith: startWith,
subscribeOn: subscribeOn,
switchAll: switchAll,
switchMap: switchMap,
switchMapTo: switchMapTo,
take: take,
takeLast: takeLast,
takeUntil: takeUntil,
takeWhile: takeWhile,
tap: tap,
throttle: throttle,
throttleTime: throttleTime,
throwIfEmpty: throwIfEmpty,
timeInterval: timeInterval,
timeout: timeout,
timeoutWith: timeoutWith,
timestamp: timestamp,
toArray: toArray,
window: window$1,
windowCount: windowCount,
windowTime: windowTime,
windowToggle: windowToggle,
windowWhen: windowWhen,
withLatestFrom: withLatestFrom,
zip: zip$1,
zipAll: zipAll
});
var SubscriptionLog = (function () {
function SubscriptionLog(subscribedFrame, unsubscribedFrame) {
if (unsubscribedFrame === void 0) { unsubscribedFrame = Number.POSITIVE_INFINITY; }
this.subscribedFrame = subscribedFrame;
this.unsubscribedFrame = unsubscribedFrame;
}
return SubscriptionLog;
}());
var SubscriptionLoggable = (function () {
function SubscriptionLoggable() {
this.subscriptions = [];
}
SubscriptionLoggable.prototype.logSubscribedFrame = function () {
this.subscriptions.push(new SubscriptionLog(this.scheduler.now()));
return this.subscriptions.length - 1;
};
SubscriptionLoggable.prototype.logUnsubscribedFrame = function (index) {
var subscriptionLogs = this.subscriptions;
var oldSubscriptionLog = subscriptionLogs[index];
subscriptionLogs[index] = new SubscriptionLog(oldSubscriptionLog.subscribedFrame, this.scheduler.now());
};
return SubscriptionLoggable;
}());
function applyMixins(derivedCtor, baseCtors) {
for (var i = 0, len = baseCtors.length; i < len; i++) {
var baseCtor = baseCtors[i];
var propertyKeys = Object.getOwnPropertyNames(baseCtor.prototype);
for (var j = 0, len2 = propertyKeys.length; j < len2; j++) {
var name_1 = propertyKeys[j];
derivedCtor.prototype[name_1] = baseCtor.prototype[name_1];
}
}
}
var ColdObservable = (function (_super) {
__extends(ColdObservable, _super);
function ColdObservable(messages, scheduler) {
var _this = _super.call(this, function (subscriber) {
var observable = this;
var index = observable.logSubscribedFrame();
var subscription = new Subscription();
subscription.add(new Subscription(function () {
observable.logUnsubscribedFrame(index);
}));
observable.scheduleMessages(subscriber);
return subscription;
}) || this;
_this.messages = messages;
_this.subscriptions = [];
_this.scheduler = scheduler;
return _this;
}
ColdObservable.prototype.scheduleMessages = function (subscriber) {
var messagesLength = this.messages.length;
for (var i = 0; i < messagesLength; i++) {
var message = this.messages[i];
subscriber.add(this.scheduler.schedule(function (_a) {
var message = _a.message, subscriber = _a.subscriber;
message.notification.observe(subscriber);
}, message.frame, { message: message, subscriber: subscriber }));
}
};
return ColdObservable;
}(Observable));
applyMixins(ColdObservable, [SubscriptionLoggable]);
var HotObservable = (function (_super) {
__extends(HotObservable, _super);
function HotObservable(messages, scheduler) {
var _this = _super.call(this) || this;
_this.messages = messages;
_this.subscriptions = [];
_this.scheduler = scheduler;
return _this;
}
HotObservable.prototype._subscribe = function (subscriber) {
var subject = this;
var index = subject.logSubscribedFrame();
var subscription = new Subscription();
subscription.add(new Subscription(function () {
subject.logUnsubscribedFrame(index);
}));
subscription.add(_super.prototype._subscribe.call(this, subscriber));
return subscription;
};
HotObservable.prototype.setup = function () {
var subject = this;
var messagesLength = subject.messages.length;
for (var i = 0; i < messagesLength; i++) {
(function () {
var message = subject.messages[i];
subject.scheduler.schedule(function () { message.notification.observe(subject); }, message.frame);
})();
}
};
return HotObservable;
}(Subject));
applyMixins(HotObservable, [SubscriptionLoggable]);
var defaultMaxFrame = 750;
var TestScheduler = (function (_super) {
__extends(TestScheduler, _super);
function TestScheduler(assertDeepEqual) {
var _this = _super.call(this, VirtualAction, defaultMaxFrame) || this;
_this.assertDeepEqual = assertDeepEqual;
_this.hotObservables = [];
_this.coldObservables = [];
_this.flushTests = [];
_this.runMode = false;
return _this;
}
TestScheduler.prototype.createTime = function (marbles) {
var indexOf = marbles.indexOf('|');
if (indexOf === -1) {
throw new Error('marble diagram for time should have a completion marker "|"');
}
return indexOf * TestScheduler.frameTimeFactor;
};
TestScheduler.prototype.createColdObservable = function (marbles, values, error) {
if (marbles.indexOf('^') !== -1) {
throw new Error('cold observable cannot have subscription offset "^"');
}
if (marbles.indexOf('!') !== -1) {
throw new Error('cold observable cannot have unsubscription marker "!"');
}
var messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode);
var cold = new ColdObservable(messages, this);
this.coldObservables.push(cold);
return cold;
};
TestScheduler.prototype.createHotObservable = function (marbles, values, error) {
if (marbles.indexOf('!') !== -1) {
throw new Error('hot observable cannot have unsubscription marker "!"');
}
var messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode);
var subject = new HotObservable(messages, this);
this.hotObservables.push(subject);
return subject;
};
TestScheduler.prototype.materializeInnerObservable = function (observable, outerFrame) {
var _this = this;
var messages = [];
observable.subscribe(function (value) {
messages.push({ frame: _this.frame - outerFrame, notification: Notification.createNext(value) });
}, function (err) {
messages.push({ frame: _this.frame - outerFrame, notification: Notification.createError(err) });
}, function () {
messages.push({ frame: _this.frame - outerFrame, notification: Notification.createComplete() });
});
return messages;
};
TestScheduler.prototype.expectObservable = function (observable, subscriptionMarbles) {
var _this = this;
if (subscriptionMarbles === void 0) { subscriptionMarbles = null; }
var actual = [];
var flushTest = { actual: actual, ready: false };
var subscriptionParsed = TestScheduler.parseMarblesAsSubscriptions(subscriptionMarbles, this.runMode);
var subscriptionFrame = subscriptionParsed.subscribedFrame === Number.POSITIVE_INFINITY ?
0 : subscriptionParsed.subscribedFrame;
var unsubscriptionFrame = subscriptionParsed.unsubscribedFrame;
var subscription;
this.schedule(function () {
subscription = observable.subscribe(function (x) {
var value = x;
if (x instanceof Observable) {
value = _this.materializeInnerObservable(value, _this.frame);
}
actual.push({ frame: _this.frame, notification: Notification.createNext(value) });
}, function (err) {
actual.push({ frame: _this.frame, notification: Notification.createError(err) });
}, function () {
actual.push({ frame: _this.frame, notification: Notification.createComplete() });
});
}, subscriptionFrame);
if (unsubscriptionFrame !== Number.POSITIVE_INFINITY) {
this.schedule(function () { return subscription.unsubscribe(); }, unsubscriptionFrame);
}
this.flushTests.push(flushTest);
var runMode = this.runMode;
return {
toBe: function (marbles, values, errorValue) {
flushTest.ready = true;
flushTest.expected = TestScheduler.parseMarbles(marbles, values, errorValue, true, runMode);
}
};
};
TestScheduler.prototype.expectSubscriptions = function (actualSubscriptionLogs) {
var flushTest = { actual: actualSubscriptionLogs, ready: false };
this.flushTests.push(flushTest);
var runMode = this.runMode;
return {
toBe: function (marbles) {
var marblesArray = (typeof marbles === 'string') ? [marbles] : marbles;
flushTest.ready = true;
flushTest.expected = marblesArray.map(function (marbles) {
return TestScheduler.parseMarblesAsSubscriptions(marbles, runMode);
});
}
};
};
TestScheduler.prototype.flush = function () {
var _this = this;
var hotObservables = this.hotObservables;
while (hotObservables.length > 0) {
hotObservables.shift().setup();
}
_super.prototype.flush.call(this);
this.flushTests = this.flushTests.filter(function (test) {
if (test.ready) {
_this.assertDeepEqual(test.actual, test.expected);
return false;
}
return true;
});
};
TestScheduler.parseMarblesAsSubscriptions = function (marbles, runMode) {
var _this = this;
if (runMode === void 0) { runMode = false; }
if (typeof marbles !== 'string') {
return new SubscriptionLog(Number.POSITIVE_INFINITY);
}
var len = marbles.length;
var groupStart = -1;
var subscriptionFrame = Number.POSITIVE_INFINITY;
var unsubscriptionFrame = Number.POSITIVE_INFINITY;
var frame = 0;
var _loop_1 = function (i) {
var nextFrame = frame;
var advanceFrameBy = function (count) {
nextFrame += count * _this.frameTimeFactor;
};
var c = marbles[i];
switch (c) {
case ' ':
if (!runMode) {
advanceFrameBy(1);
}
break;
case '-':
advanceFrameBy(1);
break;
case '(':
groupStart = frame;
advanceFrameBy(1);
break;
case ')':
groupStart = -1;
advanceFrameBy(1);
break;
case '^':
if (subscriptionFrame !== Number.POSITIVE_INFINITY) {
throw new Error('found a second subscription point \'^\' in a ' +
'subscription marble diagram. There can only be one.');
}
subscriptionFrame = groupStart > -1 ? groupStart : frame;
advanceFrameBy(1);
break;
case '!':
if (unsubscriptionFrame !== Number.POSITIVE_INFINITY) {
throw new Error('found a second subscription point \'^\' in a ' +
'subscription marble diagram. There can only be one.');
}
unsubscriptionFrame = groupStart > -1 ? groupStart : frame;
break;
default:
if (runMode && c.match(/^[0-9]$/)) {
if (i === 0 || marbles[i - 1] === ' ') {
var buffer = marbles.slice(i);
var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
if (match) {
i += match[0].length - 1;
var duration = parseFloat(match[1]);
var unit = match[2];
var durationInMs = void 0;
switch (unit) {
case 'ms':
durationInMs = duration;
break;
case 's':
durationInMs = duration * 1000;
break;
case 'm':
durationInMs = duration * 1000 * 60;
break;
default:
break;
}
advanceFrameBy(durationInMs / this_1.frameTimeFactor);
break;
}
}
}
throw new Error('there can only be \'^\' and \'!\' markers in a ' +
'subscription marble diagram. Found instead \'' + c + '\'.');
}
frame = nextFrame;
out_i_1 = i;
};
var this_1 = this, out_i_1;
for (var i = 0; i < len; i++) {
_loop_1(i);
i = out_i_1;
}
if (unsubscriptionFrame < 0) {
return new SubscriptionLog(subscriptionFrame);
}
else {
return new SubscriptionLog(subscriptionFrame, unsubscriptionFrame);
}
};
TestScheduler.parseMarbles = function (marbles, values, errorValue, materializeInnerObservables, runMode) {
var _this = this;
if (materializeInnerObservables === void 0) { materializeInnerObservables = false; }
if (runMode === void 0) { runMode = false; }
if (marbles.indexOf('!') !== -1) {
throw new Error('conventional marble diagrams cannot have the ' +
'unsubscription marker "!"');
}
var len = marbles.length;
var testMessages = [];
var subIndex = runMode ? marbles.replace(/^[ ]+/, '').indexOf('^') : marbles.indexOf('^');
var frame = subIndex === -1 ? 0 : (subIndex * -this.frameTimeFactor);
var getValue = typeof values !== 'object' ?
function (x) { return x; } :
function (x) {
if (materializeInnerObservables && values[x] instanceof ColdObservable) {
return values[x].messages;
}
return values[x];
};
var groupStart = -1;
var _loop_2 = function (i) {
var nextFrame = frame;
var advanceFrameBy = function (count) {
nextFrame += count * _this.frameTimeFactor;
};
var notification = void 0;
var c = marbles[i];
switch (c) {
case ' ':
if (!runMode) {
advanceFrameBy(1);
}
break;
case '-':
advanceFrameBy(1);
break;
case '(':
groupStart = frame;
advanceFrameBy(1);
break;
case ')':
groupStart = -1;
advanceFrameBy(1);
break;
case '|':
notification = Notification.createComplete();
advanceFrameBy(1);
break;
case '^':
advanceFrameBy(1);
break;
case '#':
notification = Notification.createError(errorValue || 'error');
advanceFrameBy(1);
break;
default:
if (runMode && c.match(/^[0-9]$/)) {
if (i === 0 || marbles[i - 1] === ' ') {
var buffer = marbles.slice(i);
var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
if (match) {
i += match[0].length - 1;
var duration = parseFloat(match[1]);
var unit = match[2];
var durationInMs = void 0;
switch (unit) {
case 'ms':
durationInMs = duration;
break;
case 's':
durationInMs = duration * 1000;
break;
case 'm':
durationInMs = duration * 1000 * 60;
break;
default:
break;
}
advanceFrameBy(durationInMs / this_2.frameTimeFactor);
break;
}
}
}
notification = Notification.createNext(getValue(c));
advanceFrameBy(1);
break;
}
if (notification) {
testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification: notification });
}
frame = nextFrame;
out_i_2 = i;
};
var this_2 = this, out_i_2;
for (var i = 0; i < len; i++) {
_loop_2(i);
i = out_i_2;
}
return testMessages;
};
TestScheduler.prototype.run = function (callback) {
var prevFrameTimeFactor = TestScheduler.frameTimeFactor;
var prevMaxFrames = this.maxFrames;
TestScheduler.frameTimeFactor = 1;
this.maxFrames = Number.POSITIVE_INFINITY;
this.runMode = true;
AsyncScheduler.delegate = this;
var helpers = {
cold: this.createColdObservable.bind(this),
hot: this.createHotObservable.bind(this),
flush: this.flush.bind(this),
expectObservable: this.expectObservable.bind(this),
expectSubscriptions: this.expectSubscriptions.bind(this),
};
try {
var ret = callback(helpers);
this.flush();
return ret;
}
finally {
TestScheduler.frameTimeFactor = prevFrameTimeFactor;
this.maxFrames = prevMaxFrames;
this.runMode = false;
AsyncScheduler.delegate = undefined;
}
};
return TestScheduler;
}(VirtualTimeScheduler));
var _testing = /*#__PURE__*/Object.freeze({
TestScheduler: TestScheduler
});
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;
(function () {
if (!_root) {
throw new Error('RxJS could not find any global context (window, self, global)');
}
})();
function getCORSRequest() {
if (_root.XMLHttpRequest) {
return new _root.XMLHttpRequest();
}
else if (!!_root.XDomainRequest) {
return new _root.XDomainRequest();
}
else {
throw new Error('CORS is not supported by your browser');
}
}
function getXMLHttpRequest() {
if (_root.XMLHttpRequest) {
return new _root.XMLHttpRequest();
}
else {
var progId = void 0;
try {
var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
for (var i = 0; i < 3; i++) {
try {
progId = progIds[i];
if (new _root.ActiveXObject(progId)) {
break;
}
}
catch (e) {
}
}
return new _root.ActiveXObject(progId);
}
catch (e) {
throw new Error('XMLHttpRequest is not supported by your browser');
}
}
}
function ajaxGet(url, headers) {
if (headers === void 0) { headers = null; }
return new AjaxObservable({ method: 'GET', url: url, headers: headers });
}
function ajaxPost(url, body, headers) {
return new AjaxObservable({ method: 'POST', url: url, body: body, headers: headers });
}
function ajaxDelete(url, headers) {
return new AjaxObservable({ method: 'DELETE', url: url, headers: headers });
}
function ajaxPut(url, body, headers) {
return new AjaxObservable({ method: 'PUT', url: url, body: body, headers: headers });
}
function ajaxPatch(url, body, headers) {
return new AjaxObservable({ method: 'PATCH', url: url, body: body, headers: headers });
}
var mapResponse = map(function (x, index) { return x.response; });
function ajaxGetJSON(url, headers) {
return mapResponse(new AjaxObservable({
method: 'GET',
url: url,
responseType: 'json',
headers: headers
}));
}
var AjaxObservable = (function (_super) {
__extends(AjaxObservable, _super);
function AjaxObservable(urlOrRequest) {
var _this = _super.call(this) || this;
var request = {
async: true,
createXHR: function () {
return this.crossDomain ? getCORSRequest() : getXMLHttpRequest();
},
crossDomain: true,
withCredentials: false,
headers: {},
method: 'GET',
responseType: 'json',
timeout: 0
};
if (typeof urlOrRequest === 'string') {
request.url = urlOrRequest;
}
else {
for (var prop in urlOrRequest) {
if (urlOrRequest.hasOwnProperty(prop)) {
request[prop] = urlOrRequest[prop];
}
}
}
_this.request = request;
return _this;
}
AjaxObservable.prototype._subscribe = function (subscriber) {
return new AjaxSubscriber(subscriber, this.request);
};
AjaxObservable.create = (function () {
var create = function (urlOrRequest) {
return new AjaxObservable(urlOrRequest);
};
create.get = ajaxGet;
create.post = ajaxPost;
create.delete = ajaxDelete;
create.put = ajaxPut;
create.patch = ajaxPatch;
create.getJSON = ajaxGetJSON;
return create;
})();
return AjaxObservable;
}(Observable));
var AjaxSubscriber = (function (_super) {
__extends(AjaxSubscriber, _super);
function AjaxSubscriber(destination, request) {
var _this = _super.call(this, destination) || this;
_this.request = request;
_this.done = false;
var headers = request.headers = request.headers || {};
if (!request.crossDomain && !_this.getHeader(headers, 'X-Requested-With')) {
headers['X-Requested-With'] = 'XMLHttpRequest';
}
var contentTypeHeader = _this.getHeader(headers, 'Content-Type');
if (!contentTypeHeader && !(_root.FormData && request.body instanceof _root.FormData) && typeof request.body !== 'undefined') {
headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
}
request.body = _this.serializeBody(request.body, _this.getHeader(request.headers, 'Content-Type'));
_this.send();
return _this;
}
AjaxSubscriber.prototype.next = function (e) {
this.done = true;
var _a = this, xhr = _a.xhr, request = _a.request, destination = _a.destination;
var result;
try {
result = new AjaxResponse(e, xhr, request);
}
catch (err) {
return destination.error(err);
}
destination.next(result);
};
AjaxSubscriber.prototype.send = function () {
var _a = this, request = _a.request, _b = _a.request, user = _b.user, method = _b.method, url = _b.url, async = _b.async, password = _b.password, headers = _b.headers, body = _b.body;
try {
var xhr = this.xhr = request.createXHR();
this.setupEvents(xhr, request);
if (user) {
xhr.open(method, url, async, user, password);
}
else {
xhr.open(method, url, async);
}
if (async) {
xhr.timeout = request.timeout;
xhr.responseType = request.responseType;
}
if ('withCredentials' in xhr) {
xhr.withCredentials = !!request.withCredentials;
}
this.setHeaders(xhr, headers);
if (body) {
xhr.send(body);
}
else {
xhr.send();
}
}
catch (err) {
this.error(err);
}
};
AjaxSubscriber.prototype.serializeBody = function (body, contentType) {
if (!body || typeof body === 'string') {
return body;
}
else if (_root.FormData && body instanceof _root.FormData) {
return body;
}
if (contentType) {
var splitIndex = contentType.indexOf(';');
if (splitIndex !== -1) {
contentType = contentType.substring(0, splitIndex);
}
}
switch (contentType) {
case 'application/x-www-form-urlencoded':
return Object.keys(body).map(function (key) { return encodeURIComponent(key) + "=" + encodeURIComponent(body[key]); }).join('&');
case 'application/json':
return JSON.stringify(body);
default:
return body;
}
};
AjaxSubscriber.prototype.setHeaders = function (xhr, headers) {
for (var key in headers) {
if (headers.hasOwnProperty(key)) {
xhr.setRequestHeader(key, headers[key]);
}
}
};
AjaxSubscriber.prototype.getHeader = function (headers, headerName) {
for (var key in headers) {
if (key.toLowerCase() === headerName.toLowerCase()) {
return headers[key];
}
}
return undefined;
};
AjaxSubscriber.prototype.setupEvents = function (xhr, request) {
var progressSubscriber = request.progressSubscriber;
function xhrTimeout(e) {
var _a = xhrTimeout, subscriber = _a.subscriber, progressSubscriber = _a.progressSubscriber, request = _a.request;
if (progressSubscriber) {
progressSubscriber.error(e);
}
var error;
try {
error = new AjaxTimeoutError(this, request);
}
catch (err) {
error = err;
}
subscriber.error(error);
}
xhr.ontimeout = xhrTimeout;
xhrTimeout.request = request;
xhrTimeout.subscriber = this;
xhrTimeout.progressSubscriber = progressSubscriber;
if (xhr.upload && 'withCredentials' in xhr) {
if (progressSubscriber) {
var xhrProgress_1;
xhrProgress_1 = function (e) {
var progressSubscriber = xhrProgress_1.progressSubscriber;
progressSubscriber.next(e);
};
if (_root.XDomainRequest) {
xhr.onprogress = xhrProgress_1;
}
else {
xhr.upload.onprogress = xhrProgress_1;
}
xhrProgress_1.progressSubscriber = progressSubscriber;
}
var xhrError_1;
xhrError_1 = function (e) {
var _a = xhrError_1, progressSubscriber = _a.progressSubscriber, subscriber = _a.subscriber, request = _a.request;
if (progressSubscriber) {
progressSubscriber.error(e);
}
var error;
try {
error = new AjaxError('ajax error', this, request);
}
catch (err) {
error = err;
}
subscriber.error(error);
};
xhr.onerror = xhrError_1;
xhrError_1.request = request;
xhrError_1.subscriber = this;
xhrError_1.progressSubscriber = progressSubscriber;
}
function xhrReadyStateChange(e) {
return;
}
xhr.onreadystatechange = xhrReadyStateChange;
xhrReadyStateChange.subscriber = this;
xhrReadyStateChange.progressSubscriber = progressSubscriber;
xhrReadyStateChange.request = request;
function xhrLoad(e) {
var _a = xhrLoad, subscriber = _a.subscriber, progressSubscriber = _a.progressSubscriber, request = _a.request;
if (this.readyState === 4) {
var status_1 = this.status === 1223 ? 204 : this.status;
var response = (this.responseType === 'text' ? (this.response || this.responseText) : this.response);
if (status_1 === 0) {
status_1 = response ? 200 : 0;
}
if (status_1 < 400) {
if (progressSubscriber) {
progressSubscriber.complete();
}
subscriber.next(e);
subscriber.complete();
}
else {
if (progressSubscriber) {
progressSubscriber.error(e);
}
var error = void 0;
try {
error = new AjaxError('ajax error ' + status_1, this, request);
}
catch (err) {
error = err;
}
subscriber.error(error);
}
}
}
xhr.onload = xhrLoad;
xhrLoad.subscriber = this;
xhrLoad.progressSubscriber = progressSubscriber;
xhrLoad.request = request;
};
AjaxSubscriber.prototype.unsubscribe = function () {
var _a = this, done = _a.done, xhr = _a.xhr;
if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {
xhr.abort();
}
_super.prototype.unsubscribe.call(this);
};
return AjaxSubscriber;
}(Subscriber));
var AjaxResponse = (function () {
function AjaxResponse(originalEvent, xhr, request) {
this.originalEvent = originalEvent;
this.xhr = xhr;
this.request = request;
this.status = xhr.status;
this.responseType = xhr.responseType || request.responseType;
this.response = parseXhrResponse(this.responseType, xhr);
}
return AjaxResponse;
}());
var AjaxErrorImpl = (function () {
function AjaxErrorImpl(message, xhr, request) {
Error.call(this);
this.message = message;
this.name = 'AjaxError';
this.xhr = xhr;
this.request = request;
this.status = xhr.status;
this.responseType = xhr.responseType || request.responseType;
this.response = parseXhrResponse(this.responseType, xhr);
return this;
}
AjaxErrorImpl.prototype = Object.create(Error.prototype);
return AjaxErrorImpl;
})();
var AjaxError = AjaxErrorImpl;
function parseJson(xhr) {
if ('response' in xhr) {
return xhr.responseType ? xhr.response : JSON.parse(xhr.response || xhr.responseText || 'null');
}
else {
return JSON.parse(xhr.responseText || 'null');
}
}
function parseXhrResponse(responseType, xhr) {
switch (responseType) {
case 'json':
return parseJson(xhr);
case 'xml':
return xhr.responseXML;
case 'text':
default:
return ('response' in xhr) ? xhr.response : xhr.responseText;
}
}
function AjaxTimeoutErrorImpl(xhr, request) {
AjaxError.call(this, 'ajax timeout', xhr, request);
this.name = 'AjaxTimeoutError';
return this;
}
var AjaxTimeoutError = AjaxTimeoutErrorImpl;
var ajax = (function () { return AjaxObservable.create; })();
var _ajax = /*#__PURE__*/Object.freeze({
ajax: ajax,
AjaxResponse: AjaxResponse,
AjaxError: AjaxError,
AjaxTimeoutError: AjaxTimeoutError
});
var DEFAULT_WEBSOCKET_CONFIG = {
url: '',
deserializer: function (e) { return JSON.parse(e.data); },
serializer: function (value) { return JSON.stringify(value); },
};
var WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT = 'WebSocketSubject.error must be called with an object with an error code, and an optional reason: { code: number, reason: string }';
var WebSocketSubject = (function (_super) {
__extends(WebSocketSubject, _super);
function WebSocketSubject(urlConfigOrSource, destination) {
var _this = _super.call(this) || this;
if (urlConfigOrSource instanceof Observable) {
_this.destination = destination;
_this.source = urlConfigOrSource;
}
else {
var config = _this._config = __assign({}, DEFAULT_WEBSOCKET_CONFIG);
_this._output = new Subject();
if (typeof urlConfigOrSource === 'string') {
config.url = urlConfigOrSource;
}
else {
for (var key in urlConfigOrSource) {
if (urlConfigOrSource.hasOwnProperty(key)) {
config[key] = urlConfigOrSource[key];
}
}
}
if (!config.WebSocketCtor && WebSocket) {
config.WebSocketCtor = WebSocket;
}
else if (!config.WebSocketCtor) {
throw new Error('no WebSocket constructor can be found');
}
_this.destination = new ReplaySubject();
}
return _this;
}
WebSocketSubject.prototype.lift = function (operator) {
var sock = new WebSocketSubject(this._config, this.destination);
sock.operator = operator;
sock.source = this;
return sock;
};
WebSocketSubject.prototype._resetState = function () {
this._socket = null;
if (!this.source) {
this.destination = new ReplaySubject();
}
this._output = new Subject();
};
WebSocketSubject.prototype.multiplex = function (subMsg, unsubMsg, messageFilter) {
var self = this;
return new Observable(function (observer) {
try {
self.next(subMsg());
}
catch (err) {
observer.error(err);
}
var subscription = self.subscribe(function (x) {
try {
if (messageFilter(x)) {
observer.next(x);
}
}
catch (err) {
observer.error(err);
}
}, function (err) { return observer.error(err); }, function () { return observer.complete(); });
return function () {
try {
self.next(unsubMsg());
}
catch (err) {
observer.error(err);
}
subscription.unsubscribe();
};
});
};
WebSocketSubject.prototype._connectSocket = function () {
var _this = this;
var _a = this._config, WebSocketCtor = _a.WebSocketCtor, protocol = _a.protocol, url = _a.url, binaryType = _a.binaryType;
var observer = this._output;
var socket = null;
try {
socket = protocol ?
new WebSocketCtor(url, protocol) :
new WebSocketCtor(url);
this._socket = socket;
if (binaryType) {
this._socket.binaryType = binaryType;
}
}
catch (e) {
observer.error(e);
return;
}
var subscription = new Subscription(function () {
_this._socket = null;
if (socket && socket.readyState === 1) {
socket.close();
}
});
socket.onopen = function (e) {
var _socket = _this._socket;
if (!_socket) {
socket.close();
_this._resetState();
return;
}
var openObserver = _this._config.openObserver;
if (openObserver) {
openObserver.next(e);
}
var queue = _this.destination;
_this.destination = Subscriber.create(function (x) {
if (socket.readyState === 1) {
try {
var serializer = _this._config.serializer;
socket.send(serializer(x));
}
catch (e) {
_this.destination.error(e);
}
}
}, function (e) {
var closingObserver = _this._config.closingObserver;
if (closingObserver) {
closingObserver.next(undefined);
}
if (e && e.code) {
socket.close(e.code, e.reason);
}
else {
observer.error(new TypeError(WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT));
}
_this._resetState();
}, function () {
var closingObserver = _this._config.closingObserver;
if (closingObserver) {
closingObserver.next(undefined);
}
socket.close();
_this._resetState();
});
if (queue && queue instanceof ReplaySubject) {
subscription.add(queue.subscribe(_this.destination));
}
};
socket.onerror = function (e) {
_this._resetState();
observer.error(e);
};
socket.onclose = function (e) {
_this._resetState();
var closeObserver = _this._config.closeObserver;
if (closeObserver) {
closeObserver.next(e);
}
if (e.wasClean) {
observer.complete();
}
else {
observer.error(e);
}
};
socket.onmessage = function (e) {
try {
var deserializer = _this._config.deserializer;
observer.next(deserializer(e));
}
catch (err) {
observer.error(err);
}
};
};
WebSocketSubject.prototype._subscribe = function (subscriber) {
var _this = this;
var source = this.source;
if (source) {
return source.subscribe(subscriber);
}
if (!this._socket) {
this._connectSocket();
}
this._output.subscribe(subscriber);
subscriber.add(function () {
var _socket = _this._socket;
if (_this._output.observers.length === 0) {
if (_socket && _socket.readyState === 1) {
_socket.close();
}
_this._resetState();
}
});
return subscriber;
};
WebSocketSubject.prototype.unsubscribe = function () {
var _socket = this._socket;
if (_socket && _socket.readyState === 1) {
_socket.close();
}
this._resetState();
_super.prototype.unsubscribe.call(this);
};
return WebSocketSubject;
}(AnonymousSubject));
function webSocket(urlConfigOrSource) {
return new WebSocketSubject(urlConfigOrSource);
}
var _webSocket = /*#__PURE__*/Object.freeze({
webSocket: webSocket,
WebSocketSubject: WebSocketSubject
});
function fromFetch(input, initWithSelector) {
if (initWithSelector === void 0) { initWithSelector = {}; }
var selector = initWithSelector.selector, init = __rest(initWithSelector, ["selector"]);
return new Observable(function (subscriber) {
var controller = new AbortController();
var signal = controller.signal;
var abortable = true;
var unsubscribed = false;
var subscription = new Subscription();
subscription.add(function () {
unsubscribed = true;
if (abortable) {
controller.abort();
}
});
var perSubscriberInit;
if (init) {
if (init.signal) {
if (init.signal.aborted) {
controller.abort();
}
else {
var outerSignal_1 = init.signal;
var outerSignalHandler_1 = function () {
if (!signal.aborted) {
controller.abort();
}
};
outerSignal_1.addEventListener('abort', outerSignalHandler_1);
subscription.add(function () { return outerSignal_1.removeEventListener('abort', outerSignalHandler_1); });
}
}
perSubscriberInit = __assign({}, init, { signal: signal });
}
else {
perSubscriberInit = { signal: signal };
}
fetch(input, perSubscriberInit).then(function (response) {
if (selector) {
subscription.add(from(selector(response)).subscribe(function (value) { return subscriber.next(value); }, function (err) {
abortable = false;
if (!unsubscribed) {
subscriber.error(err);
}
}, function () {
abortable = false;
subscriber.complete();
}));
}
else {
abortable = false;
subscriber.next(response);
subscriber.complete();
}
}).catch(function (err) {
abortable = false;
if (!unsubscribed) {
subscriber.error(err);
}
});
return subscription;
});
}
var _fetch = /*#__PURE__*/Object.freeze({
fromFetch: fromFetch
});
var operators = _operators;
var testing = _testing;
var ajax$1 = _ajax;
var webSocket$1 = _webSocket;
var fetch$1 = _fetch;
exports.operators = operators;
exports.testing = testing;
exports.ajax = ajax$1;
exports.webSocket = webSocket$1;
exports.fetch = fetch$1;
exports.Observable = Observable;
exports.ConnectableObservable = ConnectableObservable;
exports.GroupedObservable = GroupedObservable;
exports.observable = observable;
exports.Subject = Subject;
exports.BehaviorSubject = BehaviorSubject;
exports.ReplaySubject = ReplaySubject;
exports.AsyncSubject = AsyncSubject;
exports.asap = asap;
exports.asapScheduler = asapScheduler;
exports.async = async;
exports.asyncScheduler = asyncScheduler;
exports.queue = queue;
exports.queueScheduler = queueScheduler;
exports.animationFrame = animationFrame;
exports.animationFrameScheduler = animationFrameScheduler;
exports.VirtualTimeScheduler = VirtualTimeScheduler;
exports.VirtualAction = VirtualAction;
exports.Scheduler = Scheduler;
exports.Subscription = Subscription;
exports.Subscriber = Subscriber;
exports.Notification = Notification;
exports.pipe = pipe;
exports.noop = noop;
exports.identity = identity;
exports.isObservable = isObservable;
exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;
exports.EmptyError = EmptyError;
exports.ObjectUnsubscribedError = ObjectUnsubscribedError;
exports.UnsubscriptionError = UnsubscriptionError;
exports.TimeoutError = TimeoutError;
exports.bindCallback = bindCallback;
exports.bindNodeCallback = bindNodeCallback;
exports.combineLatest = combineLatest;
exports.concat = concat;
exports.defer = defer;
exports.empty = empty$1;
exports.forkJoin = forkJoin;
exports.from = from;
exports.fromEvent = fromEvent;
exports.fromEventPattern = fromEventPattern;
exports.generate = generate;
exports.iif = iif;
exports.interval = interval;
exports.merge = merge;
exports.never = never;
exports.of = of;
exports.onErrorResumeNext = onErrorResumeNext;
exports.pairs = pairs;
exports.partition = partition;
exports.race = race;
exports.range = range;
exports.throwError = throwError;
exports.timer = timer;
exports.using = using;
exports.zip = zip;
exports.scheduled = scheduled;
exports.EMPTY = EMPTY;
exports.NEVER = NEVER;
exports.config = config;
Object.defineProperty(exports, '__esModule', { value: true });
})));