anl 1.0.0

package/lib/node_modules/rxjs/dist/esm5/internal/observable/fromSubscribable.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Observable = require('../Observable.js');
+
+function fromSubscribable(subscribable) {
+    return new Observable.Observable(function (subscriber) { return subscribable.subscribe(subscriber); });
+}
+
+exports.fromSubscribable = fromSubscribable;

package/lib/node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js

@@ -0,0 +1,155 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../tslib/tslib.es6.js');
+var isArrayLike = require('../util/isArrayLike.js');
+var isPromise = require('../util/isPromise.js');
+var Observable = require('../Observable.js');
+var isInteropObservable = require('../util/isInteropObservable.js');
+var isAsyncIterable = require('../util/isAsyncIterable.js');
+var throwUnobservableError = require('../util/throwUnobservableError.js');
+var isIterable = require('../util/isIterable.js');
+var isReadableStreamLike = require('../util/isReadableStreamLike.js');
+var isFunction = require('../util/isFunction.js');
+var reportUnhandledError = require('../util/reportUnhandledError.js');
+var observable = require('../symbol/observable.js');
+
+function innerFrom(input) {
+    if (input instanceof Observable.Observable) {
+        return input;
+    }
+    if (input != null) {
+        if (isInteropObservable.isInteropObservable(input)) {
+            return fromInteropObservable(input);
+        }
+        if (isArrayLike.isArrayLike(input)) {
+            return fromArrayLike(input);
+        }
+        if (isPromise.isPromise(input)) {
+            return fromPromise(input);
+        }
+        if (isAsyncIterable.isAsyncIterable(input)) {
+            return fromAsyncIterable(input);
+        }
+        if (isIterable.isIterable(input)) {
+            return fromIterable(input);
+        }
+        if (isReadableStreamLike.isReadableStreamLike(input)) {
+            return fromReadableStreamLike(input);
+        }
+    }
+    throw throwUnobservableError.createInvalidObservableTypeError(input);
+}
+function fromInteropObservable(obj) {
+    return new Observable.Observable(function (subscriber) {
+        var obs = obj[observable.observable]();
+        if (isFunction.isFunction(obs.subscribe)) {
+            return obs.subscribe(subscriber);
+        }
+        throw new TypeError('Provided object does not correctly implement Symbol.observable');
+    });
+}
+function fromArrayLike(array) {
+    return new Observable.Observable(function (subscriber) {
+        for (var i = 0; i < array.length && !subscriber.closed; i++) {
+            subscriber.next(array[i]);
+        }
+        subscriber.complete();
+    });
+}
+function fromPromise(promise) {
+    return new Observable.Observable(function (subscriber) {
+        promise
+            .then(function (value) {
+            if (!subscriber.closed) {
+                subscriber.next(value);
+                subscriber.complete();
+            }
+        }, function (err) { return subscriber.error(err); })
+            .then(null, reportUnhandledError.reportUnhandledError);
+    });
+}
+function fromIterable(iterable) {
+    return new Observable.Observable(function (subscriber) {
+        var e_1, _a;
+        try {
+            for (var iterable_1 = tslib_es6.__values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+                var value = iterable_1_1.value;
+                subscriber.next(value);
+                if (subscriber.closed) {
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        subscriber.complete();
+    });
+}
+function fromAsyncIterable(asyncIterable) {
+    return new Observable.Observable(function (subscriber) {
+        process(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
+    });
+}
+function fromReadableStreamLike(readableStream) {
+    return fromAsyncIterable(isReadableStreamLike.readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process(asyncIterable, subscriber) {
+    var asyncIterable_1, asyncIterable_1_1;
+    var e_2, _a;
+    return tslib_es6.__awaiter(this, void 0, void 0, function () {
+        var value, e_2_1;
+        return tslib_es6.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, 6, 11]);
+                    asyncIterable_1 = tslib_es6.__asyncValues(asyncIterable);
+                    _b.label = 1;
+                case 1: return [4, asyncIterable_1.next()];
+                case 2:
+                    if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+                    value = asyncIterable_1_1.value;
+                    subscriber.next(value);
+                    if (subscriber.closed) {
+                        return [2];
+                    }
+                    _b.label = 3;
+                case 3: return [3, 1];
+                case 4: return [3, 11];
+                case 5:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3, 11];
+                case 6:
+                    _b.trys.push([6, , 9, 10]);
+                    if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+                    return [4, _a.call(asyncIterable_1)];
+                case 7:
+                    _b.sent();
+                    _b.label = 8;
+                case 8: return [3, 10];
+                case 9:
+                    if (e_2) throw e_2.error;
+                    return [7];
+                case 10: return [7];
+                case 11:
+                    subscriber.complete();
+                    return [2];
+            }
+        });
+    });
+}
+
+exports.fromArrayLike = fromArrayLike;
+exports.fromAsyncIterable = fromAsyncIterable;
+exports.fromInteropObservable = fromInteropObservable;
+exports.fromIterable = fromIterable;
+exports.fromPromise = fromPromise;
+exports.fromReadableStreamLike = fromReadableStreamLike;
+exports.innerFrom = innerFrom;

package/lib/node_modules/rxjs/dist/esm5/internal/observable/of.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var args = require('../util/args.js');
+var from = require('./from.js');
+
+function of() {
+    var args$1 = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args$1[_i] = arguments[_i];
+    }
+    var scheduler = args.popScheduler(args$1);
+    return from.from(args$1, scheduler);
+}
+
+exports.of = of;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../tslib/tslib.es6.js');
+var Subscriber = require('../Subscriber.js');
+
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = (function (_super) {
+    tslib_es6.__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.Subscriber));
+
+exports.OperatorSubscriber = OperatorSubscriber;
+exports.createOperatorSubscriber = createOperatorSubscriber;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/concatMap.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mergeMap = require('./mergeMap.js');
+var isFunction = require('../util/isFunction.js');
+
+function concatMap(project, resultSelector) {
+    return isFunction.isFunction(resultSelector) ? mergeMap.mergeMap(project, resultSelector, 1) : mergeMap.mergeMap(project, 1);
+}
+
+exports.concatMap = concatMap;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/connect.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Subject = require('../Subject.js');
+var innerFrom = require('../observable/innerFrom.js');
+var lift = require('../util/lift.js');
+var fromSubscribable = require('../observable/fromSubscribable.js');
+
+var DEFAULT_CONFIG = {
+    connector: function () { return new Subject.Subject(); },
+};
+function connect(selector, config) {
+    if (config === void 0) { config = DEFAULT_CONFIG; }
+    var connector = config.connector;
+    return lift.operate(function (source, subscriber) {
+        var subject = connector();
+        innerFrom.innerFrom(selector(fromSubscribable.fromSubscribable(subject))).subscribe(subscriber);
+        subscriber.add(source.subscribe(subject));
+    });
+}
+
+exports.connect = connect;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/filter.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lift = require('../util/lift.js');
+var OperatorSubscriber = require('./OperatorSubscriber.js');
+
+function filter(predicate, thisArg) {
+    return lift.operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(OperatorSubscriber.createOperatorSubscriber(subscriber, function (value) { return predicate.call(thisArg, value, index++) && subscriber.next(value); }));
+    });
+}
+
+exports.filter = filter;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/flatMap.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mergeMap = require('./mergeMap.js');
+
+var flatMap = mergeMap.mergeMap;
+
+exports.flatMap = flatMap;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/map.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lift = require('../util/lift.js');
+var OperatorSubscriber = require('./OperatorSubscriber.js');
+
+function map(project, thisArg) {
+    return lift.operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(OperatorSubscriber.createOperatorSubscriber(subscriber, function (value) {
+            subscriber.next(project.call(thisArg, value, index++));
+        }));
+    });
+}
+
+exports.map = map;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innerFrom = require('../observable/innerFrom.js');
+var executeSchedule = require('../util/executeSchedule.js');
+var OperatorSubscriber = require('./OperatorSubscriber.js');
+
+function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+    var buffer = [];
+    var active = 0;
+    var index = 0;
+    var isComplete = false;
+    var checkComplete = function () {
+        if (isComplete && !buffer.length && !active) {
+            subscriber.complete();
+        }
+    };
+    var outerNext = function (value) { return (active < concurrent ? doInnerSub(value) : buffer.push(value)); };
+    var doInnerSub = function (value) {
+        expand && subscriber.next(value);
+        active++;
+        var innerComplete = false;
+        innerFrom.innerFrom(project(value, index++)).subscribe(OperatorSubscriber.createOperatorSubscriber(subscriber, function (innerValue) {
+            onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
+            if (expand) {
+                outerNext(innerValue);
+            }
+            else {
+                subscriber.next(innerValue);
+            }
+        }, function () {
+            innerComplete = true;
+        }, undefined, function () {
+            if (innerComplete) {
+                try {
+                    active--;
+                    var _loop_1 = function () {
+                        var bufferedValue = buffer.shift();
+                        if (innerSubScheduler) {
+                            executeSchedule.executeSchedule(subscriber, innerSubScheduler, function () { return doInnerSub(bufferedValue); });
+                        }
+                        else {
+                            doInnerSub(bufferedValue);
+                        }
+                    };
+                    while (buffer.length && active < concurrent) {
+                        _loop_1();
+                    }
+                    checkComplete();
+                }
+                catch (err) {
+                    subscriber.error(err);
+                }
+            }
+        }));
+    };
+    source.subscribe(OperatorSubscriber.createOperatorSubscriber(subscriber, outerNext, function () {
+        isComplete = true;
+        checkComplete();
+    }));
+    return function () {
+        additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
+    };
+}
+
+exports.mergeInternals = mergeInternals;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/mergeMap.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var map = require('./map.js');
+var innerFrom = require('../observable/innerFrom.js');
+var lift = require('../util/lift.js');
+var mergeInternals = require('./mergeInternals.js');
+var isFunction = require('../util/isFunction.js');
+
+function mergeMap(project, resultSelector, concurrent) {
+    if (concurrent === void 0) { concurrent = Infinity; }
+    if (isFunction.isFunction(resultSelector)) {
+        return mergeMap(function (a, i) { return map.map(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom.innerFrom(project(a, i))); }, concurrent);
+    }
+    else if (typeof resultSelector === 'number') {
+        concurrent = resultSelector;
+    }
+    return lift.operate(function (source, subscriber) { return mergeInternals.mergeInternals(source, subscriber, project, concurrent); });
+}
+
+exports.mergeMap = mergeMap;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/multicast.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ConnectableObservable = require('../observable/ConnectableObservable.js');
+var isFunction = require('../util/isFunction.js');
+var connect = require('./connect.js');
+
+function multicast(subjectOrSubjectFactory, selector) {
+    var subjectFactory = isFunction.isFunction(subjectOrSubjectFactory) ? subjectOrSubjectFactory : function () { return subjectOrSubjectFactory; };
+    if (isFunction.isFunction(selector)) {
+        return connect.connect(selector, {
+            connector: subjectFactory,
+        });
+    }
+    return function (source) { return new ConnectableObservable.ConnectableObservable(source, subjectFactory); };
+}
+
+exports.multicast = multicast;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/observeOn.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var executeSchedule = require('../util/executeSchedule.js');
+var lift = require('../util/lift.js');
+var OperatorSubscriber = require('./OperatorSubscriber.js');
+
+function observeOn(scheduler, delay) {
+    if (delay === void 0) { delay = 0; }
+    return lift.operate(function (source, subscriber) {
+        source.subscribe(OperatorSubscriber.createOperatorSubscriber(subscriber, function (value) { return executeSchedule.executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule.executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule.executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
+    });
+}
+
+exports.observeOn = observeOn;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/publish.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Subject = require('../Subject.js');
+var multicast = require('./multicast.js');
+var connect = require('./connect.js');
+
+function publish(selector) {
+    return selector ? function (source) { return connect.connect(selector)(source); } : function (source) { return multicast.multicast(new Subject.Subject())(source); };
+}
+
+exports.publish = publish;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/reduce.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var scanInternals = require('./scanInternals.js');
+var lift = require('../util/lift.js');
+
+function reduce(accumulator, seed) {
+    return lift.operate(scanInternals.scanInternals(accumulator, seed, arguments.length >= 2, false, true));
+}
+
+exports.reduce = reduce;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/refCount.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lift = require('../util/lift.js');
+var OperatorSubscriber = require('./OperatorSubscriber.js');
+
+function refCount() {
+    return lift.operate(function (source, subscriber) {
+        var connection = null;
+        source._refCount++;
+        var refCounter = OperatorSubscriber.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();
+        }
+    });
+}
+
+exports.refCount = refCount;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/scanInternals.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var OperatorSubscriber = require('./OperatorSubscriber.js');
+
+function scanInternals(accumulator, seed, hasSeed, emitOnNext, emitBeforeComplete) {
+    return function (source, subscriber) {
+        var hasState = hasSeed;
+        var state = seed;
+        var index = 0;
+        source.subscribe(OperatorSubscriber.createOperatorSubscriber(subscriber, function (value) {
+            var i = index++;
+            state = hasState
+                ?
+                    accumulator(state, value, i)
+                :
+                    ((hasState = true), value);
+            emitOnNext && subscriber.next(state);
+        }, emitBeforeComplete &&
+            (function () {
+                hasState && subscriber.next(state);
+                subscriber.complete();
+            })));
+    };
+}
+
+exports.scanInternals = scanInternals;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/share.js

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../tslib/tslib.es6.js');
+var innerFrom = require('../observable/innerFrom.js');
+var Subject = require('../Subject.js');
+var Subscriber = require('../Subscriber.js');
+var lift = require('../util/lift.js');
+
+function share(options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.connector, connector = _a === void 0 ? function () { return new Subject.Subject(); } : _a, _b = options.resetOnError, resetOnError = _b === void 0 ? true : _b, _c = options.resetOnComplete, resetOnComplete = _c === void 0 ? true : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === void 0 ? true : _d;
+    return function (wrapperSource) {
+        var connection;
+        var resetConnection;
+        var subject;
+        var refCount = 0;
+        var hasCompleted = false;
+        var hasErrored = false;
+        var cancelReset = function () {
+            resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
+            resetConnection = undefined;
+        };
+        var reset = function () {
+            cancelReset();
+            connection = subject = undefined;
+            hasCompleted = hasErrored = false;
+        };
+        var resetAndUnsubscribe = function () {
+            var conn = connection;
+            reset();
+            conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
+        };
+        return lift.operate(function (source, subscriber) {
+            refCount++;
+            if (!hasErrored && !hasCompleted) {
+                cancelReset();
+            }
+            var dest = (subject = subject !== null && subject !== void 0 ? subject : connector());
+            subscriber.add(function () {
+                refCount--;
+                if (refCount === 0 && !hasErrored && !hasCompleted) {
+                    resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+                }
+            });
+            dest.subscribe(subscriber);
+            if (!connection &&
+                refCount > 0) {
+                connection = new Subscriber.SafeSubscriber({
+                    next: function (value) { return dest.next(value); },
+                    error: function (err) {
+                        hasErrored = true;
+                        cancelReset();
+                        resetConnection = handleReset(reset, resetOnError, err);
+                        dest.error(err);
+                    },
+                    complete: function () {
+                        hasCompleted = true;
+                        cancelReset();
+                        resetConnection = handleReset(reset, resetOnComplete);
+                        dest.complete();
+                    },
+                });
+                innerFrom.innerFrom(source).subscribe(connection);
+            }
+        })(wrapperSource);
+    };
+}
+function handleReset(reset, on) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    if (on === true) {
+        reset();
+        return;
+    }
+    if (on === false) {
+        return;
+    }
+    var onSubscriber = new Subscriber.SafeSubscriber({
+        next: function () {
+            onSubscriber.unsubscribe();
+            reset();
+        },
+    });
+    return innerFrom.innerFrom(on.apply(void 0, tslib_es6.__spreadArray([], tslib_es6.__read(args)))).subscribe(onSubscriber);
+}
+
+exports.share = share;

package/lib/node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lift = require('../util/lift.js');
+
+function subscribeOn(scheduler, delay) {
+    if (delay === void 0) { delay = 0; }
+    return lift.operate(function (source, subscriber) {
+        subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
+    });
+}
+
+exports.subscribeOn = subscribeOn;