@flarehr/apollo-super-selection 3.52.60060 → 3.53.61179

package/dist/lib/cjs/{datorama-akita-7f4b082a.js → datorama-akita-6c9cb8fb.js}

@@ -1,7 +1,5 @@
 'use strict';
 
-const delay = require('./delay-81aff2f1.js');
-
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -40,6 +38,571 @@ function __metadata(metadataKey, metadataValue) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
 
+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;
+}
+
 const ObjectUnsubscribedErrorImpl = (() => {
     function ObjectUnsubscribedErrorImpl() {
         Error.call(this);
@@ -52,7 +615,7 @@ const ObjectUnsubscribedErrorImpl = (() => {
 })();
 const ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;
 
-class SubjectSubscription extends delay.Subscription {
+class SubjectSubscription extends Subscription {
     constructor(subject, subscriber) {
         super();
         this.subject = subject;
@@ -77,13 +640,13 @@ class SubjectSubscription extends delay.Subscription {
     }
 }
 
-class SubjectSubscriber extends delay.Subscriber {
+class SubjectSubscriber extends Subscriber {
     constructor(destination) {
         super(destination);
         this.destination = destination;
     }
 }
-class Subject extends delay.Observable {
+class Subject extends Observable {
     constructor() {
         super();
         this.observers = [];
@@ -92,7 +655,7 @@ class Subject extends delay.Observable {
         this.hasError = false;
         this.thrownError = null;
     }
-    [delay.rxSubscriber]() {
+    [rxSubscriber]() {
         return new SubjectSubscriber(this);
     }
     lift(operator) {
@@ -160,11 +723,11 @@ class Subject extends delay.Observable {
         }
         else if (this.hasError) {
             subscriber.error(this.thrownError);
-            return delay.Subscription.EMPTY;
+            return Subscription.EMPTY;
         }
         else if (this.isStopped) {
             subscriber.complete();
-            return delay.Subscription.EMPTY;
+            return Subscription.EMPTY;
         }
         else {
             this.observers.push(subscriber);
@@ -172,7 +735,7 @@ class Subject extends delay.Observable {
         }
     }
     asObservable() {
-        const observable = new delay.Observable();
+        const observable = new Observable();
         observable.source = this;
         return observable;
     }
@@ -210,7 +773,7 @@ class AnonymousSubject extends Subject {
             return this.source.subscribe(subscriber);
         }
         else {
-            return delay.Subscription.EMPTY;
+            return Subscription.EMPTY;
         }
     }
 }
@@ -246,7 +809,95 @@ class BehaviorSubject extends Subject {
     }
 }
 
-class QueueAction extends delay.AsyncAction {
+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 QueueAction extends AsyncAction {
     constructor(scheduler, work) {
         super(scheduler, work);
         this.scheduler = scheduler;
@@ -274,13 +925,208 @@ class QueueAction extends delay.AsyncAction {
     }
 }
 
-class QueueScheduler extends delay.AsyncScheduler {
+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;
+        }
+    }
+}
+
+class QueueScheduler extends AsyncScheduler {
 }
 
 const queueScheduler = new QueueScheduler(QueueAction);
 const queue = queueScheduler;
 
-class ObserveOnSubscriber extends delay.Subscriber {
+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);
+
+class ObserveOnSubscriber extends Subscriber {
     constructor(destination, scheduler, delay = 0) {
         super(destination);
         this.scheduler = scheduler;
@@ -296,14 +1142,14 @@ class ObserveOnSubscriber extends delay.Subscriber {
         destination.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));
     }
     _next(value) {
-        this.scheduleMessage(delay.Notification.createNext(value));
+        this.scheduleMessage(Notification.createNext(value));
     }
     _error(err) {
-        this.scheduleMessage(delay.Notification.createError(err));
+        this.scheduleMessage(Notification.createError(err));
         this.unsubscribe();
     }
     _complete() {
-        this.scheduleMessage(delay.Notification.createComplete());
+        this.scheduleMessage(Notification.createComplete());
         this.unsubscribe();
     }
 }
@@ -357,7 +1203,7 @@ class ReplaySubject extends Subject {
             throw new ObjectUnsubscribedError();
         }
         else if (this.isStopped || this.hasError) {
-            subscription = delay.Subscription.EMPTY;
+            subscription = Subscription.EMPTY;
         }
         else {
             this.observers.push(subscriber);
@@ -416,8 +1262,11 @@ class ReplayEvent {
     }
 }
 
+const asyncScheduler = new AsyncScheduler(AsyncAction);
+const async = asyncScheduler;
+
 function isObservable(obj) {
-    return !!obj && (obj instanceof delay.Observable || (typeof obj.lift === 'function' && typeof obj.subscribe === 'function'));
+    return !!obj && (obj instanceof Observable || (typeof obj.lift === 'function' && typeof obj.subscribe === 'function'));
 }
 
 const ArgumentOutOfRangeErrorImpl = (() => {
@@ -449,7 +1298,7 @@ class MapOperator {
         return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
     }
 }
-class MapSubscriber extends delay.Subscriber {
+class MapSubscriber extends Subscriber {
     constructor(destination, project, thisArg) {
         super(destination);
         this.project = project;
@@ -476,7 +1325,7 @@ const subscribeToPromise = (promise) => (subscriber) => {
             subscriber.complete();
         }
     }, (err) => subscriber.error(err))
-        .then(null, delay.hostReportError);
+        .then(null, hostReportError);
     return subscriber;
 };
 
@@ -519,7 +1368,7 @@ const subscribeToIterable = (iterable) => (subscriber) => {
 };
 
 const subscribeToObservable = (obj) => (subscriber) => {
-    const obs = obj[delay.observable]();
+    const obs = obj[observable]();
     if (typeof obs.subscribe !== 'function') {
         throw new TypeError('Provided object does not correctly implement Symbol.observable');
     }
@@ -535,11 +1384,11 @@ function isPromise(value) {
 }
 
 const subscribeTo = (result) => {
-    if (!!result && typeof result[delay.observable] === 'function') {
+    if (!!result && typeof result[observable] === 'function') {
         return subscribeToObservable(result);
     }
     else if (isArrayLike(result)) {
-        return delay.subscribeToArray(result);
+        return subscribeToArray(result);
     }
     else if (isPromise(result)) {
         return subscribeToPromise(result);
@@ -548,7 +1397,7 @@ const subscribeTo = (result) => {
         return subscribeToIterable(result);
     }
     else {
-        const value = delay.isObject(result) ? 'an invalid object' : `'${result}'`;
+        const value = isObject(result) ? 'an invalid object' : `'${result}'`;
         const msg = `You provided ${value} where a stream was expected.`
             + ' You can provide an Observable, Promise, Array, or Iterable.';
         throw new TypeError(msg);
@@ -556,11 +1405,11 @@ const subscribeTo = (result) => {
 };
 
 function scheduleObservable(input, scheduler) {
-    return new delay.Observable(subscriber => {
-        const sub = new delay.Subscription();
+    return new Observable(subscriber => {
+        const sub = new Subscription();
         sub.add(scheduler.schedule(() => {
-            const observable = input[delay.observable]();
-            sub.add(observable.subscribe({
+            const observable$1 = input[observable]();
+            sub.add(observable$1.subscribe({
                 next(value) { sub.add(scheduler.schedule(() => subscriber.next(value))); },
                 error(err) { sub.add(scheduler.schedule(() => subscriber.error(err))); },
                 complete() { sub.add(scheduler.schedule(() => subscriber.complete())); },
@@ -571,8 +1420,8 @@ function scheduleObservable(input, scheduler) {
 }
 
 function schedulePromise(input, scheduler) {
-    return new delay.Observable(subscriber => {
-        const sub = new delay.Subscription();
+    return new Observable(subscriber => {
+        const sub = new Subscription();
         sub.add(scheduler.schedule(() => input.then(value => {
             sub.add(scheduler.schedule(() => {
                 subscriber.next(value);
@@ -589,8 +1438,8 @@ function scheduleIterable(input, scheduler) {
     if (!input) {
         throw new Error('Iterable cannot be null');
     }
-    return new delay.Observable(subscriber => {
-        const sub = new delay.Subscription();
+    return new Observable(subscriber => {
+        const sub = new Subscription();
         let iterator$1;
         sub.add(() => {
             if (iterator$1 && typeof iterator$1.return === 'function') {
@@ -628,7 +1477,7 @@ function scheduleIterable(input, scheduler) {
 }
 
 function isInteropObservable(input) {
-    return input && typeof input[delay.observable] === 'function';
+    return input && typeof input[observable] === 'function';
 }
 
 function isIterable(input) {
@@ -644,7 +1493,7 @@ function scheduled(input, scheduler) {
             return schedulePromise(input, scheduler);
         }
         else if (isArrayLike(input)) {
-            return delay.scheduleArray(input, scheduler);
+            return scheduleArray(input, scheduler);
         }
         else if (isIterable(input) || typeof input === 'string') {
             return scheduleIterable(input, scheduler);
@@ -655,17 +1504,17 @@ function scheduled(input, scheduler) {
 
 function from(input, scheduler) {
     if (!scheduler) {
-        if (input instanceof delay.Observable) {
+        if (input instanceof Observable) {
             return input;
         }
-        return new delay.Observable(subscribeTo(input));
+        return new Observable(subscribeTo(input));
     }
     else {
         return scheduled(input, scheduler);
     }
 }
 
-class SimpleInnerSubscriber extends delay.Subscriber {
+class SimpleInnerSubscriber extends Subscriber {
     constructor(parent) {
         super();
         this.parent = parent;
@@ -682,7 +1531,7 @@ class SimpleInnerSubscriber extends delay.Subscriber {
         this.unsubscribe();
     }
 }
-class SimpleOuterSubscriber extends delay.Subscriber {
+class SimpleOuterSubscriber extends Subscriber {
     notifyNext(innerValue) {
         this.destination.next(innerValue);
     }
@@ -697,7 +1546,7 @@ function innerSubscribe(result, innerSubscriber) {
     if (innerSubscriber.closed) {
         return undefined;
     }
-    if (result instanceof delay.Observable) {
+    if (result instanceof Observable) {
         return result.subscribe(innerSubscriber);
     }
     return subscribeTo(result)(innerSubscriber);
@@ -717,7 +1566,7 @@ class FilterOperator {
         return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
     }
 }
-class FilterSubscriber extends delay.Subscriber {
+class FilterSubscriber extends Subscriber {
     constructor(destination, predicate, thisArg) {
         super(destination);
         this.predicate = predicate;
@@ -739,6 +1588,89 @@ class FilterSubscriber extends delay.Subscriber {
     }
 }
 
+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;
+    }
+}
+
 function distinctUntilChanged(compare, keySelector) {
     return (source) => source.lift(new DistinctUntilChangedOperator(compare, keySelector));
 }
@@ -751,7 +1683,7 @@ class DistinctUntilChangedOperator {
         return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));
     }
 }
-class DistinctUntilChangedSubscriber extends delay.Subscriber {
+class DistinctUntilChangedSubscriber extends Subscriber {
     constructor(destination, compare, keySelector) {
         super(destination);
         this.keySelector = keySelector;
@@ -795,7 +1727,7 @@ class DistinctUntilChangedSubscriber extends delay.Subscriber {
 function take(count) {
     return (source) => {
         if (count === 0) {
-            return delay.empty();
+            return empty$1();
         }
         else {
             return source.lift(new TakeOperator(count));
@@ -813,7 +1745,7 @@ class TakeOperator {
         return source.subscribe(new TakeSubscriber(subscriber, this.total));
     }
 }
-class TakeSubscriber extends delay.Subscriber {
+class TakeSubscriber extends Subscriber {
     constructor(destination, total) {
         super(destination);
         this.total = total;
@@ -999,24 +1931,24 @@ function isDev() {
 }
 
 // @internal
-function isObject(value) {
+function isObject$1(value) {
     const type = typeof value;
     return value != null && (type == 'object' || type == 'function');
 }
 
 // @internal
-function isArray(value) {
+function isArray$1(value) {
     return Array.isArray(value);
 }
 
 // @internal
 function getActiveEntities(idOrOptions, ids, currentActive) {
     let result;
-    if (isArray(idOrOptions)) {
+    if (isArray$1(idOrOptions)) {
         result = idOrOptions;
     }
     else {
-        if (isObject(idOrOptions)) {
+        if (isObject$1(idOrOptions)) {
             if (isNil(currentActive))
                 return;
             idOrOptions = Object.assign({ wrap: true }, idOrOptions);
@@ -1058,14 +1990,14 @@ function isDefined(val) {
 
 // @internal
 function isEmpty(arr) {
-    if (isArray(arr)) {
+    if (isArray$1(arr)) {
         return arr.length === 0;
     }
     return false;
 }
 
 // @internal
-function isFunction(value) {
+function isFunction$1(value) {
     return typeof value === 'function';
 }
 
@@ -1080,7 +2012,7 @@ function hasActiveState(state) {
 }
 // @internal
 function isMultiActiveState(active) {
-    return isArray(active);
+    return isArray$1(active);
 }
 // @internal
 function resolveActiveEntity({ active, ids, entities }) {
@@ -1155,7 +2087,7 @@ function applyMiddleware(entities, preAddEntity) {
 function setEntities({ state, entities, idKey, preAddEntity, isNativePreAdd }) {
     let newEntities;
     let newIds;
-    if (isArray(entities)) {
+    if (isArray$1(entities)) {
         const resolve = toEntitiesObject(entities, idKey, preAddEntity);
         newEntities = resolve.entities;
         newIds = resolve.ids;
@@ -1299,7 +2231,7 @@ function isTransactionInProcess() {
 }
 // @internal
 function commit() {
-    return transactionManager.batchTransaction ? transactionManager.batchTransaction.asObservable() : delay.of(true);
+    return transactionManager.batchTransaction ? transactionManager.batchTransaction.asObservable() : of(true);
 }
 /**
  *  A logical transaction.
@@ -1485,7 +2417,7 @@ class Store {
     }
     // @internal
     _setState(newState, _dispatchAction = true) {
-        if (isFunction(newState)) {
+        if (isFunction$1(newState)) {
             const _newState = newState(this._value());
             this.storeValue = __DEV__ ? this.deepFreeze(_newState) : _newState;
         }
@@ -1532,8 +2464,8 @@ class Store {
         isDev() && setAction('Update');
         let newState;
         const currentState = this._value();
-        if (isFunction(stateOrCallback)) {
-            newState = isFunction(this._producerFn) ? this._producerFn(currentState, stateOrCallback) : stateOrCallback(currentState);
+        if (isFunction$1(stateOrCallback)) {
+            newState = isFunction$1(this._producerFn) ? this._producerFn(currentState, stateOrCallback) : stateOrCallback(currentState);
         }
         else {
             newState = stateOrCallback;
@@ -1623,8 +2555,8 @@ function updateEntities({ state, ids, idKey, newStateOrFn, preUpdateEntity, prod
         }
         const oldEntity = state.entities[id];
         let newState;
-        if (isFunction(newStateOrFn)) {
-            newState = isFunction(producerFn) ? producerFn(oldEntity, newStateOrFn) : newStateOrFn(oldEntity);
+        if (isFunction$1(newStateOrFn)) {
+            newState = isFunction$1(producerFn) ? producerFn(oldEntity, newStateOrFn) : newStateOrFn(oldEntity);
         }
         else {
             newState = newStateOrFn;
@@ -1782,7 +2714,7 @@ class EntityStore extends Store {
             return;
         }
         let ids = [];
-        if (isFunction(idsOrFnOrState)) {
+        if (isFunction$1(idsOrFnOrState)) {
             // We need to filter according the predicate function
             ids = this.ids.filter((id) => idsOrFnOrState(this.entities[id]));
         }
@@ -1814,12 +2746,12 @@ class EntityStore extends Store {
     upsert(ids, newState, onCreate, options = {}) {
         const toArray = coerceArray(ids);
         const predicate = (isUpdate) => (id) => hasEntity(this.entities, id) === isUpdate;
-        const baseClass = isFunction(onCreate) ? options.baseClass : onCreate ? onCreate.baseClass : undefined;
-        const isClassBased = isFunction(baseClass);
+        const baseClass = isFunction$1(onCreate) ? options.baseClass : onCreate ? onCreate.baseClass : undefined;
+        const isClassBased = isFunction$1(baseClass);
         const updateIds = toArray.filter(predicate(true));
         const newEntities = toArray.filter(predicate(false)).map((id) => {
             const newStateObj = typeof newState === 'function' ? newState({}) : newState;
-            const entity = isFunction(onCreate) ? onCreate(id, newStateObj) : newStateObj;
+            const entity = isFunction$1(onCreate) ? onCreate(id, newStateObj) : newStateObj;
             const withId = Object.assign({}, entity, { [this.idKey]: id });
             if (isClassBased) {
                 return new baseClass(withId);
@@ -1921,7 +2853,7 @@ class EntityStore extends Store {
         const idPassed = isDefined(idsOrFn);
         // null means remove all
         let ids = [];
-        if (isFunction(idsOrFn)) {
+        if (isFunction$1(idsOrFn)) {
             ids = this.ids.filter((entityId) => idsOrFn(this.entities[entityId]));
         }
         else {
@@ -2089,7 +3021,7 @@ class EntityStore extends Store {
     }
     handleUICreation(add = false) {
         const ids = this.ids;
-        const isFunc = isFunction(this.ui._akitaCreateEntityFn);
+        const isFunc = isFunction$1(this.ui._akitaCreateEntityFn);
         let uiEntities;
         const createFn = (id) => {
             const current = this.entities[id];
@@ -2167,7 +3099,7 @@ const queryConfigKey = 'akitaQueryConfig';
 
 function compareKeys(keysOrFuncs) {
     return function (prevState, currState) {
-        const isFns = isFunction(keysOrFuncs[0]);
+        const isFns = isFunction$1(keysOrFuncs[0]);
         // Return when they are NOT changed
         return keysOrFuncs.some(keyOrFunc => {
             if (isFns) {
@@ -2189,7 +3121,7 @@ class Query {
     }
     select(project) {
         let mapFn;
-        if (isFunction(project)) {
+        if (isFunction$1(project)) {
             mapFn = project;
         }
         else if (isString(project)) {
@@ -2199,7 +3131,7 @@ class Query {
             return this.store
                 ._select(state => state)
                 .pipe(distinctUntilChanged(compareKeys(project)), map(state => {
-                if (isFunction(project[0])) {
+                if (isFunction$1(project[0])) {
                     return project.map(func => func(state));
                 }
                 return project.reduce((acc, k) => {
@@ -2321,7 +3253,7 @@ function setValue(obj, prop, val) {
             acc[part] = Object.assign({}, acc[part]);
             return acc && acc[part];
         }
-        acc[part] = Array.isArray(acc[part]) || !isObject(acc[part]) ? val : Object.assign({}, acc[part], val);
+        acc[part] = Array.isArray(acc[part]) || !isObject$1(acc[part]) ? val : Object.assign({}, acc[part], val);
         return acc && acc[part];
     }, obj);
     return obj;
@@ -2440,7 +3372,7 @@ class PaginatorPlugin extends AkitaPlugin {
         /**
          * Proxy to the query loading
          */
-        this.isLoading$ = this.query.selectLoading().pipe(delay.delay(0));
+        this.isLoading$ = this.query.selectLoading().pipe(delay(0));
         this.config = Object.assign(paginatorDefaults, config);
         const { startWith, cacheTimeout } = this.config;
         this.page = new BehaviorSubject(startWith);
@@ -2691,14 +3623,19 @@ var EntityStoreAction;
     EntityStoreAction["UpsertManyEntities"] = "UPSERT_MANY_ENTITIES";
 })(EntityStoreAction || (EntityStoreAction = {}));
 
+exports.Observable = Observable;
 exports.Query = Query;
 exports.SimpleInnerSubscriber = SimpleInnerSubscriber;
 exports.SimpleOuterSubscriber = SimpleOuterSubscriber;
 exports.Store = Store;
 exports.StoreConfig = StoreConfig;
+exports.Subscriber = Subscriber;
+exports.async = async;
 exports.distinctUntilChanged = distinctUntilChanged;
 exports.enableAkitaProdMode = enableAkitaProdMode;
 exports.filter = filter;
 exports.from = from;
 exports.innerSubscribe = innerSubscribe;
+exports.isArray = isArray;
+exports.isFunction = isFunction;
 exports.map = map;