4695 lines
143 KiB
JavaScript
4695 lines
143 KiB
JavaScript
// node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
|
|
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;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
|
|
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;
|
|
};
|
|
});
|
|
|
|
// node_modules/tslib/tslib.es6.mjs
|
|
var extendStatics = function(d, b) {
|
|
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
|
|
d2.__proto__ = b2;
|
|
} || function(d2, b2) {
|
|
for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[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 __awaiter(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
}
|
|
function __generator(thisArg, body) {
|
|
var _ = { label: 0, sent: function() {
|
|
if (t[0] & 1) throw t[1];
|
|
return t[1];
|
|
}, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
|
|
return this;
|
|
}), g;
|
|
function verb(n) {
|
|
return function(v) {
|
|
return step([n, v]);
|
|
};
|
|
}
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0:
|
|
case 1:
|
|
t = op;
|
|
break;
|
|
case 4:
|
|
_.label++;
|
|
return { value: op[1], done: false };
|
|
case 5:
|
|
_.label++;
|
|
y = op[1];
|
|
op = [0];
|
|
continue;
|
|
case 7:
|
|
op = _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
_ = 0;
|
|
continue;
|
|
}
|
|
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
_.label = op[1];
|
|
break;
|
|
}
|
|
if (op[0] === 6 && _.label < t[1]) {
|
|
_.label = t[1];
|
|
t = op;
|
|
break;
|
|
}
|
|
if (t && _.label < t[2]) {
|
|
_.label = t[2];
|
|
_.ops.push(op);
|
|
break;
|
|
}
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) {
|
|
op = [6, e];
|
|
y = 0;
|
|
} finally {
|
|
f = t = 0;
|
|
}
|
|
if (op[0] & 5) throw op[1];
|
|
return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
}
|
|
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 };
|
|
} finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
} finally {
|
|
if (e) throw e.error;
|
|
}
|
|
}
|
|
return ar;
|
|
}
|
|
function __spreadArray(to, from2, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from2.length, ar; i < l; i++) {
|
|
if (ar || !(i in from2)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from2, 0, i);
|
|
ar[i] = from2[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from2));
|
|
}
|
|
function __await(v) {
|
|
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
|
}
|
|
function __asyncGenerator(thisArg, _arguments, generator) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
|
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
|
|
return this;
|
|
}, i;
|
|
function awaitReturn(f) {
|
|
return function(v) {
|
|
return Promise.resolve(v).then(f, reject);
|
|
};
|
|
}
|
|
function verb(n, f) {
|
|
if (g[n]) {
|
|
i[n] = function(v) {
|
|
return new Promise(function(a, b) {
|
|
q.push([n, v, a, b]) > 1 || resume(n, v);
|
|
});
|
|
};
|
|
if (f) i[n] = f(i[n]);
|
|
}
|
|
}
|
|
function resume(n, v) {
|
|
try {
|
|
step(g[n](v));
|
|
} catch (e) {
|
|
settle(q[0][3], e);
|
|
}
|
|
}
|
|
function step(r) {
|
|
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
|
|
}
|
|
function fulfill(value) {
|
|
resume("next", value);
|
|
}
|
|
function reject(value) {
|
|
resume("throw", value);
|
|
}
|
|
function settle(f, v) {
|
|
if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
|
|
}
|
|
}
|
|
function __asyncValues(o) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var m = o[Symbol.asyncIterator], i;
|
|
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
|
|
return this;
|
|
}, i);
|
|
function verb(n) {
|
|
i[n] = o[n] && function(v) {
|
|
return new Promise(function(resolve, reject) {
|
|
v = o[n](v), settle(resolve, reject, v.done, v.value);
|
|
});
|
|
};
|
|
}
|
|
function settle(resolve, reject, d, v) {
|
|
Promise.resolve(v).then(function(v2) {
|
|
resolve({ value: v2, done: d });
|
|
}, reject);
|
|
}
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isFunction.js
|
|
function isFunction(value) {
|
|
return typeof value === "function";
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
|
|
function arrRemove(arr, item) {
|
|
if (arr) {
|
|
var index = arr.indexOf(item);
|
|
0 <= index && arr.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/Subscription.js
|
|
var Subscription = (function() {
|
|
function Subscription2(initialTeardown) {
|
|
this.initialTeardown = initialTeardown;
|
|
this.closed = false;
|
|
this._parentage = null;
|
|
this._finalizers = null;
|
|
}
|
|
Subscription2.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);
|
|
}
|
|
}
|
|
};
|
|
Subscription2.prototype.add = function(teardown) {
|
|
var _a;
|
|
if (teardown && teardown !== this) {
|
|
if (this.closed) {
|
|
execFinalizer(teardown);
|
|
} else {
|
|
if (teardown instanceof Subscription2) {
|
|
if (teardown.closed || teardown._hasParent(this)) {
|
|
return;
|
|
}
|
|
teardown._addParent(this);
|
|
}
|
|
(this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
|
|
}
|
|
}
|
|
};
|
|
Subscription2.prototype._hasParent = function(parent) {
|
|
var _parentage = this._parentage;
|
|
return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
|
|
};
|
|
Subscription2.prototype._addParent = function(parent) {
|
|
var _parentage = this._parentage;
|
|
this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
|
|
};
|
|
Subscription2.prototype._removeParent = function(parent) {
|
|
var _parentage = this._parentage;
|
|
if (_parentage === parent) {
|
|
this._parentage = null;
|
|
} else if (Array.isArray(_parentage)) {
|
|
arrRemove(_parentage, parent);
|
|
}
|
|
};
|
|
Subscription2.prototype.remove = function(teardown) {
|
|
var _finalizers = this._finalizers;
|
|
_finalizers && arrRemove(_finalizers, teardown);
|
|
if (teardown instanceof Subscription2) {
|
|
teardown._removeParent(this);
|
|
}
|
|
};
|
|
Subscription2.EMPTY = (function() {
|
|
var empty2 = new Subscription2();
|
|
empty2.closed = true;
|
|
return empty2;
|
|
})();
|
|
return Subscription2;
|
|
})();
|
|
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();
|
|
}
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/config.js
|
|
var config = {
|
|
onUnhandledError: null,
|
|
onStoppedNotification: null,
|
|
Promise: void 0,
|
|
useDeprecatedSynchronousErrorHandling: false,
|
|
useDeprecatedNextContext: false
|
|
};
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/noop.js
|
|
function noop() {
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
|
|
var timeoutProvider = {
|
|
setTimeout: function(handler, timeout2) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
var delegate = timeoutProvider.delegate;
|
|
if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
|
|
return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout2], __read(args)));
|
|
}
|
|
return setTimeout.apply(void 0, __spreadArray([handler, timeout2], __read(args)));
|
|
},
|
|
clearTimeout: function(handle) {
|
|
var delegate = timeoutProvider.delegate;
|
|
return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
|
|
},
|
|
delegate: void 0
|
|
};
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
|
|
function reportUnhandledError(err) {
|
|
timeoutProvider.setTimeout(function() {
|
|
var onUnhandledError = config.onUnhandledError;
|
|
if (onUnhandledError) {
|
|
onUnhandledError(err);
|
|
} else {
|
|
throw err;
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
|
|
var COMPLETE_NOTIFICATION = (function() {
|
|
return createNotification("C", void 0, void 0);
|
|
})();
|
|
function errorNotification(error) {
|
|
return createNotification("E", void 0, error);
|
|
}
|
|
function nextNotification(value) {
|
|
return createNotification("N", value, void 0);
|
|
}
|
|
function createNotification(kind, value, error) {
|
|
return {
|
|
kind,
|
|
value,
|
|
error
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/errorContext.js
|
|
var context = null;
|
|
function errorContext(cb) {
|
|
if (config.useDeprecatedSynchronousErrorHandling) {
|
|
var isRoot = !context;
|
|
if (isRoot) {
|
|
context = { errorThrown: false, error: null };
|
|
}
|
|
cb();
|
|
if (isRoot) {
|
|
var _a = context, errorThrown = _a.errorThrown, error = _a.error;
|
|
context = null;
|
|
if (errorThrown) {
|
|
throw error;
|
|
}
|
|
}
|
|
} else {
|
|
cb();
|
|
}
|
|
}
|
|
function captureError(err) {
|
|
if (config.useDeprecatedSynchronousErrorHandling && context) {
|
|
context.errorThrown = true;
|
|
context.error = err;
|
|
}
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/Subscriber.js
|
|
var Subscriber = (function(_super) {
|
|
__extends(Subscriber2, _super);
|
|
function Subscriber2(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;
|
|
}
|
|
Subscriber2.create = function(next, error, complete) {
|
|
return new SafeSubscriber(next, error, complete);
|
|
};
|
|
Subscriber2.prototype.next = function(value) {
|
|
if (this.isStopped) {
|
|
handleStoppedNotification(nextNotification(value), this);
|
|
} else {
|
|
this._next(value);
|
|
}
|
|
};
|
|
Subscriber2.prototype.error = function(err) {
|
|
if (this.isStopped) {
|
|
handleStoppedNotification(errorNotification(err), this);
|
|
} else {
|
|
this.isStopped = true;
|
|
this._error(err);
|
|
}
|
|
};
|
|
Subscriber2.prototype.complete = function() {
|
|
if (this.isStopped) {
|
|
handleStoppedNotification(COMPLETE_NOTIFICATION, this);
|
|
} else {
|
|
this.isStopped = true;
|
|
this._complete();
|
|
}
|
|
};
|
|
Subscriber2.prototype.unsubscribe = function() {
|
|
if (!this.closed) {
|
|
this.isStopped = true;
|
|
_super.prototype.unsubscribe.call(this);
|
|
this.destination = null;
|
|
}
|
|
};
|
|
Subscriber2.prototype._next = function(value) {
|
|
this.destination.next(value);
|
|
};
|
|
Subscriber2.prototype._error = function(err) {
|
|
try {
|
|
this.destination.error(err);
|
|
} finally {
|
|
this.unsubscribe();
|
|
}
|
|
};
|
|
Subscriber2.prototype._complete = function() {
|
|
try {
|
|
this.destination.complete();
|
|
} finally {
|
|
this.unsubscribe();
|
|
}
|
|
};
|
|
return Subscriber2;
|
|
})(Subscription);
|
|
var _bind = Function.prototype.bind;
|
|
function bind(fn, thisArg) {
|
|
return _bind.call(fn, thisArg);
|
|
}
|
|
var ConsumerObserver = (function() {
|
|
function ConsumerObserver2(partialObserver) {
|
|
this.partialObserver = partialObserver;
|
|
}
|
|
ConsumerObserver2.prototype.next = function(value) {
|
|
var partialObserver = this.partialObserver;
|
|
if (partialObserver.next) {
|
|
try {
|
|
partialObserver.next(value);
|
|
} catch (error) {
|
|
handleUnhandledError(error);
|
|
}
|
|
}
|
|
};
|
|
ConsumerObserver2.prototype.error = function(err) {
|
|
var partialObserver = this.partialObserver;
|
|
if (partialObserver.error) {
|
|
try {
|
|
partialObserver.error(err);
|
|
} catch (error) {
|
|
handleUnhandledError(error);
|
|
}
|
|
} else {
|
|
handleUnhandledError(err);
|
|
}
|
|
};
|
|
ConsumerObserver2.prototype.complete = function() {
|
|
var partialObserver = this.partialObserver;
|
|
if (partialObserver.complete) {
|
|
try {
|
|
partialObserver.complete();
|
|
} catch (error) {
|
|
handleUnhandledError(error);
|
|
}
|
|
}
|
|
};
|
|
return ConsumerObserver2;
|
|
})();
|
|
var SafeSubscriber = (function(_super) {
|
|
__extends(SafeSubscriber2, _super);
|
|
function SafeSubscriber2(observerOrNext, error, complete) {
|
|
var _this = _super.call(this) || this;
|
|
var partialObserver;
|
|
if (isFunction(observerOrNext) || !observerOrNext) {
|
|
partialObserver = {
|
|
next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
|
|
error: error !== null && error !== void 0 ? error : void 0,
|
|
complete: complete !== null && complete !== void 0 ? complete : void 0
|
|
};
|
|
} 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 SafeSubscriber2;
|
|
})(Subscriber);
|
|
function handleUnhandledError(error) {
|
|
if (config.useDeprecatedSynchronousErrorHandling) {
|
|
captureError(error);
|
|
} else {
|
|
reportUnhandledError(error);
|
|
}
|
|
}
|
|
function defaultErrorHandler(err) {
|
|
throw err;
|
|
}
|
|
function handleStoppedNotification(notification, subscriber) {
|
|
var onStoppedNotification = config.onStoppedNotification;
|
|
onStoppedNotification && timeoutProvider.setTimeout(function() {
|
|
return onStoppedNotification(notification, subscriber);
|
|
});
|
|
}
|
|
var EMPTY_OBSERVER = {
|
|
closed: true,
|
|
next: noop,
|
|
error: defaultErrorHandler,
|
|
complete: noop
|
|
};
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/symbol/observable.js
|
|
var observable = (function() {
|
|
return typeof Symbol === "function" && Symbol.observable || "@@observable";
|
|
})();
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/identity.js
|
|
function identity(x) {
|
|
return x;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/pipe.js
|
|
function pipe() {
|
|
var fns = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
fns[_i] = arguments[_i];
|
|
}
|
|
return pipeFromArray(fns);
|
|
}
|
|
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);
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/Observable.js
|
|
var Observable = (function() {
|
|
function Observable2(subscribe) {
|
|
if (subscribe) {
|
|
this._subscribe = subscribe;
|
|
}
|
|
}
|
|
Observable2.prototype.lift = function(operator) {
|
|
var observable2 = new Observable2();
|
|
observable2.source = this;
|
|
observable2.operator = operator;
|
|
return observable2;
|
|
};
|
|
Observable2.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;
|
|
};
|
|
Observable2.prototype._trySubscribe = function(sink) {
|
|
try {
|
|
return this._subscribe(sink);
|
|
} catch (err) {
|
|
sink.error(err);
|
|
}
|
|
};
|
|
Observable2.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);
|
|
});
|
|
};
|
|
Observable2.prototype._subscribe = function(subscriber) {
|
|
var _a;
|
|
return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
|
|
};
|
|
Observable2.prototype[observable] = function() {
|
|
return this;
|
|
};
|
|
Observable2.prototype.pipe = function() {
|
|
var operations = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
operations[_i] = arguments[_i];
|
|
}
|
|
return pipeFromArray(operations)(this);
|
|
};
|
|
Observable2.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);
|
|
});
|
|
});
|
|
};
|
|
Observable2.create = function(subscribe) {
|
|
return new Observable2(subscribe);
|
|
};
|
|
return Observable2;
|
|
})();
|
|
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);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/lift.js
|
|
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");
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
|
|
function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
|
|
return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
|
|
}
|
|
var OperatorSubscriber = (function(_super) {
|
|
__extends(OperatorSubscriber2, _super);
|
|
function OperatorSubscriber2(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 (err2) {
|
|
destination.error(err2);
|
|
} 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;
|
|
}
|
|
OperatorSubscriber2.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 OperatorSubscriber2;
|
|
})(Subscriber);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/refCount.js
|
|
function refCount() {
|
|
return operate(function(source, subscriber) {
|
|
var connection = null;
|
|
source._refCount++;
|
|
var refCounter = createOperatorSubscriber(subscriber, void 0, void 0, void 0, 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();
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/ConnectableObservable.js
|
|
var ConnectableObservable = (function(_super) {
|
|
__extends(ConnectableObservable2, _super);
|
|
function ConnectableObservable2(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;
|
|
}
|
|
ConnectableObservable2.prototype._subscribe = function(subscriber) {
|
|
return this.getSubject().subscribe(subscriber);
|
|
};
|
|
ConnectableObservable2.prototype.getSubject = function() {
|
|
var subject = this._subject;
|
|
if (!subject || subject.isStopped) {
|
|
this._subject = this.subjectFactory();
|
|
}
|
|
return this._subject;
|
|
};
|
|
ConnectableObservable2.prototype._teardown = function() {
|
|
this._refCount = 0;
|
|
var _connection = this._connection;
|
|
this._subject = this._connection = null;
|
|
_connection === null || _connection === void 0 ? void 0 : _connection.unsubscribe();
|
|
};
|
|
ConnectableObservable2.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, void 0, 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;
|
|
};
|
|
ConnectableObservable2.prototype.refCount = function() {
|
|
return refCount()(this);
|
|
};
|
|
return ConnectableObservable2;
|
|
})(Observable);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js
|
|
var ObjectUnsubscribedError = createErrorClass(function(_super) {
|
|
return function ObjectUnsubscribedErrorImpl() {
|
|
_super(this);
|
|
this.name = "ObjectUnsubscribedError";
|
|
this.message = "object unsubscribed";
|
|
};
|
|
});
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/Subject.js
|
|
var Subject = (function(_super) {
|
|
__extends(Subject2, _super);
|
|
function Subject2() {
|
|
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;
|
|
}
|
|
Subject2.prototype.lift = function(operator) {
|
|
var subject = new AnonymousSubject(this, this);
|
|
subject.operator = operator;
|
|
return subject;
|
|
};
|
|
Subject2.prototype._throwIfClosed = function() {
|
|
if (this.closed) {
|
|
throw new ObjectUnsubscribedError();
|
|
}
|
|
};
|
|
Subject2.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;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
};
|
|
Subject2.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);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
Subject2.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();
|
|
}
|
|
}
|
|
});
|
|
};
|
|
Subject2.prototype.unsubscribe = function() {
|
|
this.isStopped = this.closed = true;
|
|
this.observers = this.currentObservers = null;
|
|
};
|
|
Object.defineProperty(Subject2.prototype, "observed", {
|
|
get: function() {
|
|
var _a;
|
|
return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Subject2.prototype._trySubscribe = function(subscriber) {
|
|
this._throwIfClosed();
|
|
return _super.prototype._trySubscribe.call(this, subscriber);
|
|
};
|
|
Subject2.prototype._subscribe = function(subscriber) {
|
|
this._throwIfClosed();
|
|
this._checkFinalizedStatuses(subscriber);
|
|
return this._innerSubscribe(subscriber);
|
|
};
|
|
Subject2.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);
|
|
});
|
|
};
|
|
Subject2.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();
|
|
}
|
|
};
|
|
Subject2.prototype.asObservable = function() {
|
|
var observable2 = new Observable();
|
|
observable2.source = this;
|
|
return observable2;
|
|
};
|
|
Subject2.create = function(destination, source) {
|
|
return new AnonymousSubject(destination, source);
|
|
};
|
|
return Subject2;
|
|
})(Observable);
|
|
var AnonymousSubject = (function(_super) {
|
|
__extends(AnonymousSubject2, _super);
|
|
function AnonymousSubject2(destination, source) {
|
|
var _this = _super.call(this) || this;
|
|
_this.destination = destination;
|
|
_this.source = source;
|
|
return _this;
|
|
}
|
|
AnonymousSubject2.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);
|
|
};
|
|
AnonymousSubject2.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);
|
|
};
|
|
AnonymousSubject2.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);
|
|
};
|
|
AnonymousSubject2.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 AnonymousSubject2;
|
|
})(Subject);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/BehaviorSubject.js
|
|
var BehaviorSubject = (function(_super) {
|
|
__extends(BehaviorSubject2, _super);
|
|
function BehaviorSubject2(_value) {
|
|
var _this = _super.call(this) || this;
|
|
_this._value = _value;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(BehaviorSubject2.prototype, "value", {
|
|
get: function() {
|
|
return this.getValue();
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
BehaviorSubject2.prototype._subscribe = function(subscriber) {
|
|
var subscription = _super.prototype._subscribe.call(this, subscriber);
|
|
!subscription.closed && subscriber.next(this._value);
|
|
return subscription;
|
|
};
|
|
BehaviorSubject2.prototype.getValue = function() {
|
|
var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
|
|
if (hasError) {
|
|
throw thrownError;
|
|
}
|
|
this._throwIfClosed();
|
|
return _value;
|
|
};
|
|
BehaviorSubject2.prototype.next = function(value) {
|
|
_super.prototype.next.call(this, this._value = value);
|
|
};
|
|
return BehaviorSubject2;
|
|
})(Subject);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js
|
|
var dateTimestampProvider = {
|
|
now: function() {
|
|
return (dateTimestampProvider.delegate || Date).now();
|
|
},
|
|
delegate: void 0
|
|
};
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/ReplaySubject.js
|
|
var ReplaySubject = (function(_super) {
|
|
__extends(ReplaySubject2, _super);
|
|
function ReplaySubject2(_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;
|
|
}
|
|
ReplaySubject2.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);
|
|
};
|
|
ReplaySubject2.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;
|
|
};
|
|
ReplaySubject2.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 last3 = 0;
|
|
for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
|
|
last3 = i;
|
|
}
|
|
last3 && _buffer.splice(0, last3 + 1);
|
|
}
|
|
};
|
|
return ReplaySubject2;
|
|
})(Subject);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/AsyncSubject.js
|
|
var AsyncSubject = (function(_super) {
|
|
__extends(AsyncSubject2, _super);
|
|
function AsyncSubject2() {
|
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
|
_this._value = null;
|
|
_this._hasValue = false;
|
|
_this._isComplete = false;
|
|
return _this;
|
|
}
|
|
AsyncSubject2.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();
|
|
}
|
|
};
|
|
AsyncSubject2.prototype.next = function(value) {
|
|
if (!this.isStopped) {
|
|
this._value = value;
|
|
this._hasValue = true;
|
|
}
|
|
};
|
|
AsyncSubject2.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 AsyncSubject2;
|
|
})(Subject);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/Scheduler.js
|
|
var Scheduler = (function() {
|
|
function Scheduler2(schedulerActionCtor, now) {
|
|
if (now === void 0) {
|
|
now = Scheduler2.now;
|
|
}
|
|
this.schedulerActionCtor = schedulerActionCtor;
|
|
this.now = now;
|
|
}
|
|
Scheduler2.prototype.schedule = function(work, delay2, state) {
|
|
if (delay2 === void 0) {
|
|
delay2 = 0;
|
|
}
|
|
return new this.schedulerActionCtor(this, work).schedule(state, delay2);
|
|
};
|
|
Scheduler2.now = dateTimestampProvider.now;
|
|
return Scheduler2;
|
|
})();
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduler/Action.js
|
|
var Action = (function(_super) {
|
|
__extends(Action2, _super);
|
|
function Action2(scheduler, work) {
|
|
return _super.call(this) || this;
|
|
}
|
|
Action2.prototype.schedule = function(state, delay2) {
|
|
if (delay2 === void 0) {
|
|
delay2 = 0;
|
|
}
|
|
return this;
|
|
};
|
|
return Action2;
|
|
})(Subscription);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduler/intervalProvider.js
|
|
var intervalProvider = {
|
|
setInterval: function(handler, timeout2) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
var delegate = intervalProvider.delegate;
|
|
if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
|
|
return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout2], __read(args)));
|
|
}
|
|
return setInterval.apply(void 0, __spreadArray([handler, timeout2], __read(args)));
|
|
},
|
|
clearInterval: function(handle) {
|
|
var delegate = intervalProvider.delegate;
|
|
return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
|
|
},
|
|
delegate: void 0
|
|
};
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduler/AsyncAction.js
|
|
var AsyncAction = (function(_super) {
|
|
__extends(AsyncAction2, _super);
|
|
function AsyncAction2(scheduler, work) {
|
|
var _this = _super.call(this, scheduler, work) || this;
|
|
_this.scheduler = scheduler;
|
|
_this.work = work;
|
|
_this.pending = false;
|
|
return _this;
|
|
}
|
|
AsyncAction2.prototype.schedule = function(state, delay2) {
|
|
var _a;
|
|
if (delay2 === void 0) {
|
|
delay2 = 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, delay2);
|
|
}
|
|
this.pending = true;
|
|
this.delay = delay2;
|
|
this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay2);
|
|
return this;
|
|
};
|
|
AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay2) {
|
|
if (delay2 === void 0) {
|
|
delay2 = 0;
|
|
}
|
|
return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay2);
|
|
};
|
|
AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay2) {
|
|
if (delay2 === void 0) {
|
|
delay2 = 0;
|
|
}
|
|
if (delay2 != null && this.delay === delay2 && this.pending === false) {
|
|
return id;
|
|
}
|
|
if (id != null) {
|
|
intervalProvider.clearInterval(id);
|
|
}
|
|
return void 0;
|
|
};
|
|
AsyncAction2.prototype.execute = function(state, delay2) {
|
|
if (this.closed) {
|
|
return new Error("executing a cancelled action");
|
|
}
|
|
this.pending = false;
|
|
var error = this._execute(state, delay2);
|
|
if (error) {
|
|
return error;
|
|
} else if (this.pending === false && this.id != null) {
|
|
this.id = this.recycleAsyncId(this.scheduler, this.id, null);
|
|
}
|
|
};
|
|
AsyncAction2.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;
|
|
}
|
|
};
|
|
AsyncAction2.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 AsyncAction2;
|
|
})(Action);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduler/AsyncScheduler.js
|
|
var AsyncScheduler = (function(_super) {
|
|
__extends(AsyncScheduler2, _super);
|
|
function AsyncScheduler2(SchedulerAction, now) {
|
|
if (now === void 0) {
|
|
now = Scheduler.now;
|
|
}
|
|
var _this = _super.call(this, SchedulerAction, now) || this;
|
|
_this.actions = [];
|
|
_this._active = false;
|
|
return _this;
|
|
}
|
|
AsyncScheduler2.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 AsyncScheduler2;
|
|
})(Scheduler);
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduler/async.js
|
|
var asyncScheduler = new AsyncScheduler(AsyncAction);
|
|
var async = asyncScheduler;
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/empty.js
|
|
var EMPTY = new Observable(function(subscriber) {
|
|
return subscriber.complete();
|
|
});
|
|
function empty(scheduler) {
|
|
return scheduler ? emptyScheduled(scheduler) : EMPTY;
|
|
}
|
|
function emptyScheduled(scheduler) {
|
|
return new Observable(function(subscriber) {
|
|
return scheduler.schedule(function() {
|
|
return subscriber.complete();
|
|
});
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js
|
|
function executeSchedule(parentSubscription, scheduler, work, delay2, repeat2) {
|
|
if (delay2 === void 0) {
|
|
delay2 = 0;
|
|
}
|
|
if (repeat2 === void 0) {
|
|
repeat2 = false;
|
|
}
|
|
var scheduleSubscription = scheduler.schedule(function() {
|
|
work();
|
|
if (repeat2) {
|
|
parentSubscription.add(this.schedule(null, delay2));
|
|
} else {
|
|
this.unsubscribe();
|
|
}
|
|
}, delay2);
|
|
parentSubscription.add(scheduleSubscription);
|
|
if (!repeat2) {
|
|
return scheduleSubscription;
|
|
}
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/observeOn.js
|
|
function observeOn(scheduler, delay2) {
|
|
if (delay2 === void 0) {
|
|
delay2 = 0;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return executeSchedule(subscriber, scheduler, function() {
|
|
return subscriber.next(value);
|
|
}, delay2);
|
|
}, function() {
|
|
return executeSchedule(subscriber, scheduler, function() {
|
|
return subscriber.complete();
|
|
}, delay2);
|
|
}, function(err) {
|
|
return executeSchedule(subscriber, scheduler, function() {
|
|
return subscriber.error(err);
|
|
}, delay2);
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js
|
|
function subscribeOn(scheduler, delay2) {
|
|
if (delay2 === void 0) {
|
|
delay2 = 0;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
subscriber.add(scheduler.schedule(function() {
|
|
return source.subscribe(subscriber);
|
|
}, delay2));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js
|
|
var isArrayLike = (function(x) {
|
|
return x && typeof x.length === "number" && typeof x !== "function";
|
|
});
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isPromise.js
|
|
function isPromise(value) {
|
|
return isFunction(value === null || value === void 0 ? void 0 : value.then);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js
|
|
function isInteropObservable(input) {
|
|
return isFunction(input[observable]);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js
|
|
function isAsyncIterable(obj) {
|
|
return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js
|
|
function createInvalidObservableTypeError(input) {
|
|
return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/symbol/iterator.js
|
|
function getSymbolIterator() {
|
|
if (typeof Symbol !== "function" || !Symbol.iterator) {
|
|
return "@@iterator";
|
|
}
|
|
return Symbol.iterator;
|
|
}
|
|
var iterator = getSymbolIterator();
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isIterable.js
|
|
function isIterable(input) {
|
|
return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js
|
|
function readableStreamLikeToAsyncGenerator(readableStream) {
|
|
return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
|
|
var reader, _a, value, done;
|
|
return __generator(this, function(_b) {
|
|
switch (_b.label) {
|
|
case 0:
|
|
reader = readableStream.getReader();
|
|
_b.label = 1;
|
|
case 1:
|
|
_b.trys.push([1, , 9, 10]);
|
|
_b.label = 2;
|
|
case 2:
|
|
if (false) return [3, 8];
|
|
return [4, __await(reader.read())];
|
|
case 3:
|
|
_a = _b.sent(), value = _a.value, done = _a.done;
|
|
if (!done) return [3, 5];
|
|
return [4, __await(void 0)];
|
|
case 4:
|
|
return [2, _b.sent()];
|
|
case 5:
|
|
return [4, __await(value)];
|
|
case 6:
|
|
return [4, _b.sent()];
|
|
case 7:
|
|
_b.sent();
|
|
return [3, 2];
|
|
case 8:
|
|
return [3, 10];
|
|
case 9:
|
|
reader.releaseLock();
|
|
return [7];
|
|
case 10:
|
|
return [2];
|
|
}
|
|
});
|
|
});
|
|
}
|
|
function isReadableStreamLike(obj) {
|
|
return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js
|
|
function innerFrom(input) {
|
|
if (input instanceof Observable) {
|
|
return input;
|
|
}
|
|
if (input != null) {
|
|
if (isInteropObservable(input)) {
|
|
return fromInteropObservable(input);
|
|
}
|
|
if (isArrayLike(input)) {
|
|
return fromArrayLike(input);
|
|
}
|
|
if (isPromise(input)) {
|
|
return fromPromise(input);
|
|
}
|
|
if (isAsyncIterable(input)) {
|
|
return fromAsyncIterable(input);
|
|
}
|
|
if (isIterable(input)) {
|
|
return fromIterable(input);
|
|
}
|
|
if (isReadableStreamLike(input)) {
|
|
return fromReadableStreamLike(input);
|
|
}
|
|
}
|
|
throw createInvalidObservableTypeError(input);
|
|
}
|
|
function fromInteropObservable(obj) {
|
|
return new Observable(function(subscriber) {
|
|
var obs = obj[observable]();
|
|
if (isFunction(obs.subscribe)) {
|
|
return obs.subscribe(subscriber);
|
|
}
|
|
throw new TypeError("Provided object does not correctly implement Symbol.observable");
|
|
});
|
|
}
|
|
function fromArrayLike(array) {
|
|
return new 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(function(subscriber) {
|
|
promise.then(function(value) {
|
|
if (!subscriber.closed) {
|
|
subscriber.next(value);
|
|
subscriber.complete();
|
|
}
|
|
}, function(err) {
|
|
return subscriber.error(err);
|
|
}).then(null, reportUnhandledError);
|
|
});
|
|
}
|
|
function fromIterable(iterable) {
|
|
return new Observable(function(subscriber) {
|
|
var e_1, _a;
|
|
try {
|
|
for (var iterable_1 = __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(function(subscriber) {
|
|
process(asyncIterable, subscriber).catch(function(err) {
|
|
return subscriber.error(err);
|
|
});
|
|
});
|
|
}
|
|
function fromReadableStreamLike(readableStream) {
|
|
return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
|
|
}
|
|
function process(asyncIterable, subscriber) {
|
|
var asyncIterable_1, asyncIterable_1_1;
|
|
var e_2, _a;
|
|
return __awaiter(this, void 0, void 0, function() {
|
|
var value, e_2_1;
|
|
return __generator(this, function(_b) {
|
|
switch (_b.label) {
|
|
case 0:
|
|
_b.trys.push([0, 5, 6, 11]);
|
|
asyncIterable_1 = __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];
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleObservable.js
|
|
function scheduleObservable(input, scheduler) {
|
|
return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduled/schedulePromise.js
|
|
function schedulePromise(input, scheduler) {
|
|
return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleArray.js
|
|
function scheduleArray(input, scheduler) {
|
|
return new Observable(function(subscriber) {
|
|
var i = 0;
|
|
return scheduler.schedule(function() {
|
|
if (i === input.length) {
|
|
subscriber.complete();
|
|
} else {
|
|
subscriber.next(input[i++]);
|
|
if (!subscriber.closed) {
|
|
this.schedule();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleIterable.js
|
|
function scheduleIterable(input, scheduler) {
|
|
return new Observable(function(subscriber) {
|
|
var iterator2;
|
|
executeSchedule(subscriber, scheduler, function() {
|
|
iterator2 = input[iterator]();
|
|
executeSchedule(subscriber, scheduler, function() {
|
|
var _a;
|
|
var value;
|
|
var done;
|
|
try {
|
|
_a = iterator2.next(), value = _a.value, done = _a.done;
|
|
} catch (err) {
|
|
subscriber.error(err);
|
|
return;
|
|
}
|
|
if (done) {
|
|
subscriber.complete();
|
|
} else {
|
|
subscriber.next(value);
|
|
}
|
|
}, 0, true);
|
|
});
|
|
return function() {
|
|
return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
|
|
};
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleAsyncIterable.js
|
|
function scheduleAsyncIterable(input, scheduler) {
|
|
if (!input) {
|
|
throw new Error("Iterable cannot be null");
|
|
}
|
|
return new Observable(function(subscriber) {
|
|
executeSchedule(subscriber, scheduler, function() {
|
|
var iterator2 = input[Symbol.asyncIterator]();
|
|
executeSchedule(subscriber, scheduler, function() {
|
|
iterator2.next().then(function(result) {
|
|
if (result.done) {
|
|
subscriber.complete();
|
|
} else {
|
|
subscriber.next(result.value);
|
|
}
|
|
});
|
|
}, 0, true);
|
|
});
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleReadableStreamLike.js
|
|
function scheduleReadableStreamLike(input, scheduler) {
|
|
return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduled.js
|
|
function scheduled(input, scheduler) {
|
|
if (input != null) {
|
|
if (isInteropObservable(input)) {
|
|
return scheduleObservable(input, scheduler);
|
|
}
|
|
if (isArrayLike(input)) {
|
|
return scheduleArray(input, scheduler);
|
|
}
|
|
if (isPromise(input)) {
|
|
return schedulePromise(input, scheduler);
|
|
}
|
|
if (isAsyncIterable(input)) {
|
|
return scheduleAsyncIterable(input, scheduler);
|
|
}
|
|
if (isIterable(input)) {
|
|
return scheduleIterable(input, scheduler);
|
|
}
|
|
if (isReadableStreamLike(input)) {
|
|
return scheduleReadableStreamLike(input, scheduler);
|
|
}
|
|
}
|
|
throw createInvalidObservableTypeError(input);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/from.js
|
|
function from(input, scheduler) {
|
|
return scheduler ? scheduled(input, scheduler) : innerFrom(input);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
|
|
function isScheduler(value) {
|
|
return value && isFunction(value.schedule);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/args.js
|
|
function last(arr) {
|
|
return arr[arr.length - 1];
|
|
}
|
|
function popResultSelector(args) {
|
|
return isFunction(last(args)) ? args.pop() : void 0;
|
|
}
|
|
function popScheduler(args) {
|
|
return isScheduler(last(args)) ? args.pop() : void 0;
|
|
}
|
|
function popNumber(args, defaultValue) {
|
|
return typeof last(args) === "number" ? args.pop() : defaultValue;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/of.js
|
|
function of() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var scheduler = popScheduler(args);
|
|
return from(args, scheduler);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/throwError.js
|
|
function throwError(errorOrErrorFactory, scheduler) {
|
|
var errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function() {
|
|
return errorOrErrorFactory;
|
|
};
|
|
var init = function(subscriber) {
|
|
return subscriber.error(errorFactory());
|
|
};
|
|
return new Observable(scheduler ? function(subscriber) {
|
|
return scheduler.schedule(init, 0, subscriber);
|
|
} : init);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/Notification.js
|
|
var NotificationKind;
|
|
(function(NotificationKind2) {
|
|
NotificationKind2["NEXT"] = "N";
|
|
NotificationKind2["ERROR"] = "E";
|
|
NotificationKind2["COMPLETE"] = "C";
|
|
})(NotificationKind || (NotificationKind = {}));
|
|
var Notification = (function() {
|
|
function Notification2(kind, value, error) {
|
|
this.kind = kind;
|
|
this.value = value;
|
|
this.error = error;
|
|
this.hasValue = kind === "N";
|
|
}
|
|
Notification2.prototype.observe = function(observer) {
|
|
return observeNotification(this, observer);
|
|
};
|
|
Notification2.prototype.do = function(nextHandler, errorHandler, completeHandler) {
|
|
var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
|
|
return kind === "N" ? nextHandler === null || nextHandler === void 0 ? void 0 : nextHandler(value) : kind === "E" ? errorHandler === null || errorHandler === void 0 ? void 0 : errorHandler(error) : completeHandler === null || completeHandler === void 0 ? void 0 : completeHandler();
|
|
};
|
|
Notification2.prototype.accept = function(nextOrObserver, error, complete) {
|
|
var _a;
|
|
return isFunction((_a = nextOrObserver) === null || _a === void 0 ? void 0 : _a.next) ? this.observe(nextOrObserver) : this.do(nextOrObserver, error, complete);
|
|
};
|
|
Notification2.prototype.toObservable = function() {
|
|
var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
|
|
var result = kind === "N" ? of(value) : kind === "E" ? throwError(function() {
|
|
return error;
|
|
}) : kind === "C" ? EMPTY : 0;
|
|
if (!result) {
|
|
throw new TypeError("Unexpected notification kind " + kind);
|
|
}
|
|
return result;
|
|
};
|
|
Notification2.createNext = function(value) {
|
|
return new Notification2("N", value);
|
|
};
|
|
Notification2.createError = function(err) {
|
|
return new Notification2("E", void 0, err);
|
|
};
|
|
Notification2.createComplete = function() {
|
|
return Notification2.completeNotification;
|
|
};
|
|
Notification2.completeNotification = new Notification2("C");
|
|
return Notification2;
|
|
})();
|
|
function observeNotification(notification, observer) {
|
|
var _a, _b, _c;
|
|
var _d = notification, kind = _d.kind, value = _d.value, error = _d.error;
|
|
if (typeof kind !== "string") {
|
|
throw new TypeError('Invalid notification, missing "kind"');
|
|
}
|
|
kind === "N" ? (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, value) : kind === "E" ? (_b = observer.error) === null || _b === void 0 ? void 0 : _b.call(observer, error) : (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/EmptyError.js
|
|
var EmptyError = createErrorClass(function(_super) {
|
|
return function EmptyErrorImpl() {
|
|
_super(this);
|
|
this.name = "EmptyError";
|
|
this.message = "no elements in sequence";
|
|
};
|
|
});
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/ArgumentOutOfRangeError.js
|
|
var ArgumentOutOfRangeError = createErrorClass(function(_super) {
|
|
return function ArgumentOutOfRangeErrorImpl() {
|
|
_super(this);
|
|
this.name = "ArgumentOutOfRangeError";
|
|
this.message = "argument out of range";
|
|
};
|
|
});
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/NotFoundError.js
|
|
var NotFoundError = createErrorClass(function(_super) {
|
|
return function NotFoundErrorImpl(message) {
|
|
_super(this);
|
|
this.name = "NotFoundError";
|
|
this.message = message;
|
|
};
|
|
});
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/SequenceError.js
|
|
var SequenceError = createErrorClass(function(_super) {
|
|
return function SequenceErrorImpl(message) {
|
|
_super(this);
|
|
this.name = "SequenceError";
|
|
this.message = message;
|
|
};
|
|
});
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/isDate.js
|
|
function isValidDate(value) {
|
|
return value instanceof Date && !isNaN(value);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/timeout.js
|
|
var TimeoutError = 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;
|
|
};
|
|
});
|
|
function timeout(config2, schedulerArg) {
|
|
var _a = isValidDate(config2) ? { first: config2 } : typeof config2 === "number" ? { each: config2 } : config2, first2 = _a.first, each = _a.each, _b = _a.with, _with = _b === void 0 ? timeoutErrorFactory : _b, _c = _a.scheduler, scheduler = _c === void 0 ? schedulerArg !== null && schedulerArg !== void 0 ? schedulerArg : asyncScheduler : _c, _d = _a.meta, meta = _d === void 0 ? null : _d;
|
|
if (first2 == null && each == null) {
|
|
throw new TypeError("No timeout provided.");
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var originalSourceSubscription;
|
|
var timerSubscription;
|
|
var lastValue = null;
|
|
var seen = 0;
|
|
var startTimer = function(delay2) {
|
|
timerSubscription = executeSchedule(subscriber, scheduler, function() {
|
|
try {
|
|
originalSourceSubscription.unsubscribe();
|
|
innerFrom(_with({
|
|
meta,
|
|
lastValue,
|
|
seen
|
|
})).subscribe(subscriber);
|
|
} catch (err) {
|
|
subscriber.error(err);
|
|
}
|
|
}, delay2);
|
|
};
|
|
originalSourceSubscription = source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
|
|
seen++;
|
|
subscriber.next(lastValue = value);
|
|
each > 0 && startTimer(each);
|
|
}, void 0, void 0, function() {
|
|
if (!(timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.closed)) {
|
|
timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
|
|
}
|
|
lastValue = null;
|
|
}));
|
|
!seen && startTimer(first2 != null ? typeof first2 === "number" ? first2 : +first2 - scheduler.now() : each);
|
|
});
|
|
}
|
|
function timeoutErrorFactory(info) {
|
|
throw new TimeoutError(info);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/map.js
|
|
function map(project, thisArg) {
|
|
return operate(function(source, subscriber) {
|
|
var index = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
subscriber.next(project.call(thisArg, value, index++));
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/argsArgArrayOrObject.js
|
|
var isArray = Array.isArray;
|
|
var getPrototypeOf = Object.getPrototypeOf;
|
|
var objectProto = Object.prototype;
|
|
var getKeys = Object.keys;
|
|
function argsArgArrayOrObject(args) {
|
|
if (args.length === 1) {
|
|
var first_1 = args[0];
|
|
if (isArray(first_1)) {
|
|
return { args: first_1, keys: null };
|
|
}
|
|
if (isPOJO(first_1)) {
|
|
var keys = getKeys(first_1);
|
|
return {
|
|
args: keys.map(function(key) {
|
|
return first_1[key];
|
|
}),
|
|
keys
|
|
};
|
|
}
|
|
}
|
|
return { args, keys: null };
|
|
}
|
|
function isPOJO(obj) {
|
|
return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/mapOneOrManyArgs.js
|
|
var isArray2 = Array.isArray;
|
|
function callOrApply(fn, args) {
|
|
return isArray2(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
|
|
}
|
|
function mapOneOrManyArgs(fn) {
|
|
return map(function(args) {
|
|
return callOrApply(fn, args);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/createObject.js
|
|
function createObject(keys, values) {
|
|
return keys.reduce(function(result, key, i) {
|
|
return result[key] = values[i], result;
|
|
}, {});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/combineLatest.js
|
|
function combineLatest() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var scheduler = popScheduler(args);
|
|
var resultSelector = popResultSelector(args);
|
|
var _a = argsArgArrayOrObject(args), observables = _a.args, keys = _a.keys;
|
|
if (observables.length === 0) {
|
|
return from([], scheduler);
|
|
}
|
|
var result = new Observable(combineLatestInit(observables, scheduler, keys ? function(values) {
|
|
return createObject(keys, values);
|
|
} : identity));
|
|
return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
|
|
}
|
|
function combineLatestInit(observables, scheduler, valueTransform) {
|
|
if (valueTransform === void 0) {
|
|
valueTransform = identity;
|
|
}
|
|
return function(subscriber) {
|
|
maybeSchedule(scheduler, function() {
|
|
var length = observables.length;
|
|
var values = new Array(length);
|
|
var active = length;
|
|
var remainingFirstValues = length;
|
|
var _loop_1 = function(i2) {
|
|
maybeSchedule(scheduler, function() {
|
|
var source = from(observables[i2], scheduler);
|
|
var hasFirstValue = false;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
values[i2] = value;
|
|
if (!hasFirstValue) {
|
|
hasFirstValue = true;
|
|
remainingFirstValues--;
|
|
}
|
|
if (!remainingFirstValues) {
|
|
subscriber.next(valueTransform(values.slice()));
|
|
}
|
|
}, function() {
|
|
if (!--active) {
|
|
subscriber.complete();
|
|
}
|
|
}));
|
|
}, subscriber);
|
|
};
|
|
for (var i = 0; i < length; i++) {
|
|
_loop_1(i);
|
|
}
|
|
}, subscriber);
|
|
};
|
|
}
|
|
function maybeSchedule(scheduler, execute, subscription) {
|
|
if (scheduler) {
|
|
executeSchedule(subscription, scheduler, execute);
|
|
} else {
|
|
execute();
|
|
}
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js
|
|
function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand2, innerSubScheduler, additionalFinalizer) {
|
|
var buffer2 = [];
|
|
var active = 0;
|
|
var index = 0;
|
|
var isComplete = false;
|
|
var checkComplete = function() {
|
|
if (isComplete && !buffer2.length && !active) {
|
|
subscriber.complete();
|
|
}
|
|
};
|
|
var outerNext = function(value) {
|
|
return active < concurrent ? doInnerSub(value) : buffer2.push(value);
|
|
};
|
|
var doInnerSub = function(value) {
|
|
expand2 && subscriber.next(value);
|
|
active++;
|
|
var innerComplete = false;
|
|
innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function(innerValue) {
|
|
onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
|
|
if (expand2) {
|
|
outerNext(innerValue);
|
|
} else {
|
|
subscriber.next(innerValue);
|
|
}
|
|
}, function() {
|
|
innerComplete = true;
|
|
}, void 0, function() {
|
|
if (innerComplete) {
|
|
try {
|
|
active--;
|
|
var _loop_1 = function() {
|
|
var bufferedValue = buffer2.shift();
|
|
if (innerSubScheduler) {
|
|
executeSchedule(subscriber, innerSubScheduler, function() {
|
|
return doInnerSub(bufferedValue);
|
|
});
|
|
} else {
|
|
doInnerSub(bufferedValue);
|
|
}
|
|
};
|
|
while (buffer2.length && active < concurrent) {
|
|
_loop_1();
|
|
}
|
|
checkComplete();
|
|
} catch (err) {
|
|
subscriber.error(err);
|
|
}
|
|
}
|
|
}));
|
|
};
|
|
source.subscribe(createOperatorSubscriber(subscriber, outerNext, function() {
|
|
isComplete = true;
|
|
checkComplete();
|
|
}));
|
|
return function() {
|
|
additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/mergeMap.js
|
|
function mergeMap(project, resultSelector, concurrent) {
|
|
if (concurrent === void 0) {
|
|
concurrent = Infinity;
|
|
}
|
|
if (isFunction(resultSelector)) {
|
|
return mergeMap(function(a, i) {
|
|
return map(function(b, ii) {
|
|
return resultSelector(a, b, i, ii);
|
|
})(innerFrom(project(a, i)));
|
|
}, concurrent);
|
|
} else if (typeof resultSelector === "number") {
|
|
concurrent = resultSelector;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
return mergeInternals(source, subscriber, project, concurrent);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/mergeAll.js
|
|
function mergeAll(concurrent) {
|
|
if (concurrent === void 0) {
|
|
concurrent = Infinity;
|
|
}
|
|
return mergeMap(identity, concurrent);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/concatAll.js
|
|
function concatAll() {
|
|
return mergeAll(1);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/concat.js
|
|
function concat() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
return concatAll()(from(args, popScheduler(args)));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/timer.js
|
|
function timer(dueTime, intervalOrScheduler, scheduler) {
|
|
if (dueTime === void 0) {
|
|
dueTime = 0;
|
|
}
|
|
if (scheduler === void 0) {
|
|
scheduler = async;
|
|
}
|
|
var intervalDuration = -1;
|
|
if (intervalOrScheduler != null) {
|
|
if (isScheduler(intervalOrScheduler)) {
|
|
scheduler = intervalOrScheduler;
|
|
} else {
|
|
intervalDuration = intervalOrScheduler;
|
|
}
|
|
}
|
|
return new Observable(function(subscriber) {
|
|
var due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
|
|
if (due < 0) {
|
|
due = 0;
|
|
}
|
|
var n = 0;
|
|
return scheduler.schedule(function() {
|
|
if (!subscriber.closed) {
|
|
subscriber.next(n++);
|
|
if (0 <= intervalDuration) {
|
|
this.schedule(void 0, intervalDuration);
|
|
} else {
|
|
subscriber.complete();
|
|
}
|
|
}
|
|
}, due);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/interval.js
|
|
function interval(period, scheduler) {
|
|
if (period === void 0) {
|
|
period = 0;
|
|
}
|
|
if (scheduler === void 0) {
|
|
scheduler = asyncScheduler;
|
|
}
|
|
if (period < 0) {
|
|
period = 0;
|
|
}
|
|
return timer(period, period, scheduler);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/argsOrArgArray.js
|
|
var isArray3 = Array.isArray;
|
|
function argsOrArgArray(args) {
|
|
return args.length === 1 && isArray3(args[0]) ? args[0] : args;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/onErrorResumeNext.js
|
|
function onErrorResumeNext() {
|
|
var sources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
sources[_i] = arguments[_i];
|
|
}
|
|
var nextSources = argsOrArgArray(sources);
|
|
return new Observable(function(subscriber) {
|
|
var sourceIndex = 0;
|
|
var subscribeNext = function() {
|
|
if (sourceIndex < nextSources.length) {
|
|
var nextSource = void 0;
|
|
try {
|
|
nextSource = innerFrom(nextSources[sourceIndex++]);
|
|
} catch (err) {
|
|
subscribeNext();
|
|
return;
|
|
}
|
|
var innerSubscriber = new OperatorSubscriber(subscriber, void 0, noop, noop);
|
|
nextSource.subscribe(innerSubscriber);
|
|
innerSubscriber.add(subscribeNext);
|
|
} else {
|
|
subscriber.complete();
|
|
}
|
|
};
|
|
subscribeNext();
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/filter.js
|
|
function filter(predicate, thisArg) {
|
|
return operate(function(source, subscriber) {
|
|
var index = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return predicate.call(thisArg, value, index++) && subscriber.next(value);
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/race.js
|
|
function race() {
|
|
var sources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
sources[_i] = arguments[_i];
|
|
}
|
|
sources = argsOrArgArray(sources);
|
|
return sources.length === 1 ? innerFrom(sources[0]) : new Observable(raceInit(sources));
|
|
}
|
|
function raceInit(sources) {
|
|
return function(subscriber) {
|
|
var subscriptions = [];
|
|
var _loop_1 = function(i2) {
|
|
subscriptions.push(innerFrom(sources[i2]).subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
if (subscriptions) {
|
|
for (var s = 0; s < subscriptions.length; s++) {
|
|
s !== i2 && subscriptions[s].unsubscribe();
|
|
}
|
|
subscriptions = null;
|
|
}
|
|
subscriber.next(value);
|
|
})));
|
|
};
|
|
for (var i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {
|
|
_loop_1(i);
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/zip.js
|
|
function zip() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var resultSelector = popResultSelector(args);
|
|
var sources = argsOrArgArray(args);
|
|
return sources.length ? new Observable(function(subscriber) {
|
|
var buffers = sources.map(function() {
|
|
return [];
|
|
});
|
|
var completed = sources.map(function() {
|
|
return false;
|
|
});
|
|
subscriber.add(function() {
|
|
buffers = completed = null;
|
|
});
|
|
var _loop_1 = function(sourceIndex2) {
|
|
innerFrom(sources[sourceIndex2]).subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
buffers[sourceIndex2].push(value);
|
|
if (buffers.every(function(buffer2) {
|
|
return buffer2.length;
|
|
})) {
|
|
var result = buffers.map(function(buffer2) {
|
|
return buffer2.shift();
|
|
});
|
|
subscriber.next(resultSelector ? resultSelector.apply(void 0, __spreadArray([], __read(result))) : result);
|
|
if (buffers.some(function(buffer2, i) {
|
|
return !buffer2.length && completed[i];
|
|
})) {
|
|
subscriber.complete();
|
|
}
|
|
}
|
|
}, function() {
|
|
completed[sourceIndex2] = true;
|
|
!buffers[sourceIndex2].length && subscriber.complete();
|
|
}));
|
|
};
|
|
for (var sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
|
|
_loop_1(sourceIndex);
|
|
}
|
|
return function() {
|
|
buffers = completed = null;
|
|
};
|
|
}) : EMPTY;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/audit.js
|
|
function audit(durationSelector) {
|
|
return operate(function(source, subscriber) {
|
|
var hasValue = false;
|
|
var lastValue = null;
|
|
var durationSubscriber = null;
|
|
var isComplete = false;
|
|
var endDuration = function() {
|
|
durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
|
|
durationSubscriber = null;
|
|
if (hasValue) {
|
|
hasValue = false;
|
|
var value = lastValue;
|
|
lastValue = null;
|
|
subscriber.next(value);
|
|
}
|
|
isComplete && subscriber.complete();
|
|
};
|
|
var cleanupDuration = function() {
|
|
durationSubscriber = null;
|
|
isComplete && subscriber.complete();
|
|
};
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
hasValue = true;
|
|
lastValue = value;
|
|
if (!durationSubscriber) {
|
|
innerFrom(durationSelector(value)).subscribe(durationSubscriber = createOperatorSubscriber(subscriber, endDuration, cleanupDuration));
|
|
}
|
|
}, function() {
|
|
isComplete = true;
|
|
(!hasValue || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/auditTime.js
|
|
function auditTime(duration, scheduler) {
|
|
if (scheduler === void 0) {
|
|
scheduler = asyncScheduler;
|
|
}
|
|
return audit(function() {
|
|
return timer(duration, scheduler);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/buffer.js
|
|
function buffer(closingNotifier) {
|
|
return operate(function(source, subscriber) {
|
|
var currentBuffer = [];
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return currentBuffer.push(value);
|
|
}, function() {
|
|
subscriber.next(currentBuffer);
|
|
subscriber.complete();
|
|
}));
|
|
innerFrom(closingNotifier).subscribe(createOperatorSubscriber(subscriber, function() {
|
|
var b = currentBuffer;
|
|
currentBuffer = [];
|
|
subscriber.next(b);
|
|
}, noop));
|
|
return function() {
|
|
currentBuffer = null;
|
|
};
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/bufferCount.js
|
|
function bufferCount(bufferSize, startBufferEvery) {
|
|
if (startBufferEvery === void 0) {
|
|
startBufferEvery = null;
|
|
}
|
|
startBufferEvery = startBufferEvery !== null && startBufferEvery !== void 0 ? startBufferEvery : bufferSize;
|
|
return operate(function(source, subscriber) {
|
|
var buffers = [];
|
|
var count2 = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var e_1, _a, e_2, _b;
|
|
var toEmit = null;
|
|
if (count2++ % startBufferEvery === 0) {
|
|
buffers.push([]);
|
|
}
|
|
try {
|
|
for (var buffers_1 = __values(buffers), buffers_1_1 = buffers_1.next(); !buffers_1_1.done; buffers_1_1 = buffers_1.next()) {
|
|
var buffer2 = buffers_1_1.value;
|
|
buffer2.push(value);
|
|
if (bufferSize <= buffer2.length) {
|
|
toEmit = toEmit !== null && toEmit !== void 0 ? toEmit : [];
|
|
toEmit.push(buffer2);
|
|
}
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (buffers_1_1 && !buffers_1_1.done && (_a = buffers_1.return)) _a.call(buffers_1);
|
|
} finally {
|
|
if (e_1) throw e_1.error;
|
|
}
|
|
}
|
|
if (toEmit) {
|
|
try {
|
|
for (var toEmit_1 = __values(toEmit), toEmit_1_1 = toEmit_1.next(); !toEmit_1_1.done; toEmit_1_1 = toEmit_1.next()) {
|
|
var buffer2 = toEmit_1_1.value;
|
|
arrRemove(buffers, buffer2);
|
|
subscriber.next(buffer2);
|
|
}
|
|
} catch (e_2_1) {
|
|
e_2 = { error: e_2_1 };
|
|
} finally {
|
|
try {
|
|
if (toEmit_1_1 && !toEmit_1_1.done && (_b = toEmit_1.return)) _b.call(toEmit_1);
|
|
} finally {
|
|
if (e_2) throw e_2.error;
|
|
}
|
|
}
|
|
}
|
|
}, function() {
|
|
var e_3, _a;
|
|
try {
|
|
for (var buffers_2 = __values(buffers), buffers_2_1 = buffers_2.next(); !buffers_2_1.done; buffers_2_1 = buffers_2.next()) {
|
|
var buffer2 = buffers_2_1.value;
|
|
subscriber.next(buffer2);
|
|
}
|
|
} catch (e_3_1) {
|
|
e_3 = { error: e_3_1 };
|
|
} finally {
|
|
try {
|
|
if (buffers_2_1 && !buffers_2_1.done && (_a = buffers_2.return)) _a.call(buffers_2);
|
|
} finally {
|
|
if (e_3) throw e_3.error;
|
|
}
|
|
}
|
|
subscriber.complete();
|
|
}, void 0, function() {
|
|
buffers = null;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/bufferTime.js
|
|
function bufferTime(bufferTimeSpan) {
|
|
var _a, _b;
|
|
var otherArgs = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
otherArgs[_i - 1] = arguments[_i];
|
|
}
|
|
var scheduler = (_a = popScheduler(otherArgs)) !== null && _a !== void 0 ? _a : asyncScheduler;
|
|
var bufferCreationInterval = (_b = otherArgs[0]) !== null && _b !== void 0 ? _b : null;
|
|
var maxBufferSize = otherArgs[1] || Infinity;
|
|
return operate(function(source, subscriber) {
|
|
var bufferRecords = [];
|
|
var restartOnEmit = false;
|
|
var emit = function(record) {
|
|
var buffer2 = record.buffer, subs = record.subs;
|
|
subs.unsubscribe();
|
|
arrRemove(bufferRecords, record);
|
|
subscriber.next(buffer2);
|
|
restartOnEmit && startBuffer();
|
|
};
|
|
var startBuffer = function() {
|
|
if (bufferRecords) {
|
|
var subs = new Subscription();
|
|
subscriber.add(subs);
|
|
var buffer2 = [];
|
|
var record_1 = {
|
|
buffer: buffer2,
|
|
subs
|
|
};
|
|
bufferRecords.push(record_1);
|
|
executeSchedule(subs, scheduler, function() {
|
|
return emit(record_1);
|
|
}, bufferTimeSpan);
|
|
}
|
|
};
|
|
if (bufferCreationInterval !== null && bufferCreationInterval >= 0) {
|
|
executeSchedule(subscriber, scheduler, startBuffer, bufferCreationInterval, true);
|
|
} else {
|
|
restartOnEmit = true;
|
|
}
|
|
startBuffer();
|
|
var bufferTimeSubscriber = createOperatorSubscriber(subscriber, function(value) {
|
|
var e_1, _a2;
|
|
var recordsCopy = bufferRecords.slice();
|
|
try {
|
|
for (var recordsCopy_1 = __values(recordsCopy), recordsCopy_1_1 = recordsCopy_1.next(); !recordsCopy_1_1.done; recordsCopy_1_1 = recordsCopy_1.next()) {
|
|
var record = recordsCopy_1_1.value;
|
|
var buffer2 = record.buffer;
|
|
buffer2.push(value);
|
|
maxBufferSize <= buffer2.length && emit(record);
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (recordsCopy_1_1 && !recordsCopy_1_1.done && (_a2 = recordsCopy_1.return)) _a2.call(recordsCopy_1);
|
|
} finally {
|
|
if (e_1) throw e_1.error;
|
|
}
|
|
}
|
|
}, function() {
|
|
while (bufferRecords === null || bufferRecords === void 0 ? void 0 : bufferRecords.length) {
|
|
subscriber.next(bufferRecords.shift().buffer);
|
|
}
|
|
bufferTimeSubscriber === null || bufferTimeSubscriber === void 0 ? void 0 : bufferTimeSubscriber.unsubscribe();
|
|
subscriber.complete();
|
|
subscriber.unsubscribe();
|
|
}, void 0, function() {
|
|
return bufferRecords = null;
|
|
});
|
|
source.subscribe(bufferTimeSubscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/bufferToggle.js
|
|
function bufferToggle(openings, closingSelector) {
|
|
return operate(function(source, subscriber) {
|
|
var buffers = [];
|
|
innerFrom(openings).subscribe(createOperatorSubscriber(subscriber, function(openValue) {
|
|
var buffer2 = [];
|
|
buffers.push(buffer2);
|
|
var closingSubscription = new Subscription();
|
|
var emitBuffer = function() {
|
|
arrRemove(buffers, buffer2);
|
|
subscriber.next(buffer2);
|
|
closingSubscription.unsubscribe();
|
|
};
|
|
closingSubscription.add(innerFrom(closingSelector(openValue)).subscribe(createOperatorSubscriber(subscriber, emitBuffer, noop)));
|
|
}, noop));
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var e_1, _a;
|
|
try {
|
|
for (var buffers_1 = __values(buffers), buffers_1_1 = buffers_1.next(); !buffers_1_1.done; buffers_1_1 = buffers_1.next()) {
|
|
var buffer2 = buffers_1_1.value;
|
|
buffer2.push(value);
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (buffers_1_1 && !buffers_1_1.done && (_a = buffers_1.return)) _a.call(buffers_1);
|
|
} finally {
|
|
if (e_1) throw e_1.error;
|
|
}
|
|
}
|
|
}, function() {
|
|
while (buffers.length > 0) {
|
|
subscriber.next(buffers.shift());
|
|
}
|
|
subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/bufferWhen.js
|
|
function bufferWhen(closingSelector) {
|
|
return operate(function(source, subscriber) {
|
|
var buffer2 = null;
|
|
var closingSubscriber = null;
|
|
var openBuffer = function() {
|
|
closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
|
|
var b = buffer2;
|
|
buffer2 = [];
|
|
b && subscriber.next(b);
|
|
innerFrom(closingSelector()).subscribe(closingSubscriber = createOperatorSubscriber(subscriber, openBuffer, noop));
|
|
};
|
|
openBuffer();
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return buffer2 === null || buffer2 === void 0 ? void 0 : buffer2.push(value);
|
|
}, function() {
|
|
buffer2 && subscriber.next(buffer2);
|
|
subscriber.complete();
|
|
}, void 0, function() {
|
|
return buffer2 = closingSubscriber = null;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/catchError.js
|
|
function catchError(selector) {
|
|
return operate(function(source, subscriber) {
|
|
var innerSub = null;
|
|
var syncUnsub = false;
|
|
var handledResult;
|
|
innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
|
|
handledResult = innerFrom(selector(err, catchError(selector)(source)));
|
|
if (innerSub) {
|
|
innerSub.unsubscribe();
|
|
innerSub = null;
|
|
handledResult.subscribe(subscriber);
|
|
} else {
|
|
syncUnsub = true;
|
|
}
|
|
}));
|
|
if (syncUnsub) {
|
|
innerSub.unsubscribe();
|
|
innerSub = null;
|
|
handledResult.subscribe(subscriber);
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/scanInternals.js
|
|
function scanInternals(accumulator, seed, hasSeed, emitOnNext, emitBeforeComplete) {
|
|
return function(source, subscriber) {
|
|
var hasState = hasSeed;
|
|
var state = seed;
|
|
var index = 0;
|
|
source.subscribe(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();
|
|
})));
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/reduce.js
|
|
function reduce(accumulator, seed) {
|
|
return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/toArray.js
|
|
var arrReducer = function(arr, value) {
|
|
return arr.push(value), arr;
|
|
};
|
|
function toArray() {
|
|
return operate(function(source, subscriber) {
|
|
reduce(arrReducer, [])(source).subscribe(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/joinAllInternals.js
|
|
function joinAllInternals(joinFn, project) {
|
|
return pipe(toArray(), mergeMap(function(sources) {
|
|
return joinFn(sources);
|
|
}), project ? mapOneOrManyArgs(project) : identity);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/combineLatestAll.js
|
|
function combineLatestAll(project) {
|
|
return joinAllInternals(combineLatest, project);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/combineAll.js
|
|
var combineAll = combineLatestAll;
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/combineLatest.js
|
|
function combineLatest2() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var resultSelector = popResultSelector(args);
|
|
return resultSelector ? pipe(combineLatest2.apply(void 0, __spreadArray([], __read(args))), mapOneOrManyArgs(resultSelector)) : operate(function(source, subscriber) {
|
|
combineLatestInit(__spreadArray([source], __read(argsOrArgArray(args))))(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/combineLatestWith.js
|
|
function combineLatestWith() {
|
|
var otherSources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
otherSources[_i] = arguments[_i];
|
|
}
|
|
return combineLatest2.apply(void 0, __spreadArray([], __read(otherSources)));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/concatMap.js
|
|
function concatMap(project, resultSelector) {
|
|
return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/concatMapTo.js
|
|
function concatMapTo(innerObservable, resultSelector) {
|
|
return isFunction(resultSelector) ? concatMap(function() {
|
|
return innerObservable;
|
|
}, resultSelector) : concatMap(function() {
|
|
return innerObservable;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/concat.js
|
|
function concat2() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var scheduler = popScheduler(args);
|
|
return operate(function(source, subscriber) {
|
|
concatAll()(from(__spreadArray([source], __read(args)), scheduler)).subscribe(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/concatWith.js
|
|
function concatWith() {
|
|
var otherSources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
otherSources[_i] = arguments[_i];
|
|
}
|
|
return concat2.apply(void 0, __spreadArray([], __read(otherSources)));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/observable/fromSubscribable.js
|
|
function fromSubscribable(subscribable) {
|
|
return new Observable(function(subscriber) {
|
|
return subscribable.subscribe(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/connect.js
|
|
var DEFAULT_CONFIG = {
|
|
connector: function() {
|
|
return new Subject();
|
|
}
|
|
};
|
|
function connect(selector, config2) {
|
|
if (config2 === void 0) {
|
|
config2 = DEFAULT_CONFIG;
|
|
}
|
|
var connector = config2.connector;
|
|
return operate(function(source, subscriber) {
|
|
var subject = connector();
|
|
innerFrom(selector(fromSubscribable(subject))).subscribe(subscriber);
|
|
subscriber.add(source.subscribe(subject));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/count.js
|
|
function count(predicate) {
|
|
return reduce(function(total, value, i) {
|
|
return !predicate || predicate(value, i) ? total + 1 : total;
|
|
}, 0);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/debounce.js
|
|
function debounce(durationSelector) {
|
|
return operate(function(source, subscriber) {
|
|
var hasValue = false;
|
|
var lastValue = null;
|
|
var durationSubscriber = null;
|
|
var emit = function() {
|
|
durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
|
|
durationSubscriber = null;
|
|
if (hasValue) {
|
|
hasValue = false;
|
|
var value = lastValue;
|
|
lastValue = null;
|
|
subscriber.next(value);
|
|
}
|
|
};
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
|
|
hasValue = true;
|
|
lastValue = value;
|
|
durationSubscriber = createOperatorSubscriber(subscriber, emit, noop);
|
|
innerFrom(durationSelector(value)).subscribe(durationSubscriber);
|
|
}, function() {
|
|
emit();
|
|
subscriber.complete();
|
|
}, void 0, function() {
|
|
lastValue = durationSubscriber = null;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/debounceTime.js
|
|
function debounceTime(dueTime, scheduler) {
|
|
if (scheduler === void 0) {
|
|
scheduler = asyncScheduler;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var activeTask = null;
|
|
var lastValue = null;
|
|
var lastTime = null;
|
|
var emit = function() {
|
|
if (activeTask) {
|
|
activeTask.unsubscribe();
|
|
activeTask = null;
|
|
var value = lastValue;
|
|
lastValue = null;
|
|
subscriber.next(value);
|
|
}
|
|
};
|
|
function emitWhenIdle() {
|
|
var targetTime = lastTime + dueTime;
|
|
var now = scheduler.now();
|
|
if (now < targetTime) {
|
|
activeTask = this.schedule(void 0, targetTime - now);
|
|
subscriber.add(activeTask);
|
|
return;
|
|
}
|
|
emit();
|
|
}
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
lastValue = value;
|
|
lastTime = scheduler.now();
|
|
if (!activeTask) {
|
|
activeTask = scheduler.schedule(emitWhenIdle, dueTime);
|
|
subscriber.add(activeTask);
|
|
}
|
|
}, function() {
|
|
emit();
|
|
subscriber.complete();
|
|
}, void 0, function() {
|
|
lastValue = activeTask = null;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/defaultIfEmpty.js
|
|
function defaultIfEmpty(defaultValue) {
|
|
return operate(function(source, subscriber) {
|
|
var hasValue = false;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
hasValue = true;
|
|
subscriber.next(value);
|
|
}, function() {
|
|
if (!hasValue) {
|
|
subscriber.next(defaultValue);
|
|
}
|
|
subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/take.js
|
|
function take(count2) {
|
|
return count2 <= 0 ? function() {
|
|
return EMPTY;
|
|
} : operate(function(source, subscriber) {
|
|
var seen = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
if (++seen <= count2) {
|
|
subscriber.next(value);
|
|
if (count2 <= seen) {
|
|
subscriber.complete();
|
|
}
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/ignoreElements.js
|
|
function ignoreElements() {
|
|
return operate(function(source, subscriber) {
|
|
source.subscribe(createOperatorSubscriber(subscriber, noop));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/mapTo.js
|
|
function mapTo(value) {
|
|
return map(function() {
|
|
return value;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/delayWhen.js
|
|
function delayWhen(delayDurationSelector, subscriptionDelay) {
|
|
if (subscriptionDelay) {
|
|
return function(source) {
|
|
return concat(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector)));
|
|
};
|
|
}
|
|
return mergeMap(function(value, index) {
|
|
return innerFrom(delayDurationSelector(value, index)).pipe(take(1), mapTo(value));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/delay.js
|
|
function delay(due, scheduler) {
|
|
if (scheduler === void 0) {
|
|
scheduler = asyncScheduler;
|
|
}
|
|
var duration = timer(due, scheduler);
|
|
return delayWhen(function() {
|
|
return duration;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/dematerialize.js
|
|
function dematerialize() {
|
|
return operate(function(source, subscriber) {
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(notification) {
|
|
return observeNotification(notification, subscriber);
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/distinct.js
|
|
function distinct(keySelector, flushes) {
|
|
return operate(function(source, subscriber) {
|
|
var distinctKeys = /* @__PURE__ */ new Set();
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var key = keySelector ? keySelector(value) : value;
|
|
if (!distinctKeys.has(key)) {
|
|
distinctKeys.add(key);
|
|
subscriber.next(value);
|
|
}
|
|
}));
|
|
flushes && innerFrom(flushes).subscribe(createOperatorSubscriber(subscriber, function() {
|
|
return distinctKeys.clear();
|
|
}, noop));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/distinctUntilChanged.js
|
|
function distinctUntilChanged(comparator, keySelector) {
|
|
if (keySelector === void 0) {
|
|
keySelector = identity;
|
|
}
|
|
comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
|
|
return operate(function(source, subscriber) {
|
|
var previousKey;
|
|
var first2 = true;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var currentKey = keySelector(value);
|
|
if (first2 || !comparator(previousKey, currentKey)) {
|
|
first2 = false;
|
|
previousKey = currentKey;
|
|
subscriber.next(value);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
function defaultCompare(a, b) {
|
|
return a === b;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/distinctUntilKeyChanged.js
|
|
function distinctUntilKeyChanged(key, compare) {
|
|
return distinctUntilChanged(function(x, y) {
|
|
return compare ? compare(x[key], y[key]) : x[key] === y[key];
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/throwIfEmpty.js
|
|
function throwIfEmpty(errorFactory) {
|
|
if (errorFactory === void 0) {
|
|
errorFactory = defaultErrorFactory;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var hasValue = false;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
hasValue = true;
|
|
subscriber.next(value);
|
|
}, function() {
|
|
return hasValue ? subscriber.complete() : subscriber.error(errorFactory());
|
|
}));
|
|
});
|
|
}
|
|
function defaultErrorFactory() {
|
|
return new EmptyError();
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/elementAt.js
|
|
function elementAt(index, defaultValue) {
|
|
if (index < 0) {
|
|
throw new ArgumentOutOfRangeError();
|
|
}
|
|
var hasDefaultValue = arguments.length >= 2;
|
|
return function(source) {
|
|
return source.pipe(filter(function(v, i) {
|
|
return i === index;
|
|
}), take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function() {
|
|
return new ArgumentOutOfRangeError();
|
|
}));
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/endWith.js
|
|
function endWith() {
|
|
var values = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
values[_i] = arguments[_i];
|
|
}
|
|
return function(source) {
|
|
return concat(source, of.apply(void 0, __spreadArray([], __read(values))));
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/every.js
|
|
function every(predicate, thisArg) {
|
|
return operate(function(source, subscriber) {
|
|
var index = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
if (!predicate.call(thisArg, value, index++, source)) {
|
|
subscriber.next(false);
|
|
subscriber.complete();
|
|
}
|
|
}, function() {
|
|
subscriber.next(true);
|
|
subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/exhaustMap.js
|
|
function exhaustMap(project, resultSelector) {
|
|
if (resultSelector) {
|
|
return function(source) {
|
|
return source.pipe(exhaustMap(function(a, i) {
|
|
return innerFrom(project(a, i)).pipe(map(function(b, ii) {
|
|
return resultSelector(a, b, i, ii);
|
|
}));
|
|
}));
|
|
};
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var index = 0;
|
|
var innerSub = null;
|
|
var isComplete = false;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(outerValue) {
|
|
if (!innerSub) {
|
|
innerSub = createOperatorSubscriber(subscriber, void 0, function() {
|
|
innerSub = null;
|
|
isComplete && subscriber.complete();
|
|
});
|
|
innerFrom(project(outerValue, index++)).subscribe(innerSub);
|
|
}
|
|
}, function() {
|
|
isComplete = true;
|
|
!innerSub && subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/exhaustAll.js
|
|
function exhaustAll() {
|
|
return exhaustMap(identity);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/exhaust.js
|
|
var exhaust = exhaustAll;
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/expand.js
|
|
function expand(project, concurrent, scheduler) {
|
|
if (concurrent === void 0) {
|
|
concurrent = Infinity;
|
|
}
|
|
concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
|
|
return operate(function(source, subscriber) {
|
|
return mergeInternals(source, subscriber, project, concurrent, void 0, true, scheduler);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/finalize.js
|
|
function finalize(callback) {
|
|
return operate(function(source, subscriber) {
|
|
try {
|
|
source.subscribe(subscriber);
|
|
} finally {
|
|
subscriber.add(callback);
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/find.js
|
|
function find(predicate, thisArg) {
|
|
return operate(createFind(predicate, thisArg, "value"));
|
|
}
|
|
function createFind(predicate, thisArg, emit) {
|
|
var findIndex2 = emit === "index";
|
|
return function(source, subscriber) {
|
|
var index = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var i = index++;
|
|
if (predicate.call(thisArg, value, i, source)) {
|
|
subscriber.next(findIndex2 ? i : value);
|
|
subscriber.complete();
|
|
}
|
|
}, function() {
|
|
subscriber.next(findIndex2 ? -1 : void 0);
|
|
subscriber.complete();
|
|
}));
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/findIndex.js
|
|
function findIndex(predicate, thisArg) {
|
|
return operate(createFind(predicate, thisArg, "index"));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/first.js
|
|
function first(predicate, defaultValue) {
|
|
var hasDefaultValue = arguments.length >= 2;
|
|
return function(source) {
|
|
return source.pipe(predicate ? filter(function(v, i) {
|
|
return predicate(v, i, source);
|
|
}) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function() {
|
|
return new EmptyError();
|
|
}));
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/groupBy.js
|
|
function groupBy(keySelector, elementOrOptions, duration, connector) {
|
|
return operate(function(source, subscriber) {
|
|
var element;
|
|
if (!elementOrOptions || typeof elementOrOptions === "function") {
|
|
element = elementOrOptions;
|
|
} else {
|
|
duration = elementOrOptions.duration, element = elementOrOptions.element, connector = elementOrOptions.connector;
|
|
}
|
|
var groups = /* @__PURE__ */ new Map();
|
|
var notify = function(cb) {
|
|
groups.forEach(cb);
|
|
cb(subscriber);
|
|
};
|
|
var handleError = function(err) {
|
|
return notify(function(consumer) {
|
|
return consumer.error(err);
|
|
});
|
|
};
|
|
var activeGroups = 0;
|
|
var teardownAttempted = false;
|
|
var groupBySourceSubscriber = new OperatorSubscriber(subscriber, function(value) {
|
|
try {
|
|
var key_1 = keySelector(value);
|
|
var group_1 = groups.get(key_1);
|
|
if (!group_1) {
|
|
groups.set(key_1, group_1 = connector ? connector() : new Subject());
|
|
var grouped = createGroupedObservable(key_1, group_1);
|
|
subscriber.next(grouped);
|
|
if (duration) {
|
|
var durationSubscriber_1 = createOperatorSubscriber(group_1, function() {
|
|
group_1.complete();
|
|
durationSubscriber_1 === null || durationSubscriber_1 === void 0 ? void 0 : durationSubscriber_1.unsubscribe();
|
|
}, void 0, void 0, function() {
|
|
return groups.delete(key_1);
|
|
});
|
|
groupBySourceSubscriber.add(innerFrom(duration(grouped)).subscribe(durationSubscriber_1));
|
|
}
|
|
}
|
|
group_1.next(element ? element(value) : value);
|
|
} catch (err) {
|
|
handleError(err);
|
|
}
|
|
}, function() {
|
|
return notify(function(consumer) {
|
|
return consumer.complete();
|
|
});
|
|
}, handleError, function() {
|
|
return groups.clear();
|
|
}, function() {
|
|
teardownAttempted = true;
|
|
return activeGroups === 0;
|
|
});
|
|
source.subscribe(groupBySourceSubscriber);
|
|
function createGroupedObservable(key, groupSubject) {
|
|
var result = new Observable(function(groupSubscriber) {
|
|
activeGroups++;
|
|
var innerSub = groupSubject.subscribe(groupSubscriber);
|
|
return function() {
|
|
innerSub.unsubscribe();
|
|
--activeGroups === 0 && teardownAttempted && groupBySourceSubscriber.unsubscribe();
|
|
};
|
|
});
|
|
result.key = key;
|
|
return result;
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/isEmpty.js
|
|
function isEmpty() {
|
|
return operate(function(source, subscriber) {
|
|
source.subscribe(createOperatorSubscriber(subscriber, function() {
|
|
subscriber.next(false);
|
|
subscriber.complete();
|
|
}, function() {
|
|
subscriber.next(true);
|
|
subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/takeLast.js
|
|
function takeLast(count2) {
|
|
return count2 <= 0 ? function() {
|
|
return EMPTY;
|
|
} : operate(function(source, subscriber) {
|
|
var buffer2 = [];
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
buffer2.push(value);
|
|
count2 < buffer2.length && buffer2.shift();
|
|
}, function() {
|
|
var e_1, _a;
|
|
try {
|
|
for (var buffer_1 = __values(buffer2), buffer_1_1 = buffer_1.next(); !buffer_1_1.done; buffer_1_1 = buffer_1.next()) {
|
|
var value = buffer_1_1.value;
|
|
subscriber.next(value);
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (buffer_1_1 && !buffer_1_1.done && (_a = buffer_1.return)) _a.call(buffer_1);
|
|
} finally {
|
|
if (e_1) throw e_1.error;
|
|
}
|
|
}
|
|
subscriber.complete();
|
|
}, void 0, function() {
|
|
buffer2 = null;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/last.js
|
|
function last2(predicate, defaultValue) {
|
|
var hasDefaultValue = arguments.length >= 2;
|
|
return function(source) {
|
|
return source.pipe(predicate ? filter(function(v, i) {
|
|
return predicate(v, i, source);
|
|
}) : identity, takeLast(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function() {
|
|
return new EmptyError();
|
|
}));
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/materialize.js
|
|
function materialize() {
|
|
return operate(function(source, subscriber) {
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
subscriber.next(Notification.createNext(value));
|
|
}, function() {
|
|
subscriber.next(Notification.createComplete());
|
|
subscriber.complete();
|
|
}, function(err) {
|
|
subscriber.next(Notification.createError(err));
|
|
subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/max.js
|
|
function max(comparer) {
|
|
return reduce(isFunction(comparer) ? function(x, y) {
|
|
return comparer(x, y) > 0 ? x : y;
|
|
} : function(x, y) {
|
|
return x > y ? x : y;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/flatMap.js
|
|
var flatMap = mergeMap;
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/mergeMapTo.js
|
|
function mergeMapTo(innerObservable, resultSelector, concurrent) {
|
|
if (concurrent === void 0) {
|
|
concurrent = Infinity;
|
|
}
|
|
if (isFunction(resultSelector)) {
|
|
return mergeMap(function() {
|
|
return innerObservable;
|
|
}, resultSelector, concurrent);
|
|
}
|
|
if (typeof resultSelector === "number") {
|
|
concurrent = resultSelector;
|
|
}
|
|
return mergeMap(function() {
|
|
return innerObservable;
|
|
}, concurrent);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/mergeScan.js
|
|
function mergeScan(accumulator, seed, concurrent) {
|
|
if (concurrent === void 0) {
|
|
concurrent = Infinity;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var state = seed;
|
|
return mergeInternals(source, subscriber, function(value, index) {
|
|
return accumulator(state, value, index);
|
|
}, concurrent, function(value) {
|
|
state = value;
|
|
}, false, void 0, function() {
|
|
return state = null;
|
|
});
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/merge.js
|
|
function merge() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var scheduler = popScheduler(args);
|
|
var concurrent = popNumber(args, Infinity);
|
|
return operate(function(source, subscriber) {
|
|
mergeAll(concurrent)(from(__spreadArray([source], __read(args)), scheduler)).subscribe(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/mergeWith.js
|
|
function mergeWith() {
|
|
var otherSources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
otherSources[_i] = arguments[_i];
|
|
}
|
|
return merge.apply(void 0, __spreadArray([], __read(otherSources)));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/min.js
|
|
function min(comparer) {
|
|
return reduce(isFunction(comparer) ? function(x, y) {
|
|
return comparer(x, y) < 0 ? x : y;
|
|
} : function(x, y) {
|
|
return x < y ? x : y;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/multicast.js
|
|
function multicast(subjectOrSubjectFactory, selector) {
|
|
var subjectFactory = isFunction(subjectOrSubjectFactory) ? subjectOrSubjectFactory : function() {
|
|
return subjectOrSubjectFactory;
|
|
};
|
|
if (isFunction(selector)) {
|
|
return connect(selector, {
|
|
connector: subjectFactory
|
|
});
|
|
}
|
|
return function(source) {
|
|
return new ConnectableObservable(source, subjectFactory);
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/onErrorResumeNextWith.js
|
|
function onErrorResumeNextWith() {
|
|
var sources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
sources[_i] = arguments[_i];
|
|
}
|
|
var nextSources = argsOrArgArray(sources);
|
|
return function(source) {
|
|
return onErrorResumeNext.apply(void 0, __spreadArray([source], __read(nextSources)));
|
|
};
|
|
}
|
|
var onErrorResumeNext2 = onErrorResumeNextWith;
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/pairwise.js
|
|
function pairwise() {
|
|
return operate(function(source, subscriber) {
|
|
var prev;
|
|
var hasPrev = false;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var p = prev;
|
|
prev = value;
|
|
hasPrev && subscriber.next([p, value]);
|
|
hasPrev = true;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/pluck.js
|
|
function pluck() {
|
|
var properties = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
properties[_i] = arguments[_i];
|
|
}
|
|
var length = properties.length;
|
|
if (length === 0) {
|
|
throw new Error("list of properties cannot be empty.");
|
|
}
|
|
return map(function(x) {
|
|
var currentProp = x;
|
|
for (var i = 0; i < length; i++) {
|
|
var p = currentProp === null || currentProp === void 0 ? void 0 : currentProp[properties[i]];
|
|
if (typeof p !== "undefined") {
|
|
currentProp = p;
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
return currentProp;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/publish.js
|
|
function publish(selector) {
|
|
return selector ? function(source) {
|
|
return connect(selector)(source);
|
|
} : function(source) {
|
|
return multicast(new Subject())(source);
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/publishBehavior.js
|
|
function publishBehavior(initialValue) {
|
|
return function(source) {
|
|
var subject = new BehaviorSubject(initialValue);
|
|
return new ConnectableObservable(source, function() {
|
|
return subject;
|
|
});
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/publishLast.js
|
|
function publishLast() {
|
|
return function(source) {
|
|
var subject = new AsyncSubject();
|
|
return new ConnectableObservable(source, function() {
|
|
return subject;
|
|
});
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/publishReplay.js
|
|
function publishReplay(bufferSize, windowTime2, selectorOrScheduler, timestampProvider) {
|
|
if (selectorOrScheduler && !isFunction(selectorOrScheduler)) {
|
|
timestampProvider = selectorOrScheduler;
|
|
}
|
|
var selector = isFunction(selectorOrScheduler) ? selectorOrScheduler : void 0;
|
|
return function(source) {
|
|
return multicast(new ReplaySubject(bufferSize, windowTime2, timestampProvider), selector)(source);
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/raceWith.js
|
|
function raceWith() {
|
|
var otherSources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
otherSources[_i] = arguments[_i];
|
|
}
|
|
return !otherSources.length ? identity : operate(function(source, subscriber) {
|
|
raceInit(__spreadArray([source], __read(otherSources)))(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/repeat.js
|
|
function repeat(countOrConfig) {
|
|
var _a;
|
|
var count2 = Infinity;
|
|
var delay2;
|
|
if (countOrConfig != null) {
|
|
if (typeof countOrConfig === "object") {
|
|
_a = countOrConfig.count, count2 = _a === void 0 ? Infinity : _a, delay2 = countOrConfig.delay;
|
|
} else {
|
|
count2 = countOrConfig;
|
|
}
|
|
}
|
|
return count2 <= 0 ? function() {
|
|
return EMPTY;
|
|
} : operate(function(source, subscriber) {
|
|
var soFar = 0;
|
|
var sourceSub;
|
|
var resubscribe = function() {
|
|
sourceSub === null || sourceSub === void 0 ? void 0 : sourceSub.unsubscribe();
|
|
sourceSub = null;
|
|
if (delay2 != null) {
|
|
var notifier = typeof delay2 === "number" ? timer(delay2) : innerFrom(delay2(soFar));
|
|
var notifierSubscriber_1 = createOperatorSubscriber(subscriber, function() {
|
|
notifierSubscriber_1.unsubscribe();
|
|
subscribeToSource();
|
|
});
|
|
notifier.subscribe(notifierSubscriber_1);
|
|
} else {
|
|
subscribeToSource();
|
|
}
|
|
};
|
|
var subscribeToSource = function() {
|
|
var syncUnsub = false;
|
|
sourceSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, function() {
|
|
if (++soFar < count2) {
|
|
if (sourceSub) {
|
|
resubscribe();
|
|
} else {
|
|
syncUnsub = true;
|
|
}
|
|
} else {
|
|
subscriber.complete();
|
|
}
|
|
}));
|
|
if (syncUnsub) {
|
|
resubscribe();
|
|
}
|
|
};
|
|
subscribeToSource();
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/repeatWhen.js
|
|
function repeatWhen(notifier) {
|
|
return operate(function(source, subscriber) {
|
|
var innerSub;
|
|
var syncResub = false;
|
|
var completions$;
|
|
var isNotifierComplete = false;
|
|
var isMainComplete = false;
|
|
var checkComplete = function() {
|
|
return isMainComplete && isNotifierComplete && (subscriber.complete(), true);
|
|
};
|
|
var getCompletionSubject = function() {
|
|
if (!completions$) {
|
|
completions$ = new Subject();
|
|
innerFrom(notifier(completions$)).subscribe(createOperatorSubscriber(subscriber, function() {
|
|
if (innerSub) {
|
|
subscribeForRepeatWhen();
|
|
} else {
|
|
syncResub = true;
|
|
}
|
|
}, function() {
|
|
isNotifierComplete = true;
|
|
checkComplete();
|
|
}));
|
|
}
|
|
return completions$;
|
|
};
|
|
var subscribeForRepeatWhen = function() {
|
|
isMainComplete = false;
|
|
innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, function() {
|
|
isMainComplete = true;
|
|
!checkComplete() && getCompletionSubject().next();
|
|
}));
|
|
if (syncResub) {
|
|
innerSub.unsubscribe();
|
|
innerSub = null;
|
|
syncResub = false;
|
|
subscribeForRepeatWhen();
|
|
}
|
|
};
|
|
subscribeForRepeatWhen();
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/retry.js
|
|
function retry(configOrCount) {
|
|
if (configOrCount === void 0) {
|
|
configOrCount = Infinity;
|
|
}
|
|
var config2;
|
|
if (configOrCount && typeof configOrCount === "object") {
|
|
config2 = configOrCount;
|
|
} else {
|
|
config2 = {
|
|
count: configOrCount
|
|
};
|
|
}
|
|
var _a = config2.count, count2 = _a === void 0 ? Infinity : _a, delay2 = config2.delay, _b = config2.resetOnSuccess, resetOnSuccess = _b === void 0 ? false : _b;
|
|
return count2 <= 0 ? identity : operate(function(source, subscriber) {
|
|
var soFar = 0;
|
|
var innerSub;
|
|
var subscribeForRetry = function() {
|
|
var syncUnsub = false;
|
|
innerSub = source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
if (resetOnSuccess) {
|
|
soFar = 0;
|
|
}
|
|
subscriber.next(value);
|
|
}, void 0, function(err) {
|
|
if (soFar++ < count2) {
|
|
var resub_1 = function() {
|
|
if (innerSub) {
|
|
innerSub.unsubscribe();
|
|
innerSub = null;
|
|
subscribeForRetry();
|
|
} else {
|
|
syncUnsub = true;
|
|
}
|
|
};
|
|
if (delay2 != null) {
|
|
var notifier = typeof delay2 === "number" ? timer(delay2) : innerFrom(delay2(err, soFar));
|
|
var notifierSubscriber_1 = createOperatorSubscriber(subscriber, function() {
|
|
notifierSubscriber_1.unsubscribe();
|
|
resub_1();
|
|
}, function() {
|
|
subscriber.complete();
|
|
});
|
|
notifier.subscribe(notifierSubscriber_1);
|
|
} else {
|
|
resub_1();
|
|
}
|
|
} else {
|
|
subscriber.error(err);
|
|
}
|
|
}));
|
|
if (syncUnsub) {
|
|
innerSub.unsubscribe();
|
|
innerSub = null;
|
|
subscribeForRetry();
|
|
}
|
|
};
|
|
subscribeForRetry();
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/retryWhen.js
|
|
function retryWhen(notifier) {
|
|
return operate(function(source, subscriber) {
|
|
var innerSub;
|
|
var syncResub = false;
|
|
var errors$;
|
|
var subscribeForRetryWhen = function() {
|
|
innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
|
|
if (!errors$) {
|
|
errors$ = new Subject();
|
|
innerFrom(notifier(errors$)).subscribe(createOperatorSubscriber(subscriber, function() {
|
|
return innerSub ? subscribeForRetryWhen() : syncResub = true;
|
|
}));
|
|
}
|
|
if (errors$) {
|
|
errors$.next(err);
|
|
}
|
|
}));
|
|
if (syncResub) {
|
|
innerSub.unsubscribe();
|
|
innerSub = null;
|
|
syncResub = false;
|
|
subscribeForRetryWhen();
|
|
}
|
|
};
|
|
subscribeForRetryWhen();
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/sample.js
|
|
function sample(notifier) {
|
|
return operate(function(source, subscriber) {
|
|
var hasValue = false;
|
|
var lastValue = null;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
hasValue = true;
|
|
lastValue = value;
|
|
}));
|
|
innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function() {
|
|
if (hasValue) {
|
|
hasValue = false;
|
|
var value = lastValue;
|
|
lastValue = null;
|
|
subscriber.next(value);
|
|
}
|
|
}, noop));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/sampleTime.js
|
|
function sampleTime(period, scheduler) {
|
|
if (scheduler === void 0) {
|
|
scheduler = asyncScheduler;
|
|
}
|
|
return sample(interval(period, scheduler));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/scan.js
|
|
function scan(accumulator, seed) {
|
|
return operate(scanInternals(accumulator, seed, arguments.length >= 2, true));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/sequenceEqual.js
|
|
function sequenceEqual(compareTo, comparator) {
|
|
if (comparator === void 0) {
|
|
comparator = function(a, b) {
|
|
return a === b;
|
|
};
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var aState = createState();
|
|
var bState = createState();
|
|
var emit = function(isEqual) {
|
|
subscriber.next(isEqual);
|
|
subscriber.complete();
|
|
};
|
|
var createSubscriber = function(selfState, otherState) {
|
|
var sequenceEqualSubscriber = createOperatorSubscriber(subscriber, function(a) {
|
|
var buffer2 = otherState.buffer, complete = otherState.complete;
|
|
if (buffer2.length === 0) {
|
|
complete ? emit(false) : selfState.buffer.push(a);
|
|
} else {
|
|
!comparator(a, buffer2.shift()) && emit(false);
|
|
}
|
|
}, function() {
|
|
selfState.complete = true;
|
|
var complete = otherState.complete, buffer2 = otherState.buffer;
|
|
complete && emit(buffer2.length === 0);
|
|
sequenceEqualSubscriber === null || sequenceEqualSubscriber === void 0 ? void 0 : sequenceEqualSubscriber.unsubscribe();
|
|
});
|
|
return sequenceEqualSubscriber;
|
|
};
|
|
source.subscribe(createSubscriber(aState, bState));
|
|
innerFrom(compareTo).subscribe(createSubscriber(bState, aState));
|
|
});
|
|
}
|
|
function createState() {
|
|
return {
|
|
buffer: [],
|
|
complete: false
|
|
};
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/share.js
|
|
function share(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
var _a = options.connector, connector = _a === void 0 ? function() {
|
|
return new 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 refCount2 = 0;
|
|
var hasCompleted = false;
|
|
var hasErrored = false;
|
|
var cancelReset = function() {
|
|
resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
|
|
resetConnection = void 0;
|
|
};
|
|
var reset = function() {
|
|
cancelReset();
|
|
connection = subject = void 0;
|
|
hasCompleted = hasErrored = false;
|
|
};
|
|
var resetAndUnsubscribe = function() {
|
|
var conn = connection;
|
|
reset();
|
|
conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
|
|
};
|
|
return operate(function(source, subscriber) {
|
|
refCount2++;
|
|
if (!hasErrored && !hasCompleted) {
|
|
cancelReset();
|
|
}
|
|
var dest = subject = subject !== null && subject !== void 0 ? subject : connector();
|
|
subscriber.add(function() {
|
|
refCount2--;
|
|
if (refCount2 === 0 && !hasErrored && !hasCompleted) {
|
|
resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
|
|
}
|
|
});
|
|
dest.subscribe(subscriber);
|
|
if (!connection && refCount2 > 0) {
|
|
connection = new 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(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 SafeSubscriber({
|
|
next: function() {
|
|
onSubscriber.unsubscribe();
|
|
reset();
|
|
}
|
|
});
|
|
return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/shareReplay.js
|
|
function shareReplay(configOrBufferSize, windowTime2, scheduler) {
|
|
var _a, _b, _c;
|
|
var bufferSize;
|
|
var refCount2 = false;
|
|
if (configOrBufferSize && typeof configOrBufferSize === "object") {
|
|
_a = configOrBufferSize.bufferSize, bufferSize = _a === void 0 ? Infinity : _a, _b = configOrBufferSize.windowTime, windowTime2 = _b === void 0 ? Infinity : _b, _c = configOrBufferSize.refCount, refCount2 = _c === void 0 ? false : _c, scheduler = configOrBufferSize.scheduler;
|
|
} else {
|
|
bufferSize = configOrBufferSize !== null && configOrBufferSize !== void 0 ? configOrBufferSize : Infinity;
|
|
}
|
|
return share({
|
|
connector: function() {
|
|
return new ReplaySubject(bufferSize, windowTime2, scheduler);
|
|
},
|
|
resetOnError: true,
|
|
resetOnComplete: false,
|
|
resetOnRefCountZero: refCount2
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/single.js
|
|
function single(predicate) {
|
|
return operate(function(source, subscriber) {
|
|
var hasValue = false;
|
|
var singleValue;
|
|
var seenValue = false;
|
|
var index = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
seenValue = true;
|
|
if (!predicate || predicate(value, index++, source)) {
|
|
hasValue && subscriber.error(new SequenceError("Too many matching values"));
|
|
hasValue = true;
|
|
singleValue = value;
|
|
}
|
|
}, function() {
|
|
if (hasValue) {
|
|
subscriber.next(singleValue);
|
|
subscriber.complete();
|
|
} else {
|
|
subscriber.error(seenValue ? new NotFoundError("No matching values") : new EmptyError());
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/skip.js
|
|
function skip(count2) {
|
|
return filter(function(_, index) {
|
|
return count2 <= index;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/skipLast.js
|
|
function skipLast(skipCount) {
|
|
return skipCount <= 0 ? identity : operate(function(source, subscriber) {
|
|
var ring = new Array(skipCount);
|
|
var seen = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var valueIndex = seen++;
|
|
if (valueIndex < skipCount) {
|
|
ring[valueIndex] = value;
|
|
} else {
|
|
var index = valueIndex % skipCount;
|
|
var oldValue = ring[index];
|
|
ring[index] = value;
|
|
subscriber.next(oldValue);
|
|
}
|
|
}));
|
|
return function() {
|
|
ring = null;
|
|
};
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/skipUntil.js
|
|
function skipUntil(notifier) {
|
|
return operate(function(source, subscriber) {
|
|
var taking = false;
|
|
var skipSubscriber = createOperatorSubscriber(subscriber, function() {
|
|
skipSubscriber === null || skipSubscriber === void 0 ? void 0 : skipSubscriber.unsubscribe();
|
|
taking = true;
|
|
}, noop);
|
|
innerFrom(notifier).subscribe(skipSubscriber);
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return taking && subscriber.next(value);
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/skipWhile.js
|
|
function skipWhile(predicate) {
|
|
return operate(function(source, subscriber) {
|
|
var taking = false;
|
|
var index = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return (taking || (taking = !predicate(value, index++))) && subscriber.next(value);
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/startWith.js
|
|
function startWith() {
|
|
var values = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
values[_i] = arguments[_i];
|
|
}
|
|
var scheduler = popScheduler(values);
|
|
return operate(function(source, subscriber) {
|
|
(scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/switchMap.js
|
|
function switchMap(project, resultSelector) {
|
|
return operate(function(source, subscriber) {
|
|
var innerSubscriber = null;
|
|
var index = 0;
|
|
var isComplete = false;
|
|
var checkComplete = function() {
|
|
return isComplete && !innerSubscriber && subscriber.complete();
|
|
};
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
|
|
var innerIndex = 0;
|
|
var outerIndex = index++;
|
|
innerFrom(project(value, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, function(innerValue) {
|
|
return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue);
|
|
}, function() {
|
|
innerSubscriber = null;
|
|
checkComplete();
|
|
}));
|
|
}, function() {
|
|
isComplete = true;
|
|
checkComplete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/switchAll.js
|
|
function switchAll() {
|
|
return switchMap(identity);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/switchMapTo.js
|
|
function switchMapTo(innerObservable, resultSelector) {
|
|
return isFunction(resultSelector) ? switchMap(function() {
|
|
return innerObservable;
|
|
}, resultSelector) : switchMap(function() {
|
|
return innerObservable;
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/switchScan.js
|
|
function switchScan(accumulator, seed) {
|
|
return operate(function(source, subscriber) {
|
|
var state = seed;
|
|
switchMap(function(value, index) {
|
|
return accumulator(state, value, index);
|
|
}, function(_, innerValue) {
|
|
return state = innerValue, innerValue;
|
|
})(source).subscribe(subscriber);
|
|
return function() {
|
|
state = null;
|
|
};
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js
|
|
function takeUntil(notifier) {
|
|
return operate(function(source, subscriber) {
|
|
innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function() {
|
|
return subscriber.complete();
|
|
}, noop));
|
|
!subscriber.closed && source.subscribe(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/takeWhile.js
|
|
function takeWhile(predicate, inclusive) {
|
|
if (inclusive === void 0) {
|
|
inclusive = false;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var index = 0;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var result = predicate(value, index++);
|
|
(result || inclusive) && subscriber.next(value);
|
|
!result && subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/tap.js
|
|
function tap(observerOrNext, error, complete) {
|
|
var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
|
|
return tapObserver ? operate(function(source, subscriber) {
|
|
var _a;
|
|
(_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
|
|
var isUnsub = true;
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var _a2;
|
|
(_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value);
|
|
subscriber.next(value);
|
|
}, function() {
|
|
var _a2;
|
|
isUnsub = false;
|
|
(_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
|
|
subscriber.complete();
|
|
}, function(err) {
|
|
var _a2;
|
|
isUnsub = false;
|
|
(_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
|
|
subscriber.error(err);
|
|
}, function() {
|
|
var _a2, _b;
|
|
if (isUnsub) {
|
|
(_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
|
|
}
|
|
(_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
|
|
}));
|
|
}) : identity;
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/throttle.js
|
|
function throttle(durationSelector, config2) {
|
|
return operate(function(source, subscriber) {
|
|
var _a = config2 !== null && config2 !== void 0 ? config2 : {}, _b = _a.leading, leading = _b === void 0 ? true : _b, _c = _a.trailing, trailing = _c === void 0 ? false : _c;
|
|
var hasValue = false;
|
|
var sendValue = null;
|
|
var throttled = null;
|
|
var isComplete = false;
|
|
var endThrottling = function() {
|
|
throttled === null || throttled === void 0 ? void 0 : throttled.unsubscribe();
|
|
throttled = null;
|
|
if (trailing) {
|
|
send();
|
|
isComplete && subscriber.complete();
|
|
}
|
|
};
|
|
var cleanupThrottling = function() {
|
|
throttled = null;
|
|
isComplete && subscriber.complete();
|
|
};
|
|
var startThrottle = function(value) {
|
|
return throttled = innerFrom(durationSelector(value)).subscribe(createOperatorSubscriber(subscriber, endThrottling, cleanupThrottling));
|
|
};
|
|
var send = function() {
|
|
if (hasValue) {
|
|
hasValue = false;
|
|
var value = sendValue;
|
|
sendValue = null;
|
|
subscriber.next(value);
|
|
!isComplete && startThrottle(value);
|
|
}
|
|
};
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
hasValue = true;
|
|
sendValue = value;
|
|
!(throttled && !throttled.closed) && (leading ? send() : startThrottle(value));
|
|
}, function() {
|
|
isComplete = true;
|
|
!(trailing && hasValue && throttled && !throttled.closed) && subscriber.complete();
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/throttleTime.js
|
|
function throttleTime(duration, scheduler, config2) {
|
|
if (scheduler === void 0) {
|
|
scheduler = asyncScheduler;
|
|
}
|
|
var duration$ = timer(duration, scheduler);
|
|
return throttle(function() {
|
|
return duration$;
|
|
}, config2);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/timeInterval.js
|
|
function timeInterval(scheduler) {
|
|
if (scheduler === void 0) {
|
|
scheduler = asyncScheduler;
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
var last3 = scheduler.now();
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var now = scheduler.now();
|
|
var interval2 = now - last3;
|
|
last3 = now;
|
|
subscriber.next(new TimeInterval(value, interval2));
|
|
}));
|
|
});
|
|
}
|
|
var TimeInterval = /* @__PURE__ */ (function() {
|
|
function TimeInterval2(value, interval2) {
|
|
this.value = value;
|
|
this.interval = interval2;
|
|
}
|
|
return TimeInterval2;
|
|
})();
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/timeoutWith.js
|
|
function timeoutWith(due, withObservable, scheduler) {
|
|
var first2;
|
|
var each;
|
|
var _with;
|
|
scheduler = scheduler !== null && scheduler !== void 0 ? scheduler : async;
|
|
if (isValidDate(due)) {
|
|
first2 = due;
|
|
} else if (typeof due === "number") {
|
|
each = due;
|
|
}
|
|
if (withObservable) {
|
|
_with = function() {
|
|
return withObservable;
|
|
};
|
|
} else {
|
|
throw new TypeError("No observable provided to switch to");
|
|
}
|
|
if (first2 == null && each == null) {
|
|
throw new TypeError("No timeout provided.");
|
|
}
|
|
return timeout({
|
|
first: first2,
|
|
each,
|
|
scheduler,
|
|
with: _with
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/timestamp.js
|
|
function timestamp(timestampProvider) {
|
|
if (timestampProvider === void 0) {
|
|
timestampProvider = dateTimestampProvider;
|
|
}
|
|
return map(function(value) {
|
|
return { value, timestamp: timestampProvider.now() };
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/window.js
|
|
function window(windowBoundaries) {
|
|
return operate(function(source, subscriber) {
|
|
var windowSubject = new Subject();
|
|
subscriber.next(windowSubject.asObservable());
|
|
var errorHandler = function(err) {
|
|
windowSubject.error(err);
|
|
subscriber.error(err);
|
|
};
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return windowSubject === null || windowSubject === void 0 ? void 0 : windowSubject.next(value);
|
|
}, function() {
|
|
windowSubject.complete();
|
|
subscriber.complete();
|
|
}, errorHandler));
|
|
innerFrom(windowBoundaries).subscribe(createOperatorSubscriber(subscriber, function() {
|
|
windowSubject.complete();
|
|
subscriber.next(windowSubject = new Subject());
|
|
}, noop, errorHandler));
|
|
return function() {
|
|
windowSubject === null || windowSubject === void 0 ? void 0 : windowSubject.unsubscribe();
|
|
windowSubject = null;
|
|
};
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/windowCount.js
|
|
function windowCount(windowSize, startWindowEvery) {
|
|
if (startWindowEvery === void 0) {
|
|
startWindowEvery = 0;
|
|
}
|
|
var startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
|
|
return operate(function(source, subscriber) {
|
|
var windows = [new Subject()];
|
|
var starts = [];
|
|
var count2 = 0;
|
|
subscriber.next(windows[0].asObservable());
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var e_1, _a;
|
|
try {
|
|
for (var windows_1 = __values(windows), windows_1_1 = windows_1.next(); !windows_1_1.done; windows_1_1 = windows_1.next()) {
|
|
var window_1 = windows_1_1.value;
|
|
window_1.next(value);
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (windows_1_1 && !windows_1_1.done && (_a = windows_1.return)) _a.call(windows_1);
|
|
} finally {
|
|
if (e_1) throw e_1.error;
|
|
}
|
|
}
|
|
var c = count2 - windowSize + 1;
|
|
if (c >= 0 && c % startEvery === 0) {
|
|
windows.shift().complete();
|
|
}
|
|
if (++count2 % startEvery === 0) {
|
|
var window_2 = new Subject();
|
|
windows.push(window_2);
|
|
subscriber.next(window_2.asObservable());
|
|
}
|
|
}, function() {
|
|
while (windows.length > 0) {
|
|
windows.shift().complete();
|
|
}
|
|
subscriber.complete();
|
|
}, function(err) {
|
|
while (windows.length > 0) {
|
|
windows.shift().error(err);
|
|
}
|
|
subscriber.error(err);
|
|
}, function() {
|
|
starts = null;
|
|
windows = null;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/windowTime.js
|
|
function windowTime(windowTimeSpan) {
|
|
var _a, _b;
|
|
var otherArgs = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
otherArgs[_i - 1] = arguments[_i];
|
|
}
|
|
var scheduler = (_a = popScheduler(otherArgs)) !== null && _a !== void 0 ? _a : asyncScheduler;
|
|
var windowCreationInterval = (_b = otherArgs[0]) !== null && _b !== void 0 ? _b : null;
|
|
var maxWindowSize = otherArgs[1] || Infinity;
|
|
return operate(function(source, subscriber) {
|
|
var windowRecords = [];
|
|
var restartOnClose = false;
|
|
var closeWindow = function(record) {
|
|
var window2 = record.window, subs = record.subs;
|
|
window2.complete();
|
|
subs.unsubscribe();
|
|
arrRemove(windowRecords, record);
|
|
restartOnClose && startWindow();
|
|
};
|
|
var startWindow = function() {
|
|
if (windowRecords) {
|
|
var subs = new Subscription();
|
|
subscriber.add(subs);
|
|
var window_1 = new Subject();
|
|
var record_1 = {
|
|
window: window_1,
|
|
subs,
|
|
seen: 0
|
|
};
|
|
windowRecords.push(record_1);
|
|
subscriber.next(window_1.asObservable());
|
|
executeSchedule(subs, scheduler, function() {
|
|
return closeWindow(record_1);
|
|
}, windowTimeSpan);
|
|
}
|
|
};
|
|
if (windowCreationInterval !== null && windowCreationInterval >= 0) {
|
|
executeSchedule(subscriber, scheduler, startWindow, windowCreationInterval, true);
|
|
} else {
|
|
restartOnClose = true;
|
|
}
|
|
startWindow();
|
|
var loop = function(cb) {
|
|
return windowRecords.slice().forEach(cb);
|
|
};
|
|
var terminate = function(cb) {
|
|
loop(function(_a2) {
|
|
var window2 = _a2.window;
|
|
return cb(window2);
|
|
});
|
|
cb(subscriber);
|
|
subscriber.unsubscribe();
|
|
};
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
loop(function(record) {
|
|
record.window.next(value);
|
|
maxWindowSize <= ++record.seen && closeWindow(record);
|
|
});
|
|
}, function() {
|
|
return terminate(function(consumer) {
|
|
return consumer.complete();
|
|
});
|
|
}, function(err) {
|
|
return terminate(function(consumer) {
|
|
return consumer.error(err);
|
|
});
|
|
}));
|
|
return function() {
|
|
windowRecords = null;
|
|
};
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/windowToggle.js
|
|
function windowToggle(openings, closingSelector) {
|
|
return operate(function(source, subscriber) {
|
|
var windows = [];
|
|
var handleError = function(err) {
|
|
while (0 < windows.length) {
|
|
windows.shift().error(err);
|
|
}
|
|
subscriber.error(err);
|
|
};
|
|
innerFrom(openings).subscribe(createOperatorSubscriber(subscriber, function(openValue) {
|
|
var window2 = new Subject();
|
|
windows.push(window2);
|
|
var closingSubscription = new Subscription();
|
|
var closeWindow = function() {
|
|
arrRemove(windows, window2);
|
|
window2.complete();
|
|
closingSubscription.unsubscribe();
|
|
};
|
|
var closingNotifier;
|
|
try {
|
|
closingNotifier = innerFrom(closingSelector(openValue));
|
|
} catch (err) {
|
|
handleError(err);
|
|
return;
|
|
}
|
|
subscriber.next(window2.asObservable());
|
|
closingSubscription.add(closingNotifier.subscribe(createOperatorSubscriber(subscriber, closeWindow, noop, handleError)));
|
|
}, noop));
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
var e_1, _a;
|
|
var windowsCopy = windows.slice();
|
|
try {
|
|
for (var windowsCopy_1 = __values(windowsCopy), windowsCopy_1_1 = windowsCopy_1.next(); !windowsCopy_1_1.done; windowsCopy_1_1 = windowsCopy_1.next()) {
|
|
var window_1 = windowsCopy_1_1.value;
|
|
window_1.next(value);
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (windowsCopy_1_1 && !windowsCopy_1_1.done && (_a = windowsCopy_1.return)) _a.call(windowsCopy_1);
|
|
} finally {
|
|
if (e_1) throw e_1.error;
|
|
}
|
|
}
|
|
}, function() {
|
|
while (0 < windows.length) {
|
|
windows.shift().complete();
|
|
}
|
|
subscriber.complete();
|
|
}, handleError, function() {
|
|
while (0 < windows.length) {
|
|
windows.shift().unsubscribe();
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/windowWhen.js
|
|
function windowWhen(closingSelector) {
|
|
return operate(function(source, subscriber) {
|
|
var window2;
|
|
var closingSubscriber;
|
|
var handleError = function(err) {
|
|
window2.error(err);
|
|
subscriber.error(err);
|
|
};
|
|
var openWindow = function() {
|
|
closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
|
|
window2 === null || window2 === void 0 ? void 0 : window2.complete();
|
|
window2 = new Subject();
|
|
subscriber.next(window2.asObservable());
|
|
var closingNotifier;
|
|
try {
|
|
closingNotifier = innerFrom(closingSelector());
|
|
} catch (err) {
|
|
handleError(err);
|
|
return;
|
|
}
|
|
closingNotifier.subscribe(closingSubscriber = createOperatorSubscriber(subscriber, openWindow, openWindow, handleError));
|
|
};
|
|
openWindow();
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
return window2.next(value);
|
|
}, function() {
|
|
window2.complete();
|
|
subscriber.complete();
|
|
}, handleError, function() {
|
|
closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
|
|
window2 = null;
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/withLatestFrom.js
|
|
function withLatestFrom() {
|
|
var inputs = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
inputs[_i] = arguments[_i];
|
|
}
|
|
var project = popResultSelector(inputs);
|
|
return operate(function(source, subscriber) {
|
|
var len = inputs.length;
|
|
var otherValues = new Array(len);
|
|
var hasValue = inputs.map(function() {
|
|
return false;
|
|
});
|
|
var ready = false;
|
|
var _loop_1 = function(i2) {
|
|
innerFrom(inputs[i2]).subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
otherValues[i2] = value;
|
|
if (!ready && !hasValue[i2]) {
|
|
hasValue[i2] = true;
|
|
(ready = hasValue.every(identity)) && (hasValue = null);
|
|
}
|
|
}, noop));
|
|
};
|
|
for (var i = 0; i < len; i++) {
|
|
_loop_1(i);
|
|
}
|
|
source.subscribe(createOperatorSubscriber(subscriber, function(value) {
|
|
if (ready) {
|
|
var values = __spreadArray([value], __read(otherValues));
|
|
subscriber.next(project ? project.apply(void 0, __spreadArray([], __read(values))) : values);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/zipAll.js
|
|
function zipAll(project) {
|
|
return joinAllInternals(zip, project);
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/zip.js
|
|
function zip2() {
|
|
var sources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
sources[_i] = arguments[_i];
|
|
}
|
|
return operate(function(source, subscriber) {
|
|
zip.apply(void 0, __spreadArray([source], __read(sources))).subscribe(subscriber);
|
|
});
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/operators/zipWith.js
|
|
function zipWith() {
|
|
var otherInputs = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
otherInputs[_i] = arguments[_i];
|
|
}
|
|
return zip2.apply(void 0, __spreadArray([], __read(otherInputs)));
|
|
}
|
|
|
|
// node_modules/rxjs/dist/esm5/internal/util/not.js
|
|
function not(pred, thisArg) {
|
|
return function(value, index) {
|
|
return !pred.call(thisArg, value, index);
|
|
};
|
|
}
|
|
|
|
export {
|
|
__extends,
|
|
__generator,
|
|
__read,
|
|
__spreadArray,
|
|
isFunction,
|
|
UnsubscriptionError,
|
|
Subscription,
|
|
config,
|
|
noop,
|
|
Subscriber,
|
|
SafeSubscriber,
|
|
observable,
|
|
identity,
|
|
pipe,
|
|
Observable,
|
|
createOperatorSubscriber,
|
|
refCount,
|
|
ConnectableObservable,
|
|
ObjectUnsubscribedError,
|
|
Subject,
|
|
BehaviorSubject,
|
|
ReplaySubject,
|
|
AsyncSubject,
|
|
AsyncAction,
|
|
Scheduler,
|
|
AsyncScheduler,
|
|
asyncScheduler,
|
|
async,
|
|
EMPTY,
|
|
empty,
|
|
isScheduler,
|
|
popResultSelector,
|
|
popScheduler,
|
|
popNumber,
|
|
isArrayLike,
|
|
innerFrom,
|
|
observeOn,
|
|
subscribeOn,
|
|
scheduleIterable,
|
|
scheduled,
|
|
from,
|
|
of,
|
|
throwError,
|
|
NotificationKind,
|
|
Notification,
|
|
EmptyError,
|
|
ArgumentOutOfRangeError,
|
|
NotFoundError,
|
|
SequenceError,
|
|
TimeoutError,
|
|
timeout,
|
|
map,
|
|
mapOneOrManyArgs,
|
|
argsArgArrayOrObject,
|
|
createObject,
|
|
combineLatest,
|
|
mergeMap,
|
|
mergeAll,
|
|
concatAll,
|
|
concat,
|
|
timer,
|
|
interval,
|
|
argsOrArgArray,
|
|
onErrorResumeNext,
|
|
not,
|
|
filter,
|
|
race,
|
|
zip,
|
|
audit,
|
|
auditTime,
|
|
buffer,
|
|
bufferCount,
|
|
bufferTime,
|
|
bufferToggle,
|
|
bufferWhen,
|
|
catchError,
|
|
reduce,
|
|
toArray,
|
|
combineLatestAll,
|
|
combineAll,
|
|
combineLatest2,
|
|
combineLatestWith,
|
|
concatMap,
|
|
concatMapTo,
|
|
concat2,
|
|
concatWith,
|
|
connect,
|
|
count,
|
|
debounce,
|
|
debounceTime,
|
|
defaultIfEmpty,
|
|
take,
|
|
ignoreElements,
|
|
mapTo,
|
|
delayWhen,
|
|
delay,
|
|
dematerialize,
|
|
distinct,
|
|
distinctUntilChanged,
|
|
distinctUntilKeyChanged,
|
|
throwIfEmpty,
|
|
elementAt,
|
|
endWith,
|
|
every,
|
|
exhaustMap,
|
|
exhaustAll,
|
|
exhaust,
|
|
expand,
|
|
finalize,
|
|
find,
|
|
findIndex,
|
|
first,
|
|
groupBy,
|
|
isEmpty,
|
|
takeLast,
|
|
last2 as last,
|
|
materialize,
|
|
max,
|
|
flatMap,
|
|
mergeMapTo,
|
|
mergeScan,
|
|
merge,
|
|
mergeWith,
|
|
min,
|
|
multicast,
|
|
onErrorResumeNextWith,
|
|
onErrorResumeNext2,
|
|
pairwise,
|
|
pluck,
|
|
publish,
|
|
publishBehavior,
|
|
publishLast,
|
|
publishReplay,
|
|
raceWith,
|
|
repeat,
|
|
repeatWhen,
|
|
retry,
|
|
retryWhen,
|
|
sample,
|
|
sampleTime,
|
|
scan,
|
|
sequenceEqual,
|
|
share,
|
|
shareReplay,
|
|
single,
|
|
skip,
|
|
skipLast,
|
|
skipUntil,
|
|
skipWhile,
|
|
startWith,
|
|
switchMap,
|
|
switchAll,
|
|
switchMapTo,
|
|
switchScan,
|
|
takeUntil,
|
|
takeWhile,
|
|
tap,
|
|
throttle,
|
|
throttleTime,
|
|
timeInterval,
|
|
timeoutWith,
|
|
timestamp,
|
|
window,
|
|
windowCount,
|
|
windowTime,
|
|
windowToggle,
|
|
windowWhen,
|
|
withLatestFrom,
|
|
zipAll,
|
|
zip2,
|
|
zipWith
|
|
};
|
|
//# sourceMappingURL=chunk-MARUHEWW.js.map
|