@blackglory/structures 0.10.22 → 0.11.1

package/dist/es2015/index.mjs

@@ -66,12 +66,12 @@ _undefined$1.isntUndefined = isntUndefined$1;
 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;
 
@@ -901,39 +901,39 @@ function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout =
 }
 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);
@@ -942,12 +942,12 @@ function setImmediate$1(cb) {
         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);
@@ -967,7 +967,7 @@ setTimeoutLoop$1.setTimeoutLoop = setTimeoutLoop;
 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);
@@ -997,10 +997,10 @@ setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
 	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);
 	
@@ -1124,12 +1124,12 @@ _undefined.isntUndefined = isntUndefined;
 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;
 
@@ -4022,1632 +4022,6 @@ class TrieMap {
     }
 }
 
-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 = [];
@@ -6298,6 +4672,7 @@ class BitSet {
         if (added) {
             this._size++;
         }
+        return added;
     }
     delete(value) {
         var _a;
@@ -6397,6 +4772,7 @@ class TypedBitSet {
         if (added) {
             this._size++;
         }
+        return added;
     }
     delete(value) {
         var _a;
@@ -6428,5 +4804,5 @@ class TypedBitSet {
     }
 }
 
-export { BadEventError, BitSet, Box, DynamicTypedArray, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SortedSet, SparseMap, SparseSet, TLRUMap, TrieMap, TypedBitSet, TypedSparseMap, TypedSparseSet, convertArrayToCons, convertConsToArray, sliceArrayLeft, sliceArrayRight, truncateArrayLeft, truncateArrayRight };
+export { BitSet, Box, DynamicTypedArray, Emitter, ExpirableMap, HashMap, HashSet, LRUMap, Queue, SortedSet, SparseMap, SparseSet, TLRUMap, TrieMap, TypedBitSet, TypedSparseMap, TypedSparseSet, convertArrayToCons, convertConsToArray, sliceArrayLeft, sliceArrayRight, truncateArrayLeft, truncateArrayRight };
 //# sourceMappingURL=index.mjs.map