@haiilo/catalyst 0.5.1 → 0.5.3

package/dist/cjs/cat-scrollable.cjs.entry.js

@@ -1,4526 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const index = require('./index-abcb3941.js');
-
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-function createErrorClass(createImpl) {
-    const _super = (instance) => {
-        Error.call(instance);
-        instance.stack = new Error().stack;
-    };
-    const ctorFunc = createImpl(_super);
-    ctorFunc.prototype = Object.create(Error.prototype);
-    ctorFunc.prototype.constructor = ctorFunc;
-    return ctorFunc;
-}
-
-const UnsubscriptionError = createErrorClass((_super) => function UnsubscriptionErrorImpl(errors) {
-    _super(this);
-    this.message = errors
-        ? `${errors.length} errors occurred during unsubscription:
-${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}`
-        : '';
-    this.name = 'UnsubscriptionError';
-    this.errors = errors;
-});
-
-function arrRemove(arr, item) {
-    if (arr) {
-        const index = arr.indexOf(item);
-        0 <= index && arr.splice(index, 1);
-    }
-}
-
-class Subscription {
-    constructor(initialTeardown) {
-        this.initialTeardown = initialTeardown;
-        this.closed = false;
-        this._parentage = null;
-        this._finalizers = null;
-    }
-    unsubscribe() {
-        let errors;
-        if (!this.closed) {
-            this.closed = true;
-            const { _parentage } = this;
-            if (_parentage) {
-                this._parentage = null;
-                if (Array.isArray(_parentage)) {
-                    for (const parent of _parentage) {
-                        parent.remove(this);
-                    }
-                }
-                else {
-                    _parentage.remove(this);
-                }
-            }
-            const { initialTeardown: initialFinalizer } = this;
-            if (isFunction(initialFinalizer)) {
-                try {
-                    initialFinalizer();
-                }
-                catch (e) {
-                    errors = e instanceof UnsubscriptionError ? e.errors : [e];
-                }
-            }
-            const { _finalizers } = this;
-            if (_finalizers) {
-                this._finalizers = null;
-                for (const finalizer of _finalizers) {
-                    try {
-                        execFinalizer(finalizer);
-                    }
-                    catch (err) {
-                        errors = errors !== null && errors !== void 0 ? errors : [];
-                        if (err instanceof UnsubscriptionError) {
-                            errors = [...errors, ...err.errors];
-                        }
-                        else {
-                            errors.push(err);
-                        }
-                    }
-                }
-            }
-            if (errors) {
-                throw new UnsubscriptionError(errors);
-            }
-        }
-    }
-    add(teardown) {
-        var _a;
-        if (teardown && teardown !== this) {
-            if (this.closed) {
-                execFinalizer(teardown);
-            }
-            else {
-                if (teardown instanceof Subscription) {
-                    if (teardown.closed || teardown._hasParent(this)) {
-                        return;
-                    }
-                    teardown._addParent(this);
-                }
-                (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
-            }
-        }
-    }
-    _hasParent(parent) {
-        const { _parentage } = this;
-        return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
-    }
-    _addParent(parent) {
-        const { _parentage } = this;
-        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
-    }
-    _removeParent(parent) {
-        const { _parentage } = this;
-        if (_parentage === parent) {
-            this._parentage = null;
-        }
-        else if (Array.isArray(_parentage)) {
-            arrRemove(_parentage, parent);
-        }
-    }
-    remove(teardown) {
-        const { _finalizers } = this;
-        _finalizers && arrRemove(_finalizers, teardown);
-        if (teardown instanceof Subscription) {
-            teardown._removeParent(this);
-        }
-    }
-}
-Subscription.EMPTY = (() => {
-    const empty = new Subscription();
-    empty.closed = true;
-    return empty;
-})();
-const EMPTY_SUBSCRIPTION = Subscription.EMPTY;
-function isSubscription(value) {
-    return (value instanceof Subscription ||
-        (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
-}
-function execFinalizer(finalizer) {
-    if (isFunction(finalizer)) {
-        finalizer();
-    }
-    else {
-        finalizer.unsubscribe();
-    }
-}
-
-const config = {
-    onUnhandledError: null,
-    onStoppedNotification: null,
-    Promise: undefined,
-    useDeprecatedSynchronousErrorHandling: false,
-    useDeprecatedNextContext: false,
-};
-
-const timeoutProvider = {
-    setTimeout(handler, timeout, ...args) {
-        const { delegate } = timeoutProvider;
-        if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
-            return delegate.setTimeout(handler, timeout, ...args);
-        }
-        return setTimeout(handler, timeout, ...args);
-    },
-    clearTimeout(handle) {
-        const { delegate } = timeoutProvider;
-        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
-    },
-    delegate: undefined,
-};
-
-function reportUnhandledError(err) {
-    timeoutProvider.setTimeout(() => {
-        const { onUnhandledError } = config;
-        if (onUnhandledError) {
-            onUnhandledError(err);
-        }
-        else {
-            throw err;
-        }
-    });
-}
-
-function noop() { }
-
-const COMPLETE_NOTIFICATION = (() => createNotification('C', undefined, undefined))();
-function errorNotification(error) {
-    return createNotification('E', undefined, error);
-}
-function nextNotification(value) {
-    return createNotification('N', value, undefined);
-}
-function createNotification(kind, value, error) {
-    return {
-        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) {
-        super();
-        this.isStopped = false;
-        if (destination) {
-            this.destination = destination;
-            if (isSubscription(destination)) {
-                destination.add(this);
-            }
-        }
-        else {
-            this.destination = EMPTY_OBSERVER;
-        }
-    }
-    static create(next, error, complete) {
-        return new SafeSubscriber(next, error, complete);
-    }
-    next(value) {
-        if (this.isStopped) {
-            handleStoppedNotification(nextNotification(value), this);
-        }
-        else {
-            this._next(value);
-        }
-    }
-    error(err) {
-        if (this.isStopped) {
-            handleStoppedNotification(errorNotification(err), this);
-        }
-        else {
-            this.isStopped = true;
-            this._error(err);
-        }
-    }
-    complete() {
-        if (this.isStopped) {
-            handleStoppedNotification(COMPLETE_NOTIFICATION, this);
-        }
-        else {
-            this.isStopped = true;
-            this._complete();
-        }
-    }
-    unsubscribe() {
-        if (!this.closed) {
-            this.isStopped = true;
-            super.unsubscribe();
-            this.destination = null;
-        }
-    }
-    _next(value) {
-        this.destination.next(value);
-    }
-    _error(err) {
-        try {
-            this.destination.error(err);
-        }
-        finally {
-            this.unsubscribe();
-        }
-    }
-    _complete() {
-        try {
-            this.destination.complete();
-        }
-        finally {
-            this.unsubscribe();
-        }
-    }
-}
-const _bind = Function.prototype.bind;
-function bind(fn, thisArg) {
-    return _bind.call(fn, thisArg);
-}
-class ConsumerObserver {
-    constructor(partialObserver) {
-        this.partialObserver = partialObserver;
-    }
-    next(value) {
-        const { partialObserver } = this;
-        if (partialObserver.next) {
-            try {
-                partialObserver.next(value);
-            }
-            catch (error) {
-                handleUnhandledError(error);
-            }
-        }
-    }
-    error(err) {
-        const { partialObserver } = this;
-        if (partialObserver.error) {
-            try {
-                partialObserver.error(err);
-            }
-            catch (error) {
-                handleUnhandledError(error);
-            }
-        }
-        else {
-            handleUnhandledError(err);
-        }
-    }
-    complete() {
-        const { partialObserver } = this;
-        if (partialObserver.complete) {
-            try {
-                partialObserver.complete();
-            }
-            catch (error) {
-                handleUnhandledError(error);
-            }
-        }
-    }
-}
-class SafeSubscriber extends Subscriber {
-    constructor(observerOrNext, error, complete) {
-        super();
-        let partialObserver;
-        if (isFunction(observerOrNext) || !observerOrNext) {
-            partialObserver = {
-                next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined,
-                error: error !== null && error !== void 0 ? error : undefined,
-                complete: complete !== null && complete !== void 0 ? complete : undefined,
-            };
-        }
-        else {
-            let context;
-            if (this && config.useDeprecatedNextContext) {
-                context = Object.create(observerOrNext);
-                context.unsubscribe = () => this.unsubscribe();
-                partialObserver = {
-                    next: observerOrNext.next && bind(observerOrNext.next, context),
-                    error: observerOrNext.error && bind(observerOrNext.error, context),
-                    complete: observerOrNext.complete && bind(observerOrNext.complete, context),
-                };
-            }
-            else {
-                partialObserver = observerOrNext;
-            }
-        }
-        this.destination = new ConsumerObserver(partialObserver);
-    }
-}
-function handleUnhandledError(error) {
-    if (config.useDeprecatedSynchronousErrorHandling) {
-        captureError(error);
-    }
-    else {
-        reportUnhandledError(error);
-    }
-}
-function defaultErrorHandler(err) {
-    throw err;
-}
-function handleStoppedNotification(notification, subscriber) {
-    const { onStoppedNotification } = config;
-    onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
-}
-const EMPTY_OBSERVER = {
-    closed: true,
-    next: noop,
-    error: defaultErrorHandler,
-    complete: noop,
-};
-
-const observable = (() => (typeof Symbol === 'function' && Symbol.observable) || '@@observable')();
-
-function identity(x) {
-    return x;
-}
-
-function pipe(...fns) {
-    return pipeFromArray(fns);
-}
-function pipeFromArray(fns) {
-    if (fns.length === 0) {
-        return identity;
-    }
-    if (fns.length === 1) {
-        return fns[0];
-    }
-    return function piped(input) {
-        return fns.reduce((prev, fn) => fn(prev), input);
-    };
-}
-
-class Observable {
-    constructor(subscribe) {
-        if (subscribe) {
-            this._subscribe = subscribe;
-        }
-    }
-    lift(operator) {
-        const observable = new Observable();
-        observable.source = this;
-        observable.operator = operator;
-        return observable;
-    }
-    subscribe(observerOrNext, error, complete) {
-        const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
-        errorContext(() => {
-            const { operator, source } = this;
-            subscriber.add(operator
-                ?
-                    operator.call(subscriber, source)
-                : source
-                    ?
-                        this._subscribe(subscriber)
-                    :
-                        this._trySubscribe(subscriber));
-        });
-        return subscriber;
-    }
-    _trySubscribe(sink) {
-        try {
-            return this._subscribe(sink);
-        }
-        catch (err) {
-            sink.error(err);
-        }
-    }
-    forEach(next, promiseCtor) {
-        promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor((resolve, reject) => {
-            const subscriber = new SafeSubscriber({
-                next: (value) => {
-                    try {
-                        next(value);
-                    }
-                    catch (err) {
-                        reject(err);
-                        subscriber.unsubscribe();
-                    }
-                },
-                error: reject,
-                complete: resolve,
-            });
-            this.subscribe(subscriber);
-        });
-    }
-    _subscribe(subscriber) {
-        var _a;
-        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
-    }
-    [observable]() {
-        return this;
-    }
-    pipe(...operations) {
-        return pipeFromArray(operations)(this);
-    }
-    toPromise(promiseCtor) {
-        promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor((resolve, reject) => {
-            let value;
-            this.subscribe((x) => (value = x), (err) => reject(err), () => resolve(value));
-        });
-    }
-}
-Observable.create = (subscribe) => {
-    return new Observable(subscribe);
-};
-function getPromiseCtor(promiseCtor) {
-    var _a;
-    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
-}
-function isObserver(value) {
-    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
-}
-function isSubscriber(value) {
-    return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
-}
-
-function hasLift(source) {
-    return isFunction(source === null || source === void 0 ? void 0 : source.lift);
-}
-function operate(init) {
-    return (source) => {
-        if (hasLift(source)) {
-            return source.lift(function (liftedSource) {
-                try {
-                    return init(liftedSource, this);
-                }
-                catch (err) {
-                    this.error(err);
-                }
-            });
-        }
-        throw new TypeError('Unable to lift unknown Observable type');
-    };
-}
-
-function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
-    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
-}
-class OperatorSubscriber extends Subscriber {
-    constructor(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
-        super(destination);
-        this.onFinalize = onFinalize;
-        this.shouldUnsubscribe = shouldUnsubscribe;
-        this._next = onNext
-            ? function (value) {
-                try {
-                    onNext(value);
-                }
-                catch (err) {
-                    destination.error(err);
-                }
-            }
-            : super._next;
-        this._error = onError
-            ? function (err) {
-                try {
-                    onError(err);
-                }
-                catch (err) {
-                    destination.error(err);
-                }
-                finally {
-                    this.unsubscribe();
-                }
-            }
-            : super._error;
-        this._complete = onComplete
-            ? function () {
-                try {
-                    onComplete();
-                }
-                catch (err) {
-                    destination.error(err);
-                }
-                finally {
-                    this.unsubscribe();
-                }
-            }
-            : super._complete;
-    }
-    unsubscribe() {
-        var _a;
-        if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
-            const { closed } = this;
-            super.unsubscribe();
-            !closed && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
-        }
-    }
-}
-
-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';
-    this.message = 'object unsubscribed';
-});
-
-class Subject extends Observable {
-    constructor() {
-        super();
-        this.closed = false;
-        this.currentObservers = null;
-        this.observers = [];
-        this.isStopped = false;
-        this.hasError = false;
-        this.thrownError = null;
-    }
-    lift(operator) {
-        const subject = new AnonymousSubject(this, this);
-        subject.operator = operator;
-        return subject;
-    }
-    _throwIfClosed() {
-        if (this.closed) {
-            throw new ObjectUnsubscribedError();
-        }
-    }
-    next(value) {
-        errorContext(() => {
-            this._throwIfClosed();
-            if (!this.isStopped) {
-                if (!this.currentObservers) {
-                    this.currentObservers = Array.from(this.observers);
-                }
-                for (const observer of this.currentObservers) {
-                    observer.next(value);
-                }
-            }
-        });
-    }
-    error(err) {
-        errorContext(() => {
-            this._throwIfClosed();
-            if (!this.isStopped) {
-                this.hasError = this.isStopped = true;
-                this.thrownError = err;
-                const { observers } = this;
-                while (observers.length) {
-                    observers.shift().error(err);
-                }
-            }
-        });
-    }
-    complete() {
-        errorContext(() => {
-            this._throwIfClosed();
-            if (!this.isStopped) {
-                this.isStopped = true;
-                const { observers } = this;
-                while (observers.length) {
-                    observers.shift().complete();
-                }
-            }
-        });
-    }
-    unsubscribe() {
-        this.isStopped = this.closed = true;
-        this.observers = this.currentObservers = null;
-    }
-    get observed() {
-        var _a;
-        return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
-    }
-    _trySubscribe(subscriber) {
-        this._throwIfClosed();
-        return super._trySubscribe(subscriber);
-    }
-    _subscribe(subscriber) {
-        this._throwIfClosed();
-        this._checkFinalizedStatuses(subscriber);
-        return this._innerSubscribe(subscriber);
-    }
-    _innerSubscribe(subscriber) {
-        const { hasError, isStopped, observers } = this;
-        if (hasError || isStopped) {
-            return EMPTY_SUBSCRIPTION;
-        }
-        this.currentObservers = null;
-        observers.push(subscriber);
-        return new Subscription(() => {
-            this.currentObservers = null;
-            arrRemove(observers, subscriber);
-        });
-    }
-    _checkFinalizedStatuses(subscriber) {
-        const { hasError, thrownError, isStopped } = this;
-        if (hasError) {
-            subscriber.error(thrownError);
-        }
-        else if (isStopped) {
-            subscriber.complete();
-        }
-    }
-    asObservable() {
-        const observable = new Observable();
-        observable.source = this;
-        return observable;
-    }
-}
-Subject.create = (destination, source) => {
-    return new AnonymousSubject(destination, source);
-};
-class AnonymousSubject extends Subject {
-    constructor(destination, source) {
-        super();
-        this.destination = destination;
-        this.source = source;
-    }
-    next(value) {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
-    }
-    error(err) {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
-    }
-    complete() {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
-    }
-    _subscribe(subscriber) {
-        var _a, _b;
-        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
-    }
-}
-
-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$1(arr) {
-    return arr[arr.length - 1];
-}
-function popResultSelector(args) {
-    return isFunction(last$1(args)) ? args.pop() : undefined;
-}
-function popScheduler(args) {
-    return isScheduler(last$1(args)) ? args.pop() : undefined;
-}
-function popNumber(args, 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
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-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 */
-
-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 __());
-}
-
-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 () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !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);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-}
-
-function __asyncDelegator(o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
-}
-
-function __asyncValues(o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-}
-
-function __makeTemplateObject(cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-};
-
-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');
-
-function isPromise(value) {
-    return isFunction(value === null || value === void 0 ? void 0 : value.then);
-}
-
-function isInteropObservable(input) {
-    return isFunction(input[observable]);
-}
-
-function isAsyncIterable(obj) {
-    return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
-}
-
-function createInvalidObservableTypeError(input) {
-    return new TypeError(`You provided ${input !== null && typeof input === 'object' ? 'an invalid object' : `'${input}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`);
-}
-
-function getSymbolIterator() {
-    if (typeof Symbol !== 'function' || !Symbol.iterator) {
-        return '@@iterator';
-    }
-    return Symbol.iterator;
-}
-const iterator = getSymbolIterator();
-
-function isIterable(input) {
-    return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
-}
-
-function readableStreamLikeToAsyncGenerator(readableStream) {
-    return __asyncGenerator(this, arguments, function* readableStreamLikeToAsyncGenerator_1() {
-        const reader = readableStream.getReader();
-        try {
-            while (true) {
-                const { value, done } = yield __await(reader.read());
-                if (done) {
-                    return yield __await(void 0);
-                }
-                yield yield __await(value);
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    });
-}
-function isReadableStreamLike(obj) {
-    return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
-}
-
-function innerFrom(input) {
-    if (input instanceof Observable) {
-        return input;
-    }
-    if (input != null) {
-        if (isInteropObservable(input)) {
-            return fromInteropObservable(input);
-        }
-        if (isArrayLike(input)) {
-            return fromArrayLike(input);
-        }
-        if (isPromise(input)) {
-            return fromPromise(input);
-        }
-        if (isAsyncIterable(input)) {
-            return fromAsyncIterable(input);
-        }
-        if (isIterable(input)) {
-            return fromIterable(input);
-        }
-        if (isReadableStreamLike(input)) {
-            return fromReadableStreamLike(input);
-        }
-    }
-    throw createInvalidObservableTypeError(input);
-}
-function fromInteropObservable(obj) {
-    return new Observable((subscriber) => {
-        const obs = obj[observable]();
-        if (isFunction(obs.subscribe)) {
-            return obs.subscribe(subscriber);
-        }
-        throw new TypeError('Provided object does not correctly implement Symbol.observable');
-    });
-}
-function fromArrayLike(array) {
-    return new Observable((subscriber) => {
-        for (let i = 0; i < array.length && !subscriber.closed; i++) {
-            subscriber.next(array[i]);
-        }
-        subscriber.complete();
-    });
-}
-function fromPromise(promise) {
-    return new Observable((subscriber) => {
-        promise
-            .then((value) => {
-            if (!subscriber.closed) {
-                subscriber.next(value);
-                subscriber.complete();
-            }
-        }, (err) => subscriber.error(err))
-            .then(null, reportUnhandledError);
-    });
-}
-function fromIterable(iterable) {
-    return new Observable((subscriber) => {
-        for (const value of iterable) {
-            subscriber.next(value);
-            if (subscriber.closed) {
-                return;
-            }
-        }
-        subscriber.complete();
-    });
-}
-function fromAsyncIterable(asyncIterable) {
-    return new Observable((subscriber) => {
-        process(asyncIterable, subscriber).catch((err) => subscriber.error(err));
-    });
-}
-function fromReadableStreamLike(readableStream) {
-    return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
-}
-function process(asyncIterable, subscriber) {
-    var asyncIterable_1, asyncIterable_1_1;
-    var e_1, _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            for (asyncIterable_1 = __asyncValues(asyncIterable); asyncIterable_1_1 = yield asyncIterable_1.next(), !asyncIterable_1_1.done;) {
-                const value = asyncIterable_1_1.value;
-                subscriber.next(value);
-                if (subscriber.closed) {
-                    return;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)) yield _a.call(asyncIterable_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        subscriber.complete();
-    });
-}
-
-function executeSchedule(parentSubscription, scheduler, work, delay = 0, repeat = false) {
-    const scheduleSubscription = scheduler.schedule(function () {
-        work();
-        if (repeat) {
-            parentSubscription.add(this.schedule(null, delay));
-        }
-        else {
-            this.unsubscribe();
-        }
-    }, delay);
-    parentSubscription.add(scheduleSubscription);
-    if (!repeat) {
-        return scheduleSubscription;
-    }
-}
-
-function observeOn(scheduler, delay = 0) {
-    return operate((source, subscriber) => {
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => executeSchedule(subscriber, scheduler, () => subscriber.next(value), delay), () => executeSchedule(subscriber, scheduler, () => subscriber.complete(), delay), (err) => executeSchedule(subscriber, scheduler, () => subscriber.error(err), delay)));
-    });
-}
-
-function subscribeOn(scheduler, delay = 0) {
-    return operate((source, subscriber) => {
-        subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
-    });
-}
-
-function scheduleObservable(input, scheduler) {
-    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
-}
-
-function schedulePromise(input, scheduler) {
-    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
-}
-
-function scheduleArray(input, scheduler) {
-    return new Observable((subscriber) => {
-        let i = 0;
-        return scheduler.schedule(function () {
-            if (i === input.length) {
-                subscriber.complete();
-            }
-            else {
-                subscriber.next(input[i++]);
-                if (!subscriber.closed) {
-                    this.schedule();
-                }
-            }
-        });
-    });
-}
-
-function scheduleIterable(input, scheduler) {
-    return new Observable((subscriber) => {
-        let iterator$1;
-        executeSchedule(subscriber, scheduler, () => {
-            iterator$1 = input[iterator]();
-            executeSchedule(subscriber, scheduler, () => {
-                let value;
-                let done;
-                try {
-                    ({ value, done } = iterator$1.next());
-                }
-                catch (err) {
-                    subscriber.error(err);
-                    return;
-                }
-                if (done) {
-                    subscriber.complete();
-                }
-                else {
-                    subscriber.next(value);
-                }
-            }, 0, true);
-        });
-        return () => isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return();
-    });
-}
-
-function scheduleAsyncIterable(input, scheduler) {
-    if (!input) {
-        throw new Error('Iterable cannot be null');
-    }
-    return new Observable((subscriber) => {
-        executeSchedule(subscriber, scheduler, () => {
-            const iterator = input[Symbol.asyncIterator]();
-            executeSchedule(subscriber, scheduler, () => {
-                iterator.next().then((result) => {
-                    if (result.done) {
-                        subscriber.complete();
-                    }
-                    else {
-                        subscriber.next(result.value);
-                    }
-                });
-            }, 0, true);
-        });
-    });
-}
-
-function scheduleReadableStreamLike(input, scheduler) {
-    return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
-}
-
-function scheduled(input, scheduler) {
-    if (input != null) {
-        if (isInteropObservable(input)) {
-            return scheduleObservable(input, scheduler);
-        }
-        if (isArrayLike(input)) {
-            return scheduleArray(input, scheduler);
-        }
-        if (isPromise(input)) {
-            return schedulePromise(input, scheduler);
-        }
-        if (isAsyncIterable(input)) {
-            return scheduleAsyncIterable(input, scheduler);
-        }
-        if (isIterable(input)) {
-            return scheduleIterable(input, scheduler);
-        }
-        if (isReadableStreamLike(input)) {
-            return scheduleReadableStreamLike(input, scheduler);
-        }
-    }
-    throw createInvalidObservableTypeError(input);
-}
-
-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;
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
-            subscriber.next(project.call(thisArg, value, index++));
-        }));
-    });
-}
-
-const { isArray: isArray$2 } = Array;
-function callOrApply(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;
-    let index = 0;
-    let isComplete = false;
-    const checkComplete = () => {
-        if (isComplete && !buffer.length && !active) {
-            subscriber.complete();
-        }
-    };
-    const outerNext = (value) => (active < concurrent ? doInnerSub(value) : buffer.push(value));
-    const doInnerSub = (value) => {
-        expand && subscriber.next(value);
-        active++;
-        let innerComplete = false;
-        innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, (innerValue) => {
-            onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
-            if (expand) {
-                outerNext(innerValue);
-            }
-            else {
-                subscriber.next(innerValue);
-            }
-        }, () => {
-            innerComplete = true;
-        }, undefined, () => {
-            if (innerComplete) {
-                try {
-                    active--;
-                    while (buffer.length && active < concurrent) {
-                        const bufferedValue = buffer.shift();
-                        if (innerSubScheduler) {
-                            executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue));
-                        }
-                        else {
-                            doInnerSub(bufferedValue);
-                        }
-                    }
-                    checkComplete();
-                }
-                catch (err) {
-                    subscriber.error(err);
-                }
-            }
-        }));
-    };
-    source.subscribe(createOperatorSubscriber(subscriber, outerNext, () => {
-        isComplete = true;
-        checkComplete();
-    }));
-    return () => {
-        additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
-    };
-}
-
-function mergeMap(project, resultSelector, concurrent = Infinity) {
-    if (isFunction(resultSelector)) {
-        return mergeMap((a, i) => map((b, ii) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent);
-    }
-    else if (typeof resultSelector === 'number') {
-        concurrent = resultSelector;
-    }
-    return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent));
-}
-
-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'];
-function fromEvent(target, eventName, options, resultSelector) {
-    if (isFunction(options)) {
-        resultSelector = options;
-        options = undefined;
-    }
-    if (resultSelector) {
-        return fromEvent(target, eventName, options).pipe(mapOneOrManyArgs(resultSelector));
-    }
-    const [add, remove] = isEventTarget(target)
-        ? eventTargetMethods.map((methodName) => (handler) => target[methodName](eventName, handler, options))
-        :
-            isNodeStyleEventEmitter(target)
-                ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName))
-                : isJQueryStyleEventEmitter(target)
-                    ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName))
-                    : [];
-    if (!add) {
-        if (isArrayLike(target)) {
-            return mergeMap((subTarget) => fromEvent(subTarget, eventName, options))(innerFrom(target));
-        }
-    }
-    if (!add) {
-        throw new TypeError('Invalid event target');
-    }
-    return new Observable((subscriber) => {
-        const handler = (...args) => subscriber.next(1 < args.length ? args : args[0]);
-        add(handler);
-        return () => remove(handler);
-    });
-}
-function toCommonHandlerRegistry(target, eventName) {
-    return (methodName) => (handler) => target[methodName](eventName, handler);
-}
-function isNodeStyleEventEmitter(target) {
-    return isFunction(target.addListener) && isFunction(target.removeListener);
-}
-function isJQueryStyleEventEmitter(target) {
-    return isFunction(target.on) && isFunction(target.off);
-}
-function isEventTarget(target) {
-    return isFunction(target.addEventListener) && isFunction(target.removeEventListener);
-}
-
-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;
-    return !sources.length
-        ?
-            EMPTY
-        : sources.length === 1
-            ?
-                innerFrom(sources[0])
-            :
-                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;
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => predicate.call(thisArg, value, index++) && subscriber.next(value)));
-    });
-}
-
-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) => {
-        let previousKey;
-        let first = true;
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
-            const currentKey = keySelector(value);
-            if (first || !comparator(previousKey, currentKey)) {
-                first = false;
-                previousKey = currentKey;
-                subscriber.next(value);
-            }
-        }));
-    });
-}
-function defaultCompare(a, b) {
-    return a === b;
-}
-
-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) => {
-        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 = class {
-  constructor(hostRef) {
-    index.registerInstance(this, hostRef);
-    this.scrolledTop = index.createEvent(this, "scrolledTop", 7);
-    this.scrolledLeft = index.createEvent(this, "scrolledLeft", 7);
-    this.scrolledRight = index.createEvent(this, "scrolledRight", 7);
-    this.scrolledBottom = index.createEvent(this, "scrolledBottom", 7);
-    this.init = new Subject();
-    this.destroyed = new Subject();
-    /** Flags to enable/disable scroll shadowX. */
-    this.shadowX = true;
-    /** Flags to enable/disable scroll shadowY. */
-    this.shadowY = true;
-    /** Flags to enable/disable overflowX. */
-    this.overflowX = true;
-    /** Flags to enable/disable overflowY. */
-    this.overflowY = true;
-    /** Flag to enable/disable overscroll behavior. */
-    this.overscroll = true;
-    /**
-     * Flag to fire an initial event after content initialization.
-     */
-    this.scrolledInit = true;
-    /**
-     * Buffer to be used to calculate the scroll distance.
-     */
-    this.scrolledBuffer = 0;
-  }
-  componentDidRender() {
-    if (this.scrollElement) {
-      this.scrolled = fromEvent(this.scrollElement, 'scroll').pipe(takeUntil(this.destroyed));
-    }
-    this.attachEmitter('left', this.scrolledLeft, this.scrolledBuffer);
-    this.attachEmitter('right', this.scrolledRight, this.scrolledBuffer);
-    this.attachEmitter('bottom', this.scrolledBottom, this.scrolledBuffer);
-    this.attachEmitter('top', this.scrolledTop, this.scrolledBuffer);
-    merge$1(this.init, this.scrolled)
-      .pipe(map(() => ({
-      top: this.getScrollOffset('top') > 0,
-      left: this.getScrollOffset('left') > 0,
-      right: this.getScrollOffset('right') > 0,
-      bottom: this.getScrollOffset('bottom') > 0
-    })), distinctUntilChanged(), takeUntil(this.destroyed))
-      .subscribe(({ top, left, right, bottom }) => {
-      this.toggleClass('cat-scrollable-top', top);
-      this.toggleClass('cat-scrollable-left', left);
-      this.toggleClass('cat-scrollable-right', right);
-      this.toggleClass('cat-scrollable-bottom', bottom);
-    });
-  }
-  componentDidLoad() {
-    if (this.scrolledInit) {
-      this.init.next();
-    }
-  }
-  disconnectedCallback() {
-    this.init.complete();
-    this.destroyed.next();
-    this.destroyed.complete();
-  }
-  render() {
-    return [
-      index.h("div", { class: "scrollable-wrapper", ref: el => (this.scrollWrapperElement = el) }, this.shadowY && index.h("div", { class: "shadow-top" }), this.shadowX && index.h("div", { class: "shadow-left" }), this.shadowX && index.h("div", { class: "shadow-right" }), this.shadowY && index.h("div", { class: "shadow-bottom" })),
-      index.h("div", { ref: el => (this.scrollElement = el), class: {
-          'scrollable-content': true,
-          'scroll-x': this.overflowX,
-          'scroll-y': this.overflowY,
-          'no-overscroll': !this.overscroll
-        } }, index.h("slot", null))
-    ];
-  }
-  attachEmitter(from, emitter, buffer) {
-    merge$1(this.init, this.scrolled)
-      .pipe(map(() => this.getScrollOffset(from)))
-      .pipe(map(offset => offset <= buffer))
-      .pipe(distinctUntilChanged())
-      .pipe(filter(isLower => isLower))
-      .pipe(takeUntil(this.destroyed))
-      .subscribe(() => emitter.emit());
-  }
-  getScrollOffset(from) {
-    if (this.scrollElement) {
-      switch (from) {
-        case 'top':
-          return this.scrollElement.scrollTop;
-        case 'left':
-          return this.scrollElement.scrollLeft;
-        case 'right':
-          return this.scrollElement.scrollWidth - this.scrollElement.clientWidth - this.scrollElement.scrollLeft;
-        case 'bottom':
-          return this.scrollElement.scrollHeight - this.scrollElement.clientHeight - this.scrollElement.scrollTop;
-        default:
-          return 0;
-      }
-    }
-    return 0;
-  }
-  toggleClass(name, value) {
-    var _a, _b;
-    if (value) {
-      (_a = this.scrollWrapperElement) === null || _a === void 0 ? void 0 : _a.classList.add(name);
-    }
-    else {
-      (_b = this.scrollWrapperElement) === null || _b === void 0 ? void 0 : _b.classList.remove(name);
-    }
-  }
-};
-CatScrollable.style = catScrollableCss;
-
-exports.cat_scrollable = CatScrollable;
-
-//# sourceMappingURL=cat-scrollable.cjs.entry.js.map