@blackglory/structures 0.10.22 → 0.11.0

package/dist/es2018/index.umd.js

@@ -72,12 +72,12 @@
     var _function$1 = {};
 
     _function$1.isntFunction = _function$1.isFunction = void 0;
-    function isFunction$2(val) {
+    function isFunction$1(val) {
         return typeof val === 'function';
     }
-    _function$1.isFunction = isFunction$2;
+    _function$1.isFunction = isFunction$1;
     function isntFunction$1(val) {
-        return !isFunction$2(val);
+        return !isFunction$1(val);
     }
     _function$1.isntFunction = isntFunction$1;
 
@@ -907,39 +907,39 @@
     }
     exponentialBackoff.calculateExponentialBackoffTimeout = calculateExponentialBackoffTimeout;
 
-    var setTimeout$2 = {};
+    var setTimeout$1 = {};
 
-    setTimeout$2.setTimeout = void 0;
-    function setTimeout$1(timeout, cb) {
+    setTimeout$1.setTimeout = void 0;
+    function setTimeout(timeout, cb) {
         const timer = globalThis.setTimeout(cb, timeout);
         return () => clearTimeout(timer);
     }
-    setTimeout$2.setTimeout = setTimeout$1;
+    setTimeout$1.setTimeout = setTimeout;
 
     var setSchedule$1 = {};
 
     setSchedule$1.setSchedule = void 0;
-    const set_timeout_1$3 = setTimeout$2;
+    const set_timeout_1$3 = setTimeout$1;
     function setSchedule(timestamp, cb) {
         const timeout = timestamp - Date.now();
         return (0, set_timeout_1$3.setTimeout)(timeout, cb);
     }
     setSchedule$1.setSchedule = setSchedule;
 
-    var setInterval$2 = {};
+    var setInterval$1 = {};
 
-    setInterval$2.setInterval = void 0;
-    function setInterval$1(timeout, cb) {
+    setInterval$1.setInterval = void 0;
+    function setInterval(timeout, cb) {
         const timer = globalThis.setInterval(cb, timeout);
         return () => clearInterval(timer);
     }
-    setInterval$2.setInterval = setInterval$1;
+    setInterval$1.setInterval = setInterval;
 
-    var setImmediate$2 = {};
+    var setImmediate$1 = {};
 
-    setImmediate$2.setImmediate = void 0;
-    const set_timeout_1$2 = setTimeout$2;
-    function setImmediate$1(cb) {
+    setImmediate$1.setImmediate = void 0;
+    const set_timeout_1$2 = setTimeout$1;
+    function setImmediate(cb) {
         if (globalThis.setImmediate) {
             const timer = globalThis.setImmediate(cb);
             return () => clearImmediate(timer);
@@ -948,12 +948,12 @@
             return (0, set_timeout_1$2.setTimeout)(0, cb);
         }
     }
-    setImmediate$2.setImmediate = setImmediate$1;
+    setImmediate$1.setImmediate = setImmediate;
 
     var setTimeoutLoop$1 = {};
 
     setTimeoutLoop$1.setTimeoutLoop = void 0;
-    const set_timeout_1$1 = setTimeout$2;
+    const set_timeout_1$1 = setTimeout$1;
     function setTimeoutLoop(timeout, cb) {
         let isCancelled = false;
         let cancel = (0, set_timeout_1$1.setTimeout)(timeout, loop);
@@ -973,7 +973,7 @@
     var setDynamicTimeoutLoop$1 = {};
 
     setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = void 0;
-    const set_timeout_1 = setTimeout$2;
+    const set_timeout_1 = setTimeout$1;
     function setDynamicTimeoutLoop(timeout, cb) {
         let isCancelled = false;
         let cancel = (0, set_timeout_1.setTimeout)(timeout, loop);
@@ -1003,10 +1003,10 @@
     	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
     	};__exportStar(exponentialBackoff, exports);
-    	__exportStar(setTimeout$2, exports);
+    	__exportStar(setTimeout$1, exports);
     	__exportStar(setSchedule$1, exports);
-    	__exportStar(setInterval$2, exports);
-    	__exportStar(setImmediate$2, exports);
+    	__exportStar(setInterval$1, exports);
+    	__exportStar(setImmediate$1, exports);
     	__exportStar(setTimeoutLoop$1, exports);
     	__exportStar(setDynamicTimeoutLoop$1, exports);
     	
@@ -1130,12 +1130,12 @@
     var _function = {};
 
     _function.isntFunction = _function.isFunction = void 0;
-    function isFunction$1(val) {
+    function isFunction(val) {
         return typeof val === 'function';
     }
-    _function.isFunction = isFunction$1;
+    _function.isFunction = isFunction;
     function isntFunction(val) {
-        return !isFunction$1(val);
+        return !isFunction(val);
     }
     _function.isntFunction = isntFunction;
 
@@ -4028,1632 +4028,6 @@
         }
     }
 
-    class FiniteStateMachine {
-        constructor(schema, initialState) {
-            this.schema = schema;
-            this._state = initialState;
-        }
-        get [Symbol.toStringTag]() {
-            return this.constructor.name;
-        }
-        get state() {
-            return this._state;
-        }
-        matches(state) {
-            return this._state === state;
-        }
-        can(event) {
-            return event in this.schema[this.state];
-        }
-        /**
-         * @throws {BadEventError}
-         */
-        send(event) {
-            if (this.can(event)) {
-                this._state = this.schema[this.state][event];
-            }
-            else {
-                throw new BadEventError(this.state, event);
-            }
-        }
-    }
-    class BadEventError extends es2018Exports$1.CustomError {
-        constructor(state, event) {
-            super(`State ${state} cannot react to event ${event}`);
-        }
-    }
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-
-    var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m) return m.call(o);
-        if (o && typeof o.length === "number") return {
-            next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-            }
-        };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m) return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-        }
-        catch (error) { e = { error: error }; }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"])) m.call(i);
-            }
-            finally { if (e) throw e.error; }
-        }
-        return ar;
-    }
-
-    function __spreadArray(to, from, pack) {
-        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-            if (ar || !(i in from)) {
-                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-            }
-        }
-        return to.concat(ar || Array.prototype.slice.call(from));
-    }
-
-    function isFunction(value) {
-        return typeof value === 'function';
-    }
-
-    function createErrorClass(createImpl) {
-        var _super = function (instance) {
-            Error.call(instance);
-            instance.stack = new Error().stack;
-        };
-        var ctorFunc = createImpl(_super);
-        ctorFunc.prototype = Object.create(Error.prototype);
-        ctorFunc.prototype.constructor = ctorFunc;
-        return ctorFunc;
-    }
-
-    var UnsubscriptionError = createErrorClass(function (_super) {
-        return function UnsubscriptionErrorImpl(errors) {
-            _super(this);
-            this.message = errors
-                ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
-                : '';
-            this.name = 'UnsubscriptionError';
-            this.errors = errors;
-        };
-    });
-
-    function arrRemove(arr, item) {
-        if (arr) {
-            var index = arr.indexOf(item);
-            0 <= index && arr.splice(index, 1);
-        }
-    }
-
-    var Subscription = (function () {
-        function Subscription(initialTeardown) {
-            this.initialTeardown = initialTeardown;
-            this.closed = false;
-            this._parentage = null;
-            this._finalizers = null;
-        }
-        Subscription.prototype.unsubscribe = function () {
-            var e_1, _a, e_2, _b;
-            var errors;
-            if (!this.closed) {
-                this.closed = true;
-                var _parentage = this._parentage;
-                if (_parentage) {
-                    this._parentage = null;
-                    if (Array.isArray(_parentage)) {
-                        try {
-                            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
-                                var parent_1 = _parentage_1_1.value;
-                                parent_1.remove(this);
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                    }
-                    else {
-                        _parentage.remove(this);
-                    }
-                }
-                var initialFinalizer = this.initialTeardown;
-                if (isFunction(initialFinalizer)) {
-                    try {
-                        initialFinalizer();
-                    }
-                    catch (e) {
-                        errors = e instanceof UnsubscriptionError ? e.errors : [e];
-                    }
-                }
-                var _finalizers = this._finalizers;
-                if (_finalizers) {
-                    this._finalizers = null;
-                    try {
-                        for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
-                            var finalizer = _finalizers_1_1.value;
-                            try {
-                                execFinalizer(finalizer);
-                            }
-                            catch (err) {
-                                errors = errors !== null && errors !== void 0 ? errors : [];
-                                if (err instanceof UnsubscriptionError) {
-                                    errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
-                                }
-                                else {
-                                    errors.push(err);
-                                }
-                            }
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                }
-                if (errors) {
-                    throw new UnsubscriptionError(errors);
-                }
-            }
-        };
-        Subscription.prototype.add = function (teardown) {
-            var _a;
-            if (teardown && teardown !== this) {
-                if (this.closed) {
-                    execFinalizer(teardown);
-                }
-                else {
-                    if (teardown instanceof Subscription) {
-                        if (teardown.closed || teardown._hasParent(this)) {
-                            return;
-                        }
-                        teardown._addParent(this);
-                    }
-                    (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
-                }
-            }
-        };
-        Subscription.prototype._hasParent = function (parent) {
-            var _parentage = this._parentage;
-            return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
-        };
-        Subscription.prototype._addParent = function (parent) {
-            var _parentage = this._parentage;
-            this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
-        };
-        Subscription.prototype._removeParent = function (parent) {
-            var _parentage = this._parentage;
-            if (_parentage === parent) {
-                this._parentage = null;
-            }
-            else if (Array.isArray(_parentage)) {
-                arrRemove(_parentage, parent);
-            }
-        };
-        Subscription.prototype.remove = function (teardown) {
-            var _finalizers = this._finalizers;
-            _finalizers && arrRemove(_finalizers, teardown);
-            if (teardown instanceof Subscription) {
-                teardown._removeParent(this);
-            }
-        };
-        Subscription.EMPTY = (function () {
-            var empty = new Subscription();
-            empty.closed = true;
-            return empty;
-        })();
-        return Subscription;
-    }());
-    var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
-    function isSubscription(value) {
-        return (value instanceof Subscription ||
-            (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
-    }
-    function execFinalizer(finalizer) {
-        if (isFunction(finalizer)) {
-            finalizer();
-        }
-        else {
-            finalizer.unsubscribe();
-        }
-    }
-
-    var config = {
-        onUnhandledError: null,
-        onStoppedNotification: null,
-        Promise: undefined,
-        useDeprecatedSynchronousErrorHandling: false,
-        useDeprecatedNextContext: false,
-    };
-
-    var timeoutProvider = {
-        setTimeout: function (handler, timeout) {
-            var args = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                args[_i - 2] = arguments[_i];
-            }
-            return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
-        },
-        clearTimeout: function (handle) {
-            return (clearTimeout)(handle);
-        },
-        delegate: undefined,
-    };
-
-    function reportUnhandledError(err) {
-        timeoutProvider.setTimeout(function () {
-            {
-                throw err;
-            }
-        });
-    }
-
-    function noop() { }
-
-    function errorContext(cb) {
-        {
-            cb();
-        }
-    }
-
-    var Subscriber = (function (_super) {
-        __extends(Subscriber, _super);
-        function Subscriber(destination) {
-            var _this = _super.call(this) || this;
-            _this.isStopped = false;
-            if (destination) {
-                _this.destination = destination;
-                if (isSubscription(destination)) {
-                    destination.add(_this);
-                }
-            }
-            else {
-                _this.destination = EMPTY_OBSERVER;
-            }
-            return _this;
-        }
-        Subscriber.create = function (next, error, complete) {
-            return new SafeSubscriber(next, error, complete);
-        };
-        Subscriber.prototype.next = function (value) {
-            if (this.isStopped) ;
-            else {
-                this._next(value);
-            }
-        };
-        Subscriber.prototype.error = function (err) {
-            if (this.isStopped) ;
-            else {
-                this.isStopped = true;
-                this._error(err);
-            }
-        };
-        Subscriber.prototype.complete = function () {
-            if (this.isStopped) ;
-            else {
-                this.isStopped = true;
-                this._complete();
-            }
-        };
-        Subscriber.prototype.unsubscribe = function () {
-            if (!this.closed) {
-                this.isStopped = true;
-                _super.prototype.unsubscribe.call(this);
-                this.destination = null;
-            }
-        };
-        Subscriber.prototype._next = function (value) {
-            this.destination.next(value);
-        };
-        Subscriber.prototype._error = function (err) {
-            try {
-                this.destination.error(err);
-            }
-            finally {
-                this.unsubscribe();
-            }
-        };
-        Subscriber.prototype._complete = function () {
-            try {
-                this.destination.complete();
-            }
-            finally {
-                this.unsubscribe();
-            }
-        };
-        return Subscriber;
-    }(Subscription));
-    var _bind = Function.prototype.bind;
-    function bind(fn, thisArg) {
-        return _bind.call(fn, thisArg);
-    }
-    var ConsumerObserver = (function () {
-        function ConsumerObserver(partialObserver) {
-            this.partialObserver = partialObserver;
-        }
-        ConsumerObserver.prototype.next = function (value) {
-            var partialObserver = this.partialObserver;
-            if (partialObserver.next) {
-                try {
-                    partialObserver.next(value);
-                }
-                catch (error) {
-                    handleUnhandledError(error);
-                }
-            }
-        };
-        ConsumerObserver.prototype.error = function (err) {
-            var partialObserver = this.partialObserver;
-            if (partialObserver.error) {
-                try {
-                    partialObserver.error(err);
-                }
-                catch (error) {
-                    handleUnhandledError(error);
-                }
-            }
-            else {
-                handleUnhandledError(err);
-            }
-        };
-        ConsumerObserver.prototype.complete = function () {
-            var partialObserver = this.partialObserver;
-            if (partialObserver.complete) {
-                try {
-                    partialObserver.complete();
-                }
-                catch (error) {
-                    handleUnhandledError(error);
-                }
-            }
-        };
-        return ConsumerObserver;
-    }());
-    var SafeSubscriber = (function (_super) {
-        __extends(SafeSubscriber, _super);
-        function SafeSubscriber(observerOrNext, error, complete) {
-            var _this = _super.call(this) || this;
-            var partialObserver;
-            if (isFunction(observerOrNext) || !observerOrNext) {
-                partialObserver = {
-                    next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined,
-                    error: error !== null && error !== void 0 ? error : undefined,
-                    complete: complete !== null && complete !== void 0 ? complete : undefined,
-                };
-            }
-            else {
-                var context_1;
-                if (_this && config.useDeprecatedNextContext) {
-                    context_1 = Object.create(observerOrNext);
-                    context_1.unsubscribe = function () { return _this.unsubscribe(); };
-                    partialObserver = {
-                        next: observerOrNext.next && bind(observerOrNext.next, context_1),
-                        error: observerOrNext.error && bind(observerOrNext.error, context_1),
-                        complete: observerOrNext.complete && bind(observerOrNext.complete, context_1),
-                    };
-                }
-                else {
-                    partialObserver = observerOrNext;
-                }
-            }
-            _this.destination = new ConsumerObserver(partialObserver);
-            return _this;
-        }
-        return SafeSubscriber;
-    }(Subscriber));
-    function handleUnhandledError(error) {
-        {
-            reportUnhandledError(error);
-        }
-    }
-    function defaultErrorHandler(err) {
-        throw err;
-    }
-    var EMPTY_OBSERVER = {
-        closed: true,
-        next: noop,
-        error: defaultErrorHandler,
-        complete: noop,
-    };
-
-    var observable = (function () { return (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(function (prev, fn) { return fn(prev); }, input);
-        };
-    }
-
-    var Observable = (function () {
-        function Observable(subscribe) {
-            if (subscribe) {
-                this._subscribe = subscribe;
-            }
-        }
-        Observable.prototype.lift = function (operator) {
-            var observable = new Observable();
-            observable.source = this;
-            observable.operator = operator;
-            return observable;
-        };
-        Observable.prototype.subscribe = function (observerOrNext, error, complete) {
-            var _this = this;
-            var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
-            errorContext(function () {
-                var _a = _this, operator = _a.operator, source = _a.source;
-                subscriber.add(operator
-                    ?
-                        operator.call(subscriber, source)
-                    : source
-                        ?
-                            _this._subscribe(subscriber)
-                        :
-                            _this._trySubscribe(subscriber));
-            });
-            return subscriber;
-        };
-        Observable.prototype._trySubscribe = function (sink) {
-            try {
-                return this._subscribe(sink);
-            }
-            catch (err) {
-                sink.error(err);
-            }
-        };
-        Observable.prototype.forEach = function (next, promiseCtor) {
-            var _this = this;
-            promiseCtor = getPromiseCtor(promiseCtor);
-            return new promiseCtor(function (resolve, reject) {
-                var subscriber = new SafeSubscriber({
-                    next: function (value) {
-                        try {
-                            next(value);
-                        }
-                        catch (err) {
-                            reject(err);
-                            subscriber.unsubscribe();
-                        }
-                    },
-                    error: reject,
-                    complete: resolve,
-                });
-                _this.subscribe(subscriber);
-            });
-        };
-        Observable.prototype._subscribe = function (subscriber) {
-            var _a;
-            return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
-        };
-        Observable.prototype[observable] = function () {
-            return this;
-        };
-        Observable.prototype.pipe = function () {
-            var operations = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                operations[_i] = arguments[_i];
-            }
-            return pipeFromArray(operations)(this);
-        };
-        Observable.prototype.toPromise = function (promiseCtor) {
-            var _this = this;
-            promiseCtor = getPromiseCtor(promiseCtor);
-            return new promiseCtor(function (resolve, reject) {
-                var value;
-                _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
-            });
-        };
-        Observable.create = function (subscribe) {
-            return new Observable(subscribe);
-        };
-        return Observable;
-    }());
-    function getPromiseCtor(promiseCtor) {
-        var _a;
-        return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
-    }
-    function isObserver(value) {
-        return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
-    }
-    function isSubscriber(value) {
-        return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
-    }
-
-    function hasLift(source) {
-        return isFunction(source === null || source === void 0 ? void 0 : source.lift);
-    }
-    function operate(init) {
-        return function (source) {
-            if (hasLift(source)) {
-                return source.lift(function (liftedSource) {
-                    try {
-                        return init(liftedSource, this);
-                    }
-                    catch (err) {
-                        this.error(err);
-                    }
-                });
-            }
-            throw new TypeError('Unable to lift unknown Observable type');
-        };
-    }
-
-    function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
-        return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
-    }
-    var OperatorSubscriber = (function (_super) {
-        __extends(OperatorSubscriber, _super);
-        function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
-            var _this = _super.call(this, destination) || this;
-            _this.onFinalize = onFinalize;
-            _this.shouldUnsubscribe = shouldUnsubscribe;
-            _this._next = onNext
-                ? function (value) {
-                    try {
-                        onNext(value);
-                    }
-                    catch (err) {
-                        destination.error(err);
-                    }
-                }
-                : _super.prototype._next;
-            _this._error = onError
-                ? function (err) {
-                    try {
-                        onError(err);
-                    }
-                    catch (err) {
-                        destination.error(err);
-                    }
-                    finally {
-                        this.unsubscribe();
-                    }
-                }
-                : _super.prototype._error;
-            _this._complete = onComplete
-                ? function () {
-                    try {
-                        onComplete();
-                    }
-                    catch (err) {
-                        destination.error(err);
-                    }
-                    finally {
-                        this.unsubscribe();
-                    }
-                }
-                : _super.prototype._complete;
-            return _this;
-        }
-        OperatorSubscriber.prototype.unsubscribe = function () {
-            var _a;
-            if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
-                var closed_1 = this.closed;
-                _super.prototype.unsubscribe.call(this);
-                !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
-            }
-        };
-        return OperatorSubscriber;
-    }(Subscriber));
-
-    function refCount() {
-        return operate(function (source, subscriber) {
-            var connection = null;
-            source._refCount++;
-            var refCounter = createOperatorSubscriber(subscriber, undefined, undefined, undefined, function () {
-                if (!source || source._refCount <= 0 || 0 < --source._refCount) {
-                    connection = null;
-                    return;
-                }
-                var sharedConnection = source._connection;
-                var conn = connection;
-                connection = null;
-                if (sharedConnection && (!conn || sharedConnection === conn)) {
-                    sharedConnection.unsubscribe();
-                }
-                subscriber.unsubscribe();
-            });
-            source.subscribe(refCounter);
-            if (!refCounter.closed) {
-                connection = source.connect();
-            }
-        });
-    }
-
-    ((function (_super) {
-        __extends(ConnectableObservable, _super);
-        function ConnectableObservable(source, subjectFactory) {
-            var _this = _super.call(this) || this;
-            _this.source = source;
-            _this.subjectFactory = subjectFactory;
-            _this._subject = null;
-            _this._refCount = 0;
-            _this._connection = null;
-            if (hasLift(source)) {
-                _this.lift = source.lift;
-            }
-            return _this;
-        }
-        ConnectableObservable.prototype._subscribe = function (subscriber) {
-            return this.getSubject().subscribe(subscriber);
-        };
-        ConnectableObservable.prototype.getSubject = function () {
-            var subject = this._subject;
-            if (!subject || subject.isStopped) {
-                this._subject = this.subjectFactory();
-            }
-            return this._subject;
-        };
-        ConnectableObservable.prototype._teardown = function () {
-            this._refCount = 0;
-            var _connection = this._connection;
-            this._subject = this._connection = null;
-            _connection === null || _connection === void 0 ? void 0 : _connection.unsubscribe();
-        };
-        ConnectableObservable.prototype.connect = function () {
-            var _this = this;
-            var connection = this._connection;
-            if (!connection) {
-                connection = this._connection = new Subscription();
-                var subject_1 = this.getSubject();
-                connection.add(this.source.subscribe(createOperatorSubscriber(subject_1, undefined, function () {
-                    _this._teardown();
-                    subject_1.complete();
-                }, function (err) {
-                    _this._teardown();
-                    subject_1.error(err);
-                }, function () { return _this._teardown(); })));
-                if (connection.closed) {
-                    this._connection = null;
-                    connection = Subscription.EMPTY;
-                }
-            }
-            return connection;
-        };
-        ConnectableObservable.prototype.refCount = function () {
-            return refCount()(this);
-        };
-        return ConnectableObservable;
-    })(Observable));
-
-    var performanceTimestampProvider = {
-        now: function () {
-            return (performanceTimestampProvider.delegate || performance).now();
-        },
-        delegate: undefined,
-    };
-
-    var animationFrameProvider = {
-        schedule: function (callback) {
-            var request = requestAnimationFrame;
-            var cancel = cancelAnimationFrame;
-            var handle = request(function (timestamp) {
-                cancel = undefined;
-                callback(timestamp);
-            });
-            return new Subscription(function () { return cancel === null || cancel === void 0 ? void 0 : cancel(handle); });
-        },
-        requestAnimationFrame: function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var delegate = animationFrameProvider.delegate;
-            return ((delegate === null || delegate === void 0 ? void 0 : delegate.requestAnimationFrame) || requestAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
-        },
-        cancelAnimationFrame: function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return (cancelAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
-        },
-        delegate: undefined,
-    };
-
-    function animationFramesFactory(timestampProvider) {
-        var schedule = animationFrameProvider.schedule;
-        return new Observable(function (subscriber) {
-            var subscription = new Subscription();
-            var provider = timestampProvider || performanceTimestampProvider;
-            var start = provider.now();
-            var run = function (timestamp) {
-                var now = provider.now();
-                subscriber.next({
-                    timestamp: timestampProvider ? now : timestamp,
-                    elapsed: now - start,
-                });
-                if (!subscriber.closed) {
-                    subscription.add(schedule(run));
-                }
-            };
-            subscription.add(schedule(run));
-            return subscription;
-        });
-    }
-    animationFramesFactory();
-
-    var ObjectUnsubscribedError = createErrorClass(function (_super) {
-        return function ObjectUnsubscribedErrorImpl() {
-            _super(this);
-            this.name = 'ObjectUnsubscribedError';
-            this.message = 'object unsubscribed';
-        };
-    });
-
-    var Subject = (function (_super) {
-        __extends(Subject, _super);
-        function Subject() {
-            var _this = _super.call(this) || this;
-            _this.closed = false;
-            _this.currentObservers = null;
-            _this.observers = [];
-            _this.isStopped = false;
-            _this.hasError = false;
-            _this.thrownError = null;
-            return _this;
-        }
-        Subject.prototype.lift = function (operator) {
-            var subject = new AnonymousSubject(this, this);
-            subject.operator = operator;
-            return subject;
-        };
-        Subject.prototype._throwIfClosed = function () {
-            if (this.closed) {
-                throw new ObjectUnsubscribedError();
-            }
-        };
-        Subject.prototype.next = function (value) {
-            var _this = this;
-            errorContext(function () {
-                var e_1, _a;
-                _this._throwIfClosed();
-                if (!_this.isStopped) {
-                    if (!_this.currentObservers) {
-                        _this.currentObservers = Array.from(_this.observers);
-                    }
-                    try {
-                        for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
-                            var observer = _c.value;
-                            observer.next(value);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                }
-            });
-        };
-        Subject.prototype.error = function (err) {
-            var _this = this;
-            errorContext(function () {
-                _this._throwIfClosed();
-                if (!_this.isStopped) {
-                    _this.hasError = _this.isStopped = true;
-                    _this.thrownError = err;
-                    var observers = _this.observers;
-                    while (observers.length) {
-                        observers.shift().error(err);
-                    }
-                }
-            });
-        };
-        Subject.prototype.complete = function () {
-            var _this = this;
-            errorContext(function () {
-                _this._throwIfClosed();
-                if (!_this.isStopped) {
-                    _this.isStopped = true;
-                    var observers = _this.observers;
-                    while (observers.length) {
-                        observers.shift().complete();
-                    }
-                }
-            });
-        };
-        Subject.prototype.unsubscribe = function () {
-            this.isStopped = this.closed = true;
-            this.observers = this.currentObservers = null;
-        };
-        Object.defineProperty(Subject.prototype, "observed", {
-            get: function () {
-                var _a;
-                return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Subject.prototype._trySubscribe = function (subscriber) {
-            this._throwIfClosed();
-            return _super.prototype._trySubscribe.call(this, subscriber);
-        };
-        Subject.prototype._subscribe = function (subscriber) {
-            this._throwIfClosed();
-            this._checkFinalizedStatuses(subscriber);
-            return this._innerSubscribe(subscriber);
-        };
-        Subject.prototype._innerSubscribe = function (subscriber) {
-            var _this = this;
-            var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
-            if (hasError || isStopped) {
-                return EMPTY_SUBSCRIPTION;
-            }
-            this.currentObservers = null;
-            observers.push(subscriber);
-            return new Subscription(function () {
-                _this.currentObservers = null;
-                arrRemove(observers, subscriber);
-            });
-        };
-        Subject.prototype._checkFinalizedStatuses = function (subscriber) {
-            var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
-            if (hasError) {
-                subscriber.error(thrownError);
-            }
-            else if (isStopped) {
-                subscriber.complete();
-            }
-        };
-        Subject.prototype.asObservable = function () {
-            var observable = new Observable();
-            observable.source = this;
-            return observable;
-        };
-        Subject.create = function (destination, source) {
-            return new AnonymousSubject(destination, source);
-        };
-        return Subject;
-    }(Observable));
-    var AnonymousSubject = (function (_super) {
-        __extends(AnonymousSubject, _super);
-        function AnonymousSubject(destination, source) {
-            var _this = _super.call(this) || this;
-            _this.destination = destination;
-            _this.source = source;
-            return _this;
-        }
-        AnonymousSubject.prototype.next = function (value) {
-            var _a, _b;
-            (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
-        };
-        AnonymousSubject.prototype.error = function (err) {
-            var _a, _b;
-            (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
-        };
-        AnonymousSubject.prototype.complete = function () {
-            var _a, _b;
-            (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
-        };
-        AnonymousSubject.prototype._subscribe = function (subscriber) {
-            var _a, _b;
-            return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
-        };
-        return AnonymousSubject;
-    }(Subject));
-
-    ((function (_super) {
-        __extends(BehaviorSubject, _super);
-        function BehaviorSubject(_value) {
-            var _this = _super.call(this) || this;
-            _this._value = _value;
-            return _this;
-        }
-        Object.defineProperty(BehaviorSubject.prototype, "value", {
-            get: function () {
-                return this.getValue();
-            },
-            enumerable: false,
-            configurable: true
-        });
-        BehaviorSubject.prototype._subscribe = function (subscriber) {
-            var subscription = _super.prototype._subscribe.call(this, subscriber);
-            !subscription.closed && subscriber.next(this._value);
-            return subscription;
-        };
-        BehaviorSubject.prototype.getValue = function () {
-            var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
-            if (hasError) {
-                throw thrownError;
-            }
-            this._throwIfClosed();
-            return _value;
-        };
-        BehaviorSubject.prototype.next = function (value) {
-            _super.prototype.next.call(this, (this._value = value));
-        };
-        return BehaviorSubject;
-    })(Subject));
-
-    var dateTimestampProvider = {
-        now: function () {
-            return (dateTimestampProvider.delegate || Date).now();
-        },
-        delegate: undefined,
-    };
-
-    ((function (_super) {
-        __extends(ReplaySubject, _super);
-        function ReplaySubject(_bufferSize, _windowTime, _timestampProvider) {
-            if (_bufferSize === void 0) { _bufferSize = Infinity; }
-            if (_windowTime === void 0) { _windowTime = Infinity; }
-            if (_timestampProvider === void 0) { _timestampProvider = dateTimestampProvider; }
-            var _this = _super.call(this) || this;
-            _this._bufferSize = _bufferSize;
-            _this._windowTime = _windowTime;
-            _this._timestampProvider = _timestampProvider;
-            _this._buffer = [];
-            _this._infiniteTimeWindow = true;
-            _this._infiniteTimeWindow = _windowTime === Infinity;
-            _this._bufferSize = Math.max(1, _bufferSize);
-            _this._windowTime = Math.max(1, _windowTime);
-            return _this;
-        }
-        ReplaySubject.prototype.next = function (value) {
-            var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime;
-            if (!isStopped) {
-                _buffer.push(value);
-                !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
-            }
-            this._trimBuffer();
-            _super.prototype.next.call(this, value);
-        };
-        ReplaySubject.prototype._subscribe = function (subscriber) {
-            this._throwIfClosed();
-            this._trimBuffer();
-            var subscription = this._innerSubscribe(subscriber);
-            var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer;
-            var copy = _buffer.slice();
-            for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
-                subscriber.next(copy[i]);
-            }
-            this._checkFinalizedStatuses(subscriber);
-            return subscription;
-        };
-        ReplaySubject.prototype._trimBuffer = function () {
-            var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow;
-            var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
-            _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
-            if (!_infiniteTimeWindow) {
-                var now = _timestampProvider.now();
-                var last = 0;
-                for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
-                    last = i;
-                }
-                last && _buffer.splice(0, last + 1);
-            }
-        };
-        return ReplaySubject;
-    })(Subject));
-
-    ((function (_super) {
-        __extends(AsyncSubject, _super);
-        function AsyncSubject() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this._value = null;
-            _this._hasValue = false;
-            _this._isComplete = false;
-            return _this;
-        }
-        AsyncSubject.prototype._checkFinalizedStatuses = function (subscriber) {
-            var _a = this, hasError = _a.hasError, _hasValue = _a._hasValue, _value = _a._value, thrownError = _a.thrownError, isStopped = _a.isStopped, _isComplete = _a._isComplete;
-            if (hasError) {
-                subscriber.error(thrownError);
-            }
-            else if (isStopped || _isComplete) {
-                _hasValue && subscriber.next(_value);
-                subscriber.complete();
-            }
-        };
-        AsyncSubject.prototype.next = function (value) {
-            if (!this.isStopped) {
-                this._value = value;
-                this._hasValue = true;
-            }
-        };
-        AsyncSubject.prototype.complete = function () {
-            var _a = this, _hasValue = _a._hasValue, _value = _a._value, _isComplete = _a._isComplete;
-            if (!_isComplete) {
-                this._isComplete = true;
-                _hasValue && _super.prototype.next.call(this, _value);
-                _super.prototype.complete.call(this);
-            }
-        };
-        return AsyncSubject;
-    })(Subject));
-
-    var Action = (function (_super) {
-        __extends(Action, _super);
-        function Action(scheduler, work) {
-            return _super.call(this) || this;
-        }
-        Action.prototype.schedule = function (state, delay) {
-            return this;
-        };
-        return Action;
-    }(Subscription));
-
-    var intervalProvider = {
-        setInterval: function (handler, timeout) {
-            var args = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                args[_i - 2] = arguments[_i];
-            }
-            return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
-        },
-        clearInterval: function (handle) {
-            return (clearInterval)(handle);
-        },
-        delegate: undefined,
-    };
-
-    var AsyncAction = (function (_super) {
-        __extends(AsyncAction, _super);
-        function AsyncAction(scheduler, work) {
-            var _this = _super.call(this, scheduler, work) || this;
-            _this.scheduler = scheduler;
-            _this.work = work;
-            _this.pending = false;
-            return _this;
-        }
-        AsyncAction.prototype.schedule = function (state, delay) {
-            if (delay === void 0) { delay = 0; }
-            if (this.closed) {
-                return this;
-            }
-            this.state = state;
-            var id = this.id;
-            var 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;
-        };
-        AsyncAction.prototype.requestAsyncId = function (scheduler, _id, delay) {
-            if (delay === void 0) { delay = 0; }
-            return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
-        };
-        AsyncAction.prototype.recycleAsyncId = function (_scheduler, id, delay) {
-            if (delay === void 0) { delay = 0; }
-            if (delay != null && this.delay === delay && this.pending === false) {
-                return id;
-            }
-            intervalProvider.clearInterval(id);
-            return undefined;
-        };
-        AsyncAction.prototype.execute = function (state, delay) {
-            if (this.closed) {
-                return new Error('executing a cancelled action');
-            }
-            this.pending = false;
-            var 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);
-            }
-        };
-        AsyncAction.prototype._execute = function (state, _delay) {
-            var errored = false;
-            var errorValue;
-            try {
-                this.work(state);
-            }
-            catch (e) {
-                errored = true;
-                errorValue = e ? e : new Error('Scheduled action threw falsy error');
-            }
-            if (errored) {
-                this.unsubscribe();
-                return errorValue;
-            }
-        };
-        AsyncAction.prototype.unsubscribe = function () {
-            if (!this.closed) {
-                var _a = this, id = _a.id, scheduler = _a.scheduler;
-                var actions = scheduler.actions;
-                this.work = this.state = this.scheduler = null;
-                this.pending = false;
-                arrRemove(actions, this);
-                if (id != null) {
-                    this.id = this.recycleAsyncId(scheduler, id, null);
-                }
-                this.delay = null;
-                _super.prototype.unsubscribe.call(this);
-            }
-        };
-        return AsyncAction;
-    }(Action));
-
-    var nextHandle = 1;
-    var resolved;
-    var activeHandles = {};
-    function findAndClearHandle(handle) {
-        if (handle in activeHandles) {
-            delete activeHandles[handle];
-            return true;
-        }
-        return false;
-    }
-    var Immediate = {
-        setImmediate: function (cb) {
-            var handle = nextHandle++;
-            activeHandles[handle] = true;
-            if (!resolved) {
-                resolved = Promise.resolve();
-            }
-            resolved.then(function () { return findAndClearHandle(handle) && cb(); });
-            return handle;
-        },
-        clearImmediate: function (handle) {
-            findAndClearHandle(handle);
-        },
-    };
-
-    var setImmediate = Immediate.setImmediate, clearImmediate$1 = Immediate.clearImmediate;
-    var immediateProvider = {
-        setImmediate: function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var delegate = immediateProvider.delegate;
-            return ((delegate === null || delegate === void 0 ? void 0 : delegate.setImmediate) || setImmediate).apply(void 0, __spreadArray([], __read(args)));
-        },
-        clearImmediate: function (handle) {
-            return (clearImmediate$1)(handle);
-        },
-        delegate: undefined,
-    };
-
-    var AsapAction = (function (_super) {
-        __extends(AsapAction, _super);
-        function AsapAction(scheduler, work) {
-            var _this = _super.call(this, scheduler, work) || this;
-            _this.scheduler = scheduler;
-            _this.work = work;
-            return _this;
-        }
-        AsapAction.prototype.requestAsyncId = function (scheduler, id, delay) {
-            if (delay === void 0) { delay = 0; }
-            if (delay !== null && delay > 0) {
-                return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
-            }
-            scheduler.actions.push(this);
-            return scheduler._scheduled || (scheduler._scheduled = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, undefined)));
-        };
-        AsapAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
-            if (delay === void 0) { delay = 0; }
-            if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
-                return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
-            }
-            if (!scheduler.actions.some(function (action) { return action.id === id; })) {
-                immediateProvider.clearImmediate(id);
-                scheduler._scheduled = undefined;
-            }
-            return undefined;
-        };
-        return AsapAction;
-    }(AsyncAction));
-
-    var Scheduler = (function () {
-        function Scheduler(schedulerActionCtor, now) {
-            if (now === void 0) { now = Scheduler.now; }
-            this.schedulerActionCtor = schedulerActionCtor;
-            this.now = now;
-        }
-        Scheduler.prototype.schedule = function (work, delay, state) {
-            if (delay === void 0) { delay = 0; }
-            return new this.schedulerActionCtor(this, work).schedule(state, delay);
-        };
-        Scheduler.now = dateTimestampProvider.now;
-        return Scheduler;
-    }());
-
-    var AsyncScheduler = (function (_super) {
-        __extends(AsyncScheduler, _super);
-        function AsyncScheduler(SchedulerAction, now) {
-            if (now === void 0) { now = Scheduler.now; }
-            var _this = _super.call(this, SchedulerAction, now) || this;
-            _this.actions = [];
-            _this._active = false;
-            _this._scheduled = undefined;
-            return _this;
-        }
-        AsyncScheduler.prototype.flush = function (action) {
-            var actions = this.actions;
-            if (this._active) {
-                actions.push(action);
-                return;
-            }
-            var 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;
-            }
-        };
-        return AsyncScheduler;
-    }(Scheduler));
-
-    var AsapScheduler = (function (_super) {
-        __extends(AsapScheduler, _super);
-        function AsapScheduler() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        AsapScheduler.prototype.flush = function (action) {
-            this._active = true;
-            var flushId = this._scheduled;
-            this._scheduled = undefined;
-            var actions = this.actions;
-            var error;
-            action = action || actions.shift();
-            do {
-                if ((error = action.execute(action.state, action.delay))) {
-                    break;
-                }
-            } while ((action = actions[0]) && action.id === flushId && actions.shift());
-            this._active = false;
-            if (error) {
-                while ((action = actions[0]) && action.id === flushId && actions.shift()) {
-                    action.unsubscribe();
-                }
-                throw error;
-            }
-        };
-        return AsapScheduler;
-    }(AsyncScheduler));
-
-    new AsapScheduler(AsapAction);
-
-    new AsyncScheduler(AsyncAction);
-
-    var QueueAction = (function (_super) {
-        __extends(QueueAction, _super);
-        function QueueAction(scheduler, work) {
-            var _this = _super.call(this, scheduler, work) || this;
-            _this.scheduler = scheduler;
-            _this.work = work;
-            return _this;
-        }
-        QueueAction.prototype.schedule = function (state, delay) {
-            if (delay === void 0) { delay = 0; }
-            if (delay > 0) {
-                return _super.prototype.schedule.call(this, state, delay);
-            }
-            this.delay = delay;
-            this.state = state;
-            this.scheduler.flush(this);
-            return this;
-        };
-        QueueAction.prototype.execute = function (state, delay) {
-            return (delay > 0 || this.closed) ?
-                _super.prototype.execute.call(this, state, delay) :
-                this._execute(state, delay);
-        };
-        QueueAction.prototype.requestAsyncId = function (scheduler, id, delay) {
-            if (delay === void 0) { delay = 0; }
-            if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
-                return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
-            }
-            return scheduler.flush(this);
-        };
-        return QueueAction;
-    }(AsyncAction));
-
-    var QueueScheduler = (function (_super) {
-        __extends(QueueScheduler, _super);
-        function QueueScheduler() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return QueueScheduler;
-    }(AsyncScheduler));
-
-    new QueueScheduler(QueueAction);
-
-    var AnimationFrameAction = (function (_super) {
-        __extends(AnimationFrameAction, _super);
-        function AnimationFrameAction(scheduler, work) {
-            var _this = _super.call(this, scheduler, work) || this;
-            _this.scheduler = scheduler;
-            _this.work = work;
-            return _this;
-        }
-        AnimationFrameAction.prototype.requestAsyncId = function (scheduler, id, delay) {
-            if (delay === void 0) { delay = 0; }
-            if (delay !== null && delay > 0) {
-                return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
-            }
-            scheduler.actions.push(this);
-            return scheduler._scheduled || (scheduler._scheduled = animationFrameProvider.requestAnimationFrame(function () { return scheduler.flush(undefined); }));
-        };
-        AnimationFrameAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
-            if (delay === void 0) { delay = 0; }
-            if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
-                return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
-            }
-            if (!scheduler.actions.some(function (action) { return action.id === id; })) {
-                animationFrameProvider.cancelAnimationFrame(id);
-                scheduler._scheduled = undefined;
-            }
-            return undefined;
-        };
-        return AnimationFrameAction;
-    }(AsyncAction));
-
-    var AnimationFrameScheduler = (function (_super) {
-        __extends(AnimationFrameScheduler, _super);
-        function AnimationFrameScheduler() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        AnimationFrameScheduler.prototype.flush = function (action) {
-            this._active = true;
-            var flushId = this._scheduled;
-            this._scheduled = undefined;
-            var actions = this.actions;
-            var error;
-            action = action || actions.shift();
-            do {
-                if ((error = action.execute(action.state, action.delay))) {
-                    break;
-                }
-            } while ((action = actions[0]) && action.id === flushId && actions.shift());
-            this._active = false;
-            if (error) {
-                while ((action = actions[0]) && action.id === flushId && actions.shift()) {
-                    action.unsubscribe();
-                }
-                throw error;
-            }
-        };
-        return AnimationFrameScheduler;
-    }(AsyncScheduler));
-
-    new AnimationFrameScheduler(AnimationFrameAction);
-
-    ((function (_super) {
-        __extends(VirtualTimeScheduler, _super);
-        function VirtualTimeScheduler(schedulerActionCtor, maxFrames) {
-            if (schedulerActionCtor === void 0) { schedulerActionCtor = VirtualAction; }
-            if (maxFrames === void 0) { maxFrames = Infinity; }
-            var _this = _super.call(this, schedulerActionCtor, function () { return _this.frame; }) || this;
-            _this.maxFrames = maxFrames;
-            _this.frame = 0;
-            _this.index = -1;
-            return _this;
-        }
-        VirtualTimeScheduler.prototype.flush = function () {
-            var _a = this, actions = _a.actions, maxFrames = _a.maxFrames;
-            var error;
-            var action;
-            while ((action = actions[0]) && action.delay <= maxFrames) {
-                actions.shift();
-                this.frame = action.delay;
-                if ((error = action.execute(action.state, action.delay))) {
-                    break;
-                }
-            }
-            if (error) {
-                while ((action = actions.shift())) {
-                    action.unsubscribe();
-                }
-                throw error;
-            }
-        };
-        VirtualTimeScheduler.frameTimeFactor = 10;
-        return VirtualTimeScheduler;
-    })(AsyncScheduler));
-    var VirtualAction = (function (_super) {
-        __extends(VirtualAction, _super);
-        function VirtualAction(scheduler, work, index) {
-            if (index === void 0) { index = (scheduler.index += 1); }
-            var _this = _super.call(this, scheduler, work) || this;
-            _this.scheduler = scheduler;
-            _this.work = work;
-            _this.index = index;
-            _this.active = true;
-            _this.index = scheduler.index = index;
-            return _this;
-        }
-        VirtualAction.prototype.schedule = function (state, delay) {
-            if (delay === void 0) { delay = 0; }
-            if (Number.isFinite(delay)) {
-                if (!this.id) {
-                    return _super.prototype.schedule.call(this, state, delay);
-                }
-                this.active = false;
-                var action = new VirtualAction(this.scheduler, this.work);
-                this.add(action);
-                return action.schedule(state, delay);
-            }
-            else {
-                return Subscription.EMPTY;
-            }
-        };
-        VirtualAction.prototype.requestAsyncId = function (scheduler, id, delay) {
-            if (delay === void 0) { delay = 0; }
-            this.delay = scheduler.frame + delay;
-            var actions = scheduler.actions;
-            actions.push(this);
-            actions.sort(VirtualAction.sortActions);
-            return true;
-        };
-        VirtualAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
-            return undefined;
-        };
-        VirtualAction.prototype._execute = function (state, delay) {
-            if (this.active === true) {
-                return _super.prototype._execute.call(this, state, delay);
-            }
-        };
-        VirtualAction.sortActions = function (a, b) {
-            if (a.delay === b.delay) {
-                if (a.index === b.index) {
-                    return 0;
-                }
-                else if (a.index > b.index) {
-                    return 1;
-                }
-                else {
-                    return -1;
-                }
-            }
-            else if (a.delay > b.delay) {
-                return 1;
-            }
-            else {
-                return -1;
-            }
-        };
-        return VirtualAction;
-    }(AsyncAction));
-
-    new Observable(function (subscriber) { return subscriber.complete(); });
-
-    var NotificationKind;
-    (function (NotificationKind) {
-        NotificationKind["NEXT"] = "N";
-        NotificationKind["ERROR"] = "E";
-        NotificationKind["COMPLETE"] = "C";
-    })(NotificationKind || (NotificationKind = {}));
-
-    createErrorClass(function (_super) { return function EmptyErrorImpl() {
-        _super(this);
-        this.name = 'EmptyError';
-        this.message = 'no elements in sequence';
-    }; });
-
-    createErrorClass(function (_super) {
-        return function ArgumentOutOfRangeErrorImpl() {
-            _super(this);
-            this.name = 'ArgumentOutOfRangeError';
-            this.message = 'argument out of range';
-        };
-    });
-
-    createErrorClass(function (_super) {
-        return function NotFoundErrorImpl(message) {
-            _super(this);
-            this.name = 'NotFoundError';
-            this.message = message;
-        };
-    });
-
-    createErrorClass(function (_super) {
-        return function SequenceErrorImpl(message) {
-            _super(this);
-            this.name = 'SequenceError';
-            this.message = message;
-        };
-    });
-
-    createErrorClass(function (_super) {
-        return function TimeoutErrorImpl(info) {
-            if (info === void 0) { info = null; }
-            _super(this);
-            this.message = 'Timeout has occurred';
-            this.name = 'TimeoutError';
-            this.info = info;
-        };
-    });
-
-    new Observable(noop);
-
-    class ObservableFiniteStateMachine extends FiniteStateMachine {
-        constructor() {
-            super(...arguments);
-            this.stateChanges = new Subject();
-        }
-        get [Symbol.toStringTag]() {
-            return this.constructor.name;
-        }
-        observeStateChanges() {
-            return this.stateChanges;
-        }
-        /**
-         * @throws {BadEventError}
-         */
-        send(event) {
-            const oldState = this.state;
-            super.send(event);
-            const newState = this.state;
-            this.stateChanges.next({ event, oldState, newState });
-            if (es2018$7.isEmptyObject(this.schema[newState])) {
-                this.stateChanges.complete();
-            }
-        }
-    }
-
     class SparseSet {
         constructor(array = []) {
             this.indexToValue = [];
@@ -6434,17 +4808,14 @@
         }
     }
 
-    exports.BadEventError = BadEventError;
     exports.BitSet = BitSet;
     exports.Box = Box;
     exports.DynamicTypedArray = DynamicTypedArray;
     exports.Emitter = Emitter;
     exports.ExpirableMap = ExpirableMap;
-    exports.FiniteStateMachine = FiniteStateMachine;
     exports.HashMap = HashMap;
     exports.HashSet = HashSet;
     exports.LRUMap = LRUMap;
-    exports.ObservableFiniteStateMachine = ObservableFiniteStateMachine;
     exports.Queue = Queue;
     exports.SortedSet = SortedSet;
     exports.SparseMap = SparseMap;