@haiilo/catalyst 0.3.2 → 0.5.1

package/dist/components/cat-scrollable.js

@@ -200,11 +200,32 @@ function createNotification(kind, value, error) {
     };
 }
 
+let context = null;
 function errorContext(cb) {
-    {
+    if (config.useDeprecatedSynchronousErrorHandling) {
+        const isRoot = !context;
+        if (isRoot) {
+            context = { errorThrown: false, error: null };
+        }
+        cb();
+        if (isRoot) {
+            const { errorThrown, error } = context;
+            context = null;
+            if (errorThrown) {
+                throw error;
+            }
+        }
+    }
+    else {
         cb();
     }
 }
+function captureError(err) {
+    if (config.useDeprecatedSynchronousErrorHandling && context) {
+        context.errorThrown = true;
+        context.error = err;
+    }
+}
 
 class Subscriber extends Subscription {
     constructor(destination) {
@@ -351,7 +372,10 @@ class SafeSubscriber extends Subscriber {
     }
 }
 function handleUnhandledError(error) {
-    {
+    if (config.useDeprecatedSynchronousErrorHandling) {
+        captureError(error);
+    }
+    else {
         reportUnhandledError(error);
     }
 }
@@ -375,6 +399,9 @@ function identity(x) {
     return x;
 }
 
+function pipe(...fns) {
+    return pipeFromArray(fns);
+}
 function pipeFromArray(fns) {
     if (fns.length === 0) {
         return identity;
@@ -547,6 +574,140 @@ class OperatorSubscriber extends Subscriber {
     }
 }
 
+function refCount() {
+    return operate((source, subscriber) => {
+        let connection = null;
+        source._refCount++;
+        const refCounter = createOperatorSubscriber(subscriber, undefined, undefined, undefined, () => {
+            if (!source || source._refCount <= 0 || 0 < --source._refCount) {
+                connection = null;
+                return;
+            }
+            const sharedConnection = source._connection;
+            const conn = connection;
+            connection = null;
+            if (sharedConnection && (!conn || sharedConnection === conn)) {
+                sharedConnection.unsubscribe();
+            }
+            subscriber.unsubscribe();
+        });
+        source.subscribe(refCounter);
+        if (!refCounter.closed) {
+            connection = source.connect();
+        }
+    });
+}
+
+class ConnectableObservable extends Observable {
+    constructor(source, subjectFactory) {
+        super();
+        this.source = source;
+        this.subjectFactory = subjectFactory;
+        this._subject = null;
+        this._refCount = 0;
+        this._connection = null;
+        if (hasLift(source)) {
+            this.lift = source.lift;
+        }
+    }
+    _subscribe(subscriber) {
+        return this.getSubject().subscribe(subscriber);
+    }
+    getSubject() {
+        const subject = this._subject;
+        if (!subject || subject.isStopped) {
+            this._subject = this.subjectFactory();
+        }
+        return this._subject;
+    }
+    _teardown() {
+        this._refCount = 0;
+        const { _connection } = this;
+        this._subject = this._connection = null;
+        _connection === null || _connection === void 0 ? void 0 : _connection.unsubscribe();
+    }
+    connect() {
+        let connection = this._connection;
+        if (!connection) {
+            connection = this._connection = new Subscription();
+            const subject = this.getSubject();
+            connection.add(this.source.subscribe(createOperatorSubscriber(subject, undefined, () => {
+                this._teardown();
+                subject.complete();
+            }, (err) => {
+                this._teardown();
+                subject.error(err);
+            }, () => this._teardown())));
+            if (connection.closed) {
+                this._connection = null;
+                connection = Subscription.EMPTY;
+            }
+        }
+        return connection;
+    }
+    refCount() {
+        return refCount()(this);
+    }
+}
+
+const performanceTimestampProvider = {
+    now() {
+        return (performanceTimestampProvider.delegate || performance).now();
+    },
+    delegate: undefined,
+};
+
+const animationFrameProvider = {
+    schedule(callback) {
+        let request = requestAnimationFrame;
+        let cancel = cancelAnimationFrame;
+        const { delegate } = animationFrameProvider;
+        if (delegate) {
+            request = delegate.requestAnimationFrame;
+            cancel = delegate.cancelAnimationFrame;
+        }
+        const handle = request((timestamp) => {
+            cancel = undefined;
+            callback(timestamp);
+        });
+        return new Subscription(() => cancel === null || cancel === void 0 ? void 0 : cancel(handle));
+    },
+    requestAnimationFrame(...args) {
+        const { delegate } = animationFrameProvider;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.requestAnimationFrame) || requestAnimationFrame)(...args);
+    },
+    cancelAnimationFrame(...args) {
+        const { delegate } = animationFrameProvider;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.cancelAnimationFrame) || cancelAnimationFrame)(...args);
+    },
+    delegate: undefined,
+};
+
+function animationFrames(timestampProvider) {
+    return timestampProvider ? animationFramesFactory(timestampProvider) : DEFAULT_ANIMATION_FRAMES;
+}
+function animationFramesFactory(timestampProvider) {
+    const { schedule } = animationFrameProvider;
+    return new Observable((subscriber) => {
+        const subscription = new Subscription();
+        const provider = timestampProvider || performanceTimestampProvider;
+        const start = provider.now();
+        const run = (timestamp) => {
+            const now = provider.now();
+            subscriber.next({
+                timestamp: timestampProvider ? now : timestamp,
+                elapsed: now - start,
+            });
+            if (!subscriber.closed) {
+                subscription.add(schedule(run));
+            }
+        };
+        subscription.add(schedule(run));
+        return subscription;
+    });
+}
+const DEFAULT_ANIMATION_FRAMES = animationFramesFactory();
+
 const ObjectUnsubscribedError = createErrorClass((_super) => function ObjectUnsubscribedErrorImpl() {
     _super(this);
     this.name = 'ObjectUnsubscribedError';
@@ -682,23 +843,555 @@ class AnonymousSubject extends Subject {
     }
 }
 
+class BehaviorSubject extends Subject {
+    constructor(_value) {
+        super();
+        this._value = _value;
+    }
+    get value() {
+        return this.getValue();
+    }
+    _subscribe(subscriber) {
+        const subscription = super._subscribe(subscriber);
+        !subscription.closed && subscriber.next(this._value);
+        return subscription;
+    }
+    getValue() {
+        const { hasError, thrownError, _value } = this;
+        if (hasError) {
+            throw thrownError;
+        }
+        this._throwIfClosed();
+        return _value;
+    }
+    next(value) {
+        super.next((this._value = value));
+    }
+}
+
+const dateTimestampProvider = {
+    now() {
+        return (dateTimestampProvider.delegate || Date).now();
+    },
+    delegate: undefined,
+};
+
+class ReplaySubject extends Subject {
+    constructor(_bufferSize = Infinity, _windowTime = Infinity, _timestampProvider = dateTimestampProvider) {
+        super();
+        this._bufferSize = _bufferSize;
+        this._windowTime = _windowTime;
+        this._timestampProvider = _timestampProvider;
+        this._buffer = [];
+        this._infiniteTimeWindow = true;
+        this._infiniteTimeWindow = _windowTime === Infinity;
+        this._bufferSize = Math.max(1, _bufferSize);
+        this._windowTime = Math.max(1, _windowTime);
+    }
+    next(value) {
+        const { isStopped, _buffer, _infiniteTimeWindow, _timestampProvider, _windowTime } = this;
+        if (!isStopped) {
+            _buffer.push(value);
+            !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+        }
+        this._trimBuffer();
+        super.next(value);
+    }
+    _subscribe(subscriber) {
+        this._throwIfClosed();
+        this._trimBuffer();
+        const subscription = this._innerSubscribe(subscriber);
+        const { _infiniteTimeWindow, _buffer } = this;
+        const copy = _buffer.slice();
+        for (let i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+            subscriber.next(copy[i]);
+        }
+        this._checkFinalizedStatuses(subscriber);
+        return subscription;
+    }
+    _trimBuffer() {
+        const { _bufferSize, _timestampProvider, _buffer, _infiniteTimeWindow } = this;
+        const adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+        _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+        if (!_infiniteTimeWindow) {
+            const now = _timestampProvider.now();
+            let last = 0;
+            for (let i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
+                last = i;
+            }
+            last && _buffer.splice(0, last + 1);
+        }
+    }
+}
+
+class AsyncSubject extends Subject {
+    constructor() {
+        super(...arguments);
+        this._value = null;
+        this._hasValue = false;
+        this._isComplete = false;
+    }
+    _checkFinalizedStatuses(subscriber) {
+        const { hasError, _hasValue, _value, thrownError, isStopped, _isComplete } = this;
+        if (hasError) {
+            subscriber.error(thrownError);
+        }
+        else if (isStopped || _isComplete) {
+            _hasValue && subscriber.next(_value);
+            subscriber.complete();
+        }
+    }
+    next(value) {
+        if (!this.isStopped) {
+            this._value = value;
+            this._hasValue = true;
+        }
+    }
+    complete() {
+        const { _hasValue, _value, _isComplete } = this;
+        if (!_isComplete) {
+            this._isComplete = true;
+            _hasValue && super.next(_value);
+            super.complete();
+        }
+    }
+}
+
+class Action extends Subscription {
+    constructor(scheduler, work) {
+        super();
+    }
+    schedule(state, delay = 0) {
+        return this;
+    }
+}
+
+const intervalProvider = {
+    setInterval(handler, timeout, ...args) {
+        const { delegate } = intervalProvider;
+        if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
+            return delegate.setInterval(handler, timeout, ...args);
+        }
+        return setInterval(handler, timeout, ...args);
+    },
+    clearInterval(handle) {
+        const { delegate } = intervalProvider;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
+    },
+    delegate: undefined,
+};
+
+class AsyncAction extends Action {
+    constructor(scheduler, work) {
+        super(scheduler, work);
+        this.scheduler = scheduler;
+        this.work = work;
+        this.pending = false;
+    }
+    schedule(state, delay = 0) {
+        if (this.closed) {
+            return this;
+        }
+        this.state = state;
+        const id = this.id;
+        const 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;
+    }
+    requestAsyncId(scheduler, _id, delay = 0) {
+        return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+    }
+    recycleAsyncId(_scheduler, id, delay = 0) {
+        if (delay != null && this.delay === delay && this.pending === false) {
+            return id;
+        }
+        intervalProvider.clearInterval(id);
+        return undefined;
+    }
+    execute(state, delay) {
+        if (this.closed) {
+            return new Error('executing a cancelled action');
+        }
+        this.pending = false;
+        const 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);
+        }
+    }
+    _execute(state, _delay) {
+        let errored = false;
+        let errorValue;
+        try {
+            this.work(state);
+        }
+        catch (e) {
+            errored = true;
+            errorValue = e ? e : new Error('Scheduled action threw falsy error');
+        }
+        if (errored) {
+            this.unsubscribe();
+            return errorValue;
+        }
+    }
+    unsubscribe() {
+        if (!this.closed) {
+            const { id, scheduler } = this;
+            const { actions } = scheduler;
+            this.work = this.state = this.scheduler = null;
+            this.pending = false;
+            arrRemove(actions, this);
+            if (id != null) {
+                this.id = this.recycleAsyncId(scheduler, id, null);
+            }
+            this.delay = null;
+            super.unsubscribe();
+        }
+    }
+}
+
+let nextHandle = 1;
+let resolved;
+const activeHandles = {};
+function findAndClearHandle(handle) {
+    if (handle in activeHandles) {
+        delete activeHandles[handle];
+        return true;
+    }
+    return false;
+}
+const Immediate = {
+    setImmediate(cb) {
+        const handle = nextHandle++;
+        activeHandles[handle] = true;
+        if (!resolved) {
+            resolved = Promise.resolve();
+        }
+        resolved.then(() => findAndClearHandle(handle) && cb());
+        return handle;
+    },
+    clearImmediate(handle) {
+        findAndClearHandle(handle);
+    },
+};
+const TestTools = {
+    pending() {
+        return Object.keys(activeHandles).length;
+    }
+};
+
+const { setImmediate, clearImmediate } = Immediate;
+const immediateProvider = {
+    setImmediate(...args) {
+        const { delegate } = immediateProvider;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.setImmediate) || setImmediate)(...args);
+    },
+    clearImmediate(handle) {
+        const { delegate } = immediateProvider;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearImmediate) || clearImmediate)(handle);
+    },
+    delegate: undefined,
+};
+
+class AsapAction extends AsyncAction {
+    constructor(scheduler, work) {
+        super(scheduler, work);
+        this.scheduler = scheduler;
+        this.work = work;
+    }
+    requestAsyncId(scheduler, id, delay = 0) {
+        if (delay !== null && delay > 0) {
+            return super.requestAsyncId(scheduler, id, delay);
+        }
+        scheduler.actions.push(this);
+        return scheduler._scheduled || (scheduler._scheduled = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, undefined)));
+    }
+    recycleAsyncId(scheduler, id, delay = 0) {
+        if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
+            return super.recycleAsyncId(scheduler, id, delay);
+        }
+        if (!scheduler.actions.some((action) => action.id === id)) {
+            immediateProvider.clearImmediate(id);
+            scheduler._scheduled = undefined;
+        }
+        return undefined;
+    }
+}
+
+class Scheduler {
+    constructor(schedulerActionCtor, now = Scheduler.now) {
+        this.schedulerActionCtor = schedulerActionCtor;
+        this.now = now;
+    }
+    schedule(work, delay = 0, state) {
+        return new this.schedulerActionCtor(this, work).schedule(state, delay);
+    }
+}
+Scheduler.now = dateTimestampProvider.now;
+
+class AsyncScheduler extends Scheduler {
+    constructor(SchedulerAction, now = Scheduler.now) {
+        super(SchedulerAction, now);
+        this.actions = [];
+        this._active = false;
+        this._scheduled = undefined;
+    }
+    flush(action) {
+        const { actions } = this;
+        if (this._active) {
+            actions.push(action);
+            return;
+        }
+        let 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;
+        }
+    }
+}
+
+class AsapScheduler extends AsyncScheduler {
+    flush(action) {
+        this._active = true;
+        const flushId = this._scheduled;
+        this._scheduled = undefined;
+        const { actions } = this;
+        let error;
+        action = action || actions.shift();
+        do {
+            if ((error = action.execute(action.state, action.delay))) {
+                break;
+            }
+        } while ((action = actions[0]) && action.id === flushId && actions.shift());
+        this._active = false;
+        if (error) {
+            while ((action = actions[0]) && action.id === flushId && actions.shift()) {
+                action.unsubscribe();
+            }
+            throw error;
+        }
+    }
+}
+
+const asapScheduler = new AsapScheduler(AsapAction);
+const asap = asapScheduler;
+
+const asyncScheduler = new AsyncScheduler(AsyncAction);
+const async = asyncScheduler;
+
+class QueueAction extends AsyncAction {
+    constructor(scheduler, work) {
+        super(scheduler, work);
+        this.scheduler = scheduler;
+        this.work = work;
+    }
+    schedule(state, delay = 0) {
+        if (delay > 0) {
+            return super.schedule(state, delay);
+        }
+        this.delay = delay;
+        this.state = state;
+        this.scheduler.flush(this);
+        return this;
+    }
+    execute(state, delay) {
+        return (delay > 0 || this.closed) ?
+            super.execute(state, delay) :
+            this._execute(state, delay);
+    }
+    requestAsyncId(scheduler, id, delay = 0) {
+        if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
+            return super.requestAsyncId(scheduler, id, delay);
+        }
+        return scheduler.flush(this);
+    }
+}
+
+class QueueScheduler extends AsyncScheduler {
+}
+
+const queueScheduler = new QueueScheduler(QueueAction);
+const queue = queueScheduler;
+
+class AnimationFrameAction extends AsyncAction {
+    constructor(scheduler, work) {
+        super(scheduler, work);
+        this.scheduler = scheduler;
+        this.work = work;
+    }
+    requestAsyncId(scheduler, id, delay = 0) {
+        if (delay !== null && delay > 0) {
+            return super.requestAsyncId(scheduler, id, delay);
+        }
+        scheduler.actions.push(this);
+        return scheduler._scheduled || (scheduler._scheduled = animationFrameProvider.requestAnimationFrame(() => scheduler.flush(undefined)));
+    }
+    recycleAsyncId(scheduler, id, delay = 0) {
+        if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
+            return super.recycleAsyncId(scheduler, id, delay);
+        }
+        if (!scheduler.actions.some((action) => action.id === id)) {
+            animationFrameProvider.cancelAnimationFrame(id);
+            scheduler._scheduled = undefined;
+        }
+        return undefined;
+    }
+}
+
+class AnimationFrameScheduler extends AsyncScheduler {
+    flush(action) {
+        this._active = true;
+        const flushId = this._scheduled;
+        this._scheduled = undefined;
+        const { actions } = this;
+        let error;
+        action = action || actions.shift();
+        do {
+            if ((error = action.execute(action.state, action.delay))) {
+                break;
+            }
+        } while ((action = actions[0]) && action.id === flushId && actions.shift());
+        this._active = false;
+        if (error) {
+            while ((action = actions[0]) && action.id === flushId && actions.shift()) {
+                action.unsubscribe();
+            }
+            throw error;
+        }
+    }
+}
+
+const animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction);
+const animationFrame = animationFrameScheduler;
+
+class VirtualTimeScheduler extends AsyncScheduler {
+    constructor(schedulerActionCtor = VirtualAction, maxFrames = Infinity) {
+        super(schedulerActionCtor, () => this.frame);
+        this.maxFrames = maxFrames;
+        this.frame = 0;
+        this.index = -1;
+    }
+    flush() {
+        const { actions, maxFrames } = this;
+        let error;
+        let 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;
+class VirtualAction extends AsyncAction {
+    constructor(scheduler, work, index = (scheduler.index += 1)) {
+        super(scheduler, work);
+        this.scheduler = scheduler;
+        this.work = work;
+        this.index = index;
+        this.active = true;
+        this.index = scheduler.index = index;
+    }
+    schedule(state, delay = 0) {
+        if (Number.isFinite(delay)) {
+            if (!this.id) {
+                return super.schedule(state, delay);
+            }
+            this.active = false;
+            const action = new VirtualAction(this.scheduler, this.work);
+            this.add(action);
+            return action.schedule(state, delay);
+        }
+        else {
+            return Subscription.EMPTY;
+        }
+    }
+    requestAsyncId(scheduler, id, delay = 0) {
+        this.delay = scheduler.frame + delay;
+        const { actions } = scheduler;
+        actions.push(this);
+        actions.sort(VirtualAction.sortActions);
+        return true;
+    }
+    recycleAsyncId(scheduler, id, delay = 0) {
+        return undefined;
+    }
+    _execute(state, delay) {
+        if (this.active === true) {
+            return super._execute(state, delay);
+        }
+    }
+    static sortActions(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;
+        }
+    }
+}
+
 const EMPTY = new Observable((subscriber) => subscriber.complete());
+function empty(scheduler) {
+    return scheduler ? emptyScheduled(scheduler) : EMPTY;
+}
+function emptyScheduled(scheduler) {
+    return new Observable((subscriber) => scheduler.schedule(() => subscriber.complete()));
+}
 
 function isScheduler(value) {
     return value && isFunction(value.schedule);
 }
 
-function last(arr) {
+function last$1(arr) {
     return arr[arr.length - 1];
 }
+function popResultSelector(args) {
+    return isFunction(last$1(args)) ? args.pop() : undefined;
+}
 function popScheduler(args) {
-    return isScheduler(last(args)) ? args.pop() : undefined;
+    return isScheduler(last$1(args)) ? args.pop() : undefined;
 }
 function popNumber(args, defaultValue) {
-    return typeof last(args) === 'number' ? args.pop() : defaultValue;
+    return typeof last$1(args) === 'number' ? args.pop() : defaultValue;
 }
 
-/******************************************************************************
+/*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -712,19 +1405,113 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
+/* global Reflect, Promise */
 
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
 
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var __createBinding = Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+});
+
+function __exportStar(m, o) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
     if (o && typeof o.length === "number") return {
         next: function () {
@@ -735,6 +1522,49 @@ function __values(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
 
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+/** @deprecated */
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
 function __await(v) {
     return this instanceof __await ? (this.v = v, this) : new __await(v);
 }
@@ -751,12 +1581,54 @@ function __asyncGenerator(thisArg, _arguments, generator) {
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 }
 
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
 function __asyncValues(o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
     return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+var __setModuleDefault = Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+};
+
+function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 }
 
 const isArrayLike = ((x) => x && typeof x.length === 'number' && typeof x !== 'function');
@@ -1041,6 +1913,212 @@ function from(input, scheduler) {
     return scheduler ? scheduled(input, scheduler) : innerFrom(input);
 }
 
+function of(...args) {
+    const scheduler = popScheduler(args);
+    return from(args, scheduler);
+}
+
+function throwError(errorOrErrorFactory, scheduler) {
+    const errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : () => errorOrErrorFactory;
+    const init = (subscriber) => subscriber.error(errorFactory());
+    return new Observable(scheduler ? (subscriber) => scheduler.schedule(init, 0, subscriber) : init);
+}
+
+var NotificationKind;
+(function (NotificationKind) {
+    NotificationKind["NEXT"] = "N";
+    NotificationKind["ERROR"] = "E";
+    NotificationKind["COMPLETE"] = "C";
+})(NotificationKind || (NotificationKind = {}));
+class Notification {
+    constructor(kind, value, error) {
+        this.kind = kind;
+        this.value = value;
+        this.error = error;
+        this.hasValue = kind === 'N';
+    }
+    observe(observer) {
+        return observeNotification(this, observer);
+    }
+    do(nextHandler, errorHandler, completeHandler) {
+        const { kind, value, error } = this;
+        return kind === 'N' ? nextHandler === null || nextHandler === void 0 ? void 0 : nextHandler(value) : kind === 'E' ? errorHandler === null || errorHandler === void 0 ? void 0 : errorHandler(error) : completeHandler === null || completeHandler === void 0 ? void 0 : completeHandler();
+    }
+    accept(nextOrObserver, error, complete) {
+        var _a;
+        return isFunction((_a = nextOrObserver) === null || _a === void 0 ? void 0 : _a.next)
+            ? this.observe(nextOrObserver)
+            : this.do(nextOrObserver, error, complete);
+    }
+    toObservable() {
+        const { kind, value, error } = this;
+        const result = kind === 'N'
+            ?
+                of(value)
+            :
+                kind === 'E'
+                    ?
+                        throwError(() => error)
+                    :
+                        kind === 'C'
+                            ?
+                                EMPTY
+                            :
+                                0;
+        if (!result) {
+            throw new TypeError(`Unexpected notification kind ${kind}`);
+        }
+        return result;
+    }
+    static createNext(value) {
+        return new Notification('N', value);
+    }
+    static createError(err) {
+        return new Notification('E', undefined, err);
+    }
+    static createComplete() {
+        return Notification.completeNotification;
+    }
+}
+Notification.completeNotification = new Notification('C');
+function observeNotification(notification, observer) {
+    var _a, _b, _c;
+    const { kind, value, error } = notification;
+    if (typeof kind !== 'string') {
+        throw new TypeError('Invalid notification, missing "kind"');
+    }
+    kind === 'N' ? (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, value) : kind === 'E' ? (_b = observer.error) === null || _b === void 0 ? void 0 : _b.call(observer, error) : (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);
+}
+
+function isObservable(obj) {
+    return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe)));
+}
+
+const EmptyError = createErrorClass((_super) => function EmptyErrorImpl() {
+    _super(this);
+    this.name = 'EmptyError';
+    this.message = 'no elements in sequence';
+});
+
+function lastValueFrom(source, config) {
+    const hasConfig = typeof config === 'object';
+    return new Promise((resolve, reject) => {
+        let _hasValue = false;
+        let _value;
+        source.subscribe({
+            next: (value) => {
+                _value = value;
+                _hasValue = true;
+            },
+            error: reject,
+            complete: () => {
+                if (_hasValue) {
+                    resolve(_value);
+                }
+                else if (hasConfig) {
+                    resolve(config.defaultValue);
+                }
+                else {
+                    reject(new EmptyError());
+                }
+            },
+        });
+    });
+}
+
+function firstValueFrom(source, config) {
+    const hasConfig = typeof config === 'object';
+    return new Promise((resolve, reject) => {
+        const subscriber = new SafeSubscriber({
+            next: (value) => {
+                resolve(value);
+                subscriber.unsubscribe();
+            },
+            error: reject,
+            complete: () => {
+                if (hasConfig) {
+                    resolve(config.defaultValue);
+                }
+                else {
+                    reject(new EmptyError());
+                }
+            },
+        });
+        source.subscribe(subscriber);
+    });
+}
+
+const ArgumentOutOfRangeError = createErrorClass((_super) => function ArgumentOutOfRangeErrorImpl() {
+    _super(this);
+    this.name = 'ArgumentOutOfRangeError';
+    this.message = 'argument out of range';
+});
+
+const NotFoundError = createErrorClass((_super) => function NotFoundErrorImpl(message) {
+    _super(this);
+    this.name = 'NotFoundError';
+    this.message = message;
+});
+
+const SequenceError = createErrorClass((_super) => function SequenceErrorImpl(message) {
+    _super(this);
+    this.name = 'SequenceError';
+    this.message = message;
+});
+
+function isValidDate(value) {
+    return value instanceof Date && !isNaN(value);
+}
+
+const TimeoutError = createErrorClass((_super) => function TimeoutErrorImpl(info = null) {
+    _super(this);
+    this.message = 'Timeout has occurred';
+    this.name = 'TimeoutError';
+    this.info = info;
+});
+function timeout(config, schedulerArg) {
+    const { first, each, with: _with = timeoutErrorFactory, scheduler = schedulerArg !== null && schedulerArg !== void 0 ? schedulerArg : asyncScheduler, meta = null, } = (isValidDate(config) ? { first: config } : typeof config === 'number' ? { each: config } : config);
+    if (first == null && each == null) {
+        throw new TypeError('No timeout provided.');
+    }
+    return operate((source, subscriber) => {
+        let originalSourceSubscription;
+        let timerSubscription;
+        let lastValue = null;
+        let seen = 0;
+        const startTimer = (delay) => {
+            timerSubscription = executeSchedule(subscriber, scheduler, () => {
+                try {
+                    originalSourceSubscription.unsubscribe();
+                    innerFrom(_with({
+                        meta,
+                        lastValue,
+                        seen,
+                    })).subscribe(subscriber);
+                }
+                catch (err) {
+                    subscriber.error(err);
+                }
+            }, delay);
+        };
+        originalSourceSubscription = source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
+            seen++;
+            subscriber.next((lastValue = value));
+            each > 0 && startTimer(each);
+        }, undefined, undefined, () => {
+            if (!(timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.closed)) {
+                timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
+            }
+            lastValue = null;
+        }));
+        !seen && startTimer(first != null ? (typeof first === 'number' ? first : +first - scheduler.now()) : each);
+    });
+}
+function timeoutErrorFactory(info) {
+    throw new TimeoutError(info);
+}
+
 function map(project, thisArg) {
     return operate((source, subscriber) => {
         let index = 0;
@@ -1050,14 +2128,157 @@ function map(project, thisArg) {
     });
 }
 
-const { isArray } = Array;
+const { isArray: isArray$2 } = Array;
 function callOrApply(fn, args) {
-    return isArray(args) ? fn(...args) : fn(args);
+    return isArray$2(args) ? fn(...args) : fn(args);
 }
 function mapOneOrManyArgs(fn) {
     return map(args => callOrApply(fn, args));
 }
 
+function bindCallbackInternals(isNodeStyle, callbackFunc, resultSelector, scheduler) {
+    if (resultSelector) {
+        if (isScheduler(resultSelector)) {
+            scheduler = resultSelector;
+        }
+        else {
+            return function (...args) {
+                return bindCallbackInternals(isNodeStyle, callbackFunc, scheduler)
+                    .apply(this, args)
+                    .pipe(mapOneOrManyArgs(resultSelector));
+            };
+        }
+    }
+    if (scheduler) {
+        return function (...args) {
+            return bindCallbackInternals(isNodeStyle, callbackFunc)
+                .apply(this, args)
+                .pipe(subscribeOn(scheduler), observeOn(scheduler));
+        };
+    }
+    return function (...args) {
+        const subject = new AsyncSubject();
+        let uninitialized = true;
+        return new Observable((subscriber) => {
+            const subs = subject.subscribe(subscriber);
+            if (uninitialized) {
+                uninitialized = false;
+                let isAsync = false;
+                let isComplete = false;
+                callbackFunc.apply(this, [
+                    ...args,
+                    (...results) => {
+                        if (isNodeStyle) {
+                            const err = results.shift();
+                            if (err != null) {
+                                subject.error(err);
+                                return;
+                            }
+                        }
+                        subject.next(1 < results.length ? results : results[0]);
+                        isComplete = true;
+                        if (isAsync) {
+                            subject.complete();
+                        }
+                    },
+                ]);
+                if (isComplete) {
+                    subject.complete();
+                }
+                isAsync = true;
+            }
+            return subs;
+        });
+    };
+}
+
+function bindCallback(callbackFunc, resultSelector, scheduler) {
+    return bindCallbackInternals(false, callbackFunc, resultSelector, scheduler);
+}
+
+function bindNodeCallback(callbackFunc, resultSelector, scheduler) {
+    return bindCallbackInternals(true, callbackFunc, resultSelector, scheduler);
+}
+
+const { isArray: isArray$1 } = Array;
+const { getPrototypeOf, prototype: objectProto, keys: getKeys } = Object;
+function argsArgArrayOrObject(args) {
+    if (args.length === 1) {
+        const first = args[0];
+        if (isArray$1(first)) {
+            return { args: first, keys: null };
+        }
+        if (isPOJO(first)) {
+            const keys = getKeys(first);
+            return {
+                args: keys.map((key) => first[key]),
+                keys,
+            };
+        }
+    }
+    return { args: args, keys: null };
+}
+function isPOJO(obj) {
+    return obj && typeof obj === 'object' && getPrototypeOf(obj) === objectProto;
+}
+
+function createObject(keys, values) {
+    return keys.reduce((result, key, i) => ((result[key] = values[i]), result), {});
+}
+
+function combineLatest$1(...args) {
+    const scheduler = popScheduler(args);
+    const resultSelector = popResultSelector(args);
+    const { args: observables, keys } = argsArgArrayOrObject(args);
+    if (observables.length === 0) {
+        return from([], scheduler);
+    }
+    const result = new Observable(combineLatestInit(observables, scheduler, keys
+        ?
+            (values) => createObject(keys, values)
+        :
+            identity));
+    return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+function combineLatestInit(observables, scheduler, valueTransform = identity) {
+    return (subscriber) => {
+        maybeSchedule(scheduler, () => {
+            const { length } = observables;
+            const values = new Array(length);
+            let active = length;
+            let remainingFirstValues = length;
+            for (let i = 0; i < length; i++) {
+                maybeSchedule(scheduler, () => {
+                    const source = from(observables[i], scheduler);
+                    let hasFirstValue = false;
+                    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+                        values[i] = value;
+                        if (!hasFirstValue) {
+                            hasFirstValue = true;
+                            remainingFirstValues--;
+                        }
+                        if (!remainingFirstValues) {
+                            subscriber.next(valueTransform(values.slice()));
+                        }
+                    }, () => {
+                        if (!--active) {
+                            subscriber.complete();
+                        }
+                    }));
+                }, subscriber);
+            }
+        }, subscriber);
+    };
+}
+function maybeSchedule(scheduler, execute, subscription) {
+    if (scheduler) {
+        executeSchedule(subscription, scheduler, execute);
+    }
+    else {
+        execute();
+    }
+}
+
 function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
     const buffer = [];
     let active = 0;
@@ -1127,6 +2348,76 @@ function mergeAll(concurrent = Infinity) {
     return mergeMap(identity, concurrent);
 }
 
+function concatAll() {
+    return mergeAll(1);
+}
+
+function concat$1(...args) {
+    return concatAll()(from(args, popScheduler(args)));
+}
+
+function defer(observableFactory) {
+    return new Observable((subscriber) => {
+        innerFrom(observableFactory()).subscribe(subscriber);
+    });
+}
+
+const DEFAULT_CONFIG$1 = {
+    connector: () => new Subject(),
+    resetOnDisconnect: true,
+};
+function connectable(source, config = DEFAULT_CONFIG$1) {
+    let connection = null;
+    const { connector, resetOnDisconnect = true } = config;
+    let subject = connector();
+    const result = new Observable((subscriber) => {
+        return subject.subscribe(subscriber);
+    });
+    result.connect = () => {
+        if (!connection || connection.closed) {
+            connection = defer(() => source).subscribe(subject);
+            if (resetOnDisconnect) {
+                connection.add(() => (subject = connector()));
+            }
+        }
+        return connection;
+    };
+    return result;
+}
+
+function forkJoin(...args) {
+    const resultSelector = popResultSelector(args);
+    const { args: sources, keys } = argsArgArrayOrObject(args);
+    const result = new Observable((subscriber) => {
+        const { length } = sources;
+        if (!length) {
+            subscriber.complete();
+            return;
+        }
+        const values = new Array(length);
+        let remainingCompletions = length;
+        let remainingEmissions = length;
+        for (let sourceIndex = 0; sourceIndex < length; sourceIndex++) {
+            let hasValue = false;
+            innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, (value) => {
+                if (!hasValue) {
+                    hasValue = true;
+                    remainingEmissions--;
+                }
+                values[sourceIndex] = value;
+            }, () => remainingCompletions--, undefined, () => {
+                if (!remainingCompletions || !hasValue) {
+                    if (!remainingEmissions) {
+                        subscriber.next(keys ? createObject(keys, values) : values);
+                    }
+                    subscriber.complete();
+                }
+            }));
+        }
+    });
+    return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+
 const nodeEventEmitterMethods = ['addListener', 'removeListener'];
 const eventTargetMethods = ['addEventListener', 'removeEventListener'];
 const jqueryMethods = ['on', 'off'];
@@ -1173,7 +2464,93 @@ function isEventTarget(target) {
     return isFunction(target.addEventListener) && isFunction(target.removeEventListener);
 }
 
-function merge(...args) {
+function fromEventPattern(addHandler, removeHandler, resultSelector) {
+    if (resultSelector) {
+        return fromEventPattern(addHandler, removeHandler).pipe(mapOneOrManyArgs(resultSelector));
+    }
+    return new Observable((subscriber) => {
+        const handler = (...e) => subscriber.next(e.length === 1 ? e[0] : e);
+        const retValue = addHandler(handler);
+        return isFunction(removeHandler) ? () => removeHandler(handler, retValue) : undefined;
+    });
+}
+
+function generate(initialStateOrOptions, condition, iterate, resultSelectorOrScheduler, scheduler) {
+    let resultSelector;
+    let initialState;
+    if (arguments.length === 1) {
+        ({
+            initialState,
+            condition,
+            iterate,
+            resultSelector = identity,
+            scheduler,
+        } = initialStateOrOptions);
+    }
+    else {
+        initialState = initialStateOrOptions;
+        if (!resultSelectorOrScheduler || isScheduler(resultSelectorOrScheduler)) {
+            resultSelector = identity;
+            scheduler = resultSelectorOrScheduler;
+        }
+        else {
+            resultSelector = resultSelectorOrScheduler;
+        }
+    }
+    function* gen() {
+        for (let state = initialState; !condition || condition(state); state = iterate(state)) {
+            yield resultSelector(state);
+        }
+    }
+    return defer((scheduler
+        ?
+            () => scheduleIterable(gen(), scheduler)
+        :
+            gen));
+}
+
+function iif(condition, trueResult, falseResult) {
+    return defer(() => (condition() ? trueResult : falseResult));
+}
+
+function timer(dueTime = 0, intervalOrScheduler, scheduler = async) {
+    let intervalDuration = -1;
+    if (intervalOrScheduler != null) {
+        if (isScheduler(intervalOrScheduler)) {
+            scheduler = intervalOrScheduler;
+        }
+        else {
+            intervalDuration = intervalOrScheduler;
+        }
+    }
+    return new Observable((subscriber) => {
+        let due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
+        if (due < 0) {
+            due = 0;
+        }
+        let n = 0;
+        return scheduler.schedule(function () {
+            if (!subscriber.closed) {
+                subscriber.next(n++);
+                if (0 <= intervalDuration) {
+                    this.schedule(undefined, intervalDuration);
+                }
+                else {
+                    subscriber.complete();
+                }
+            }
+        }, due);
+    });
+}
+
+function interval(period = 0, scheduler = asyncScheduler) {
+    if (period < 0) {
+        period = 0;
+    }
+    return timer(period, period, scheduler);
+}
+
+function merge$1(...args) {
     const scheduler = popScheduler(args);
     const concurrent = popNumber(args, Infinity);
     const sources = args;
@@ -1187,6 +2564,56 @@ function merge(...args) {
                 mergeAll(concurrent)(from(sources, scheduler));
 }
 
+const NEVER = new Observable(noop);
+function never() {
+    return NEVER;
+}
+
+const { isArray } = Array;
+function argsOrArgArray(args) {
+    return args.length === 1 && isArray(args[0]) ? args[0] : args;
+}
+
+function onErrorResumeNext$1(...sources) {
+    const nextSources = argsOrArgArray(sources);
+    return operate((source, subscriber) => {
+        const remaining = [source, ...nextSources];
+        const subscribeNext = () => {
+            if (!subscriber.closed) {
+                if (remaining.length > 0) {
+                    let nextSource;
+                    try {
+                        nextSource = innerFrom(remaining.shift());
+                    }
+                    catch (err) {
+                        subscribeNext();
+                        return;
+                    }
+                    const innerSub = createOperatorSubscriber(subscriber, undefined, noop, noop);
+                    nextSource.subscribe(innerSub);
+                    innerSub.add(subscribeNext);
+                }
+                else {
+                    subscriber.complete();
+                }
+            }
+        };
+        subscribeNext();
+    });
+}
+
+function onErrorResumeNext(...sources) {
+    return onErrorResumeNext$1(argsOrArgArray(sources))(EMPTY);
+}
+
+function pairs(obj, scheduler) {
+    return from(Object.entries(obj), scheduler);
+}
+
+function not(pred, thisArg) {
+    return (value, index) => !pred.call(thisArg, value, index);
+}
+
 function filter(predicate, thisArg) {
     return operate((source, subscriber) => {
         let index = 0;
@@ -1194,6 +2621,562 @@ function filter(predicate, thisArg) {
     });
 }
 
+function partition$1(source, predicate, thisArg) {
+    return [filter(predicate, thisArg)(innerFrom(source)), filter(not(predicate, thisArg))(innerFrom(source))];
+}
+
+function race$1(...sources) {
+    sources = argsOrArgArray(sources);
+    return sources.length === 1 ? innerFrom(sources[0]) : new Observable(raceInit(sources));
+}
+function raceInit(sources) {
+    return (subscriber) => {
+        let subscriptions = [];
+        for (let i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {
+            subscriptions.push(innerFrom(sources[i]).subscribe(createOperatorSubscriber(subscriber, (value) => {
+                if (subscriptions) {
+                    for (let s = 0; s < subscriptions.length; s++) {
+                        s !== i && subscriptions[s].unsubscribe();
+                    }
+                    subscriptions = null;
+                }
+                subscriber.next(value);
+            })));
+        }
+    };
+}
+
+function range(start, count, scheduler) {
+    if (count == null) {
+        count = start;
+        start = 0;
+    }
+    if (count <= 0) {
+        return EMPTY;
+    }
+    const end = count + start;
+    return new Observable(scheduler
+        ?
+            (subscriber) => {
+                let n = start;
+                return scheduler.schedule(function () {
+                    if (n < end) {
+                        subscriber.next(n++);
+                        this.schedule();
+                    }
+                    else {
+                        subscriber.complete();
+                    }
+                });
+            }
+        :
+            (subscriber) => {
+                let n = start;
+                while (n < end && !subscriber.closed) {
+                    subscriber.next(n++);
+                }
+                subscriber.complete();
+            });
+}
+
+function using(resourceFactory, observableFactory) {
+    return new Observable((subscriber) => {
+        const resource = resourceFactory();
+        const result = observableFactory(resource);
+        const source = result ? innerFrom(result) : EMPTY;
+        source.subscribe(subscriber);
+        return () => {
+            if (resource) {
+                resource.unsubscribe();
+            }
+        };
+    });
+}
+
+function zip$1(...args) {
+    const resultSelector = popResultSelector(args);
+    const sources = argsOrArgArray(args);
+    return sources.length
+        ? new Observable((subscriber) => {
+            let buffers = sources.map(() => []);
+            let completed = sources.map(() => false);
+            subscriber.add(() => {
+                buffers = completed = null;
+            });
+            for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
+                innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, (value) => {
+                    buffers[sourceIndex].push(value);
+                    if (buffers.every((buffer) => buffer.length)) {
+                        const result = buffers.map((buffer) => buffer.shift());
+                        subscriber.next(resultSelector ? resultSelector(...result) : result);
+                        if (buffers.some((buffer, i) => !buffer.length && completed[i])) {
+                            subscriber.complete();
+                        }
+                    }
+                }, () => {
+                    completed[sourceIndex] = true;
+                    !buffers[sourceIndex].length && subscriber.complete();
+                }));
+            }
+            return () => {
+                buffers = completed = null;
+            };
+        })
+        : EMPTY;
+}
+
+function audit(durationSelector) {
+    return operate((source, subscriber) => {
+        let hasValue = false;
+        let lastValue = null;
+        let durationSubscriber = null;
+        let isComplete = false;
+        const endDuration = () => {
+            durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
+            durationSubscriber = null;
+            if (hasValue) {
+                hasValue = false;
+                const value = lastValue;
+                lastValue = null;
+                subscriber.next(value);
+            }
+            isComplete && subscriber.complete();
+        };
+        const cleanupDuration = () => {
+            durationSubscriber = null;
+            isComplete && subscriber.complete();
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            hasValue = true;
+            lastValue = value;
+            if (!durationSubscriber) {
+                innerFrom(durationSelector(value)).subscribe((durationSubscriber = createOperatorSubscriber(subscriber, endDuration, cleanupDuration)));
+            }
+        }, () => {
+            isComplete = true;
+            (!hasValue || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
+        }));
+    });
+}
+
+function auditTime(duration, scheduler = asyncScheduler) {
+    return audit(() => timer(duration, scheduler));
+}
+
+function buffer(closingNotifier) {
+    return operate((source, subscriber) => {
+        let currentBuffer = [];
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => currentBuffer.push(value), () => {
+            subscriber.next(currentBuffer);
+            subscriber.complete();
+        }));
+        closingNotifier.subscribe(createOperatorSubscriber(subscriber, () => {
+            const b = currentBuffer;
+            currentBuffer = [];
+            subscriber.next(b);
+        }, noop));
+        return () => {
+            currentBuffer = null;
+        };
+    });
+}
+
+function bufferCount(bufferSize, startBufferEvery = null) {
+    startBufferEvery = startBufferEvery !== null && startBufferEvery !== void 0 ? startBufferEvery : bufferSize;
+    return operate((source, subscriber) => {
+        let buffers = [];
+        let count = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            let toEmit = null;
+            if (count++ % startBufferEvery === 0) {
+                buffers.push([]);
+            }
+            for (const buffer of buffers) {
+                buffer.push(value);
+                if (bufferSize <= buffer.length) {
+                    toEmit = toEmit !== null && toEmit !== void 0 ? toEmit : [];
+                    toEmit.push(buffer);
+                }
+            }
+            if (toEmit) {
+                for (const buffer of toEmit) {
+                    arrRemove(buffers, buffer);
+                    subscriber.next(buffer);
+                }
+            }
+        }, () => {
+            for (const buffer of buffers) {
+                subscriber.next(buffer);
+            }
+            subscriber.complete();
+        }, undefined, () => {
+            buffers = null;
+        }));
+    });
+}
+
+function bufferTime(bufferTimeSpan, ...otherArgs) {
+    var _a, _b;
+    const scheduler = (_a = popScheduler(otherArgs)) !== null && _a !== void 0 ? _a : asyncScheduler;
+    const bufferCreationInterval = (_b = otherArgs[0]) !== null && _b !== void 0 ? _b : null;
+    const maxBufferSize = otherArgs[1] || Infinity;
+    return operate((source, subscriber) => {
+        let bufferRecords = [];
+        let restartOnEmit = false;
+        const emit = (record) => {
+            const { buffer, subs } = record;
+            subs.unsubscribe();
+            arrRemove(bufferRecords, record);
+            subscriber.next(buffer);
+            restartOnEmit && startBuffer();
+        };
+        const startBuffer = () => {
+            if (bufferRecords) {
+                const subs = new Subscription();
+                subscriber.add(subs);
+                const buffer = [];
+                const record = {
+                    buffer,
+                    subs,
+                };
+                bufferRecords.push(record);
+                executeSchedule(subs, scheduler, () => emit(record), bufferTimeSpan);
+            }
+        };
+        if (bufferCreationInterval !== null && bufferCreationInterval >= 0) {
+            executeSchedule(subscriber, scheduler, startBuffer, bufferCreationInterval, true);
+        }
+        else {
+            restartOnEmit = true;
+        }
+        startBuffer();
+        const bufferTimeSubscriber = createOperatorSubscriber(subscriber, (value) => {
+            const recordsCopy = bufferRecords.slice();
+            for (const record of recordsCopy) {
+                const { buffer } = record;
+                buffer.push(value);
+                maxBufferSize <= buffer.length && emit(record);
+            }
+        }, () => {
+            while (bufferRecords === null || bufferRecords === void 0 ? void 0 : bufferRecords.length) {
+                subscriber.next(bufferRecords.shift().buffer);
+            }
+            bufferTimeSubscriber === null || bufferTimeSubscriber === void 0 ? void 0 : bufferTimeSubscriber.unsubscribe();
+            subscriber.complete();
+            subscriber.unsubscribe();
+        }, undefined, () => (bufferRecords = null));
+        source.subscribe(bufferTimeSubscriber);
+    });
+}
+
+function bufferToggle(openings, closingSelector) {
+    return operate((source, subscriber) => {
+        const buffers = [];
+        innerFrom(openings).subscribe(createOperatorSubscriber(subscriber, (openValue) => {
+            const buffer = [];
+            buffers.push(buffer);
+            const closingSubscription = new Subscription();
+            const emitBuffer = () => {
+                arrRemove(buffers, buffer);
+                subscriber.next(buffer);
+                closingSubscription.unsubscribe();
+            };
+            closingSubscription.add(innerFrom(closingSelector(openValue)).subscribe(createOperatorSubscriber(subscriber, emitBuffer, noop)));
+        }, noop));
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            for (const buffer of buffers) {
+                buffer.push(value);
+            }
+        }, () => {
+            while (buffers.length > 0) {
+                subscriber.next(buffers.shift());
+            }
+            subscriber.complete();
+        }));
+    });
+}
+
+function bufferWhen(closingSelector) {
+    return operate((source, subscriber) => {
+        let buffer = null;
+        let closingSubscriber = null;
+        const openBuffer = () => {
+            closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
+            const b = buffer;
+            buffer = [];
+            b && subscriber.next(b);
+            innerFrom(closingSelector()).subscribe((closingSubscriber = createOperatorSubscriber(subscriber, openBuffer, noop)));
+        };
+        openBuffer();
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => buffer === null || buffer === void 0 ? void 0 : buffer.push(value), () => {
+            buffer && subscriber.next(buffer);
+            subscriber.complete();
+        }, undefined, () => (buffer = closingSubscriber = null)));
+    });
+}
+
+function catchError(selector) {
+    return operate((source, subscriber) => {
+        let innerSub = null;
+        let syncUnsub = false;
+        let handledResult;
+        innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, undefined, (err) => {
+            handledResult = innerFrom(selector(err, catchError(selector)(source)));
+            if (innerSub) {
+                innerSub.unsubscribe();
+                innerSub = null;
+                handledResult.subscribe(subscriber);
+            }
+            else {
+                syncUnsub = true;
+            }
+        }));
+        if (syncUnsub) {
+            innerSub.unsubscribe();
+            innerSub = null;
+            handledResult.subscribe(subscriber);
+        }
+    });
+}
+
+function scanInternals(accumulator, seed, hasSeed, emitOnNext, emitBeforeComplete) {
+    return (source, subscriber) => {
+        let hasState = hasSeed;
+        let state = seed;
+        let index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const i = index++;
+            state = hasState
+                ?
+                    accumulator(state, value, i)
+                :
+                    ((hasState = true), value);
+            emitOnNext && subscriber.next(state);
+        }, emitBeforeComplete &&
+            (() => {
+                hasState && subscriber.next(state);
+                subscriber.complete();
+            })));
+    };
+}
+
+function reduce(accumulator, seed) {
+    return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true));
+}
+
+const arrReducer = (arr, value) => (arr.push(value), arr);
+function toArray() {
+    return operate((source, subscriber) => {
+        reduce(arrReducer, [])(source).subscribe(subscriber);
+    });
+}
+
+function joinAllInternals(joinFn, project) {
+    return pipe(toArray(), mergeMap((sources) => joinFn(sources)), project ? mapOneOrManyArgs(project) : identity);
+}
+
+function combineLatestAll(project) {
+    return joinAllInternals(combineLatest$1, project);
+}
+
+const combineAll = combineLatestAll;
+
+function combineLatest(...args) {
+    const resultSelector = popResultSelector(args);
+    return resultSelector
+        ? pipe(combineLatest(...args), mapOneOrManyArgs(resultSelector))
+        : operate((source, subscriber) => {
+            combineLatestInit([source, ...argsOrArgArray(args)])(subscriber);
+        });
+}
+
+function combineLatestWith(...otherSources) {
+    return combineLatest(...otherSources);
+}
+
+function concatMap(project, resultSelector) {
+    return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
+}
+
+function concatMapTo(innerObservable, resultSelector) {
+    return isFunction(resultSelector) ? concatMap(() => innerObservable, resultSelector) : concatMap(() => innerObservable);
+}
+
+function concat(...args) {
+    const scheduler = popScheduler(args);
+    return operate((source, subscriber) => {
+        concatAll()(from([source, ...args], scheduler)).subscribe(subscriber);
+    });
+}
+
+function concatWith(...otherSources) {
+    return concat(...otherSources);
+}
+
+function fromSubscribable(subscribable) {
+    return new Observable((subscriber) => subscribable.subscribe(subscriber));
+}
+
+const DEFAULT_CONFIG = {
+    connector: () => new Subject(),
+};
+function connect(selector, config = DEFAULT_CONFIG) {
+    const { connector } = config;
+    return operate((source, subscriber) => {
+        const subject = connector();
+        from(selector(fromSubscribable(subject))).subscribe(subscriber);
+        subscriber.add(source.subscribe(subject));
+    });
+}
+
+function count(predicate) {
+    return reduce((total, value, i) => (!predicate || predicate(value, i) ? total + 1 : total), 0);
+}
+
+function debounce(durationSelector) {
+    return operate((source, subscriber) => {
+        let hasValue = false;
+        let lastValue = null;
+        let durationSubscriber = null;
+        const emit = () => {
+            durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
+            durationSubscriber = null;
+            if (hasValue) {
+                hasValue = false;
+                const value = lastValue;
+                lastValue = null;
+                subscriber.next(value);
+            }
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
+            hasValue = true;
+            lastValue = value;
+            durationSubscriber = createOperatorSubscriber(subscriber, emit, noop);
+            innerFrom(durationSelector(value)).subscribe(durationSubscriber);
+        }, () => {
+            emit();
+            subscriber.complete();
+        }, undefined, () => {
+            lastValue = durationSubscriber = null;
+        }));
+    });
+}
+
+function debounceTime(dueTime, scheduler = asyncScheduler) {
+    return operate((source, subscriber) => {
+        let activeTask = null;
+        let lastValue = null;
+        let lastTime = null;
+        const emit = () => {
+            if (activeTask) {
+                activeTask.unsubscribe();
+                activeTask = null;
+                const value = lastValue;
+                lastValue = null;
+                subscriber.next(value);
+            }
+        };
+        function emitWhenIdle() {
+            const targetTime = lastTime + dueTime;
+            const now = scheduler.now();
+            if (now < targetTime) {
+                activeTask = this.schedule(undefined, targetTime - now);
+                subscriber.add(activeTask);
+                return;
+            }
+            emit();
+        }
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            lastValue = value;
+            lastTime = scheduler.now();
+            if (!activeTask) {
+                activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+                subscriber.add(activeTask);
+            }
+        }, () => {
+            emit();
+            subscriber.complete();
+        }, undefined, () => {
+            lastValue = activeTask = null;
+        }));
+    });
+}
+
+function defaultIfEmpty(defaultValue) {
+    return operate((source, subscriber) => {
+        let hasValue = false;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            hasValue = true;
+            subscriber.next(value);
+        }, () => {
+            if (!hasValue) {
+                subscriber.next(defaultValue);
+            }
+            subscriber.complete();
+        }));
+    });
+}
+
+function take(count) {
+    return count <= 0
+        ?
+            () => EMPTY
+        : operate((source, subscriber) => {
+            let seen = 0;
+            source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+                if (++seen <= count) {
+                    subscriber.next(value);
+                    if (count <= seen) {
+                        subscriber.complete();
+                    }
+                }
+            }));
+        });
+}
+
+function ignoreElements() {
+    return operate((source, subscriber) => {
+        source.subscribe(createOperatorSubscriber(subscriber, noop));
+    });
+}
+
+function mapTo(value) {
+    return map(() => value);
+}
+
+function delayWhen(delayDurationSelector, subscriptionDelay) {
+    if (subscriptionDelay) {
+        return (source) => concat$1(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector)));
+    }
+    return mergeMap((value, index) => delayDurationSelector(value, index).pipe(take(1), mapTo(value)));
+}
+
+function delay(due, scheduler = asyncScheduler) {
+    const duration = timer(due, scheduler);
+    return delayWhen(() => duration);
+}
+
+function dematerialize() {
+    return operate((source, subscriber) => {
+        source.subscribe(createOperatorSubscriber(subscriber, (notification) => observeNotification(notification, subscriber)));
+    });
+}
+
+function distinct(keySelector, flushes) {
+    return operate((source, subscriber) => {
+        const distinctKeys = new Set();
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const key = keySelector ? keySelector(value) : value;
+            if (!distinctKeys.has(key)) {
+                distinctKeys.add(key);
+                subscriber.next(value);
+            }
+        }));
+        flushes === null || flushes === void 0 ? void 0 : flushes.subscribe(createOperatorSubscriber(subscriber, () => distinctKeys.clear(), noop));
+    });
+}
+
 function distinctUntilChanged(comparator, keySelector = identity) {
     comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
     return operate((source, subscriber) => {
@@ -1213,13 +3196,1216 @@ function defaultCompare(a, b) {
     return a === b;
 }
 
-function takeUntil(notifier) {
+function distinctUntilKeyChanged(key, compare) {
+    return distinctUntilChanged((x, y) => compare ? compare(x[key], y[key]) : x[key] === y[key]);
+}
+
+function throwIfEmpty(errorFactory = defaultErrorFactory) {
     return operate((source, subscriber) => {
-        innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop));
-        !subscriber.closed && source.subscribe(subscriber);
+        let hasValue = false;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            hasValue = true;
+            subscriber.next(value);
+        }, () => (hasValue ? subscriber.complete() : subscriber.error(errorFactory()))));
+    });
+}
+function defaultErrorFactory() {
+    return new EmptyError();
+}
+
+function elementAt(index, defaultValue) {
+    if (index < 0) {
+        throw new ArgumentOutOfRangeError();
+    }
+    const hasDefaultValue = arguments.length >= 2;
+    return (source) => source.pipe(filter((v, i) => i === index), take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(() => new ArgumentOutOfRangeError()));
+}
+
+function endWith(...values) {
+    return (source) => concat$1(source, of(...values));
+}
+
+function every(predicate, thisArg) {
+    return operate((source, subscriber) => {
+        let index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            if (!predicate.call(thisArg, value, index++, source)) {
+                subscriber.next(false);
+                subscriber.complete();
+            }
+        }, () => {
+            subscriber.next(true);
+            subscriber.complete();
+        }));
+    });
+}
+
+function exhaustAll() {
+    return operate((source, subscriber) => {
+        let isComplete = false;
+        let innerSub = null;
+        source.subscribe(createOperatorSubscriber(subscriber, (inner) => {
+            if (!innerSub) {
+                innerSub = innerFrom(inner).subscribe(createOperatorSubscriber(subscriber, undefined, () => {
+                    innerSub = null;
+                    isComplete && subscriber.complete();
+                }));
+            }
+        }, () => {
+            isComplete = true;
+            !innerSub && subscriber.complete();
+        }));
     });
 }
 
+const exhaust = exhaustAll;
+
+function exhaustMap(project, resultSelector) {
+    if (resultSelector) {
+        return (source) => source.pipe(exhaustMap((a, i) => innerFrom(project(a, i)).pipe(map((b, ii) => resultSelector(a, b, i, ii)))));
+    }
+    return operate((source, subscriber) => {
+        let index = 0;
+        let innerSub = null;
+        let isComplete = false;
+        source.subscribe(createOperatorSubscriber(subscriber, (outerValue) => {
+            if (!innerSub) {
+                innerSub = createOperatorSubscriber(subscriber, undefined, () => {
+                    innerSub = null;
+                    isComplete && subscriber.complete();
+                });
+                innerFrom(project(outerValue, index++)).subscribe(innerSub);
+            }
+        }, () => {
+            isComplete = true;
+            !innerSub && subscriber.complete();
+        }));
+    });
+}
+
+function expand(project, concurrent = Infinity, scheduler) {
+    concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
+    return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent, undefined, true, scheduler));
+}
+
+function finalize(callback) {
+    return operate((source, subscriber) => {
+        try {
+            source.subscribe(subscriber);
+        }
+        finally {
+            subscriber.add(callback);
+        }
+    });
+}
+
+function find(predicate, thisArg) {
+    return operate(createFind(predicate, thisArg, 'value'));
+}
+function createFind(predicate, thisArg, emit) {
+    const findIndex = emit === 'index';
+    return (source, subscriber) => {
+        let index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const i = index++;
+            if (predicate.call(thisArg, value, i, source)) {
+                subscriber.next(findIndex ? i : value);
+                subscriber.complete();
+            }
+        }, () => {
+            subscriber.next(findIndex ? -1 : undefined);
+            subscriber.complete();
+        }));
+    };
+}
+
+function findIndex(predicate, thisArg) {
+    return operate(createFind(predicate, thisArg, 'index'));
+}
+
+function first(predicate, defaultValue) {
+    const hasDefaultValue = arguments.length >= 2;
+    return (source) => source.pipe(predicate ? filter((v, i) => predicate(v, i, source)) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(() => new EmptyError()));
+}
+
+function groupBy(keySelector, elementOrOptions, duration, connector) {
+    return operate((source, subscriber) => {
+        let element;
+        if (!elementOrOptions || typeof elementOrOptions === 'function') {
+            element = elementOrOptions;
+        }
+        else {
+            ({ duration, element, connector } = elementOrOptions);
+        }
+        const groups = new Map();
+        const notify = (cb) => {
+            groups.forEach(cb);
+            cb(subscriber);
+        };
+        const handleError = (err) => notify((consumer) => consumer.error(err));
+        let activeGroups = 0;
+        let teardownAttempted = false;
+        const groupBySourceSubscriber = new OperatorSubscriber(subscriber, (value) => {
+            try {
+                const key = keySelector(value);
+                let group = groups.get(key);
+                if (!group) {
+                    groups.set(key, (group = connector ? connector() : new Subject()));
+                    const grouped = createGroupedObservable(key, group);
+                    subscriber.next(grouped);
+                    if (duration) {
+                        const durationSubscriber = createOperatorSubscriber(group, () => {
+                            group.complete();
+                            durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
+                        }, undefined, undefined, () => groups.delete(key));
+                        groupBySourceSubscriber.add(innerFrom(duration(grouped)).subscribe(durationSubscriber));
+                    }
+                }
+                group.next(element ? element(value) : value);
+            }
+            catch (err) {
+                handleError(err);
+            }
+        }, () => notify((consumer) => consumer.complete()), handleError, () => groups.clear(), () => {
+            teardownAttempted = true;
+            return activeGroups === 0;
+        });
+        source.subscribe(groupBySourceSubscriber);
+        function createGroupedObservable(key, groupSubject) {
+            const result = new Observable((groupSubscriber) => {
+                activeGroups++;
+                const innerSub = groupSubject.subscribe(groupSubscriber);
+                return () => {
+                    innerSub.unsubscribe();
+                    --activeGroups === 0 && teardownAttempted && groupBySourceSubscriber.unsubscribe();
+                };
+            });
+            result.key = key;
+            return result;
+        }
+    });
+}
+
+function isEmpty() {
+    return operate((source, subscriber) => {
+        source.subscribe(createOperatorSubscriber(subscriber, () => {
+            subscriber.next(false);
+            subscriber.complete();
+        }, () => {
+            subscriber.next(true);
+            subscriber.complete();
+        }));
+    });
+}
+
+function takeLast(count) {
+    return count <= 0
+        ? () => EMPTY
+        : operate((source, subscriber) => {
+            let buffer = [];
+            source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+                buffer.push(value);
+                count < buffer.length && buffer.shift();
+            }, () => {
+                for (const value of buffer) {
+                    subscriber.next(value);
+                }
+                subscriber.complete();
+            }, undefined, () => {
+                buffer = null;
+            }));
+        });
+}
+
+function last(predicate, defaultValue) {
+    const hasDefaultValue = arguments.length >= 2;
+    return (source) => source.pipe(predicate ? filter((v, i) => predicate(v, i, source)) : identity, takeLast(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(() => new EmptyError()));
+}
+
+function materialize() {
+    return operate((source, subscriber) => {
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            subscriber.next(Notification.createNext(value));
+        }, () => {
+            subscriber.next(Notification.createComplete());
+            subscriber.complete();
+        }, (err) => {
+            subscriber.next(Notification.createError(err));
+            subscriber.complete();
+        }));
+    });
+}
+
+function max(comparer) {
+    return reduce(isFunction(comparer) ? (x, y) => (comparer(x, y) > 0 ? x : y) : (x, y) => (x > y ? x : y));
+}
+
+const flatMap = mergeMap;
+
+function mergeMapTo(innerObservable, resultSelector, concurrent = Infinity) {
+    if (isFunction(resultSelector)) {
+        return mergeMap(() => innerObservable, resultSelector, concurrent);
+    }
+    if (typeof resultSelector === 'number') {
+        concurrent = resultSelector;
+    }
+    return mergeMap(() => innerObservable, concurrent);
+}
+
+function mergeScan(accumulator, seed, concurrent = Infinity) {
+    return operate((source, subscriber) => {
+        let state = seed;
+        return mergeInternals(source, subscriber, (value, index) => accumulator(state, value, index), concurrent, (value) => {
+            state = value;
+        }, false, undefined, () => (state = null));
+    });
+}
+
+function merge(...args) {
+    const scheduler = popScheduler(args);
+    const concurrent = popNumber(args, Infinity);
+    args = argsOrArgArray(args);
+    return operate((source, subscriber) => {
+        mergeAll(concurrent)(from([source, ...args], scheduler)).subscribe(subscriber);
+    });
+}
+
+function mergeWith(...otherSources) {
+    return merge(...otherSources);
+}
+
+function min(comparer) {
+    return reduce(isFunction(comparer) ? (x, y) => (comparer(x, y) < 0 ? x : y) : (x, y) => (x < y ? x : y));
+}
+
+function multicast(subjectOrSubjectFactory, selector) {
+    const subjectFactory = isFunction(subjectOrSubjectFactory) ? subjectOrSubjectFactory : () => subjectOrSubjectFactory;
+    if (isFunction(selector)) {
+        return connect(selector, {
+            connector: subjectFactory,
+        });
+    }
+    return (source) => new ConnectableObservable(source, subjectFactory);
+}
+
+function pairwise() {
+    return operate((source, subscriber) => {
+        let prev;
+        let hasPrev = false;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const p = prev;
+            prev = value;
+            hasPrev && subscriber.next([p, value]);
+            hasPrev = true;
+        }));
+    });
+}
+
+function pluck(...properties) {
+    const length = properties.length;
+    if (length === 0) {
+        throw new Error('list of properties cannot be empty.');
+    }
+    return map((x) => {
+        let currentProp = x;
+        for (let i = 0; i < length; i++) {
+            const p = currentProp === null || currentProp === void 0 ? void 0 : currentProp[properties[i]];
+            if (typeof p !== 'undefined') {
+                currentProp = p;
+            }
+            else {
+                return undefined;
+            }
+        }
+        return currentProp;
+    });
+}
+
+function publish(selector) {
+    return selector ? (source) => connect(selector)(source) : (source) => multicast(new Subject())(source);
+}
+
+function publishBehavior(initialValue) {
+    return (source) => {
+        const subject = new BehaviorSubject(initialValue);
+        return new ConnectableObservable(source, () => subject);
+    };
+}
+
+function publishLast() {
+    return (source) => {
+        const subject = new AsyncSubject();
+        return new ConnectableObservable(source, () => subject);
+    };
+}
+
+function publishReplay(bufferSize, windowTime, selectorOrScheduler, timestampProvider) {
+    if (selectorOrScheduler && !isFunction(selectorOrScheduler)) {
+        timestampProvider = selectorOrScheduler;
+    }
+    const selector = isFunction(selectorOrScheduler) ? selectorOrScheduler : undefined;
+    return (source) => multicast(new ReplaySubject(bufferSize, windowTime, timestampProvider), selector)(source);
+}
+
+function raceWith(...otherSources) {
+    return !otherSources.length
+        ? identity
+        : operate((source, subscriber) => {
+            raceInit([source, ...otherSources])(subscriber);
+        });
+}
+
+function repeat(countOrConfig) {
+    let count = Infinity;
+    let delay;
+    if (countOrConfig != null) {
+        if (typeof countOrConfig === 'object') {
+            ({ count = Infinity, delay } = countOrConfig);
+        }
+        else {
+            count = countOrConfig;
+        }
+    }
+    return count <= 0
+        ? () => EMPTY
+        : operate((source, subscriber) => {
+            let soFar = 0;
+            let sourceSub;
+            const resubscribe = () => {
+                sourceSub === null || sourceSub === void 0 ? void 0 : sourceSub.unsubscribe();
+                sourceSub = null;
+                if (delay != null) {
+                    const notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(soFar));
+                    const notifierSubscriber = createOperatorSubscriber(subscriber, () => {
+                        notifierSubscriber.unsubscribe();
+                        subscribeToSource();
+                    });
+                    notifier.subscribe(notifierSubscriber);
+                }
+                else {
+                    subscribeToSource();
+                }
+            };
+            const subscribeToSource = () => {
+                let syncUnsub = false;
+                sourceSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, () => {
+                    if (++soFar < count) {
+                        if (sourceSub) {
+                            resubscribe();
+                        }
+                        else {
+                            syncUnsub = true;
+                        }
+                    }
+                    else {
+                        subscriber.complete();
+                    }
+                }));
+                if (syncUnsub) {
+                    resubscribe();
+                }
+            };
+            subscribeToSource();
+        });
+}
+
+function repeatWhen(notifier) {
+    return operate((source, subscriber) => {
+        let innerSub;
+        let syncResub = false;
+        let completions$;
+        let isNotifierComplete = false;
+        let isMainComplete = false;
+        const checkComplete = () => isMainComplete && isNotifierComplete && (subscriber.complete(), true);
+        const getCompletionSubject = () => {
+            if (!completions$) {
+                completions$ = new Subject();
+                notifier(completions$).subscribe(createOperatorSubscriber(subscriber, () => {
+                    if (innerSub) {
+                        subscribeForRepeatWhen();
+                    }
+                    else {
+                        syncResub = true;
+                    }
+                }, () => {
+                    isNotifierComplete = true;
+                    checkComplete();
+                }));
+            }
+            return completions$;
+        };
+        const subscribeForRepeatWhen = () => {
+            isMainComplete = false;
+            innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, () => {
+                isMainComplete = true;
+                !checkComplete() && getCompletionSubject().next();
+            }));
+            if (syncResub) {
+                innerSub.unsubscribe();
+                innerSub = null;
+                syncResub = false;
+                subscribeForRepeatWhen();
+            }
+        };
+        subscribeForRepeatWhen();
+    });
+}
+
+function retry(configOrCount = Infinity) {
+    let config;
+    if (configOrCount && typeof configOrCount === 'object') {
+        config = configOrCount;
+    }
+    else {
+        config = {
+            count: configOrCount,
+        };
+    }
+    const { count = Infinity, delay, resetOnSuccess: resetOnSuccess = false } = config;
+    return count <= 0
+        ? identity
+        : operate((source, subscriber) => {
+            let soFar = 0;
+            let innerSub;
+            const subscribeForRetry = () => {
+                let syncUnsub = false;
+                innerSub = source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+                    if (resetOnSuccess) {
+                        soFar = 0;
+                    }
+                    subscriber.next(value);
+                }, undefined, (err) => {
+                    if (soFar++ < count) {
+                        const resub = () => {
+                            if (innerSub) {
+                                innerSub.unsubscribe();
+                                innerSub = null;
+                                subscribeForRetry();
+                            }
+                            else {
+                                syncUnsub = true;
+                            }
+                        };
+                        if (delay != null) {
+                            const notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(err, soFar));
+                            const notifierSubscriber = createOperatorSubscriber(subscriber, () => {
+                                notifierSubscriber.unsubscribe();
+                                resub();
+                            }, () => {
+                                subscriber.complete();
+                            });
+                            notifier.subscribe(notifierSubscriber);
+                        }
+                        else {
+                            resub();
+                        }
+                    }
+                    else {
+                        subscriber.error(err);
+                    }
+                }));
+                if (syncUnsub) {
+                    innerSub.unsubscribe();
+                    innerSub = null;
+                    subscribeForRetry();
+                }
+            };
+            subscribeForRetry();
+        });
+}
+
+function retryWhen(notifier) {
+    return operate((source, subscriber) => {
+        let innerSub;
+        let syncResub = false;
+        let errors$;
+        const subscribeForRetryWhen = () => {
+            innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, undefined, (err) => {
+                if (!errors$) {
+                    errors$ = new Subject();
+                    notifier(errors$).subscribe(createOperatorSubscriber(subscriber, () => innerSub ? subscribeForRetryWhen() : (syncResub = true)));
+                }
+                if (errors$) {
+                    errors$.next(err);
+                }
+            }));
+            if (syncResub) {
+                innerSub.unsubscribe();
+                innerSub = null;
+                syncResub = false;
+                subscribeForRetryWhen();
+            }
+        };
+        subscribeForRetryWhen();
+    });
+}
+
+function sample(notifier) {
+    return operate((source, subscriber) => {
+        let hasValue = false;
+        let lastValue = null;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            hasValue = true;
+            lastValue = value;
+        }));
+        notifier.subscribe(createOperatorSubscriber(subscriber, () => {
+            if (hasValue) {
+                hasValue = false;
+                const value = lastValue;
+                lastValue = null;
+                subscriber.next(value);
+            }
+        }, noop));
+    });
+}
+
+function sampleTime(period, scheduler = asyncScheduler) {
+    return sample(interval(period, scheduler));
+}
+
+function scan(accumulator, seed) {
+    return operate(scanInternals(accumulator, seed, arguments.length >= 2, true));
+}
+
+function sequenceEqual(compareTo, comparator = (a, b) => a === b) {
+    return operate((source, subscriber) => {
+        const aState = createState();
+        const bState = createState();
+        const emit = (isEqual) => {
+            subscriber.next(isEqual);
+            subscriber.complete();
+        };
+        const createSubscriber = (selfState, otherState) => {
+            const sequenceEqualSubscriber = createOperatorSubscriber(subscriber, (a) => {
+                const { buffer, complete } = otherState;
+                if (buffer.length === 0) {
+                    complete ? emit(false) : selfState.buffer.push(a);
+                }
+                else {
+                    !comparator(a, buffer.shift()) && emit(false);
+                }
+            }, () => {
+                selfState.complete = true;
+                const { complete, buffer } = otherState;
+                complete && emit(buffer.length === 0);
+                sequenceEqualSubscriber === null || sequenceEqualSubscriber === void 0 ? void 0 : sequenceEqualSubscriber.unsubscribe();
+            });
+            return sequenceEqualSubscriber;
+        };
+        source.subscribe(createSubscriber(aState, bState));
+        compareTo.subscribe(createSubscriber(bState, aState));
+    });
+}
+function createState() {
+    return {
+        buffer: [],
+        complete: false,
+    };
+}
+
+function share(options = {}) {
+    const { connector = () => new Subject(), resetOnError = true, resetOnComplete = true, resetOnRefCountZero = true } = options;
+    return (wrapperSource) => {
+        let connection = null;
+        let resetConnection = null;
+        let subject = null;
+        let refCount = 0;
+        let hasCompleted = false;
+        let hasErrored = false;
+        const cancelReset = () => {
+            resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
+            resetConnection = null;
+        };
+        const reset = () => {
+            cancelReset();
+            connection = subject = null;
+            hasCompleted = hasErrored = false;
+        };
+        const resetAndUnsubscribe = () => {
+            const conn = connection;
+            reset();
+            conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
+        };
+        return operate((source, subscriber) => {
+            refCount++;
+            if (!hasErrored && !hasCompleted) {
+                cancelReset();
+            }
+            const dest = (subject = subject !== null && subject !== void 0 ? subject : connector());
+            subscriber.add(() => {
+                refCount--;
+                if (refCount === 0 && !hasErrored && !hasCompleted) {
+                    resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+                }
+            });
+            dest.subscribe(subscriber);
+            if (!connection) {
+                connection = new SafeSubscriber({
+                    next: (value) => dest.next(value),
+                    error: (err) => {
+                        hasErrored = true;
+                        cancelReset();
+                        resetConnection = handleReset(reset, resetOnError, err);
+                        dest.error(err);
+                    },
+                    complete: () => {
+                        hasCompleted = true;
+                        cancelReset();
+                        resetConnection = handleReset(reset, resetOnComplete);
+                        dest.complete();
+                    },
+                });
+                from(source).subscribe(connection);
+            }
+        })(wrapperSource);
+    };
+}
+function handleReset(reset, on, ...args) {
+    if (on === true) {
+        reset();
+        return null;
+    }
+    if (on === false) {
+        return null;
+    }
+    return on(...args)
+        .pipe(take(1))
+        .subscribe(() => reset());
+}
+
+function shareReplay(configOrBufferSize, windowTime, scheduler) {
+    let bufferSize;
+    let refCount = false;
+    if (configOrBufferSize && typeof configOrBufferSize === 'object') {
+        ({ bufferSize = Infinity, windowTime = Infinity, refCount = false, scheduler } = configOrBufferSize);
+    }
+    else {
+        bufferSize = configOrBufferSize !== null && configOrBufferSize !== void 0 ? configOrBufferSize : Infinity;
+    }
+    return share({
+        connector: () => new ReplaySubject(bufferSize, windowTime, scheduler),
+        resetOnError: true,
+        resetOnComplete: false,
+        resetOnRefCountZero: refCount,
+    });
+}
+
+function single(predicate) {
+    return operate((source, subscriber) => {
+        let hasValue = false;
+        let singleValue;
+        let seenValue = false;
+        let index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            seenValue = true;
+            if (!predicate || predicate(value, index++, source)) {
+                hasValue && subscriber.error(new SequenceError('Too many matching values'));
+                hasValue = true;
+                singleValue = value;
+            }
+        }, () => {
+            if (hasValue) {
+                subscriber.next(singleValue);
+                subscriber.complete();
+            }
+            else {
+                subscriber.error(seenValue ? new NotFoundError('No matching values') : new EmptyError());
+            }
+        }));
+    });
+}
+
+function skip(count) {
+    return filter((_, index) => count <= index);
+}
+
+function skipLast(skipCount) {
+    return skipCount <= 0
+        ?
+            identity
+        : operate((source, subscriber) => {
+            let ring = new Array(skipCount);
+            let seen = 0;
+            source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+                const valueIndex = seen++;
+                if (valueIndex < skipCount) {
+                    ring[valueIndex] = value;
+                }
+                else {
+                    const index = valueIndex % skipCount;
+                    const oldValue = ring[index];
+                    ring[index] = value;
+                    subscriber.next(oldValue);
+                }
+            }));
+            return () => {
+                ring = null;
+            };
+        });
+}
+
+function skipUntil(notifier) {
+    return operate((source, subscriber) => {
+        let taking = false;
+        const skipSubscriber = createOperatorSubscriber(subscriber, () => {
+            skipSubscriber === null || skipSubscriber === void 0 ? void 0 : skipSubscriber.unsubscribe();
+            taking = true;
+        }, noop);
+        innerFrom(notifier).subscribe(skipSubscriber);
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => taking && subscriber.next(value)));
+    });
+}
+
+function skipWhile(predicate) {
+    return operate((source, subscriber) => {
+        let taking = false;
+        let index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => (taking || (taking = !predicate(value, index++))) && subscriber.next(value)));
+    });
+}
+
+function startWith(...values) {
+    const scheduler = popScheduler(values);
+    return operate((source, subscriber) => {
+        (scheduler ? concat$1(values, source, scheduler) : concat$1(values, source)).subscribe(subscriber);
+    });
+}
+
+function switchMap(project, resultSelector) {
+    return operate((source, subscriber) => {
+        let innerSubscriber = null;
+        let index = 0;
+        let isComplete = false;
+        const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
+            let innerIndex = 0;
+            const outerIndex = index++;
+            innerFrom(project(value, outerIndex)).subscribe((innerSubscriber = createOperatorSubscriber(subscriber, (innerValue) => subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue), () => {
+                innerSubscriber = null;
+                checkComplete();
+            })));
+        }, () => {
+            isComplete = true;
+            checkComplete();
+        }));
+    });
+}
+
+function switchAll() {
+    return switchMap(identity);
+}
+
+function switchMapTo(innerObservable, resultSelector) {
+    return isFunction(resultSelector) ? switchMap(() => innerObservable, resultSelector) : switchMap(() => innerObservable);
+}
+
+function switchScan(accumulator, seed) {
+    return operate((source, subscriber) => {
+        let state = seed;
+        switchMap((value, index) => accumulator(state, value, index), (_, innerValue) => ((state = innerValue), innerValue))(source).subscribe(subscriber);
+        return () => {
+            state = null;
+        };
+    });
+}
+
+function takeUntil(notifier) {
+    return operate((source, subscriber) => {
+        innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop));
+        !subscriber.closed && source.subscribe(subscriber);
+    });
+}
+
+function takeWhile(predicate, inclusive = false) {
+    return operate((source, subscriber) => {
+        let index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const result = predicate(value, index++);
+            (result || inclusive) && subscriber.next(value);
+            !result && subscriber.complete();
+        }));
+    });
+}
+
+function tap(observerOrNext, error, complete) {
+    const tapObserver = isFunction(observerOrNext) || error || complete
+        ?
+            { next: observerOrNext, error, complete }
+        : observerOrNext;
+    return tapObserver
+        ? operate((source, subscriber) => {
+            var _a;
+            (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+            let isUnsub = true;
+            source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+                var _a;
+                (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+                subscriber.next(value);
+            }, () => {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                subscriber.complete();
+            }, (err) => {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+                subscriber.error(err);
+            }, () => {
+                var _a, _b;
+                if (isUnsub) {
+                    (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                }
+                (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+            }));
+        })
+        :
+            identity;
+}
+
+const defaultThrottleConfig = {
+    leading: true,
+    trailing: false,
+};
+function throttle(durationSelector, config = defaultThrottleConfig) {
+    return operate((source, subscriber) => {
+        const { leading, trailing } = config;
+        let hasValue = false;
+        let sendValue = null;
+        let throttled = null;
+        let isComplete = false;
+        const endThrottling = () => {
+            throttled === null || throttled === void 0 ? void 0 : throttled.unsubscribe();
+            throttled = null;
+            if (trailing) {
+                send();
+                isComplete && subscriber.complete();
+            }
+        };
+        const cleanupThrottling = () => {
+            throttled = null;
+            isComplete && subscriber.complete();
+        };
+        const startThrottle = (value) => (throttled = innerFrom(durationSelector(value)).subscribe(createOperatorSubscriber(subscriber, endThrottling, cleanupThrottling)));
+        const send = () => {
+            if (hasValue) {
+                hasValue = false;
+                const value = sendValue;
+                sendValue = null;
+                subscriber.next(value);
+                !isComplete && startThrottle(value);
+            }
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            hasValue = true;
+            sendValue = value;
+            !(throttled && !throttled.closed) && (leading ? send() : startThrottle(value));
+        }, () => {
+            isComplete = true;
+            !(trailing && hasValue && throttled && !throttled.closed) && subscriber.complete();
+        }));
+    });
+}
+
+function throttleTime(duration, scheduler = asyncScheduler, config = defaultThrottleConfig) {
+    const duration$ = timer(duration, scheduler);
+    return throttle(() => duration$, config);
+}
+
+function timeInterval(scheduler = asyncScheduler) {
+    return operate((source, subscriber) => {
+        let last = scheduler.now();
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const now = scheduler.now();
+            const interval = now - last;
+            last = now;
+            subscriber.next(new TimeInterval(value, interval));
+        }));
+    });
+}
+class TimeInterval {
+    constructor(value, interval) {
+        this.value = value;
+        this.interval = interval;
+    }
+}
+
+function timeoutWith(due, withObservable, scheduler) {
+    let first;
+    let each;
+    let _with;
+    scheduler = scheduler !== null && scheduler !== void 0 ? scheduler : async;
+    if (isValidDate(due)) {
+        first = due;
+    }
+    else if (typeof due === 'number') {
+        each = due;
+    }
+    if (withObservable) {
+        _with = () => withObservable;
+    }
+    else {
+        throw new TypeError('No observable provided to switch to');
+    }
+    if (first == null && each == null) {
+        throw new TypeError('No timeout provided.');
+    }
+    return timeout({
+        first,
+        each,
+        scheduler,
+        with: _with,
+    });
+}
+
+function timestamp(timestampProvider = dateTimestampProvider) {
+    return map((value) => ({ value, timestamp: timestampProvider.now() }));
+}
+
+function window(windowBoundaries) {
+    return operate((source, subscriber) => {
+        let windowSubject = new Subject();
+        subscriber.next(windowSubject.asObservable());
+        const errorHandler = (err) => {
+            windowSubject.error(err);
+            subscriber.error(err);
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => windowSubject === null || windowSubject === void 0 ? void 0 : windowSubject.next(value), () => {
+            windowSubject.complete();
+            subscriber.complete();
+        }, errorHandler));
+        windowBoundaries.subscribe(createOperatorSubscriber(subscriber, () => {
+            windowSubject.complete();
+            subscriber.next((windowSubject = new Subject()));
+        }, noop, errorHandler));
+        return () => {
+            windowSubject === null || windowSubject === void 0 ? void 0 : windowSubject.unsubscribe();
+            windowSubject = null;
+        };
+    });
+}
+
+function windowCount(windowSize, startWindowEvery = 0) {
+    const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
+    return operate((source, subscriber) => {
+        let windows = [new Subject()];
+        let starts = [];
+        let count = 0;
+        subscriber.next(windows[0].asObservable());
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            for (const window of windows) {
+                window.next(value);
+            }
+            const c = count - windowSize + 1;
+            if (c >= 0 && c % startEvery === 0) {
+                windows.shift().complete();
+            }
+            if (++count % startEvery === 0) {
+                const window = new Subject();
+                windows.push(window);
+                subscriber.next(window.asObservable());
+            }
+        }, () => {
+            while (windows.length > 0) {
+                windows.shift().complete();
+            }
+            subscriber.complete();
+        }, (err) => {
+            while (windows.length > 0) {
+                windows.shift().error(err);
+            }
+            subscriber.error(err);
+        }, () => {
+            starts = null;
+            windows = null;
+        }));
+    });
+}
+
+function windowTime(windowTimeSpan, ...otherArgs) {
+    var _a, _b;
+    const scheduler = (_a = popScheduler(otherArgs)) !== null && _a !== void 0 ? _a : asyncScheduler;
+    const windowCreationInterval = (_b = otherArgs[0]) !== null && _b !== void 0 ? _b : null;
+    const maxWindowSize = otherArgs[1] || Infinity;
+    return operate((source, subscriber) => {
+        let windowRecords = [];
+        let restartOnClose = false;
+        const closeWindow = (record) => {
+            const { window, subs } = record;
+            window.complete();
+            subs.unsubscribe();
+            arrRemove(windowRecords, record);
+            restartOnClose && startWindow();
+        };
+        const startWindow = () => {
+            if (windowRecords) {
+                const subs = new Subscription();
+                subscriber.add(subs);
+                const window = new Subject();
+                const record = {
+                    window,
+                    subs,
+                    seen: 0,
+                };
+                windowRecords.push(record);
+                subscriber.next(window.asObservable());
+                executeSchedule(subs, scheduler, () => closeWindow(record), windowTimeSpan);
+            }
+        };
+        if (windowCreationInterval !== null && windowCreationInterval >= 0) {
+            executeSchedule(subscriber, scheduler, startWindow, windowCreationInterval, true);
+        }
+        else {
+            restartOnClose = true;
+        }
+        startWindow();
+        const loop = (cb) => windowRecords.slice().forEach(cb);
+        const terminate = (cb) => {
+            loop(({ window }) => cb(window));
+            cb(subscriber);
+            subscriber.unsubscribe();
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            loop((record) => {
+                record.window.next(value);
+                maxWindowSize <= ++record.seen && closeWindow(record);
+            });
+        }, () => terminate((consumer) => consumer.complete()), (err) => terminate((consumer) => consumer.error(err))));
+        return () => {
+            windowRecords = null;
+        };
+    });
+}
+
+function windowToggle(openings, closingSelector) {
+    return operate((source, subscriber) => {
+        const windows = [];
+        const handleError = (err) => {
+            while (0 < windows.length) {
+                windows.shift().error(err);
+            }
+            subscriber.error(err);
+        };
+        innerFrom(openings).subscribe(createOperatorSubscriber(subscriber, (openValue) => {
+            const window = new Subject();
+            windows.push(window);
+            const closingSubscription = new Subscription();
+            const closeWindow = () => {
+                arrRemove(windows, window);
+                window.complete();
+                closingSubscription.unsubscribe();
+            };
+            let closingNotifier;
+            try {
+                closingNotifier = innerFrom(closingSelector(openValue));
+            }
+            catch (err) {
+                handleError(err);
+                return;
+            }
+            subscriber.next(window.asObservable());
+            closingSubscription.add(closingNotifier.subscribe(createOperatorSubscriber(subscriber, closeWindow, noop, handleError)));
+        }, noop));
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const windowsCopy = windows.slice();
+            for (const window of windowsCopy) {
+                window.next(value);
+            }
+        }, () => {
+            while (0 < windows.length) {
+                windows.shift().complete();
+            }
+            subscriber.complete();
+        }, handleError, () => {
+            while (0 < windows.length) {
+                windows.shift().unsubscribe();
+            }
+        }));
+    });
+}
+
+function windowWhen(closingSelector) {
+    return operate((source, subscriber) => {
+        let window;
+        let closingSubscriber;
+        const handleError = (err) => {
+            window.error(err);
+            subscriber.error(err);
+        };
+        const openWindow = () => {
+            closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
+            window === null || window === void 0 ? void 0 : window.complete();
+            window = new Subject();
+            subscriber.next(window.asObservable());
+            let closingNotifier;
+            try {
+                closingNotifier = innerFrom(closingSelector());
+            }
+            catch (err) {
+                handleError(err);
+                return;
+            }
+            closingNotifier.subscribe((closingSubscriber = createOperatorSubscriber(subscriber, openWindow, openWindow, handleError)));
+        };
+        openWindow();
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => window.next(value), () => {
+            window.complete();
+            subscriber.complete();
+        }, handleError, () => {
+            closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
+            window = null;
+        }));
+    });
+}
+
+function withLatestFrom(...inputs) {
+    const project = popResultSelector(inputs);
+    return operate((source, subscriber) => {
+        const len = inputs.length;
+        const otherValues = new Array(len);
+        let hasValue = inputs.map(() => false);
+        let ready = false;
+        for (let i = 0; i < len; i++) {
+            innerFrom(inputs[i]).subscribe(createOperatorSubscriber(subscriber, (value) => {
+                otherValues[i] = value;
+                if (!ready && !hasValue[i]) {
+                    hasValue[i] = true;
+                    (ready = hasValue.every(identity)) && (hasValue = null);
+                }
+            }, noop));
+        }
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            if (ready) {
+                const values = [value, ...otherValues];
+                subscriber.next(project ? project(...values) : values);
+            }
+        }));
+    });
+}
+
+function zipAll(project) {
+    return joinAllInternals(zip$1, project);
+}
+
+function zip(...sources) {
+    return operate((source, subscriber) => {
+        zip$1(source, ...sources).subscribe(subscriber);
+    });
+}
+
+function zipWith(...otherInputs) {
+    return zip(...otherInputs);
+}
+
+function partition(predicate, thisArg) {
+    return (source) => [filter(predicate, thisArg)(source), filter(not(predicate, thisArg))(source)];
+}
+
+function race(...args) {
+    return raceWith(...argsOrArgArray(args));
+}
+
 const catScrollableCss = ":host{overflow:hidden;position:relative;display:flex}:host([hidden]){display:none}.shadow-bottom,.shadow-right,.shadow-left,.shadow-top{position:absolute;transition:box-shadow 0.3s cubic-bezier(0.25, 0.8, 0.25, 1)}.shadow-top{z-index:2;width:100%;top:0}.shadow-left{z-index:4;height:100%;left:0}.shadow-right{z-index:4;height:100%;right:0}.shadow-bottom{z-index:2;width:100%;bottom:0}.scrollable-wrapper{position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none}.scrollable-wrapper.cat-scrollable-top .shadow-top,.scrollable-wrapper.cat-scrollable-bottom .shadow-bottom,.scrollable-wrapper.cat-scrollable-left .shadow-left,.scrollable-wrapper.cat-scrollable-right .shadow-right{box-shadow:0 0 4px 1px rgba(16, 29, 48, 0.2)}.scrollable-content{overflow:hidden;white-space:nowrap}.scrollable-content.scroll-x{overflow-x:auto}.scrollable-content.scroll-y{overflow-y:auto}.scrollable-content.no-overscroll{overscroll-behavior:contain}";
 
 const CatScrollable$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
@@ -1260,7 +4446,7 @@ const CatScrollable$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLEleme
     this.attachEmitter('right', this.scrolledRight, this.scrolledBuffer);
     this.attachEmitter('bottom', this.scrolledBottom, this.scrolledBuffer);
     this.attachEmitter('top', this.scrolledTop, this.scrolledBuffer);
-    merge(this.init, this.scrolled)
+    merge$1(this.init, this.scrolled)
       .pipe(map(() => ({
       top: this.getScrollOffset('top') > 0,
       left: this.getScrollOffset('left') > 0,
@@ -1296,7 +4482,7 @@ const CatScrollable$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLEleme
     ];
   }
   attachEmitter(from, emitter, buffer) {
-    merge(this.init, this.scrolled)
+    merge$1(this.init, this.scrolled)
       .pipe(map(() => this.getScrollOffset(from)))
       .pipe(map(offset => offset <= buffer))
       .pipe(distinctUntilChanged())
@@ -1330,7 +4516,6 @@ const CatScrollable$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLEleme
       (_b = this.scrollWrapperElement) === null || _b === void 0 ? void 0 : _b.classList.remove(name);
     }
   }
-  get el() { return this; }
   static get style() { return catScrollableCss; }
 }, [1, "cat-scrollable", {
     "shadowX": [4, "shadow-x"],