@flarehr/apollo-super-selection 3.14.52544 → 3.17.52781

package/dist/lib/cjs/delay-81aff2f1.js

@@ -1,955 +0,0 @@
-'use strict';
-
-function isFunction(x) {
-    return typeof x === 'function';
-}
-
-let _enable_super_gross_mode_that_will_cause_bad_things = false;
-const config = {
-    Promise: undefined,
-    set useDeprecatedSynchronousErrorHandling(value) {
-        if (value) {
-            const error = new Error();
-            console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n' + error.stack);
-        }
-        else if (_enable_super_gross_mode_that_will_cause_bad_things) {
-            console.log('RxJS: Back to a better error behavior. Thank you. <3');
-        }
-        _enable_super_gross_mode_that_will_cause_bad_things = value;
-    },
-    get useDeprecatedSynchronousErrorHandling() {
-        return _enable_super_gross_mode_that_will_cause_bad_things;
-    },
-};
-
-function hostReportError(err) {
-    setTimeout(() => { throw err; }, 0);
-}
-
-const empty = {
-    closed: true,
-    next(value) { },
-    error(err) {
-        if (config.useDeprecatedSynchronousErrorHandling) {
-            throw err;
-        }
-        else {
-            hostReportError(err);
-        }
-    },
-    complete() { }
-};
-
-const isArray = (() => Array.isArray || ((x) => x && typeof x.length === 'number'))();
-
-function isObject(x) {
-    return x !== null && typeof x === 'object';
-}
-
-const UnsubscriptionErrorImpl = (() => {
-    function UnsubscriptionErrorImpl(errors) {
-        Error.call(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;
-        return this;
-    }
-    UnsubscriptionErrorImpl.prototype = Object.create(Error.prototype);
-    return UnsubscriptionErrorImpl;
-})();
-const UnsubscriptionError = UnsubscriptionErrorImpl;
-
-class Subscription {
-    constructor(unsubscribe) {
-        this.closed = false;
-        this._parentOrParents = null;
-        this._subscriptions = null;
-        if (unsubscribe) {
-            this._ctorUnsubscribe = true;
-            this._unsubscribe = unsubscribe;
-        }
-    }
-    unsubscribe() {
-        let errors;
-        if (this.closed) {
-            return;
-        }
-        let { _parentOrParents, _ctorUnsubscribe, _unsubscribe, _subscriptions } = this;
-        this.closed = true;
-        this._parentOrParents = null;
-        this._subscriptions = null;
-        if (_parentOrParents instanceof Subscription) {
-            _parentOrParents.remove(this);
-        }
-        else if (_parentOrParents !== null) {
-            for (let index = 0; index < _parentOrParents.length; ++index) {
-                const parent = _parentOrParents[index];
-                parent.remove(this);
-            }
-        }
-        if (isFunction(_unsubscribe)) {
-            if (_ctorUnsubscribe) {
-                this._unsubscribe = undefined;
-            }
-            try {
-                _unsubscribe.call(this);
-            }
-            catch (e) {
-                errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
-            }
-        }
-        if (isArray(_subscriptions)) {
-            let index = -1;
-            let len = _subscriptions.length;
-            while (++index < len) {
-                const sub = _subscriptions[index];
-                if (isObject(sub)) {
-                    try {
-                        sub.unsubscribe();
-                    }
-                    catch (e) {
-                        errors = errors || [];
-                        if (e instanceof UnsubscriptionError) {
-                            errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
-                        }
-                        else {
-                            errors.push(e);
-                        }
-                    }
-                }
-            }
-        }
-        if (errors) {
-            throw new UnsubscriptionError(errors);
-        }
-    }
-    add(teardown) {
-        let subscription = teardown;
-        if (!teardown) {
-            return Subscription.EMPTY;
-        }
-        switch (typeof teardown) {
-            case 'function':
-                subscription = new Subscription(teardown);
-            case 'object':
-                if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {
-                    return subscription;
-                }
-                else if (this.closed) {
-                    subscription.unsubscribe();
-                    return subscription;
-                }
-                else if (!(subscription instanceof Subscription)) {
-                    const tmp = subscription;
-                    subscription = new Subscription();
-                    subscription._subscriptions = [tmp];
-                }
-                break;
-            default: {
-                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');
-            }
-        }
-        let { _parentOrParents } = subscription;
-        if (_parentOrParents === null) {
-            subscription._parentOrParents = this;
-        }
-        else if (_parentOrParents instanceof Subscription) {
-            if (_parentOrParents === this) {
-                return subscription;
-            }
-            subscription._parentOrParents = [_parentOrParents, this];
-        }
-        else if (_parentOrParents.indexOf(this) === -1) {
-            _parentOrParents.push(this);
-        }
-        else {
-            return subscription;
-        }
-        const subscriptions = this._subscriptions;
-        if (subscriptions === null) {
-            this._subscriptions = [subscription];
-        }
-        else {
-            subscriptions.push(subscription);
-        }
-        return subscription;
-    }
-    remove(subscription) {
-        const subscriptions = this._subscriptions;
-        if (subscriptions) {
-            const subscriptionIndex = subscriptions.indexOf(subscription);
-            if (subscriptionIndex !== -1) {
-                subscriptions.splice(subscriptionIndex, 1);
-            }
-        }
-    }
-}
-Subscription.EMPTY = (function (empty) {
-    empty.closed = true;
-    return empty;
-}(new Subscription()));
-function flattenUnsubscriptionErrors(errors) {
-    return errors.reduce((errs, err) => errs.concat((err instanceof UnsubscriptionError) ? err.errors : err), []);
-}
-
-const rxSubscriber = (() => typeof Symbol === 'function'
-    ? Symbol('rxSubscriber')
-    : '@@rxSubscriber_' + Math.random())();
-
-class Subscriber extends Subscription {
-    constructor(destinationOrNext, error, complete) {
-        super();
-        this.syncErrorValue = null;
-        this.syncErrorThrown = false;
-        this.syncErrorThrowable = false;
-        this.isStopped = false;
-        switch (arguments.length) {
-            case 0:
-                this.destination = empty;
-                break;
-            case 1:
-                if (!destinationOrNext) {
-                    this.destination = empty;
-                    break;
-                }
-                if (typeof destinationOrNext === 'object') {
-                    if (destinationOrNext instanceof Subscriber) {
-                        this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;
-                        this.destination = destinationOrNext;
-                        destinationOrNext.add(this);
-                    }
-                    else {
-                        this.syncErrorThrowable = true;
-                        this.destination = new SafeSubscriber(this, destinationOrNext);
-                    }
-                    break;
-                }
-            default:
-                this.syncErrorThrowable = true;
-                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);
-                break;
-        }
-    }
-    [rxSubscriber]() { return this; }
-    static create(next, error, complete) {
-        const subscriber = new Subscriber(next, error, complete);
-        subscriber.syncErrorThrowable = false;
-        return subscriber;
-    }
-    next(value) {
-        if (!this.isStopped) {
-            this._next(value);
-        }
-    }
-    error(err) {
-        if (!this.isStopped) {
-            this.isStopped = true;
-            this._error(err);
-        }
-    }
-    complete() {
-        if (!this.isStopped) {
-            this.isStopped = true;
-            this._complete();
-        }
-    }
-    unsubscribe() {
-        if (this.closed) {
-            return;
-        }
-        this.isStopped = true;
-        super.unsubscribe();
-    }
-    _next(value) {
-        this.destination.next(value);
-    }
-    _error(err) {
-        this.destination.error(err);
-        this.unsubscribe();
-    }
-    _complete() {
-        this.destination.complete();
-        this.unsubscribe();
-    }
-    _unsubscribeAndRecycle() {
-        const { _parentOrParents } = this;
-        this._parentOrParents = null;
-        this.unsubscribe();
-        this.closed = false;
-        this.isStopped = false;
-        this._parentOrParents = _parentOrParents;
-        return this;
-    }
-}
-class SafeSubscriber extends Subscriber {
-    constructor(_parentSubscriber, observerOrNext, error, complete) {
-        super();
-        this._parentSubscriber = _parentSubscriber;
-        let next;
-        let context = this;
-        if (isFunction(observerOrNext)) {
-            next = observerOrNext;
-        }
-        else if (observerOrNext) {
-            next = observerOrNext.next;
-            error = observerOrNext.error;
-            complete = observerOrNext.complete;
-            if (observerOrNext !== empty) {
-                context = Object.create(observerOrNext);
-                if (isFunction(context.unsubscribe)) {
-                    this.add(context.unsubscribe.bind(context));
-                }
-                context.unsubscribe = this.unsubscribe.bind(this);
-            }
-        }
-        this._context = context;
-        this._next = next;
-        this._error = error;
-        this._complete = complete;
-    }
-    next(value) {
-        if (!this.isStopped && this._next) {
-            const { _parentSubscriber } = this;
-            if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-                this.__tryOrUnsub(this._next, value);
-            }
-            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
-                this.unsubscribe();
-            }
-        }
-    }
-    error(err) {
-        if (!this.isStopped) {
-            const { _parentSubscriber } = this;
-            const { useDeprecatedSynchronousErrorHandling } = config;
-            if (this._error) {
-                if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-                    this.__tryOrUnsub(this._error, err);
-                    this.unsubscribe();
-                }
-                else {
-                    this.__tryOrSetError(_parentSubscriber, this._error, err);
-                    this.unsubscribe();
-                }
-            }
-            else if (!_parentSubscriber.syncErrorThrowable) {
-                this.unsubscribe();
-                if (useDeprecatedSynchronousErrorHandling) {
-                    throw err;
-                }
-                hostReportError(err);
-            }
-            else {
-                if (useDeprecatedSynchronousErrorHandling) {
-                    _parentSubscriber.syncErrorValue = err;
-                    _parentSubscriber.syncErrorThrown = true;
-                }
-                else {
-                    hostReportError(err);
-                }
-                this.unsubscribe();
-            }
-        }
-    }
-    complete() {
-        if (!this.isStopped) {
-            const { _parentSubscriber } = this;
-            if (this._complete) {
-                const wrappedComplete = () => this._complete.call(this._context);
-                if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-                    this.__tryOrUnsub(wrappedComplete);
-                    this.unsubscribe();
-                }
-                else {
-                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);
-                    this.unsubscribe();
-                }
-            }
-            else {
-                this.unsubscribe();
-            }
-        }
-    }
-    __tryOrUnsub(fn, value) {
-        try {
-            fn.call(this._context, value);
-        }
-        catch (err) {
-            this.unsubscribe();
-            if (config.useDeprecatedSynchronousErrorHandling) {
-                throw err;
-            }
-            else {
-                hostReportError(err);
-            }
-        }
-    }
-    __tryOrSetError(parent, fn, value) {
-        if (!config.useDeprecatedSynchronousErrorHandling) {
-            throw new Error('bad call');
-        }
-        try {
-            fn.call(this._context, value);
-        }
-        catch (err) {
-            if (config.useDeprecatedSynchronousErrorHandling) {
-                parent.syncErrorValue = err;
-                parent.syncErrorThrown = true;
-                return true;
-            }
-            else {
-                hostReportError(err);
-                return true;
-            }
-        }
-        return false;
-    }
-    _unsubscribe() {
-        const { _parentSubscriber } = this;
-        this._context = null;
-        this._parentSubscriber = null;
-        _parentSubscriber.unsubscribe();
-    }
-}
-
-function canReportError(observer) {
-    while (observer) {
-        const { closed, destination, isStopped } = observer;
-        if (closed || isStopped) {
-            return false;
-        }
-        else if (destination && destination instanceof Subscriber) {
-            observer = destination;
-        }
-        else {
-            observer = null;
-        }
-    }
-    return true;
-}
-
-function toSubscriber(nextOrObserver, error, complete) {
-    if (nextOrObserver) {
-        if (nextOrObserver instanceof Subscriber) {
-            return nextOrObserver;
-        }
-        if (nextOrObserver[rxSubscriber]) {
-            return nextOrObserver[rxSubscriber]();
-        }
-    }
-    if (!nextOrObserver && !error && !complete) {
-        return new Subscriber(empty);
-    }
-    return new Subscriber(nextOrObserver, error, complete);
-}
-
-const observable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
-
-function identity(x) {
-    return x;
-}
-
-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) {
-        this._isScalar = false;
-        if (subscribe) {
-            this._subscribe = subscribe;
-        }
-    }
-    lift(operator) {
-        const observable = new Observable();
-        observable.source = this;
-        observable.operator = operator;
-        return observable;
-    }
-    subscribe(observerOrNext, error, complete) {
-        const { operator } = this;
-        const sink = toSubscriber(observerOrNext, error, complete);
-        if (operator) {
-            sink.add(operator.call(sink, this.source));
-        }
-        else {
-            sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?
-                this._subscribe(sink) :
-                this._trySubscribe(sink));
-        }
-        if (config.useDeprecatedSynchronousErrorHandling) {
-            if (sink.syncErrorThrowable) {
-                sink.syncErrorThrowable = false;
-                if (sink.syncErrorThrown) {
-                    throw sink.syncErrorValue;
-                }
-            }
-        }
-        return sink;
-    }
-    _trySubscribe(sink) {
-        try {
-            return this._subscribe(sink);
-        }
-        catch (err) {
-            if (config.useDeprecatedSynchronousErrorHandling) {
-                sink.syncErrorThrown = true;
-                sink.syncErrorValue = err;
-            }
-            if (canReportError(sink)) {
-                sink.error(err);
-            }
-            else {
-                console.warn(err);
-            }
-        }
-    }
-    forEach(next, promiseCtor) {
-        promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor((resolve, reject) => {
-            let subscription;
-            subscription = this.subscribe((value) => {
-                try {
-                    next(value);
-                }
-                catch (err) {
-                    reject(err);
-                    if (subscription) {
-                        subscription.unsubscribe();
-                    }
-                }
-            }, reject, resolve);
-        });
-    }
-    _subscribe(subscriber) {
-        const { source } = this;
-        return source && source.subscribe(subscriber);
-    }
-    [observable]() {
-        return this;
-    }
-    pipe(...operations) {
-        if (operations.length === 0) {
-            return this;
-        }
-        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) {
-    if (!promiseCtor) {
-        promiseCtor =  Promise;
-    }
-    if (!promiseCtor) {
-        throw new Error('no Promise impl found');
-    }
-    return promiseCtor;
-}
-
-class Action extends Subscription {
-    constructor(scheduler, work) {
-        super();
-    }
-    schedule(state, delay = 0) {
-        return this;
-    }
-}
-
-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 setInterval(scheduler.flush.bind(scheduler, this), delay);
-    }
-    recycleAsyncId(scheduler, id, delay = 0) {
-        if (delay !== null && this.delay === delay && this.pending === false) {
-            return id;
-        }
-        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 = undefined;
-        try {
-            this.work(state);
-        }
-        catch (e) {
-            errored = true;
-            errorValue = !!e && e || new Error(e);
-        }
-        if (errored) {
-            this.unsubscribe();
-            return errorValue;
-        }
-    }
-    _unsubscribe() {
-        const id = this.id;
-        const scheduler = this.scheduler;
-        const actions = scheduler.actions;
-        const index = actions.indexOf(this);
-        this.work = null;
-        this.state = null;
-        this.pending = false;
-        this.scheduler = null;
-        if (index !== -1) {
-            actions.splice(index, 1);
-        }
-        if (id != null) {
-            this.id = this.recycleAsyncId(scheduler, id, null);
-        }
-        this.delay = null;
-    }
-}
-
-class Scheduler {
-    constructor(SchedulerAction, now = Scheduler.now) {
-        this.SchedulerAction = SchedulerAction;
-        this.now = now;
-    }
-    schedule(work, delay = 0, state) {
-        return new this.SchedulerAction(this, work).schedule(state, delay);
-    }
-}
-Scheduler.now = () => Date.now();
-
-class AsyncScheduler extends Scheduler {
-    constructor(SchedulerAction, now = Scheduler.now) {
-        super(SchedulerAction, () => {
-            if (AsyncScheduler.delegate && AsyncScheduler.delegate !== this) {
-                return AsyncScheduler.delegate.now();
-            }
-            else {
-                return now();
-            }
-        });
-        this.actions = [];
-        this.active = false;
-        this.scheduled = undefined;
-    }
-    schedule(work, delay = 0, state) {
-        if (AsyncScheduler.delegate && AsyncScheduler.delegate !== this) {
-            return AsyncScheduler.delegate.schedule(work, delay, state);
-        }
-        else {
-            return super.schedule(work, delay, state);
-        }
-    }
-    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;
-        }
-    }
-}
-
-const EMPTY = new Observable(subscriber => subscriber.complete());
-function empty$1(scheduler) {
-    return scheduler ? emptyScheduled(scheduler) : EMPTY;
-}
-function emptyScheduled(scheduler) {
-    return new Observable(subscriber => scheduler.schedule(() => subscriber.complete()));
-}
-
-function isScheduler(value) {
-    return value && typeof value.schedule === 'function';
-}
-
-const subscribeToArray = (array) => (subscriber) => {
-    for (let i = 0, len = array.length; i < len && !subscriber.closed; i++) {
-        subscriber.next(array[i]);
-    }
-    subscriber.complete();
-};
-
-function scheduleArray(input, scheduler) {
-    return new Observable(subscriber => {
-        const sub = new Subscription();
-        let i = 0;
-        sub.add(scheduler.schedule(function () {
-            if (i === input.length) {
-                subscriber.complete();
-                return;
-            }
-            subscriber.next(input[i++]);
-            if (!subscriber.closed) {
-                sub.add(this.schedule());
-            }
-        }));
-        return sub;
-    });
-}
-
-function fromArray(input, scheduler) {
-    if (!scheduler) {
-        return new Observable(subscribeToArray(input));
-    }
-    else {
-        return scheduleArray(input, scheduler);
-    }
-}
-
-function of(...args) {
-    let scheduler = args[args.length - 1];
-    if (isScheduler(scheduler)) {
-        args.pop();
-        return scheduleArray(args, scheduler);
-    }
-    else {
-        return fromArray(args);
-    }
-}
-
-function throwError(error, scheduler) {
-    if (!scheduler) {
-        return new Observable(subscriber => subscriber.error(error));
-    }
-    else {
-        return new Observable(subscriber => scheduler.schedule(dispatch, 0, { error, subscriber }));
-    }
-}
-function dispatch({ error, subscriber }) {
-    subscriber.error(error);
-}
-
-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) {
-        switch (this.kind) {
-            case 'N':
-                return observer.next && observer.next(this.value);
-            case 'E':
-                return observer.error && observer.error(this.error);
-            case 'C':
-                return observer.complete && observer.complete();
-        }
-    }
-    do(next, error, complete) {
-        const kind = this.kind;
-        switch (kind) {
-            case 'N':
-                return next && next(this.value);
-            case 'E':
-                return error && error(this.error);
-            case 'C':
-                return complete && complete();
-        }
-    }
-    accept(nextOrObserver, error, complete) {
-        if (nextOrObserver && typeof nextOrObserver.next === 'function') {
-            return this.observe(nextOrObserver);
-        }
-        else {
-            return this.do(nextOrObserver, error, complete);
-        }
-    }
-    toObservable() {
-        const kind = this.kind;
-        switch (kind) {
-            case 'N':
-                return of(this.value);
-            case 'E':
-                return throwError(this.error);
-            case 'C':
-                return empty$1();
-        }
-        throw new Error('unexpected notification kind value');
-    }
-    static createNext(value) {
-        if (typeof value !== 'undefined') {
-            return new Notification('N', value);
-        }
-        return Notification.undefinedValueNotification;
-    }
-    static createError(err) {
-        return new Notification('E', undefined, err);
-    }
-    static createComplete() {
-        return Notification.completeNotification;
-    }
-}
-Notification.completeNotification = new Notification('C');
-Notification.undefinedValueNotification = new Notification('N', undefined);
-
-const asyncScheduler = new AsyncScheduler(AsyncAction);
-const async = asyncScheduler;
-
-function isDate(value) {
-    return value instanceof Date && !isNaN(+value);
-}
-
-function delay(delay, scheduler = async) {
-    const absoluteDelay = isDate(delay);
-    const delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay);
-    return (source) => source.lift(new DelayOperator(delayFor, scheduler));
-}
-class DelayOperator {
-    constructor(delay, scheduler) {
-        this.delay = delay;
-        this.scheduler = scheduler;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new DelaySubscriber(subscriber, this.delay, this.scheduler));
-    }
-}
-class DelaySubscriber extends Subscriber {
-    constructor(destination, delay, scheduler) {
-        super(destination);
-        this.delay = delay;
-        this.scheduler = scheduler;
-        this.queue = [];
-        this.active = false;
-        this.errored = false;
-    }
-    static dispatch(state) {
-        const source = state.source;
-        const queue = source.queue;
-        const scheduler = state.scheduler;
-        const destination = state.destination;
-        while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) {
-            queue.shift().notification.observe(destination);
-        }
-        if (queue.length > 0) {
-            const delay = Math.max(0, queue[0].time - scheduler.now());
-            this.schedule(state, delay);
-        }
-        else {
-            this.unsubscribe();
-            source.active = false;
-        }
-    }
-    _schedule(scheduler) {
-        this.active = true;
-        const destination = this.destination;
-        destination.add(scheduler.schedule(DelaySubscriber.dispatch, this.delay, {
-            source: this, destination: this.destination, scheduler: scheduler
-        }));
-    }
-    scheduleNotification(notification) {
-        if (this.errored === true) {
-            return;
-        }
-        const scheduler = this.scheduler;
-        const message = new DelayMessage(scheduler.now() + this.delay, notification);
-        this.queue.push(message);
-        if (this.active === false) {
-            this._schedule(scheduler);
-        }
-    }
-    _next(value) {
-        this.scheduleNotification(Notification.createNext(value));
-    }
-    _error(err) {
-        this.errored = true;
-        this.queue = [];
-        this.destination.error(err);
-        this.unsubscribe();
-    }
-    _complete() {
-        this.scheduleNotification(Notification.createComplete());
-        this.unsubscribe();
-    }
-}
-class DelayMessage {
-    constructor(time, notification) {
-        this.time = time;
-        this.notification = notification;
-    }
-}
-
-exports.AsyncAction = AsyncAction;
-exports.AsyncScheduler = AsyncScheduler;
-exports.Notification = Notification;
-exports.Observable = Observable;
-exports.Subscriber = Subscriber;
-exports.Subscription = Subscription;
-exports.async = async;
-exports.delay = delay;
-exports.empty = empty$1;
-exports.hostReportError = hostReportError;
-exports.isArray = isArray;
-exports.isFunction = isFunction;
-exports.isObject = isObject;
-exports.isScheduler = isScheduler;
-exports.observable = observable;
-exports.of = of;
-exports.rxSubscriber = rxSubscriber;
-exports.scheduleArray = scheduleArray;
-exports.subscribeToArray = subscribeToArray;