@flarehr/apollo-super-selection 1.3.54543 → 1.3.54570

package/dist/lib/esm/datorama-akita-127aea91.js

@@ -0,0 +1,3624 @@
+/*! *****************************************************************************
+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.
+***************************************************************************** */
+
+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 __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);
+        this.message = 'object unsubscribed';
+        this.name = 'ObjectUnsubscribedError';
+        return this;
+    }
+    ObjectUnsubscribedErrorImpl.prototype = Object.create(Error.prototype);
+    return ObjectUnsubscribedErrorImpl;
+})();
+const ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;
+
+class SubjectSubscription extends Subscription {
+    constructor(subject, subscriber) {
+        super();
+        this.subject = subject;
+        this.subscriber = subscriber;
+        this.closed = false;
+    }
+    unsubscribe() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        const subject = this.subject;
+        const observers = subject.observers;
+        this.subject = null;
+        if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {
+            return;
+        }
+        const subscriberIndex = observers.indexOf(this.subscriber);
+        if (subscriberIndex !== -1) {
+            observers.splice(subscriberIndex, 1);
+        }
+    }
+}
+
+class SubjectSubscriber extends Subscriber {
+    constructor(destination) {
+        super(destination);
+        this.destination = destination;
+    }
+}
+class Subject extends Observable {
+    constructor() {
+        super();
+        this.observers = [];
+        this.closed = false;
+        this.isStopped = false;
+        this.hasError = false;
+        this.thrownError = null;
+    }
+    [rxSubscriber]() {
+        return new SubjectSubscriber(this);
+    }
+    lift(operator) {
+        const subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+    }
+    next(value) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        if (!this.isStopped) {
+            const { observers } = this;
+            const len = observers.length;
+            const copy = observers.slice();
+            for (let i = 0; i < len; i++) {
+                copy[i].next(value);
+            }
+        }
+    }
+    error(err) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        this.hasError = true;
+        this.thrownError = err;
+        this.isStopped = true;
+        const { observers } = this;
+        const len = observers.length;
+        const copy = observers.slice();
+        for (let i = 0; i < len; i++) {
+            copy[i].error(err);
+        }
+        this.observers.length = 0;
+    }
+    complete() {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        this.isStopped = true;
+        const { observers } = this;
+        const len = observers.length;
+        const copy = observers.slice();
+        for (let i = 0; i < len; i++) {
+            copy[i].complete();
+        }
+        this.observers.length = 0;
+    }
+    unsubscribe() {
+        this.isStopped = true;
+        this.closed = true;
+        this.observers = null;
+    }
+    _trySubscribe(subscriber) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else {
+            return super._trySubscribe(subscriber);
+        }
+    }
+    _subscribe(subscriber) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else if (this.hasError) {
+            subscriber.error(this.thrownError);
+            return Subscription.EMPTY;
+        }
+        else if (this.isStopped) {
+            subscriber.complete();
+            return Subscription.EMPTY;
+        }
+        else {
+            this.observers.push(subscriber);
+            return new SubjectSubscription(this, subscriber);
+        }
+    }
+    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) {
+        const { destination } = this;
+        if (destination && destination.next) {
+            destination.next(value);
+        }
+    }
+    error(err) {
+        const { destination } = this;
+        if (destination && destination.error) {
+            this.destination.error(err);
+        }
+    }
+    complete() {
+        const { destination } = this;
+        if (destination && destination.complete) {
+            this.destination.complete();
+        }
+    }
+    _subscribe(subscriber) {
+        const { source } = this;
+        if (source) {
+            return this.source.subscribe(subscriber);
+        }
+        else {
+            return Subscription.EMPTY;
+        }
+    }
+}
+
+class BehaviorSubject extends Subject {
+    constructor(_value) {
+        super();
+        this._value = _value;
+    }
+    get value() {
+        return this.getValue();
+    }
+    _subscribe(subscriber) {
+        const subscription = super._subscribe(subscriber);
+        if (subscription && !subscription.closed) {
+            subscriber.next(this._value);
+        }
+        return subscription;
+    }
+    getValue() {
+        if (this.hasError) {
+            throw this.thrownError;
+        }
+        else if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else {
+            return this._value;
+        }
+    }
+    next(value) {
+        super.next(this._value = value);
+    }
+}
+
+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;
+        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 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;
+
+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;
+        this.delay = delay;
+    }
+    static dispatch(arg) {
+        const { notification, destination } = arg;
+        notification.observe(destination);
+        this.unsubscribe();
+    }
+    scheduleMessage(notification) {
+        const destination = this.destination;
+        destination.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));
+    }
+    _next(value) {
+        this.scheduleMessage(Notification.createNext(value));
+    }
+    _error(err) {
+        this.scheduleMessage(Notification.createError(err));
+        this.unsubscribe();
+    }
+    _complete() {
+        this.scheduleMessage(Notification.createComplete());
+        this.unsubscribe();
+    }
+}
+class ObserveOnMessage {
+    constructor(notification, destination) {
+        this.notification = notification;
+        this.destination = destination;
+    }
+}
+
+class ReplaySubject extends Subject {
+    constructor(bufferSize = Number.POSITIVE_INFINITY, windowTime = Number.POSITIVE_INFINITY, scheduler) {
+        super();
+        this.scheduler = scheduler;
+        this._events = [];
+        this._infiniteTimeWindow = false;
+        this._bufferSize = bufferSize < 1 ? 1 : bufferSize;
+        this._windowTime = windowTime < 1 ? 1 : windowTime;
+        if (windowTime === Number.POSITIVE_INFINITY) {
+            this._infiniteTimeWindow = true;
+            this.next = this.nextInfiniteTimeWindow;
+        }
+        else {
+            this.next = this.nextTimeWindow;
+        }
+    }
+    nextInfiniteTimeWindow(value) {
+        if (!this.isStopped) {
+            const _events = this._events;
+            _events.push(value);
+            if (_events.length > this._bufferSize) {
+                _events.shift();
+            }
+        }
+        super.next(value);
+    }
+    nextTimeWindow(value) {
+        if (!this.isStopped) {
+            this._events.push(new ReplayEvent(this._getNow(), value));
+            this._trimBufferThenGetEvents();
+        }
+        super.next(value);
+    }
+    _subscribe(subscriber) {
+        const _infiniteTimeWindow = this._infiniteTimeWindow;
+        const _events = _infiniteTimeWindow ? this._events : this._trimBufferThenGetEvents();
+        const scheduler = this.scheduler;
+        const len = _events.length;
+        let subscription;
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else if (this.isStopped || this.hasError) {
+            subscription = Subscription.EMPTY;
+        }
+        else {
+            this.observers.push(subscriber);
+            subscription = new SubjectSubscription(this, subscriber);
+        }
+        if (scheduler) {
+            subscriber.add(subscriber = new ObserveOnSubscriber(subscriber, scheduler));
+        }
+        if (_infiniteTimeWindow) {
+            for (let i = 0; i < len && !subscriber.closed; i++) {
+                subscriber.next(_events[i]);
+            }
+        }
+        else {
+            for (let i = 0; i < len && !subscriber.closed; i++) {
+                subscriber.next(_events[i].value);
+            }
+        }
+        if (this.hasError) {
+            subscriber.error(this.thrownError);
+        }
+        else if (this.isStopped) {
+            subscriber.complete();
+        }
+        return subscription;
+    }
+    _getNow() {
+        return (this.scheduler || queue).now();
+    }
+    _trimBufferThenGetEvents() {
+        const now = this._getNow();
+        const _bufferSize = this._bufferSize;
+        const _windowTime = this._windowTime;
+        const _events = this._events;
+        const eventsCount = _events.length;
+        let spliceCount = 0;
+        while (spliceCount < eventsCount) {
+            if ((now - _events[spliceCount].time) < _windowTime) {
+                break;
+            }
+            spliceCount++;
+        }
+        if (eventsCount > _bufferSize) {
+            spliceCount = Math.max(spliceCount, eventsCount - _bufferSize);
+        }
+        if (spliceCount > 0) {
+            _events.splice(0, spliceCount);
+        }
+        return _events;
+    }
+}
+class ReplayEvent {
+    constructor(time, value) {
+        this.time = time;
+        this.value = value;
+    }
+}
+
+const asyncScheduler = new AsyncScheduler(AsyncAction);
+const async = asyncScheduler;
+
+function isObservable(obj) {
+    return !!obj && (obj instanceof Observable || (typeof obj.lift === 'function' && typeof obj.subscribe === 'function'));
+}
+
+const ArgumentOutOfRangeErrorImpl = (() => {
+    function ArgumentOutOfRangeErrorImpl() {
+        Error.call(this);
+        this.message = 'argument out of range';
+        this.name = 'ArgumentOutOfRangeError';
+        return this;
+    }
+    ArgumentOutOfRangeErrorImpl.prototype = Object.create(Error.prototype);
+    return ArgumentOutOfRangeErrorImpl;
+})();
+const ArgumentOutOfRangeError = ArgumentOutOfRangeErrorImpl;
+
+function map(project, thisArg) {
+    return function mapOperation(source) {
+        if (typeof project !== 'function') {
+            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
+        }
+        return source.lift(new MapOperator(project, thisArg));
+    };
+}
+class MapOperator {
+    constructor(project, thisArg) {
+        this.project = project;
+        this.thisArg = thisArg;
+    }
+    call(subscriber, source) {
+        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
+    }
+}
+class MapSubscriber extends Subscriber {
+    constructor(destination, project, thisArg) {
+        super(destination);
+        this.project = project;
+        this.count = 0;
+        this.thisArg = thisArg || this;
+    }
+    _next(value) {
+        let result;
+        try {
+            result = this.project.call(this.thisArg, value, this.count++);
+        }
+        catch (err) {
+            this.destination.error(err);
+            return;
+        }
+        this.destination.next(result);
+    }
+}
+
+const subscribeToPromise = (promise) => (subscriber) => {
+    promise.then((value) => {
+        if (!subscriber.closed) {
+            subscriber.next(value);
+            subscriber.complete();
+        }
+    }, (err) => subscriber.error(err))
+        .then(null, hostReportError);
+    return subscriber;
+};
+
+function getSymbolIterator() {
+    if (typeof Symbol !== 'function' || !Symbol.iterator) {
+        return '@@iterator';
+    }
+    return Symbol.iterator;
+}
+const iterator = getSymbolIterator();
+
+const subscribeToIterable = (iterable) => (subscriber) => {
+    const iterator$1 = iterable[iterator]();
+    do {
+        let item;
+        try {
+            item = iterator$1.next();
+        }
+        catch (err) {
+            subscriber.error(err);
+            return subscriber;
+        }
+        if (item.done) {
+            subscriber.complete();
+            break;
+        }
+        subscriber.next(item.value);
+        if (subscriber.closed) {
+            break;
+        }
+    } while (true);
+    if (typeof iterator$1.return === 'function') {
+        subscriber.add(() => {
+            if (iterator$1.return) {
+                iterator$1.return();
+            }
+        });
+    }
+    return subscriber;
+};
+
+const subscribeToObservable = (obj) => (subscriber) => {
+    const obs = obj[observable]();
+    if (typeof obs.subscribe !== 'function') {
+        throw new TypeError('Provided object does not correctly implement Symbol.observable');
+    }
+    else {
+        return obs.subscribe(subscriber);
+    }
+};
+
+const isArrayLike = ((x) => x && typeof x.length === 'number' && typeof x !== 'function');
+
+function isPromise(value) {
+    return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';
+}
+
+const subscribeTo = (result) => {
+    if (!!result && typeof result[observable] === 'function') {
+        return subscribeToObservable(result);
+    }
+    else if (isArrayLike(result)) {
+        return subscribeToArray(result);
+    }
+    else if (isPromise(result)) {
+        return subscribeToPromise(result);
+    }
+    else if (!!result && typeof result[iterator] === 'function') {
+        return subscribeToIterable(result);
+    }
+    else {
+        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);
+    }
+};
+
+function scheduleObservable(input, scheduler) {
+    return new Observable(subscriber => {
+        const sub = new Subscription();
+        sub.add(scheduler.schedule(() => {
+            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())); },
+            }));
+        }));
+        return sub;
+    });
+}
+
+function schedulePromise(input, scheduler) {
+    return new Observable(subscriber => {
+        const sub = new Subscription();
+        sub.add(scheduler.schedule(() => input.then(value => {
+            sub.add(scheduler.schedule(() => {
+                subscriber.next(value);
+                sub.add(scheduler.schedule(() => subscriber.complete()));
+            }));
+        }, err => {
+            sub.add(scheduler.schedule(() => subscriber.error(err)));
+        })));
+        return sub;
+    });
+}
+
+function scheduleIterable(input, scheduler) {
+    if (!input) {
+        throw new Error('Iterable cannot be null');
+    }
+    return new Observable(subscriber => {
+        const sub = new Subscription();
+        let iterator$1;
+        sub.add(() => {
+            if (iterator$1 && typeof iterator$1.return === 'function') {
+                iterator$1.return();
+            }
+        });
+        sub.add(scheduler.schedule(() => {
+            iterator$1 = input[iterator]();
+            sub.add(scheduler.schedule(function () {
+                if (subscriber.closed) {
+                    return;
+                }
+                let value;
+                let done;
+                try {
+                    const result = iterator$1.next();
+                    value = result.value;
+                    done = result.done;
+                }
+                catch (err) {
+                    subscriber.error(err);
+                    return;
+                }
+                if (done) {
+                    subscriber.complete();
+                }
+                else {
+                    subscriber.next(value);
+                    this.schedule();
+                }
+            }));
+        }));
+        return sub;
+    });
+}
+
+function isInteropObservable(input) {
+    return input && typeof input[observable] === 'function';
+}
+
+function isIterable(input) {
+    return input && typeof input[iterator] === 'function';
+}
+
+function scheduled(input, scheduler) {
+    if (input != null) {
+        if (isInteropObservable(input)) {
+            return scheduleObservable(input, scheduler);
+        }
+        else if (isPromise(input)) {
+            return schedulePromise(input, scheduler);
+        }
+        else if (isArrayLike(input)) {
+            return scheduleArray(input, scheduler);
+        }
+        else if (isIterable(input) || typeof input === 'string') {
+            return scheduleIterable(input, scheduler);
+        }
+    }
+    throw new TypeError((input !== null && typeof input || input) + ' is not observable');
+}
+
+function from(input, scheduler) {
+    if (!scheduler) {
+        if (input instanceof Observable) {
+            return input;
+        }
+        return new Observable(subscribeTo(input));
+    }
+    else {
+        return scheduled(input, scheduler);
+    }
+}
+
+class SimpleInnerSubscriber extends Subscriber {
+    constructor(parent) {
+        super();
+        this.parent = parent;
+    }
+    _next(value) {
+        this.parent.notifyNext(value);
+    }
+    _error(error) {
+        this.parent.notifyError(error);
+        this.unsubscribe();
+    }
+    _complete() {
+        this.parent.notifyComplete();
+        this.unsubscribe();
+    }
+}
+class SimpleOuterSubscriber extends Subscriber {
+    notifyNext(innerValue) {
+        this.destination.next(innerValue);
+    }
+    notifyError(err) {
+        this.destination.error(err);
+    }
+    notifyComplete() {
+        this.destination.complete();
+    }
+}
+function innerSubscribe(result, innerSubscriber) {
+    if (innerSubscriber.closed) {
+        return undefined;
+    }
+    if (result instanceof Observable) {
+        return result.subscribe(innerSubscriber);
+    }
+    return subscribeTo(result)(innerSubscriber);
+}
+
+function filter(predicate, thisArg) {
+    return function filterOperatorFunction(source) {
+        return source.lift(new FilterOperator(predicate, thisArg));
+    };
+}
+class FilterOperator {
+    constructor(predicate, thisArg) {
+        this.predicate = predicate;
+        this.thisArg = thisArg;
+    }
+    call(subscriber, source) {
+        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
+    }
+}
+class FilterSubscriber extends Subscriber {
+    constructor(destination, predicate, thisArg) {
+        super(destination);
+        this.predicate = predicate;
+        this.thisArg = thisArg;
+        this.count = 0;
+    }
+    _next(value) {
+        let result;
+        try {
+            result = this.predicate.call(this.thisArg, value, this.count++);
+        }
+        catch (err) {
+            this.destination.error(err);
+            return;
+        }
+        if (result) {
+            this.destination.next(value);
+        }
+    }
+}
+
+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));
+}
+class DistinctUntilChangedOperator {
+    constructor(compare, keySelector) {
+        this.compare = compare;
+        this.keySelector = keySelector;
+    }
+    call(subscriber, source) {
+        return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));
+    }
+}
+class DistinctUntilChangedSubscriber extends Subscriber {
+    constructor(destination, compare, keySelector) {
+        super(destination);
+        this.keySelector = keySelector;
+        this.hasKey = false;
+        if (typeof compare === 'function') {
+            this.compare = compare;
+        }
+    }
+    compare(x, y) {
+        return x === y;
+    }
+    _next(value) {
+        let key;
+        try {
+            const { keySelector } = this;
+            key = keySelector ? keySelector(value) : value;
+        }
+        catch (err) {
+            return this.destination.error(err);
+        }
+        let result = false;
+        if (this.hasKey) {
+            try {
+                const { compare } = this;
+                result = compare(this.key, key);
+            }
+            catch (err) {
+                return this.destination.error(err);
+            }
+        }
+        else {
+            this.hasKey = true;
+        }
+        if (!result) {
+            this.key = key;
+            this.destination.next(value);
+        }
+    }
+}
+
+function take(count) {
+    return (source) => {
+        if (count === 0) {
+            return empty$1();
+        }
+        else {
+            return source.lift(new TakeOperator(count));
+        }
+    };
+}
+class TakeOperator {
+    constructor(total) {
+        this.total = total;
+        if (this.total < 0) {
+            throw new ArgumentOutOfRangeError;
+        }
+    }
+    call(subscriber, source) {
+        return source.subscribe(new TakeSubscriber(subscriber, this.total));
+    }
+}
+class TakeSubscriber extends Subscriber {
+    constructor(destination, total) {
+        super(destination);
+        this.total = total;
+        this.count = 0;
+    }
+    _next(value) {
+        const total = this.total;
+        const count = ++this.count;
+        if (count <= total) {
+            this.destination.next(value);
+            if (count === total) {
+                this.destination.complete();
+                this.unsubscribe();
+            }
+        }
+    }
+}
+
+function switchMap(project, resultSelector) {
+    if (typeof resultSelector === 'function') {
+        return (source) => source.pipe(switchMap((a, i) => from(project(a, i)).pipe(map((b, ii) => resultSelector(a, b, i, ii)))));
+    }
+    return (source) => source.lift(new SwitchMapOperator(project));
+}
+class SwitchMapOperator {
+    constructor(project) {
+        this.project = project;
+    }
+    call(subscriber, source) {
+        return source.subscribe(new SwitchMapSubscriber(subscriber, this.project));
+    }
+}
+class SwitchMapSubscriber extends SimpleOuterSubscriber {
+    constructor(destination, project) {
+        super(destination);
+        this.project = project;
+        this.index = 0;
+    }
+    _next(value) {
+        let result;
+        const index = this.index++;
+        try {
+            result = this.project(value, index);
+        }
+        catch (error) {
+            this.destination.error(error);
+            return;
+        }
+        this._innerSub(result);
+    }
+    _innerSub(result) {
+        const innerSubscription = this.innerSubscription;
+        if (innerSubscription) {
+            innerSubscription.unsubscribe();
+        }
+        const innerSubscriber = new SimpleInnerSubscriber(this);
+        const destination = this.destination;
+        destination.add(innerSubscriber);
+        this.innerSubscription = innerSubscribe(result, innerSubscriber);
+        if (this.innerSubscription !== innerSubscriber) {
+            destination.add(this.innerSubscription);
+        }
+    }
+    _complete() {
+        const { innerSubscription } = this;
+        if (!innerSubscription || innerSubscription.closed) {
+            super._complete();
+        }
+        this.unsubscribe();
+    }
+    _unsubscribe() {
+        this.innerSubscription = undefined;
+    }
+    notifyComplete() {
+        this.innerSubscription = undefined;
+        if (this.isStopped) {
+            super._complete();
+        }
+    }
+    notifyNext(innerValue) {
+        this.destination.next(innerValue);
+    }
+}
+
+const currentAction = {
+    type: null,
+    entityIds: null,
+    skip: false,
+};
+let customActionActive = false;
+function resetCustomAction() {
+    customActionActive = false;
+}
+// public API for custom actions. Custom action always wins
+function logAction(type, entityIds) {
+    setAction(type, entityIds);
+    customActionActive = true;
+}
+function setAction(type, entityIds) {
+    if (customActionActive === false) {
+        currentAction.type = type;
+        currentAction.entityIds = entityIds;
+    }
+}
+function action(action, entityIds) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            logAction(action, entityIds);
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+
+// @internal
+function hasEntity(entities, id) {
+    return entities.hasOwnProperty(id);
+}
+
+// @internal
+function addEntities({ state, entities, idKey, options = {}, preAddEntity }) {
+    let newEntities = {};
+    let newIds = [];
+    let hasNewEntities = false;
+    for (const entity of entities) {
+        if (hasEntity(state.entities, entity[idKey]) === false) {
+            // evaluate the middleware first to support dynamic ids
+            const current = preAddEntity(entity);
+            const entityId = current[idKey];
+            newEntities[entityId] = current;
+            if (options.prepend)
+                newIds.unshift(entityId);
+            else
+                newIds.push(entityId);
+            hasNewEntities = true;
+        }
+    }
+    return hasNewEntities
+        ? {
+            newState: Object.assign({}, state, { entities: Object.assign({}, state.entities, newEntities), ids: options.prepend ? [...newIds, ...state.ids] : [...state.ids, ...newIds] }),
+            newIds
+        }
+        : null;
+}
+
+// @internal
+function isNil(v) {
+    return v === null || v === undefined;
+}
+
+// @internal
+function coerceArray(value) {
+    if (isNil(value)) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+
+const DEFAULT_ID_KEY = 'id';
+
+var EntityActions;
+(function (EntityActions) {
+    EntityActions["Set"] = "Set";
+    EntityActions["Add"] = "Add";
+    EntityActions["Update"] = "Update";
+    EntityActions["Remove"] = "Remove";
+})(EntityActions || (EntityActions = {}));
+
+const isBrowser = typeof window !== 'undefined';
+
+let __DEV__ = true;
+function enableAkitaProdMode() {
+    __DEV__ = false;
+    if (isBrowser) {
+        delete window.$$stores;
+        delete window.$$queries;
+    }
+}
+// @internal
+function isDev() {
+    return __DEV__;
+}
+
+// @internal
+function isObject$1(value) {
+    const type = typeof value;
+    return value != null && (type == 'object' || type == 'function');
+}
+
+// @internal
+function isArray$1(value) {
+    return Array.isArray(value);
+}
+
+// @internal
+function getActiveEntities(idOrOptions, ids, currentActive) {
+    let result;
+    if (isArray$1(idOrOptions)) {
+        result = idOrOptions;
+    }
+    else {
+        if (isObject$1(idOrOptions)) {
+            if (isNil(currentActive))
+                return;
+            idOrOptions = Object.assign({ wrap: true }, idOrOptions);
+            const currentIdIndex = ids.indexOf(currentActive);
+            if (idOrOptions.prev) {
+                const isFirst = currentIdIndex === 0;
+                if (isFirst && !idOrOptions.wrap)
+                    return;
+                result = isFirst ? ids[ids.length - 1] : ids[currentIdIndex - 1];
+            }
+            else if (idOrOptions.next) {
+                const isLast = ids.length === currentIdIndex + 1;
+                if (isLast && !idOrOptions.wrap)
+                    return;
+                result = isLast ? ids[0] : ids[currentIdIndex + 1];
+            }
+        }
+        else {
+            if (idOrOptions === currentActive)
+                return;
+            result = idOrOptions;
+        }
+    }
+    return result;
+}
+
+// @internal
+const getInitialEntitiesState = () => ({
+    entities: {},
+    ids: [],
+    loading: true,
+    error: null
+});
+
+// @internal
+function isDefined(val) {
+    return isNil(val) === false;
+}
+
+// @internal
+function isEmpty(arr) {
+    if (isArray$1(arr)) {
+        return arr.length === 0;
+    }
+    return false;
+}
+
+// @internal
+function isFunction$1(value) {
+    return typeof value === 'function';
+}
+
+// @internal
+function isUndefined(value) {
+    return value === undefined;
+}
+
+// @internal
+function hasActiveState(state) {
+    return state.hasOwnProperty('active');
+}
+// @internal
+function isMultiActiveState(active) {
+    return isArray$1(active);
+}
+// @internal
+function resolveActiveEntity({ active, ids, entities }) {
+    if (isMultiActiveState(active)) {
+        return getExitingActives(active, ids);
+    }
+    if (hasEntity(entities, active) === false) {
+        return null;
+    }
+    return active;
+}
+// @internal
+function getExitingActives(currentActivesIds, newIds) {
+    const filtered = currentActivesIds.filter(id => newIds.indexOf(id) > -1);
+    /** Return the same reference if nothing has changed */
+    if (filtered.length === currentActivesIds.length) {
+        return currentActivesIds;
+    }
+    return filtered;
+}
+
+// @internal
+function removeEntities({ state, ids }) {
+    if (isNil(ids))
+        return removeAllEntities(state);
+    const entities = state.entities;
+    let newEntities = {};
+    for (const id of state.ids) {
+        if (ids.includes(id) === false) {
+            newEntities[id] = entities[id];
+        }
+    }
+    const newState = Object.assign({}, state, { entities: newEntities, ids: state.ids.filter(current => ids.includes(current) === false) });
+    if (hasActiveState(state)) {
+        newState.active = resolveActiveEntity(newState);
+    }
+    return newState;
+}
+// @internal
+function removeAllEntities(state) {
+    return Object.assign({}, state, { entities: {}, ids: [], active: isMultiActiveState(state.active) ? [] : null });
+}
+
+// @internal
+function toEntitiesObject(entities, idKey, preAddEntity) {
+    const acc = {
+        entities: {},
+        ids: []
+    };
+    for (const entity of entities) {
+        // evaluate the middleware first to support dynamic ids
+        const current = preAddEntity(entity);
+        acc.entities[current[idKey]] = current;
+        acc.ids.push(current[idKey]);
+    }
+    return acc;
+}
+
+// @internal
+function isEntityState(state) {
+    return state.entities && state.ids;
+}
+// @internal
+function applyMiddleware(entities, preAddEntity) {
+    let mapped = {};
+    for (const id of Object.keys(entities)) {
+        mapped[id] = preAddEntity(entities[id]);
+    }
+    return mapped;
+}
+// @internal
+function setEntities({ state, entities, idKey, preAddEntity, isNativePreAdd }) {
+    let newEntities;
+    let newIds;
+    if (isArray$1(entities)) {
+        const resolve = toEntitiesObject(entities, idKey, preAddEntity);
+        newEntities = resolve.entities;
+        newIds = resolve.ids;
+    }
+    else if (isEntityState(entities)) {
+        newEntities = isNativePreAdd ? entities.entities : applyMiddleware(entities.entities, preAddEntity);
+        newIds = entities.ids;
+    }
+    else {
+        // it's an object
+        newEntities = isNativePreAdd ? entities : applyMiddleware(entities, preAddEntity);
+        newIds = Object.keys(newEntities).map(id => (isNaN(id) ? id : Number(id)));
+    }
+    const newState = Object.assign({}, state, { entities: newEntities, ids: newIds, loading: false });
+    if (hasActiveState(state)) {
+        newState.active = resolveActiveEntity(newState);
+    }
+    return newState;
+}
+
+let CONFIG = {
+    resettable: false,
+    ttl: null,
+    producerFn: undefined
+};
+// @internal
+function getAkitaConfig() {
+    return CONFIG;
+}
+function getGlobalProducerFn() {
+    return CONFIG.producerFn;
+}
+
+// @internal
+function deepFreeze(o) {
+    Object.freeze(o);
+    const oIsFunction = typeof o === 'function';
+    const hasOwnProp = Object.prototype.hasOwnProperty;
+    Object.getOwnPropertyNames(o).forEach(function (prop) {
+        if (hasOwnProp.call(o, prop) &&
+            (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&
+            o[prop] !== null &&
+            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
+            !Object.isFrozen(o[prop])) {
+            deepFreeze(o[prop]);
+        }
+    });
+    return o;
+}
+
+// @internal
+const $$deleteStore = new Subject();
+// @internal
+const $$addStore = new ReplaySubject(50, 5000);
+// @internal
+const $$updateStore = new Subject();
+// @internal
+function dispatchDeleted(storeName) {
+    $$deleteStore.next(storeName);
+}
+// @internal
+function dispatchAdded(storeName) {
+    $$addStore.next(storeName);
+}
+// @internal
+function dispatchUpdate(storeName, action) {
+    $$updateStore.next({ storeName, action });
+}
+// @internal
+function assertStoreHasName(name, className) {
+    if (!name) {
+        console.error(`@StoreConfig({ name }) is missing in ${className}`);
+    }
+}
+
+// @internal
+function toBoolean(value) {
+    return value != null && `${value}` !== 'false';
+}
+
+// @internal
+function isPlainObject(value) {
+    return toBoolean(value) && value.constructor.name === 'Object';
+}
+
+const configKey = 'akitaConfig';
+function StoreConfig(metadata) {
+    return function (constructor) {
+        constructor[configKey] = { idKey: 'id' };
+        for (let i = 0, keys = Object.keys(metadata); i < keys.length; i++) {
+            const key = keys[i];
+            /* name is preserved read only key */
+            if (key === 'name') {
+                constructor[configKey]['storeName'] = metadata[key];
+            }
+            else {
+                constructor[configKey][key] = metadata[key];
+            }
+        }
+    };
+}
+
+// @internal
+const __stores__ = {};
+// @internal
+const __queries__ = {};
+if (isBrowser) {
+    window.$$stores = __stores__;
+    window.$$queries = __queries__;
+}
+
+// @internal
+const transactionFinished = new Subject();
+// @internal
+const transactionInProcess = new BehaviorSubject(false);
+// @internal
+const transactionManager = {
+    activeTransactions: 0,
+    batchTransaction: null
+};
+// @internal
+function startBatch() {
+    if (!isTransactionInProcess()) {
+        transactionManager.batchTransaction = new Subject();
+    }
+    transactionManager.activeTransactions++;
+    transactionInProcess.next(true);
+}
+// @internal
+function endBatch() {
+    if (--transactionManager.activeTransactions === 0) {
+        transactionManager.batchTransaction.next(true);
+        transactionManager.batchTransaction.complete();
+        transactionInProcess.next(false);
+        transactionFinished.next(true);
+    }
+}
+// @internal
+function isTransactionInProcess() {
+    return transactionManager.activeTransactions > 0;
+}
+// @internal
+function commit() {
+    return transactionManager.batchTransaction ? transactionManager.batchTransaction.asObservable() : of(true);
+}
+/**
+ *  A logical transaction.
+ *  Use this transaction to optimize the dispatch of all the stores.
+ *  The following code will update the store, BUT  emits only once
+ *
+ *  @example
+ *  applyTransaction(() => {
+ *    this.todosStore.add(new Todo(1, title));
+ *    this.todosStore.add(new Todo(2, title));
+ *  });
+ *
+ */
+function applyTransaction(action, thisArg = undefined) {
+    startBatch();
+    try {
+        return action.apply(thisArg);
+    }
+    finally {
+        logAction('@Transaction');
+        endBatch();
+    }
+}
+/**
+ *  A logical transaction.
+ *  Use this transaction to optimize the dispatch of all the stores.
+ *
+ *  The following code will update the store, BUT  emits only once.
+ *
+ *  @example
+ *  @transaction
+ *  addTodos() {
+ *    this.todosStore.add(new Todo(1, title));
+ *    this.todosStore.add(new Todo(2, title));
+ *  }
+ *
+ *
+ */
+function transaction() {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            return applyTransaction(() => {
+                return originalMethod.apply(this, args);
+            }, this);
+        };
+        return descriptor;
+    };
+}
+
+/**
+ *
+ * Store for managing any type of data
+ *
+ * @example
+ *
+ * export interface SessionState {
+ *   token: string;
+ *   userDetails: UserDetails
+ * }
+ *
+ * export function createInitialState(): SessionState {
+ *  return {
+ *    token: '',
+ *    userDetails: null
+ *  };
+ * }
+ *
+ * @StoreConfig({ name: 'session' })
+ * export class SessionStore extends Store<SessionState> {
+ *   constructor() {
+ *    super(createInitialState());
+ *   }
+ * }
+ */
+class Store {
+    constructor(initialState, options = {}) {
+        this.options = options;
+        this.inTransaction = false;
+        this.cache = {
+            active: new BehaviorSubject(false),
+            ttl: null,
+        };
+        this.onInit(initialState);
+    }
+    /**
+     *  Set the loading state
+     *
+     *  @example
+     *
+     *  store.setLoading(true)
+     *
+     */
+    setLoading(loading = false) {
+        if (loading !== this._value().loading) {
+            isDev() && setAction('Set Loading');
+            this._setState((state) => (Object.assign({}, state, { loading })));
+        }
+    }
+    /**
+     *
+     * Set whether the data is cached
+     *
+     * @example
+     *
+     * store.setHasCache(true)
+     * store.setHasCache(false)
+     * store.setHasCache(true, { restartTTL: true })
+     *
+     */
+    setHasCache(hasCache, options = { restartTTL: false }) {
+        if (hasCache !== this.cache.active.value) {
+            this.cache.active.next(hasCache);
+        }
+        if (options.restartTTL) {
+            const ttlConfig = this.getCacheTTL();
+            if (ttlConfig) {
+                if (this.cache.ttl !== null) {
+                    clearTimeout(this.cache.ttl);
+                }
+                this.cache.ttl = setTimeout(() => this.setHasCache(false), ttlConfig);
+            }
+        }
+    }
+    /**
+     *
+     * Sometimes we need to access the store value from a store
+     *
+     * @example middleware
+     *
+     */
+    getValue() {
+        return this.storeValue;
+    }
+    /**
+     *  Set the error state
+     *
+     *  @example
+     *
+     *  store.setError({text: 'unable to load data' })
+     *
+     */
+    setError(error) {
+        if (error !== this._value().error) {
+            isDev() && setAction('Set Error');
+            this._setState((state) => (Object.assign({}, state, { error })));
+        }
+    }
+    // @internal
+    _select(project) {
+        return this.store.asObservable().pipe(map((snapshot) => project(snapshot.state)), distinctUntilChanged());
+    }
+    // @internal
+    _value() {
+        return this.storeValue;
+    }
+    // @internal
+    _cache() {
+        return this.cache.active;
+    }
+    // @internal
+    get config() {
+        return this.constructor[configKey] || {};
+    }
+    // @internal
+    get storeName() {
+        return this.config.storeName || this.options.storeName || this.options.name;
+    }
+    // @internal
+    get deepFreeze() {
+        return this.config.deepFreezeFn || this.options.deepFreezeFn || deepFreeze;
+    }
+    // @internal
+    get cacheConfig() {
+        return this.config.cache || this.options.cache;
+    }
+    get _producerFn() {
+        return this.config.producerFn || this.options.producerFn || getGlobalProducerFn();
+    }
+    // @internal
+    get resettable() {
+        return isDefined(this.config.resettable) ? this.config.resettable : this.options.resettable;
+    }
+    // @internal
+    _setState(newState, _dispatchAction = true) {
+        if (isFunction$1(newState)) {
+            const _newState = newState(this._value());
+            this.storeValue = __DEV__ ? this.deepFreeze(_newState) : _newState;
+        }
+        else {
+            this.storeValue = newState;
+        }
+        if (!this.store) {
+            this.store = new BehaviorSubject({ state: this.storeValue });
+            if (isDev()) {
+                this.store.subscribe(({ action }) => {
+                    if (action) {
+                        dispatchUpdate(this.storeName, action);
+                    }
+                });
+            }
+            return;
+        }
+        if (isTransactionInProcess()) {
+            this.handleTransaction();
+            return;
+        }
+        this.dispatch(this.storeValue, _dispatchAction);
+    }
+    /**
+     *
+     * Reset the current store back to the initial value
+     *
+     * @example
+     *
+     * store.reset()
+     *
+     */
+    reset() {
+        if (this.isResettable()) {
+            isDev() && setAction('Reset');
+            this._setState(() => Object.assign({}, this._initialState));
+            this.setHasCache(false);
+        }
+        else {
+            isDev() && console.warn(`You need to enable the reset functionality`);
+        }
+    }
+    update(stateOrCallback) {
+        isDev() && setAction('Update');
+        let newState;
+        const currentState = this._value();
+        if (isFunction$1(stateOrCallback)) {
+            newState = isFunction$1(this._producerFn) ? this._producerFn(currentState, stateOrCallback) : stateOrCallback(currentState);
+        }
+        else {
+            newState = stateOrCallback;
+        }
+        const withHook = this.akitaPreUpdate(currentState, Object.assign({}, currentState, newState));
+        const resolved = isPlainObject(currentState) ? withHook : new currentState.constructor(withHook);
+        this._setState(resolved);
+    }
+    updateStoreConfig(newOptions) {
+        this.options = Object.assign({}, this.options, newOptions);
+    }
+    // @internal
+    akitaPreUpdate(_, nextState) {
+        return nextState;
+    }
+    ngOnDestroy() {
+        this.destroy();
+    }
+    /**
+     *
+     * Destroy the store
+     *
+     * @example
+     *
+     * store.destroy()
+     *
+     */
+    destroy() {
+        const hmrEnabled = isBrowser ? window.hmrEnabled : false;
+        if (!hmrEnabled && this === __stores__[this.storeName]) {
+            delete __stores__[this.storeName];
+            dispatchDeleted(this.storeName);
+            this.setHasCache(false);
+            this.cache.active.complete();
+            this.store.complete();
+        }
+    }
+    onInit(initialState) {
+        __stores__[this.storeName] = this;
+        this._setState(() => initialState);
+        dispatchAdded(this.storeName);
+        if (this.isResettable()) {
+            this._initialState = initialState;
+        }
+        isDev() && assertStoreHasName(this.storeName, this.constructor.name);
+    }
+    dispatch(state, _dispatchAction = true) {
+        let action = undefined;
+        if (_dispatchAction) {
+            action = currentAction;
+            resetCustomAction();
+        }
+        this.store.next({ state, action });
+    }
+    watchTransaction() {
+        commit().subscribe(() => {
+            this.inTransaction = false;
+            this.dispatch(this._value());
+        });
+    }
+    isResettable() {
+        if (this.resettable === false) {
+            return false;
+        }
+        return this.resettable || getAkitaConfig().resettable;
+    }
+    handleTransaction() {
+        if (!this.inTransaction) {
+            this.watchTransaction();
+            this.inTransaction = true;
+        }
+    }
+    getCacheTTL() {
+        return (this.cacheConfig && this.cacheConfig.ttl) || getAkitaConfig().ttl;
+    }
+}
+
+// @internal
+function updateEntities({ state, ids, idKey, newStateOrFn, preUpdateEntity, producerFn, onEntityIdChanges }) {
+    const updatedEntities = {};
+    let isUpdatingIdKey = false;
+    let idToUpdate;
+    for (const id of ids) {
+        // if the entity doesn't exist don't do anything
+        if (hasEntity(state.entities, id) === false) {
+            continue;
+        }
+        const oldEntity = state.entities[id];
+        let newState;
+        if (isFunction$1(newStateOrFn)) {
+            newState = isFunction$1(producerFn) ? producerFn(oldEntity, newStateOrFn) : newStateOrFn(oldEntity);
+        }
+        else {
+            newState = newStateOrFn;
+        }
+        const isIdChanged = newState.hasOwnProperty(idKey) && newState[idKey] !== oldEntity[idKey];
+        let newEntity;
+        idToUpdate = id;
+        if (isIdChanged) {
+            isUpdatingIdKey = true;
+            idToUpdate = newState[idKey];
+        }
+        const merged = Object.assign({}, oldEntity, newState);
+        if (isPlainObject(oldEntity)) {
+            newEntity = merged;
+        }
+        else {
+            /**
+             * In case that new state is class of it's own, there's
+             * a possibility that it will be different than the old
+             * class.
+             * For example, Old state is an instance of animal class
+             * and new state is instance of person class.
+             * To avoid run over new person class with the old animal
+             * class we check if the new state is a class of it's own.
+             * If so, use it. Otherwise, use the old state class
+             */
+            if (isPlainObject(newState)) {
+                newEntity = new oldEntity.constructor(merged);
+            }
+            else {
+                newEntity = new newState.constructor(merged);
+            }
+        }
+        updatedEntities[idToUpdate] = preUpdateEntity(oldEntity, newEntity);
+    }
+    let updatedIds = state.ids;
+    let stateEntities = state.entities;
+    if (isUpdatingIdKey) {
+        const [id] = ids;
+        const _a = state.entities, _b = id, rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        stateEntities = rest;
+        updatedIds = state.ids.map((current) => (current === id ? idToUpdate : current));
+        onEntityIdChanges(id, idToUpdate);
+    }
+    return Object.assign({}, state, { entities: Object.assign({}, stateEntities, updatedEntities), ids: updatedIds });
+}
+
+var _b;
+/**
+ *
+ * Store for managing a collection of entities
+ *
+ * @example
+ *
+ * export interface WidgetsState extends EntityState<Widget> { }
+ *
+ * @StoreConfig({ name: 'widgets' })
+ *  export class WidgetsStore extends EntityStore<WidgetsState> {
+ *   constructor() {
+ *     super();
+ *   }
+ * }
+ *
+ *
+ */
+class EntityStore extends Store {
+    constructor(initialState = {}, options = {}) {
+        super(Object.assign({}, getInitialEntitiesState(), initialState), options);
+        this.options = options;
+        this.entityActions = new Subject();
+        this.entityIdChanges = new Subject();
+    }
+    // @internal
+    get selectEntityAction$() {
+        return this.entityActions.asObservable();
+    }
+    // @internal
+    get selectEntityIdChanges$() {
+        return this.entityIdChanges.asObservable();
+    }
+    // @internal
+    get idKey() {
+        return this.config.idKey || this.options.idKey || DEFAULT_ID_KEY;
+    }
+    /**
+     *
+     * Replace current collection with provided collection
+     *
+     * @example
+     *
+     * this.store.set([Entity, Entity])
+     * this.store.set({ids: [], entities: {}})
+     * this.store.set({ 1: {}, 2: {}})
+     *
+     */
+    set(entities, options = {}) {
+        if (isNil(entities))
+            return;
+        isDev() && setAction('Set Entity');
+        const isNativePreAdd = this.akitaPreAddEntity === EntityStore.prototype.akitaPreAddEntity;
+        this.setHasCache(true, { restartTTL: true });
+        this._setState((state) => {
+            const newState = setEntities({
+                state,
+                entities,
+                idKey: this.idKey,
+                preAddEntity: this.akitaPreAddEntity,
+                isNativePreAdd,
+            });
+            if (isUndefined(options.activeId) === false) {
+                newState.active = options.activeId;
+            }
+            return newState;
+        });
+        if (this.hasInitialUIState()) {
+            this.handleUICreation();
+        }
+        this.entityActions.next({ type: EntityActions.Set, ids: this.ids });
+    }
+    /**
+     * Add entities
+     *
+     * @example
+     *
+     * this.store.add([Entity, Entity])
+     * this.store.add(Entity)
+     * this.store.add(Entity, { prepend: true })
+     *
+     * this.store.add(Entity, { loading: false })
+     */
+    add(entities, options = { loading: false }) {
+        const collection = coerceArray(entities);
+        if (isEmpty(collection))
+            return;
+        const data = addEntities({
+            state: this._value(),
+            preAddEntity: this.akitaPreAddEntity,
+            entities: collection,
+            idKey: this.idKey,
+            options,
+        });
+        if (data) {
+            isDev() && setAction('Add Entity');
+            data.newState.loading = options.loading;
+            this._setState(() => data.newState);
+            if (this.hasInitialUIState()) {
+                this.handleUICreation(true);
+            }
+            this.entityActions.next({ type: EntityActions.Add, ids: data.newIds });
+        }
+    }
+    update(idsOrFnOrState, newStateOrFn) {
+        if (isUndefined(newStateOrFn)) {
+            super.update(idsOrFnOrState);
+            return;
+        }
+        let ids = [];
+        if (isFunction$1(idsOrFnOrState)) {
+            // We need to filter according the predicate function
+            ids = this.ids.filter((id) => idsOrFnOrState(this.entities[id]));
+        }
+        else {
+            // If it's nil we want all of them
+            ids = isNil(idsOrFnOrState) ? this.ids : coerceArray(idsOrFnOrState);
+        }
+        if (isEmpty(ids))
+            return;
+        isDev() && setAction('Update Entity', ids);
+        let entityIdChanged;
+        this._setState((state) => updateEntities({
+            idKey: this.idKey,
+            ids,
+            preUpdateEntity: this.akitaPreUpdateEntity,
+            state,
+            newStateOrFn,
+            producerFn: this._producerFn,
+            onEntityIdChanges: (oldId, newId) => {
+                entityIdChanged = { oldId, newId };
+                this.entityIdChanges.next(Object.assign({}, entityIdChanged, { pending: true }));
+            },
+        }));
+        if (entityIdChanged) {
+            this.entityIdChanges.next(Object.assign({}, entityIdChanged, { pending: false }));
+        }
+        this.entityActions.next({ type: EntityActions.Update, ids });
+    }
+    upsert(ids, newState, onCreate, options = {}) {
+        const toArray = coerceArray(ids);
+        const predicate = (isUpdate) => (id) => hasEntity(this.entities, id) === isUpdate;
+        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$1(onCreate) ? onCreate(id, newStateObj) : newStateObj;
+            const withId = Object.assign({}, entity, { [this.idKey]: id });
+            if (isClassBased) {
+                return new baseClass(withId);
+            }
+            return withId;
+        });
+        // it can be any of the three types
+        this.update(updateIds, newState);
+        this.add(newEntities);
+        isDev() && logAction('Upsert Entity');
+    }
+    /**
+     *
+     * Upsert entity collection (idKey must be present)
+     *
+     * @example
+     *
+     * store.upsertMany([ { id: 1 }, { id: 2 }]);
+     *
+     * store.upsertMany([ { id: 1 }, { id: 2 }], { loading: true  });
+     * store.upsertMany([ { id: 1 }, { id: 2 }], { baseClass: Todo  });
+     *
+     */
+    upsertMany(entities, options = {}) {
+        const addedIds = [];
+        const updatedIds = [];
+        const updatedEntities = {};
+        // Update the state directly to optimize performance
+        for (const entity of entities) {
+            const withPreCheckHook = this.akitaPreCheckEntity(entity);
+            const id = withPreCheckHook[this.idKey];
+            if (hasEntity(this.entities, id)) {
+                const prev = this._value().entities[id];
+                const merged = Object.assign({}, this._value().entities[id], withPreCheckHook);
+                const next = options.baseClass ? new options.baseClass(merged) : merged;
+                const withHook = this.akitaPreUpdateEntity(prev, next);
+                const nextId = withHook[this.idKey];
+                updatedEntities[nextId] = withHook;
+                updatedIds.push(nextId);
+            }
+            else {
+                const newEntity = options.baseClass ? new options.baseClass(withPreCheckHook) : withPreCheckHook;
+                const withHook = this.akitaPreAddEntity(newEntity);
+                const nextId = withHook[this.idKey];
+                addedIds.push(nextId);
+                updatedEntities[nextId] = withHook;
+            }
+        }
+        isDev() && logAction('Upsert Many');
+        this._setState((state) => (Object.assign({}, state, { ids: addedIds.length ? [...state.ids, ...addedIds] : state.ids, entities: Object.assign({}, state.entities, updatedEntities), loading: !!options.loading })));
+        updatedIds.length && this.entityActions.next({ type: EntityActions.Update, ids: updatedIds });
+        addedIds.length && this.entityActions.next({ type: EntityActions.Add, ids: addedIds });
+        if (addedIds.length && this.hasUIStore()) {
+            this.handleUICreation(true);
+        }
+    }
+    /**
+     *
+     * Replace one or more entities (except the id property)
+     *
+     *
+     * @example
+     *
+     * this.store.replace(5, newEntity)
+     * this.store.replace([1,2,3], newEntity)
+     */
+    replace(ids, newState) {
+        const toArray = coerceArray(ids);
+        if (isEmpty(toArray))
+            return;
+        let replaced = {};
+        for (const id of toArray) {
+            newState[this.idKey] = id;
+            replaced[id] = newState;
+        }
+        isDev() && setAction('Replace Entity', ids);
+        this._setState((state) => (Object.assign({}, state, { entities: Object.assign({}, state.entities, replaced) })));
+    }
+    /**
+     *
+     * Move entity inside the collection
+     *
+     *
+     * @example
+     *
+     * this.store.move(fromIndex, toIndex)
+     */
+    move(from, to) {
+        const ids = this.ids.slice();
+        ids.splice(to < 0 ? ids.length + to : to, 0, ids.splice(from, 1)[0]);
+        isDev() && setAction('Move Entity');
+        this._setState((state) => (Object.assign({}, state, { 
+            // Change the entities reference so that selectAll emit
+            entities: Object.assign({}, state.entities), ids })));
+    }
+    remove(idsOrFn) {
+        if (isEmpty(this.ids))
+            return;
+        const idPassed = isDefined(idsOrFn);
+        // null means remove all
+        let ids = [];
+        if (isFunction$1(idsOrFn)) {
+            ids = this.ids.filter((entityId) => idsOrFn(this.entities[entityId]));
+        }
+        else {
+            ids = idPassed ? coerceArray(idsOrFn) : this.ids;
+        }
+        if (isEmpty(ids))
+            return;
+        isDev() && setAction('Remove Entity', ids);
+        this._setState((state) => removeEntities({ state, ids }));
+        if (!idPassed) {
+            this.setHasCache(false);
+        }
+        this.handleUIRemove(ids);
+        this.entityActions.next({ type: EntityActions.Remove, ids });
+    }
+    /**
+     *
+     * Update the active entity
+     *
+     * @example
+     *
+     * this.store.updateActive({ completed: true })
+     * this.store.updateActive(active => {
+     *   return {
+     *     config: {
+     *      ..active.config,
+     *      date
+     *     }
+     *   }
+     * })
+     */
+    updateActive(newStateOrCallback) {
+        const ids = coerceArray(this.active);
+        isDev() && setAction('Update Active', ids);
+        this.update(ids, newStateOrCallback);
+    }
+    setActive(idOrOptions) {
+        const active = getActiveEntities(idOrOptions, this.ids, this.active);
+        if (active === undefined) {
+            return;
+        }
+        isDev() && setAction('Set Active', active);
+        this._setActive(active);
+    }
+    /**
+     * Add active entities
+     *
+     * @example
+     *
+     * store.addActive(2);
+     * store.addActive([3, 4, 5]);
+     */
+    addActive(ids) {
+        const toArray = coerceArray(ids);
+        if (isEmpty(toArray))
+            return;
+        const everyExist = toArray.every((id) => this.active.indexOf(id) > -1);
+        if (everyExist)
+            return;
+        isDev() && setAction('Add Active', ids);
+        this._setState((state) => {
+            /** Protect against case that one of the items in the array exist */
+            const uniques = Array.from(new Set([...state.active, ...toArray]));
+            return Object.assign({}, state, { active: uniques });
+        });
+    }
+    /**
+     * Remove active entities
+     *
+     * @example
+     *
+     * store.removeActive(2)
+     * store.removeActive([3, 4, 5])
+     */
+    removeActive(ids) {
+        const toArray = coerceArray(ids);
+        if (isEmpty(toArray))
+            return;
+        const someExist = toArray.some((id) => this.active.indexOf(id) > -1);
+        if (!someExist)
+            return;
+        isDev() && setAction('Remove Active', ids);
+        this._setState((state) => {
+            return Object.assign({}, state, { active: Array.isArray(state.active) ? state.active.filter((currentId) => toArray.indexOf(currentId) === -1) : null });
+        });
+    }
+    /**
+     * Toggle active entities
+     *
+     * @example
+     *
+     * store.toggle(2)
+     * store.toggle([3, 4, 5])
+     */
+    toggleActive(ids) {
+        const toArray = coerceArray(ids);
+        const filterExists = (remove) => (id) => this.active.includes(id) === remove;
+        const remove = toArray.filter(filterExists(true));
+        const add = toArray.filter(filterExists(false));
+        this.removeActive(remove);
+        this.addActive(add);
+        isDev() && logAction('Toggle Active');
+    }
+    /**
+     *
+     * Create sub UI store for managing Entity's UI state
+     *
+     * @example
+     *
+     * export type ProductUI = {
+     *   isLoading: boolean;
+     *   isOpen: boolean
+     * }
+     *
+     * interface ProductsUIState extends EntityState<ProductUI> {}
+     *
+     * export class ProductsStore EntityStore<ProductsState, Product> {
+     *   ui: EntityUIStore<ProductsUIState, ProductUI>;
+     *
+     *   constructor() {
+     *     super();
+     *     this.createUIStore();
+     *   }
+     *
+     * }
+     */
+    createUIStore(initialState = {}, storeConfig = {}) {
+        const defaults = { name: `UI/${this.storeName}`, idKey: this.idKey };
+        this.ui = new EntityUIStore(initialState, Object.assign({}, defaults, storeConfig));
+        return this.ui;
+    }
+    // @internal
+    destroy() {
+        super.destroy();
+        if (this.ui instanceof EntityStore) {
+            this.ui.destroy();
+        }
+        this.entityActions.complete();
+    }
+    // @internal
+    akitaPreUpdateEntity(_, nextEntity) {
+        return nextEntity;
+    }
+    // @internal
+    akitaPreAddEntity(newEntity) {
+        return newEntity;
+    }
+    // @internal
+    akitaPreCheckEntity(newEntity) {
+        return newEntity;
+    }
+    get ids() {
+        return this._value().ids;
+    }
+    get entities() {
+        return this._value().entities;
+    }
+    get active() {
+        return this._value().active;
+    }
+    _setActive(ids) {
+        this._setState((state) => {
+            return Object.assign({}, state, { active: ids });
+        });
+    }
+    handleUICreation(add = false) {
+        const ids = this.ids;
+        const isFunc = isFunction$1(this.ui._akitaCreateEntityFn);
+        let uiEntities;
+        const createFn = (id) => {
+            const current = this.entities[id];
+            const ui = isFunc ? this.ui._akitaCreateEntityFn(current) : this.ui._akitaCreateEntityFn;
+            return Object.assign({ [this.idKey]: current[this.idKey] }, ui);
+        };
+        if (add) {
+            uiEntities = this.ids.filter((id) => isUndefined(this.ui.entities[id])).map(createFn);
+        }
+        else {
+            uiEntities = ids.map(createFn);
+        }
+        add ? this.ui.add(uiEntities) : this.ui.set(uiEntities);
+    }
+    hasInitialUIState() {
+        return this.hasUIStore() && isUndefined(this.ui._akitaCreateEntityFn) === false;
+    }
+    handleUIRemove(ids) {
+        if (this.hasUIStore()) {
+            this.ui.remove(ids);
+        }
+    }
+    hasUIStore() {
+        return this.ui instanceof EntityUIStore;
+    }
+}
+__decorate([
+    transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], EntityStore.prototype, "upsert", null);
+__decorate([
+    transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_b = typeof T !== "undefined" && T) === "function" ? _b : Object]),
+    __metadata("design:returntype", void 0)
+], EntityStore.prototype, "toggleActive", null);
+// @internal
+class EntityUIStore extends EntityStore {
+    constructor(initialState = {}, storeConfig = {}) {
+        super(initialState, storeConfig);
+    }
+    /**
+     *
+     * Set the initial UI entity state. This function will determine the entity's
+     * initial state when we call `set()` or `add()`.
+     *
+     * @example
+     *
+     * constructor() {
+     *   super();
+     *   this.createUIStore().setInitialEntityState(entity => ({ isLoading: false, isOpen: true }));
+     *   this.createUIStore().setInitialEntityState({ isLoading: false, isOpen: true });
+     * }
+     *
+     */
+    setInitialEntityState(createFn) {
+        this._akitaCreateEntityFn = createFn;
+    }
+}
+
+var Order;
+(function (Order) {
+    Order["ASC"] = "asc";
+    Order["DESC"] = "desc";
+})(Order || (Order = {}));
+
+// @internal
+function isString(value) {
+    return typeof value === 'string';
+}
+
+const queryConfigKey = 'akitaQueryConfig';
+
+function compareKeys(keysOrFuncs) {
+    return function (prevState, currState) {
+        const isFns = isFunction$1(keysOrFuncs[0]);
+        // Return when they are NOT changed
+        return keysOrFuncs.some(keyOrFunc => {
+            if (isFns) {
+                return keyOrFunc(prevState) !== keyOrFunc(currState);
+            }
+            return prevState[keyOrFunc] !== currState[keyOrFunc];
+        }) === false;
+    };
+}
+
+class Query {
+    constructor(store) {
+        this.store = store;
+        this.__store__ = store;
+        if (isDev()) {
+            // @internal
+            __queries__[store.storeName] = this;
+        }
+    }
+    select(project) {
+        let mapFn;
+        if (isFunction$1(project)) {
+            mapFn = project;
+        }
+        else if (isString(project)) {
+            mapFn = state => state[project];
+        }
+        else if (Array.isArray(project)) {
+            return this.store
+                ._select(state => state)
+                .pipe(distinctUntilChanged(compareKeys(project)), map(state => {
+                if (isFunction$1(project[0])) {
+                    return project.map(func => func(state));
+                }
+                return project.reduce((acc, k) => {
+                    acc[k] = state[k];
+                    return acc;
+                }, {});
+            }));
+        }
+        else {
+            mapFn = state => state;
+        }
+        return this.store._select(mapFn);
+    }
+    /**
+     * Select the loading state
+     *
+     * @example
+     *
+     * this.query.selectLoading().subscribe(isLoading => {})
+     */
+    selectLoading() {
+        return this.select(state => state.loading);
+    }
+    /**
+     * Select the error state
+     *
+     * @example
+     *
+     * this.query.selectError().subscribe(error => {})
+     */
+    selectError() {
+        return this.select(state => state.error);
+    }
+    /**
+     * Get the store's value
+     *
+     * @example
+     *
+     * this.query.getValue()
+     *
+     */
+    getValue() {
+        return this.store._value();
+    }
+    /**
+     * Select the cache state
+     *
+     * @example
+     *
+     * this.query.selectHasCache().pipe(
+     *   switchMap(hasCache => {
+     *     return hasCache ? of() : http().pipe(res => store.set(res))
+     *   })
+     * )
+     */
+    selectHasCache() {
+        return this.store._cache().asObservable();
+    }
+    /**
+     * Whether we've cached data
+     *
+     * @example
+     *
+     * this.query.getHasCache()
+     *
+     */
+    getHasCache() {
+        return this.store._cache().value;
+    }
+    // @internal
+    get config() {
+        return this.constructor[queryConfigKey];
+    }
+}
+
+/**
+ * @example
+ *
+ * query.selectEntity(2).pipe(filterNil)
+ */
+const filterNil = (source) => source.pipe(filter((value) => value !== null && typeof value !== 'undefined'));
+
+/**
+ * @internal
+ *
+ * @example
+ *
+ * getValue(state, 'todos.ui')
+ *
+ */
+function getValue(obj, prop) {
+    /** return the whole state  */
+    if (prop.split('.').length === 1) {
+        return obj;
+    }
+    const removeStoreName = prop
+        .split('.')
+        .slice(1)
+        .join('.');
+    return removeStoreName.split('.').reduce((acc, part) => acc && acc[part], obj);
+}
+
+/**
+ * @internal
+ *
+ * @example
+ * setValue(state, 'todos.ui', { filter: {} })
+ */
+function setValue(obj, prop, val) {
+    const split = prop.split('.');
+    if (split.length === 1) {
+        return Object.assign({}, obj, val);
+    }
+    obj = Object.assign({}, obj);
+    const lastIndex = split.length - 2;
+    const removeStoreName = prop.split('.').slice(1);
+    removeStoreName.reduce((acc, part, index) => {
+        if (index !== lastIndex) {
+            acc[part] = Object.assign({}, acc[part]);
+            return acc && acc[part];
+        }
+        acc[part] = Array.isArray(acc[part]) || !isObject$1(acc[part]) ? val : Object.assign({}, acc[part], val);
+        return acc && acc[part];
+    }, obj);
+    return obj;
+}
+const _persistStateInit = new ReplaySubject(1);
+
+class AkitaPlugin {
+    constructor(query, config) {
+        this.query = query;
+        if (config && config.resetFn) {
+            if (getAkitaConfig().resettable) {
+                this.onReset(config.resetFn);
+            }
+        }
+    }
+    /** This method is responsible for getting access to the query. */
+    getQuery() {
+        return this.query;
+    }
+    /** This method is responsible for getting access to the store. */
+    getStore() {
+        return this.getQuery().__store__;
+    }
+    /** This method is responsible tells whether the plugin is entityBased or not.  */
+    isEntityBased(entityId) {
+        return toBoolean(entityId);
+    }
+    /** This method is responsible for selecting the source; it can be the whole store or one entity. */
+    selectSource(entityId, property) {
+        if (this.isEntityBased(entityId)) {
+            return this.getQuery().selectEntity(entityId).pipe(filterNil);
+        }
+        if (property) {
+            return this.getQuery().select(state => getValue(state, this.withStoreName(property)));
+        }
+        return this.getQuery().select();
+    }
+    getSource(entityId, property) {
+        if (this.isEntityBased(entityId)) {
+            return this.getQuery().getEntity(entityId);
+        }
+        const state = this.getQuery().getValue();
+        if (property) {
+            return getValue(state, this.withStoreName(property));
+        }
+        return state;
+    }
+    withStoreName(prop) {
+        return `${this.storeName}.${prop}`;
+    }
+    get storeName() {
+        return this.getStore().storeName;
+    }
+    /** This method is responsible for updating the store or one entity; it can be the whole store or one entity. */
+    updateStore(newState, entityId, property) {
+        if (this.isEntityBased(entityId)) {
+            this.getStore().update(entityId, newState);
+        }
+        else {
+            if (property) {
+                this.getStore()._setState(state => {
+                    return setValue(state, this.withStoreName(property), newState);
+                });
+                return;
+            }
+            this.getStore()._setState(state => (Object.assign({}, state, newState)));
+        }
+    }
+    /**
+     * Function to invoke upon reset
+     */
+    onReset(fn) {
+        const original = this.getStore().reset;
+        this.getStore().reset = (...params) => {
+            /** It should run after the plugin destroy method */
+            setTimeout(() => {
+                original.apply(this.getStore(), params);
+                fn();
+            });
+        };
+    }
+}
+
+const paginatorDefaults = {
+    pagesControls: false,
+    range: false,
+    startWith: 1,
+    cacheTimeout: undefined,
+    clearStoreWithCache: true
+};
+class PaginatorPlugin extends AkitaPlugin {
+    constructor(query, config = {}) {
+        super(query, {
+            resetFn: () => {
+                this.initial = false;
+                this.destroy({ clearCache: true, currentPage: 1 });
+            }
+        });
+        this.query = query;
+        this.config = config;
+        /** Save current filters, sorting, etc. in cache */
+        this.metadata = new Map();
+        this.pages = new Map();
+        this.pagination = {
+            currentPage: 1,
+            perPage: 0,
+            total: 0,
+            lastPage: 0,
+            data: []
+        };
+        /**
+         * When the user navigates to a different page and return
+         * we don't want to call `clearCache` on first time.
+         */
+        this.initial = true;
+        /**
+         * Proxy to the query loading
+         */
+        this.isLoading$ = this.query.selectLoading().pipe(delay(0));
+        this.config = Object.assign(paginatorDefaults, config);
+        const { startWith, cacheTimeout } = this.config;
+        this.page = new BehaviorSubject(startWith);
+        if (isObservable(cacheTimeout)) {
+            this.clearCacheSubscription = cacheTimeout.subscribe(() => this.clearCache());
+        }
+    }
+    /**
+     * Listen to page changes
+     */
+    get pageChanges() {
+        return this.page.asObservable();
+    }
+    /**
+     * Get the current page number
+     */
+    get currentPage() {
+        return this.pagination.currentPage;
+    }
+    /**
+     * Check if current page is the first one
+     */
+    get isFirst() {
+        return this.currentPage === 1;
+    }
+    /**
+     * Check if current page is the last one
+     */
+    get isLast() {
+        return this.currentPage === this.pagination.lastPage;
+    }
+    /**
+     * Whether to generate an array of pages for *ngFor
+     * [1, 2, 3, 4]
+     */
+    withControls() {
+        this.config.pagesControls = true;
+        return this;
+    }
+    /**
+     * Whether to generate the `from` and `to` keys
+     * [1, 2, 3, 4]
+     */
+    withRange() {
+        this.config.range = true;
+        return this;
+    }
+    /**
+     * Set the loading state
+     */
+    setLoading(value = true) {
+        this.getStore().setLoading(value);
+    }
+    /**
+     * Update the pagination object and add the page
+     */
+    update(response) {
+        this.pagination = response;
+        this.addPage(response.data);
+    }
+    /**
+     *
+     * Set the ids and add the page to store
+     */
+    addPage(data) {
+        this.pages.set(this.currentPage, { ids: data.map(entity => entity[this.getStore().idKey]) });
+        this.getStore().upsertMany(data);
+    }
+    /**
+     * Clear the cache.
+     */
+    clearCache(options = {}) {
+        if (!this.initial) {
+            logAction('@Pagination - Clear Cache');
+            if (options.clearStore !== false && (this.config.clearStoreWithCache || options.clearStore)) {
+                this.getStore().remove();
+            }
+            this.pages = new Map();
+            this.metadata = new Map();
+        }
+        this.initial = false;
+    }
+    clearPage(page) {
+        this.pages.delete(page);
+    }
+    /**
+     * Clear the cache timeout and optionally the pages
+     */
+    destroy({ clearCache, currentPage } = {}) {
+        if (this.clearCacheSubscription) {
+            this.clearCacheSubscription.unsubscribe();
+        }
+        if (clearCache) {
+            this.clearCache();
+        }
+        if (!isUndefined(currentPage)) {
+            this.setPage(currentPage);
+        }
+        this.initial = true;
+    }
+    /**
+     * Whether the provided page is active
+     */
+    isPageActive(page) {
+        return this.currentPage === page;
+    }
+    /**
+     * Set the current page
+     */
+    setPage(page) {
+        if (page !== this.currentPage || !this.hasPage(page)) {
+            this.page.next((this.pagination.currentPage = page));
+        }
+    }
+    /**
+     * Increment current page
+     */
+    nextPage() {
+        if (this.currentPage !== this.pagination.lastPage) {
+            this.setPage(this.pagination.currentPage + 1);
+        }
+    }
+    /**
+     * Decrement current page
+     */
+    prevPage() {
+        if (this.pagination.currentPage > 1) {
+            this.setPage(this.pagination.currentPage - 1);
+        }
+    }
+    /**
+     * Set current page to last
+     */
+    setLastPage() {
+        this.setPage(this.pagination.lastPage);
+    }
+    /**
+     * Set current page to first
+     */
+    setFirstPage() {
+        this.setPage(1);
+    }
+    /**
+     * Check if page exists in cache
+     */
+    hasPage(page) {
+        return this.pages.has(page);
+    }
+    /**
+     * Get the current page if it's in cache, otherwise invoke the request
+     */
+    getPage(req) {
+        let page = this.pagination.currentPage;
+        if (this.hasPage(page)) {
+            return this.selectPage(page);
+        }
+        else {
+            this.setLoading(true);
+            return from(req()).pipe(switchMap((config) => {
+                page = config.currentPage;
+                applyTransaction(() => {
+                    this.setLoading(false);
+                    this.update(config);
+                });
+                return this.selectPage(page);
+            }));
+        }
+    }
+    getQuery() {
+        return this.query;
+    }
+    refreshCurrentPage() {
+        if (isNil(this.currentPage) === false) {
+            this.clearPage(this.currentPage);
+            this.setPage(this.currentPage);
+        }
+    }
+    getFrom() {
+        if (this.isFirst) {
+            return 1;
+        }
+        return (this.currentPage - 1) * this.pagination.perPage + 1;
+    }
+    getTo() {
+        if (this.isLast) {
+            return this.pagination.total;
+        }
+        return this.currentPage * this.pagination.perPage;
+    }
+    /**
+     * Select the page
+     */
+    selectPage(page) {
+        return this.query.selectAll({ asObject: true }).pipe(take(1), map(entities => {
+            let response = Object.assign({}, this.pagination, { data: this.pages.get(page).ids.map(id => entities[id]) });
+            const { range, pagesControls } = this.config;
+            /** If no total - calc it */
+            if (isNaN(this.pagination.total)) {
+                if (response.lastPage === 1) {
+                    response.total = response.data ? response.data.length : 0;
+                }
+                else {
+                    response.total = response.perPage * response.lastPage;
+                }
+                this.pagination.total = response.total;
+            }
+            if (range) {
+                response.from = this.getFrom();
+                response.to = this.getTo();
+            }
+            if (pagesControls) {
+                response.pageControls = generatePages(this.pagination.total, this.pagination.perPage);
+            }
+            return response;
+        }));
+    }
+}
+__decorate([
+    action('@Pagination - New Page'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], PaginatorPlugin.prototype, "update", null);
+/**
+ * Generate an array so we can ngFor them to navigate between pages
+ */
+function generatePages(total, perPage) {
+    const len = Math.ceil(total / perPage);
+    let arr = [];
+    for (let i = 0; i < len; i++) {
+        arr.push(i + 1);
+    }
+    return arr;
+}
+
+var StoreAction;
+(function (StoreAction) {
+    StoreAction["Update"] = "UPDATE";
+})(StoreAction || (StoreAction = {}));
+var EntityStoreAction;
+(function (EntityStoreAction) {
+    EntityStoreAction["Update"] = "UPDATE";
+    EntityStoreAction["AddEntities"] = "ADD_ENTITIES";
+    EntityStoreAction["SetEntities"] = "SET_ENTITIES";
+    EntityStoreAction["UpdateEntities"] = "UPDATE_ENTITIES";
+    EntityStoreAction["RemoveEntities"] = "REMOVE_ENTITIES";
+    EntityStoreAction["UpsertEntities"] = "UPSERT_ENTITIES";
+    EntityStoreAction["UpsertManyEntities"] = "UPSERT_MANY_ENTITIES";
+})(EntityStoreAction || (EntityStoreAction = {}));
+
+export { Observable as O, Query as Q, SimpleOuterSubscriber as S, SimpleInnerSubscriber as a, isArray as b, isFunction as c, async as d, enableAkitaProdMode as e, from as f, Subscriber as g, distinctUntilChanged as h, innerSubscribe as i, filter as j, StoreConfig as k, Store as l, map as m };