aboutsummaryrefslogtreecommitdiffstats
path: root/node_modules/rxjs/dist/bundles/rxjs.umd.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/rxjs/dist/bundles/rxjs.umd.js')
-rw-r--r--node_modules/rxjs/dist/bundles/rxjs.umd.js6849
1 files changed, 6849 insertions, 0 deletions
diff --git a/node_modules/rxjs/dist/bundles/rxjs.umd.js b/node_modules/rxjs/dist/bundles/rxjs.umd.js
new file mode 100644
index 0000000..955897c
--- /dev/null
+++ b/node_modules/rxjs/dist/bundles/rxjs.umd.js
@@ -0,0 +1,6849 @@
+/**
+ @license
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright (c) 2015-2018 Google, Inc., Netflix, Inc., Microsoft Corp. and contributors
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+ **/
+/**
+ @license
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright (c) 2015-2018 Google, Inc., Netflix, Inc., Microsoft Corp. and contributors
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+ **/
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define('rxjs', ['exports'], factory) :
+ (factory((global.rxjs = {})));
+}(this, (function (exports) { 'use strict';
+
+ /*! *****************************************************************************
+ Copyright (c) Microsoft Corporation.
+
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted.
+
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ PERFORMANCE OF THIS SOFTWARE.
+ ***************************************************************************** */
+ /* global Reflect, Promise */
+
+ var extendStatics = function(d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+
+ function __extends(d, b) {
+ if (typeof b !== "function" && b !== null)
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ }
+
+ var __assign = function() {
+ __assign = Object.assign || function __assign(t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+ }
+ return t;
+ };
+ return __assign.apply(this, arguments);
+ };
+
+ function __rest(s, e) {
+ var t = {};
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+ t[p] = s[p];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+ if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+ t[p[i]] = s[p[i]];
+ }
+ return t;
+ }
+
+ function __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;
+ return g = { next: verb(0), "throw": verb(1), "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 (_) 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: error }; }
+ finally {
+ try {
+ if (r && !r.done && (m = i["return"])) m.call(i);
+ }
+ finally { if (e) throw e.error; }
+ }
+ return ar;
+ }
+
+ function __spreadArray(to, from, pack) {
+ if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+ if (ar || !(i in from)) {
+ if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+ ar[i] = from[i];
+ }
+ }
+ return to.concat(ar || Array.prototype.slice.call(from));
+ }
+
+ function __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 = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+ function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+ 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(v) { resolve({ value: v, done: d }); }, reject); }
+ }
+
+ function isFunction(value) {
+ return typeof value === 'function';
+ }
+
+ function createErrorClass(createImpl) {
+ var _super = function (instance) {
+ Error.call(instance);
+ instance.stack = new Error().stack;
+ };
+ var ctorFunc = createImpl(_super);
+ ctorFunc.prototype = Object.create(Error.prototype);
+ ctorFunc.prototype.constructor = ctorFunc;
+ return ctorFunc;
+ }
+
+ var UnsubscriptionError = createErrorClass(function (_super) {
+ return function UnsubscriptionErrorImpl(errors) {
+ _super(this);
+ this.message = errors
+ ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n ')
+ : '';
+ this.name = 'UnsubscriptionError';
+ this.errors = errors;
+ };
+ });
+
+ function arrRemove(arr, item) {
+ if (arr) {
+ var index = arr.indexOf(item);
+ 0 <= index && arr.splice(index, 1);
+ }
+ }
+
+ var Subscription = (function () {
+ function Subscription(initialTeardown) {
+ this.initialTeardown = initialTeardown;
+ this.closed = false;
+ this._parentage = null;
+ this._finalizers = null;
+ }
+ Subscription.prototype.unsubscribe = function () {
+ var e_1, _a, e_2, _b;
+ var errors;
+ if (!this.closed) {
+ this.closed = true;
+ var _parentage = this._parentage;
+ if (_parentage) {
+ this._parentage = null;
+ if (Array.isArray(_parentage)) {
+ try {
+ for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+ var parent_1 = _parentage_1_1.value;
+ parent_1.remove(this);
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ }
+ else {
+ _parentage.remove(this);
+ }
+ }
+ var initialFinalizer = this.initialTeardown;
+ if (isFunction(initialFinalizer)) {
+ try {
+ initialFinalizer();
+ }
+ catch (e) {
+ errors = e instanceof UnsubscriptionError ? e.errors : [e];
+ }
+ }
+ var _finalizers = this._finalizers;
+ if (_finalizers) {
+ this._finalizers = null;
+ try {
+ for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+ var finalizer = _finalizers_1_1.value;
+ try {
+ execFinalizer(finalizer);
+ }
+ catch (err) {
+ errors = errors !== null && errors !== void 0 ? errors : [];
+ if (err instanceof UnsubscriptionError) {
+ errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+ }
+ else {
+ errors.push(err);
+ }
+ }
+ }
+ }
+ catch (e_2_1) { e_2 = { error: e_2_1 }; }
+ finally {
+ try {
+ if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+ }
+ finally { if (e_2) throw e_2.error; }
+ }
+ }
+ if (errors) {
+ throw new UnsubscriptionError(errors);
+ }
+ }
+ };
+ Subscription.prototype.add = function (teardown) {
+ var _a;
+ if (teardown && teardown !== this) {
+ if (this.closed) {
+ execFinalizer(teardown);
+ }
+ else {
+ if (teardown instanceof Subscription) {
+ if (teardown.closed || teardown._hasParent(this)) {
+ return;
+ }
+ teardown._addParent(this);
+ }
+ (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+ }
+ }
+ };
+ Subscription.prototype._hasParent = function (parent) {
+ var _parentage = this._parentage;
+ return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+ };
+ Subscription.prototype._addParent = function (parent) {
+ var _parentage = this._parentage;
+ this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+ };
+ Subscription.prototype._removeParent = function (parent) {
+ var _parentage = this._parentage;
+ if (_parentage === parent) {
+ this._parentage = null;
+ }
+ else if (Array.isArray(_parentage)) {
+ arrRemove(_parentage, parent);
+ }
+ };
+ Subscription.prototype.remove = function (teardown) {
+ var _finalizers = this._finalizers;
+ _finalizers && arrRemove(_finalizers, teardown);
+ if (teardown instanceof Subscription) {
+ teardown._removeParent(this);
+ }
+ };
+ Subscription.EMPTY = (function () {
+ var empty = new Subscription();
+ empty.closed = true;
+ return empty;
+ })();
+ return Subscription;
+ }());
+ var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+ function isSubscription(value) {
+ return (value instanceof Subscription ||
+ (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
+ }
+ function execFinalizer(finalizer) {
+ if (isFunction(finalizer)) {
+ finalizer();
+ }
+ else {
+ finalizer.unsubscribe();
+ }
+ }
+
+ var config = {
+ onUnhandledError: null,
+ onStoppedNotification: null,
+ Promise: undefined,
+ useDeprecatedSynchronousErrorHandling: false,
+ useDeprecatedNextContext: false,
+ };
+
+ var timeoutProvider = {
+ setTimeout: function (handler, timeout) {
+ var args = [];
+ for (var _i = 2; _i < arguments.length; _i++) {
+ args[_i - 2] = arguments[_i];
+ }
+ var delegate = timeoutProvider.delegate;
+ if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+ return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+ }
+ return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+ },
+ clearTimeout: function (handle) {
+ var delegate = timeoutProvider.delegate;
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+ },
+ delegate: undefined,
+ };
+
+ function reportUnhandledError(err) {
+ timeoutProvider.setTimeout(function () {
+ var onUnhandledError = config.onUnhandledError;
+ if (onUnhandledError) {
+ onUnhandledError(err);
+ }
+ else {
+ throw err;
+ }
+ });
+ }
+
+ function noop() { }
+
+ var COMPLETE_NOTIFICATION = (function () { return createNotification('C', undefined, undefined); })();
+ function errorNotification(error) {
+ return createNotification('E', undefined, error);
+ }
+ function nextNotification(value) {
+ return createNotification('N', value, undefined);
+ }
+ function createNotification(kind, value, error) {
+ return {
+ kind: kind,
+ value: value,
+ error: error,
+ };
+ }
+
+ 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;
+ }
+ }
+
+ var Subscriber = (function (_super) {
+ __extends(Subscriber, _super);
+ function Subscriber(destination) {
+ var _this = _super.call(this) || this;
+ _this.isStopped = false;
+ if (destination) {
+ _this.destination = destination;
+ if (isSubscription(destination)) {
+ destination.add(_this);
+ }
+ }
+ else {
+ _this.destination = EMPTY_OBSERVER;
+ }
+ return _this;
+ }
+ Subscriber.create = function (next, error, complete) {
+ return new SafeSubscriber(next, error, complete);
+ };
+ Subscriber.prototype.next = function (value) {
+ if (this.isStopped) {
+ handleStoppedNotification(nextNotification(value), this);
+ }
+ else {
+ this._next(value);
+ }
+ };
+ Subscriber.prototype.error = function (err) {
+ if (this.isStopped) {
+ handleStoppedNotification(errorNotification(err), this);
+ }
+ else {
+ this.isStopped = true;
+ this._error(err);
+ }
+ };
+ Subscriber.prototype.complete = function () {
+ if (this.isStopped) {
+ handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+ }
+ else {
+ this.isStopped = true;
+ this._complete();
+ }
+ };
+ Subscriber.prototype.unsubscribe = function () {
+ if (!this.closed) {
+ this.isStopped = true;
+ _super.prototype.unsubscribe.call(this);
+ this.destination = null;
+ }
+ };
+ Subscriber.prototype._next = function (value) {
+ this.destination.next(value);
+ };
+ Subscriber.prototype._error = function (err) {
+ try {
+ this.destination.error(err);
+ }
+ finally {
+ this.unsubscribe();
+ }
+ };
+ Subscriber.prototype._complete = function () {
+ try {
+ this.destination.complete();
+ }
+ finally {
+ this.unsubscribe();
+ }
+ };
+ return Subscriber;
+ }(Subscription));
+ var _bind = Function.prototype.bind;
+ function bind(fn, thisArg) {
+ return _bind.call(fn, thisArg);
+ }
+ var ConsumerObserver = (function () {
+ function ConsumerObserver(partialObserver) {
+ this.partialObserver = partialObserver;
+ }
+ ConsumerObserver.prototype.next = function (value) {
+ var partialObserver = this.partialObserver;
+ if (partialObserver.next) {
+ try {
+ partialObserver.next(value);
+ }
+ catch (error) {
+ handleUnhandledError(error);
+ }
+ }
+ };
+ ConsumerObserver.prototype.error = function (err) {
+ var partialObserver = this.partialObserver;
+ if (partialObserver.error) {
+ try {
+ partialObserver.error(err);
+ }
+ catch (error) {
+ handleUnhandledError(error);
+ }
+ }
+ else {
+ handleUnhandledError(err);
+ }
+ };
+ ConsumerObserver.prototype.complete = function () {
+ var partialObserver = this.partialObserver;
+ if (partialObserver.complete) {
+ try {
+ partialObserver.complete();
+ }
+ catch (error) {
+ handleUnhandledError(error);
+ }
+ }
+ };
+ return ConsumerObserver;
+ }());
+ var SafeSubscriber = (function (_super) {
+ __extends(SafeSubscriber, _super);
+ function SafeSubscriber(observerOrNext, error, complete) {
+ var _this = _super.call(this) || this;
+ var partialObserver;
+ if (isFunction(observerOrNext) || !observerOrNext) {
+ partialObserver = {
+ next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
+ error: error !== null && error !== void 0 ? error : undefined,
+ complete: complete !== null && complete !== void 0 ? complete : undefined,
+ };
+ }
+ else {
+ var context_1;
+ if (_this && config.useDeprecatedNextContext) {
+ context_1 = Object.create(observerOrNext);
+ context_1.unsubscribe = function () { return _this.unsubscribe(); };
+ partialObserver = {
+ next: observerOrNext.next && bind(observerOrNext.next, context_1),
+ error: observerOrNext.error && bind(observerOrNext.error, context_1),
+ complete: observerOrNext.complete && bind(observerOrNext.complete, context_1),
+ };
+ }
+ else {
+ partialObserver = observerOrNext;
+ }
+ }
+ _this.destination = new ConsumerObserver(partialObserver);
+ return _this;
+ }
+ return SafeSubscriber;
+ }(Subscriber));
+ function handleUnhandledError(error) {
+ 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,
+ };
+
+ var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
+
+ function identity(x) {
+ return x;
+ }
+
+ 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);
+ };
+ }
+
+ var Observable = (function () {
+ function Observable(subscribe) {
+ if (subscribe) {
+ this._subscribe = subscribe;
+ }
+ }
+ Observable.prototype.lift = function (operator) {
+ var observable$$1 = new Observable();
+ observable$$1.source = this;
+ observable$$1.operator = operator;
+ return observable$$1;
+ };
+ Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+ var _this = this;
+ var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+ errorContext(function () {
+ var _a = _this, operator = _a.operator, source = _a.source;
+ subscriber.add(operator
+ ?
+ operator.call(subscriber, source)
+ : source
+ ?
+ _this._subscribe(subscriber)
+ :
+ _this._trySubscribe(subscriber));
+ });
+ return subscriber;
+ };
+ Observable.prototype._trySubscribe = function (sink) {
+ try {
+ return this._subscribe(sink);
+ }
+ catch (err) {
+ sink.error(err);
+ }
+ };
+ Observable.prototype.forEach = function (next, promiseCtor) {
+ var _this = this;
+ promiseCtor = getPromiseCtor(promiseCtor);
+ return new promiseCtor(function (resolve, reject) {
+ var subscriber = new SafeSubscriber({
+ next: function (value) {
+ try {
+ next(value);
+ }
+ catch (err) {
+ reject(err);
+ subscriber.unsubscribe();
+ }
+ },
+ error: reject,
+ complete: resolve,
+ });
+ _this.subscribe(subscriber);
+ });
+ };
+ Observable.prototype._subscribe = function (subscriber) {
+ var _a;
+ return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+ };
+ Observable.prototype[observable] = function () {
+ return this;
+ };
+ Observable.prototype.pipe = function () {
+ var operations = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ operations[_i] = arguments[_i];
+ }
+ return pipeFromArray(operations)(this);
+ };
+ Observable.prototype.toPromise = function (promiseCtor) {
+ var _this = this;
+ promiseCtor = getPromiseCtor(promiseCtor);
+ return new promiseCtor(function (resolve, reject) {
+ var value;
+ _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
+ });
+ };
+ Observable.create = function (subscribe) {
+ return new Observable(subscribe);
+ };
+ return Observable;
+ }());
+ function getPromiseCtor(promiseCtor) {
+ var _a;
+ return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+ }
+ function isObserver(value) {
+ return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+ }
+ function isSubscriber(value) {
+ return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+ }
+
+ function hasLift(source) {
+ return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+ }
+ function operate(init) {
+ return function (source) {
+ if (hasLift(source)) {
+ return source.lift(function (liftedSource) {
+ try {
+ return init(liftedSource, this);
+ }
+ catch (err) {
+ this.error(err);
+ }
+ });
+ }
+ throw new TypeError('Unable to lift unknown Observable type');
+ };
+ }
+
+ function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+ return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+ }
+ var OperatorSubscriber = (function (_super) {
+ __extends(OperatorSubscriber, _super);
+ function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+ var _this = _super.call(this, destination) || this;
+ _this.onFinalize = onFinalize;
+ _this.shouldUnsubscribe = shouldUnsubscribe;
+ _this._next = onNext
+ ? function (value) {
+ try {
+ onNext(value);
+ }
+ catch (err) {
+ destination.error(err);
+ }
+ }
+ : _super.prototype._next;
+ _this._error = onError
+ ? function (err) {
+ try {
+ onError(err);
+ }
+ catch (err) {
+ destination.error(err);
+ }
+ finally {
+ this.unsubscribe();
+ }
+ }
+ : _super.prototype._error;
+ _this._complete = onComplete
+ ? function () {
+ try {
+ onComplete();
+ }
+ catch (err) {
+ destination.error(err);
+ }
+ finally {
+ this.unsubscribe();
+ }
+ }
+ : _super.prototype._complete;
+ return _this;
+ }
+ OperatorSubscriber.prototype.unsubscribe = function () {
+ var _a;
+ if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+ var closed_1 = this.closed;
+ _super.prototype.unsubscribe.call(this);
+ !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+ }
+ };
+ return OperatorSubscriber;
+ }(Subscriber));
+
+ function refCount() {
+ return operate(function (source, subscriber) {
+ var connection = null;
+ source._refCount++;
+ var refCounter = createOperatorSubscriber(subscriber, undefined, undefined, undefined, function () {
+ if (!source || source._refCount <= 0 || 0 < --source._refCount) {
+ connection = null;
+ return;
+ }
+ var sharedConnection = source._connection;
+ var conn = connection;
+ connection = null;
+ if (sharedConnection && (!conn || sharedConnection === conn)) {
+ sharedConnection.unsubscribe();
+ }
+ subscriber.unsubscribe();
+ });
+ source.subscribe(refCounter);
+ if (!refCounter.closed) {
+ connection = source.connect();
+ }
+ });
+ }
+
+ var ConnectableObservable = (function (_super) {
+ __extends(ConnectableObservable, _super);
+ function ConnectableObservable(source, subjectFactory) {
+ var _this = _super.call(this) || this;
+ _this.source = source;
+ _this.subjectFactory = subjectFactory;
+ _this._subject = null;
+ _this._refCount = 0;
+ _this._connection = null;
+ if (hasLift(source)) {
+ _this.lift = source.lift;
+ }
+ return _this;
+ }
+ ConnectableObservable.prototype._subscribe = function (subscriber) {
+ return this.getSubject().subscribe(subscriber);
+ };
+ ConnectableObservable.prototype.getSubject = function () {
+ var subject = this._subject;
+ if (!subject || subject.isStopped) {
+ this._subject = this.subjectFactory();
+ }
+ return this._subject;
+ };
+ ConnectableObservable.prototype._teardown = function () {
+ this._refCount = 0;
+ var _connection = this._connection;
+ this._subject = this._connection = null;
+ _connection === null || _connection === void 0 ? void 0 : _connection.unsubscribe();
+ };
+ ConnectableObservable.prototype.connect = function () {
+ var _this = this;
+ var connection = this._connection;
+ if (!connection) {
+ connection = this._connection = new Subscription();
+ var subject_1 = this.getSubject();
+ connection.add(this.source.subscribe(createOperatorSubscriber(subject_1, undefined, function () {
+ _this._teardown();
+ subject_1.complete();
+ }, function (err) {
+ _this._teardown();
+ subject_1.error(err);
+ }, function () { return _this._teardown(); })));
+ if (connection.closed) {
+ this._connection = null;
+ connection = Subscription.EMPTY;
+ }
+ }
+ return connection;
+ };
+ ConnectableObservable.prototype.refCount = function () {
+ return refCount()(this);
+ };
+ return ConnectableObservable;
+ }(Observable));
+
+ var performanceTimestampProvider = {
+ now: function () {
+ return (performanceTimestampProvider.delegate || performance).now();
+ },
+ delegate: undefined,
+ };
+
+ var animationFrameProvider = {
+ schedule: function (callback) {
+ var request = requestAnimationFrame;
+ var cancel = cancelAnimationFrame;
+ var delegate = animationFrameProvider.delegate;
+ if (delegate) {
+ request = delegate.requestAnimationFrame;
+ cancel = delegate.cancelAnimationFrame;
+ }
+ var handle = request(function (timestamp) {
+ cancel = undefined;
+ callback(timestamp);
+ });
+ return new Subscription(function () { return cancel === null || cancel === void 0 ? void 0 : cancel(handle); });
+ },
+ requestAnimationFrame: function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var delegate = animationFrameProvider.delegate;
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.requestAnimationFrame) || requestAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
+ },
+ cancelAnimationFrame: function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var delegate = animationFrameProvider.delegate;
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.cancelAnimationFrame) || cancelAnimationFrame).apply(void 0, __spreadArray([], __read(args)));
+ },
+ delegate: undefined,
+ };
+
+ function animationFrames(timestampProvider) {
+ return timestampProvider ? animationFramesFactory(timestampProvider) : DEFAULT_ANIMATION_FRAMES;
+ }
+ function animationFramesFactory(timestampProvider) {
+ return new Observable(function (subscriber) {
+ var provider = timestampProvider || performanceTimestampProvider;
+ var start = provider.now();
+ var id = 0;
+ var run = function () {
+ if (!subscriber.closed) {
+ id = animationFrameProvider.requestAnimationFrame(function (timestamp) {
+ id = 0;
+ var now = provider.now();
+ subscriber.next({
+ timestamp: timestampProvider ? now : timestamp,
+ elapsed: now - start,
+ });
+ run();
+ });
+ }
+ };
+ run();
+ return function () {
+ if (id) {
+ animationFrameProvider.cancelAnimationFrame(id);
+ }
+ };
+ });
+ }
+ var DEFAULT_ANIMATION_FRAMES = animationFramesFactory();
+
+ var ObjectUnsubscribedError = createErrorClass(function (_super) {
+ return function ObjectUnsubscribedErrorImpl() {
+ _super(this);
+ this.name = 'ObjectUnsubscribedError';
+ this.message = 'object unsubscribed';
+ };
+ });
+
+ var Subject = (function (_super) {
+ __extends(Subject, _super);
+ function Subject() {
+ var _this = _super.call(this) || this;
+ _this.closed = false;
+ _this.currentObservers = null;
+ _this.observers = [];
+ _this.isStopped = false;
+ _this.hasError = false;
+ _this.thrownError = null;
+ return _this;
+ }
+ Subject.prototype.lift = function (operator) {
+ var subject = new AnonymousSubject(this, this);
+ subject.operator = operator;
+ return subject;
+ };
+ Subject.prototype._throwIfClosed = function () {
+ if (this.closed) {
+ throw new ObjectUnsubscribedError();
+ }
+ };
+ Subject.prototype.next = function (value) {
+ var _this = this;
+ errorContext(function () {
+ var e_1, _a;
+ _this._throwIfClosed();
+ if (!_this.isStopped) {
+ if (!_this.currentObservers) {
+ _this.currentObservers = Array.from(_this.observers);
+ }
+ try {
+ for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+ var observer = _c.value;
+ observer.next(value);
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ }
+ });
+ };
+ Subject.prototype.error = function (err) {
+ var _this = this;
+ errorContext(function () {
+ _this._throwIfClosed();
+ if (!_this.isStopped) {
+ _this.hasError = _this.isStopped = true;
+ _this.thrownError = err;
+ var observers = _this.observers;
+ while (observers.length) {
+ observers.shift().error(err);
+ }
+ }
+ });
+ };
+ Subject.prototype.complete = function () {
+ var _this = this;
+ errorContext(function () {
+ _this._throwIfClosed();
+ if (!_this.isStopped) {
+ _this.isStopped = true;
+ var observers = _this.observers;
+ while (observers.length) {
+ observers.shift().complete();
+ }
+ }
+ });
+ };
+ Subject.prototype.unsubscribe = function () {
+ this.isStopped = this.closed = true;
+ this.observers = this.currentObservers = null;
+ };
+ Object.defineProperty(Subject.prototype, "observed", {
+ get: function () {
+ var _a;
+ return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Subject.prototype._trySubscribe = function (subscriber) {
+ this._throwIfClosed();
+ return _super.prototype._trySubscribe.call(this, subscriber);
+ };
+ Subject.prototype._subscribe = function (subscriber) {
+ this._throwIfClosed();
+ this._checkFinalizedStatuses(subscriber);
+ return this._innerSubscribe(subscriber);
+ };
+ Subject.prototype._innerSubscribe = function (subscriber) {
+ var _this = this;
+ var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+ if (hasError || isStopped) {
+ return EMPTY_SUBSCRIPTION;
+ }
+ this.currentObservers = null;
+ observers.push(subscriber);
+ return new Subscription(function () {
+ _this.currentObservers = null;
+ arrRemove(observers, subscriber);
+ });
+ };
+ Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+ var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+ if (hasError) {
+ subscriber.error(thrownError);
+ }
+ else if (isStopped) {
+ subscriber.complete();
+ }
+ };
+ Subject.prototype.asObservable = function () {
+ var observable = new Observable();
+ observable.source = this;
+ return observable;
+ };
+ Subject.create = function (destination, source) {
+ return new AnonymousSubject(destination, source);
+ };
+ return Subject;
+ }(Observable));
+ var AnonymousSubject = (function (_super) {
+ __extends(AnonymousSubject, _super);
+ function AnonymousSubject(destination, source) {
+ var _this = _super.call(this) || this;
+ _this.destination = destination;
+ _this.source = source;
+ return _this;
+ }
+ AnonymousSubject.prototype.next = function (value) {
+ var _a, _b;
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+ };
+ AnonymousSubject.prototype.error = function (err) {
+ var _a, _b;
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+ };
+ AnonymousSubject.prototype.complete = function () {
+ var _a, _b;
+ (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+ };
+ AnonymousSubject.prototype._subscribe = function (subscriber) {
+ var _a, _b;
+ return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+ };
+ return AnonymousSubject;
+ }(Subject));
+
+ var BehaviorSubject = (function (_super) {
+ __extends(BehaviorSubject, _super);
+ function BehaviorSubject(_value) {
+ var _this = _super.call(this) || this;
+ _this._value = _value;
+ return _this;
+ }
+ Object.defineProperty(BehaviorSubject.prototype, "value", {
+ get: function () {
+ return this.getValue();
+ },
+ enumerable: false,
+ configurable: true
+ });
+ BehaviorSubject.prototype._subscribe = function (subscriber) {
+ var subscription = _super.prototype._subscribe.call(this, subscriber);
+ !subscription.closed && subscriber.next(this._value);
+ return subscription;
+ };
+ BehaviorSubject.prototype.getValue = function () {
+ var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
+ if (hasError) {
+ throw thrownError;
+ }
+ this._throwIfClosed();
+ return _value;
+ };
+ BehaviorSubject.prototype.next = function (value) {
+ _super.prototype.next.call(this, (this._value = value));
+ };
+ return BehaviorSubject;
+ }(Subject));
+
+ var dateTimestampProvider = {
+ now: function () {
+ return (dateTimestampProvider.delegate || Date).now();
+ },
+ delegate: undefined,
+ };
+
+ var ReplaySubject = (function (_super) {
+ __extends(ReplaySubject, _super);
+ function ReplaySubject(_bufferSize, _windowTime, _timestampProvider) {
+ if (_bufferSize === void 0) { _bufferSize = Infinity; }
+ if (_windowTime === void 0) { _windowTime = Infinity; }
+ if (_timestampProvider === void 0) { _timestampProvider = dateTimestampProvider; }
+ var _this = _super.call(this) || this;
+ _this._bufferSize = _bufferSize;
+ _this._windowTime = _windowTime;
+ _this._timestampProvider = _timestampProvider;
+ _this._buffer = [];
+ _this._infiniteTimeWindow = true;
+ _this._infiniteTimeWindow = _windowTime === Infinity;
+ _this._bufferSize = Math.max(1, _bufferSize);
+ _this._windowTime = Math.max(1, _windowTime);
+ return _this;
+ }
+ ReplaySubject.prototype.next = function (value) {
+ var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime;
+ if (!isStopped) {
+ _buffer.push(value);
+ !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+ }
+ this._trimBuffer();
+ _super.prototype.next.call(this, value);
+ };
+ ReplaySubject.prototype._subscribe = function (subscriber) {
+ this._throwIfClosed();
+ this._trimBuffer();
+ var subscription = this._innerSubscribe(subscriber);
+ var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer;
+ var copy = _buffer.slice();
+ for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+ subscriber.next(copy[i]);
+ }
+ this._checkFinalizedStatuses(subscriber);
+ return subscription;
+ };
+ ReplaySubject.prototype._trimBuffer = function () {
+ var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow;
+ var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+ _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+ if (!_infiniteTimeWindow) {
+ var now = _timestampProvider.now();
+ var last = 0;
+ for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
+ last = i;
+ }
+ last && _buffer.splice(0, last + 1);
+ }
+ };
+ return ReplaySubject;
+ }(Subject));
+
+ var AsyncSubject = (function (_super) {
+ __extends(AsyncSubject, _super);
+ function AsyncSubject() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this._value = null;
+ _this._hasValue = false;
+ _this._isComplete = false;
+ return _this;
+ }
+ AsyncSubject.prototype._checkFinalizedStatuses = function (subscriber) {
+ var _a = this, hasError = _a.hasError, _hasValue = _a._hasValue, _value = _a._value, thrownError = _a.thrownError, isStopped = _a.isStopped, _isComplete = _a._isComplete;
+ if (hasError) {
+ subscriber.error(thrownError);
+ }
+ else if (isStopped || _isComplete) {
+ _hasValue && subscriber.next(_value);
+ subscriber.complete();
+ }
+ };
+ AsyncSubject.prototype.next = function (value) {
+ if (!this.isStopped) {
+ this._value = value;
+ this._hasValue = true;
+ }
+ };
+ AsyncSubject.prototype.complete = function () {
+ var _a = this, _hasValue = _a._hasValue, _value = _a._value, _isComplete = _a._isComplete;
+ if (!_isComplete) {
+ this._isComplete = true;
+ _hasValue && _super.prototype.next.call(this, _value);
+ _super.prototype.complete.call(this);
+ }
+ };
+ return AsyncSubject;
+ }(Subject));
+
+ var Action = (function (_super) {
+ __extends(Action, _super);
+ function Action(scheduler, work) {
+ return _super.call(this) || this;
+ }
+ Action.prototype.schedule = function (state, delay) {
+ if (delay === void 0) { delay = 0; }
+ return this;
+ };
+ return Action;
+ }(Subscription));
+
+ var intervalProvider = {
+ setInterval: function (handler, timeout) {
+ var args = [];
+ for (var _i = 2; _i < arguments.length; _i++) {
+ args[_i - 2] = arguments[_i];
+ }
+ var delegate = intervalProvider.delegate;
+ if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
+ return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+ }
+ return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+ },
+ clearInterval: function (handle) {
+ var delegate = intervalProvider.delegate;
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
+ },
+ delegate: undefined,
+ };
+
+ var AsyncAction = (function (_super) {
+ __extends(AsyncAction, _super);
+ function AsyncAction(scheduler, work) {
+ var _this = _super.call(this, scheduler, work) || this;
+ _this.scheduler = scheduler;
+ _this.work = work;
+ _this.pending = false;
+ return _this;
+ }
+ AsyncAction.prototype.schedule = function (state, delay) {
+ var _a;
+ if (delay === void 0) { delay = 0; }
+ if (this.closed) {
+ return this;
+ }
+ this.state = state;
+ var id = this.id;
+ var scheduler = this.scheduler;
+ if (id != null) {
+ this.id = this.recycleAsyncId(scheduler, id, delay);
+ }
+ this.pending = true;
+ this.delay = delay;
+ this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
+ return this;
+ };
+ AsyncAction.prototype.requestAsyncId = function (scheduler, _id, delay) {
+ if (delay === void 0) { delay = 0; }
+ return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+ };
+ AsyncAction.prototype.recycleAsyncId = function (_scheduler, id, delay) {
+ if (delay === void 0) { delay = 0; }
+ if (delay != null && this.delay === delay && this.pending === false) {
+ return id;
+ }
+ if (id != null) {
+ intervalProvider.clearInterval(id);
+ }
+ return undefined;
+ };
+ AsyncAction.prototype.execute = function (state, delay) {
+ if (this.closed) {
+ return new Error('executing a cancelled action');
+ }
+ this.pending = false;
+ var error = this._execute(state, delay);
+ if (error) {
+ return error;
+ }
+ else if (this.pending === false && this.id != null) {
+ this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+ }
+ };
+ AsyncAction.prototype._execute = function (state, _delay) {
+ var errored = false;
+ var errorValue;
+ try {
+ this.work(state);
+ }
+ catch (e) {
+ errored = true;
+ errorValue = e ? e : new Error('Scheduled action threw falsy error');
+ }
+ if (errored) {
+ this.unsubscribe();
+ return errorValue;
+ }
+ };
+ AsyncAction.prototype.unsubscribe = function () {
+ if (!this.closed) {
+ var _a = this, id = _a.id, scheduler = _a.scheduler;
+ var actions = scheduler.actions;
+ this.work = this.state = this.scheduler = null;
+ this.pending = false;
+ arrRemove(actions, this);
+ if (id != null) {
+ this.id = this.recycleAsyncId(scheduler, id, null);
+ }
+ this.delay = null;
+ _super.prototype.unsubscribe.call(this);
+ }
+ };
+ return AsyncAction;
+ }(Action));
+
+ var nextHandle = 1;
+ var resolved;
+ var activeHandles = {};
+ function findAndClearHandle(handle) {
+ if (handle in activeHandles) {
+ delete activeHandles[handle];
+ return true;
+ }
+ return false;
+ }
+ var Immediate = {
+ setImmediate: function (cb) {
+ var handle = nextHandle++;
+ activeHandles[handle] = true;
+ if (!resolved) {
+ resolved = Promise.resolve();
+ }
+ resolved.then(function () { return findAndClearHandle(handle) && cb(); });
+ return handle;
+ },
+ clearImmediate: function (handle) {
+ findAndClearHandle(handle);
+ },
+ };
+
+ var setImmediate = Immediate.setImmediate, clearImmediate = Immediate.clearImmediate;
+ var immediateProvider = {
+ setImmediate: function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var delegate = immediateProvider.delegate;
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.setImmediate) || setImmediate).apply(void 0, __spreadArray([], __read(args)));
+ },
+ clearImmediate: function (handle) {
+ var delegate = immediateProvider.delegate;
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearImmediate) || clearImmediate)(handle);
+ },
+ delegate: undefined,
+ };
+
+ var AsapAction = (function (_super) {
+ __extends(AsapAction, _super);
+ function AsapAction(scheduler, work) {
+ var _this = _super.call(this, scheduler, work) || this;
+ _this.scheduler = scheduler;
+ _this.work = work;
+ return _this;
+ }
+ AsapAction.prototype.requestAsyncId = function (scheduler, id, delay) {
+ if (delay === void 0) { delay = 0; }
+ if (delay !== null && delay > 0) {
+ return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
+ }
+ scheduler.actions.push(this);
+ return scheduler._scheduled || (scheduler._scheduled = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, undefined)));
+ };
+ AsapAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
+ var _a;
+ if (delay === void 0) { delay = 0; }
+ if (delay != null ? delay > 0 : this.delay > 0) {
+ return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
+ }
+ var actions = scheduler.actions;
+ if (id != null && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
+ immediateProvider.clearImmediate(id);
+ if (scheduler._scheduled === id) {
+ scheduler._scheduled = undefined;
+ }
+ }
+ return undefined;
+ };
+ return AsapAction;
+ }(AsyncAction));
+
+ var Scheduler = (function () {
+ function Scheduler(schedulerActionCtor, now) {
+ if (now === void 0) { now = Scheduler.now; }
+ this.schedulerActionCtor = schedulerActionCtor;
+ this.now = now;
+ }
+ Scheduler.prototype.schedule = function (work, delay, state) {
+ if (delay === void 0) { delay = 0; }
+ return new this.schedulerActionCtor(this, work).schedule(state, delay);
+ };
+ Scheduler.now = dateTimestampProvider.now;
+ return Scheduler;
+ }());
+
+ var AsyncScheduler = (function (_super) {
+ __extends(AsyncScheduler, _super);
+ function AsyncScheduler(SchedulerAction, now) {
+ if (now === void 0) { now = Scheduler.now; }
+ var _this = _super.call(this, SchedulerAction, now) || this;
+ _this.actions = [];
+ _this._active = false;
+ return _this;
+ }
+ AsyncScheduler.prototype.flush = function (action) {
+ var actions = this.actions;
+ if (this._active) {
+ actions.push(action);
+ return;
+ }
+ var error;
+ this._active = true;
+ do {
+ if ((error = action.execute(action.state, action.delay))) {
+ break;
+ }
+ } while ((action = actions.shift()));
+ this._active = false;
+ if (error) {
+ while ((action = actions.shift())) {
+ action.unsubscribe();
+ }
+ throw error;
+ }
+ };
+ return AsyncScheduler;
+ }(Scheduler));
+
+ var AsapScheduler = (function (_super) {
+ __extends(AsapScheduler, _super);
+ function AsapScheduler() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ AsapScheduler.prototype.flush = function (action) {
+ this._active = true;
+ var flushId = this._scheduled;
+ this._scheduled = undefined;
+ var actions = this.actions;
+ var error;
+ action = action || actions.shift();
+ do {
+ if ((error = action.execute(action.state, action.delay))) {
+ break;
+ }
+ } while ((action = actions[0]) && action.id === flushId && actions.shift());
+ this._active = false;
+ if (error) {
+ while ((action = actions[0]) && action.id === flushId && actions.shift()) {
+ action.unsubscribe();
+ }
+ throw error;
+ }
+ };
+ return AsapScheduler;
+ }(AsyncScheduler));
+
+ var asapScheduler = new AsapScheduler(AsapAction);
+ var asap = asapScheduler;
+
+ var asyncScheduler = new AsyncScheduler(AsyncAction);
+ var async = asyncScheduler;
+
+ var QueueAction = (function (_super) {
+ __extends(QueueAction, _super);
+ function QueueAction(scheduler, work) {
+ var _this = _super.call(this, scheduler, work) || this;
+ _this.scheduler = scheduler;
+ _this.work = work;
+ return _this;
+ }
+ QueueAction.prototype.schedule = function (state, delay) {
+ if (delay === void 0) { delay = 0; }
+ if (delay > 0) {
+ return _super.prototype.schedule.call(this, state, delay);
+ }
+ this.delay = delay;
+ this.state = state;
+ this.scheduler.flush(this);
+ return this;
+ };
+ QueueAction.prototype.execute = function (state, delay) {
+ return delay > 0 || this.closed ? _super.prototype.execute.call(this, state, delay) : this._execute(state, delay);
+ };
+ QueueAction.prototype.requestAsyncId = function (scheduler, id, delay) {
+ if (delay === void 0) { delay = 0; }
+ if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
+ return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
+ }
+ scheduler.flush(this);
+ return 0;
+ };
+ return QueueAction;
+ }(AsyncAction));
+
+ var QueueScheduler = (function (_super) {
+ __extends(QueueScheduler, _super);
+ function QueueScheduler() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ return QueueScheduler;
+ }(AsyncScheduler));
+
+ var queueScheduler = new QueueScheduler(QueueAction);
+ var queue = queueScheduler;
+
+ var AnimationFrameAction = (function (_super) {
+ __extends(AnimationFrameAction, _super);
+ function AnimationFrameAction(scheduler, work) {
+ var _this = _super.call(this, scheduler, work) || this;
+ _this.scheduler = scheduler;
+ _this.work = work;
+ return _this;
+ }
+ AnimationFrameAction.prototype.requestAsyncId = function (scheduler, id, delay) {
+ if (delay === void 0) { delay = 0; }
+ if (delay !== null && delay > 0) {
+ return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
+ }
+ scheduler.actions.push(this);
+ return scheduler._scheduled || (scheduler._scheduled = animationFrameProvider.requestAnimationFrame(function () { return scheduler.flush(undefined); }));
+ };
+ AnimationFrameAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
+ var _a;
+ if (delay === void 0) { delay = 0; }
+ if (delay != null ? delay > 0 : this.delay > 0) {
+ return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
+ }
+ var actions = scheduler.actions;
+ if (id != null && id === scheduler._scheduled && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
+ animationFrameProvider.cancelAnimationFrame(id);
+ scheduler._scheduled = undefined;
+ }
+ return undefined;
+ };
+ return AnimationFrameAction;
+ }(AsyncAction));
+
+ var AnimationFrameScheduler = (function (_super) {
+ __extends(AnimationFrameScheduler, _super);
+ function AnimationFrameScheduler() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ AnimationFrameScheduler.prototype.flush = function (action) {
+ this._active = true;
+ var flushId;
+ if (action) {
+ flushId = action.id;
+ }
+ else {
+ flushId = this._scheduled;
+ this._scheduled = undefined;
+ }
+ var actions = this.actions;
+ var error;
+ action = action || actions.shift();
+ do {
+ if ((error = action.execute(action.state, action.delay))) {
+ break;
+ }
+ } while ((action = actions[0]) && action.id === flushId && actions.shift());
+ this._active = false;
+ if (error) {
+ while ((action = actions[0]) && action.id === flushId && actions.shift()) {
+ action.unsubscribe();
+ }
+ throw error;
+ }
+ };
+ return AnimationFrameScheduler;
+ }(AsyncScheduler));
+
+ var animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction);
+ var animationFrame = animationFrameScheduler;
+
+ var VirtualTimeScheduler = (function (_super) {
+ __extends(VirtualTimeScheduler, _super);
+ function VirtualTimeScheduler(schedulerActionCtor, maxFrames) {
+ if (schedulerActionCtor === void 0) { schedulerActionCtor = VirtualAction; }
+ if (maxFrames === void 0) { maxFrames = Infinity; }
+ var _this = _super.call(this, schedulerActionCtor, function () { return _this.frame; }) || this;
+ _this.maxFrames = maxFrames;
+ _this.frame = 0;
+ _this.index = -1;
+ return _this;
+ }
+ VirtualTimeScheduler.prototype.flush = function () {
+ var _a = this, actions = _a.actions, maxFrames = _a.maxFrames;
+ var error;
+ var action;
+ while ((action = actions[0]) && action.delay <= maxFrames) {
+ actions.shift();
+ this.frame = action.delay;
+ if ((error = action.execute(action.state, action.delay))) {
+ break;
+ }
+ }
+ if (error) {
+ while ((action = actions.shift())) {
+ action.unsubscribe();
+ }
+ throw error;
+ }
+ };
+ VirtualTimeScheduler.frameTimeFactor = 10;
+ return VirtualTimeScheduler;
+ }(AsyncScheduler));
+ var VirtualAction = (function (_super) {
+ __extends(VirtualAction, _super);
+ function VirtualAction(scheduler, work, index) {
+ if (index === void 0) { index = (scheduler.index += 1); }
+ var _this = _super.call(this, scheduler, work) || this;
+ _this.scheduler = scheduler;
+ _this.work = work;
+ _this.index = index;
+ _this.active = true;
+ _this.index = scheduler.index = index;
+ return _this;
+ }
+ VirtualAction.prototype.schedule = function (state, delay) {
+ if (delay === void 0) { delay = 0; }
+ if (Number.isFinite(delay)) {
+ if (!this.id) {
+ return _super.prototype.schedule.call(this, state, delay);
+ }
+ this.active = false;
+ var action = new VirtualAction(this.scheduler, this.work);
+ this.add(action);
+ return action.schedule(state, delay);
+ }
+ else {
+ return Subscription.EMPTY;
+ }
+ };
+ VirtualAction.prototype.requestAsyncId = function (scheduler, id, delay) {
+ if (delay === void 0) { delay = 0; }
+ this.delay = scheduler.frame + delay;
+ var actions = scheduler.actions;
+ actions.push(this);
+ actions.sort(VirtualAction.sortActions);
+ return 1;
+ };
+ VirtualAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
+ if (delay === void 0) { delay = 0; }
+ return undefined;
+ };
+ VirtualAction.prototype._execute = function (state, delay) {
+ if (this.active === true) {
+ return _super.prototype._execute.call(this, state, delay);
+ }
+ };
+ VirtualAction.sortActions = function (a, b) {
+ if (a.delay === b.delay) {
+ if (a.index === b.index) {
+ return 0;
+ }
+ else if (a.index > b.index) {
+ return 1;
+ }
+ else {
+ return -1;
+ }
+ }
+ else if (a.delay > b.delay) {
+ return 1;
+ }
+ else {
+ return -1;
+ }
+ };
+ return VirtualAction;
+ }(AsyncAction));
+
+ 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(); }); });
+ }
+
+ function isScheduler(value) {
+ return value && isFunction(value.schedule);
+ }
+
+ function last(arr) {
+ return arr[arr.length - 1];
+ }
+ function popResultSelector(args) {
+ return isFunction(last(args)) ? args.pop() : undefined;
+ }
+ function popScheduler(args) {
+ return isScheduler(last(args)) ? args.pop() : undefined;
+ }
+ function popNumber(args, defaultValue) {
+ return typeof last(args) === 'number' ? args.pop() : defaultValue;
+ }
+
+ var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
+
+ function isPromise(value) {
+ return isFunction(value === null || value === void 0 ? void 0 : value.then);
+ }
+
+ function isInteropObservable(input) {
+ return isFunction(input[observable]);
+ }
+
+ function isAsyncIterable(obj) {
+ return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+ }
+
+ 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.");
+ }
+
+ function getSymbolIterator() {
+ if (typeof Symbol !== 'function' || !Symbol.iterator) {
+ return '@@iterator';
+ }
+ return Symbol.iterator;
+ }
+ var iterator = getSymbolIterator();
+
+ function isIterable(input) {
+ return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+ }
+
+ 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:
+ 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);
+ }
+
+ 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];
+ }
+ });
+ });
+ }
+
+ function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+ if (delay === void 0) { delay = 0; }
+ if (repeat === void 0) { repeat = false; }
+ var scheduleSubscription = scheduler.schedule(function () {
+ work();
+ if (repeat) {
+ parentSubscription.add(this.schedule(null, delay));
+ }
+ else {
+ this.unsubscribe();
+ }
+ }, delay);
+ parentSubscription.add(scheduleSubscription);
+ if (!repeat) {
+ return scheduleSubscription;
+ }
+ }
+
+ function observeOn(scheduler, delay) {
+ if (delay === void 0) { delay = 0; }
+ return operate(function (source, subscriber) {
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) { return executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
+ });
+ }
+
+ function subscribeOn(scheduler, delay) {
+ if (delay === void 0) { delay = 0; }
+ return operate(function (source, subscriber) {
+ subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
+ });
+ }
+
+ function scheduleObservable(input, scheduler) {
+ return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+ }
+
+ function schedulePromise(input, scheduler) {
+ return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+ }
+
+ 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();
+ }
+ }
+ });
+ });
+ }
+
+ function scheduleIterable(input, scheduler) {
+ return new Observable(function (subscriber) {
+ var iterator$$1;
+ executeSchedule(subscriber, scheduler, function () {
+ iterator$$1 = input[iterator]();
+ executeSchedule(subscriber, scheduler, function () {
+ var _a;
+ var value;
+ var done;
+ try {
+ (_a = iterator$$1.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(iterator$$1 === null || iterator$$1 === void 0 ? void 0 : iterator$$1.return) && iterator$$1.return(); };
+ });
+ }
+
+ function scheduleAsyncIterable(input, scheduler) {
+ if (!input) {
+ throw new Error('Iterable cannot be null');
+ }
+ return new Observable(function (subscriber) {
+ executeSchedule(subscriber, scheduler, function () {
+ var iterator = input[Symbol.asyncIterator]();
+ executeSchedule(subscriber, scheduler, function () {
+ iterator.next().then(function (result) {
+ if (result.done) {
+ subscriber.complete();
+ }
+ else {
+ subscriber.next(result.value);
+ }
+ });
+ }, 0, true);
+ });
+ });
+ }
+
+ function scheduleReadableStreamLike(input, scheduler) {
+ return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+ }
+
+ 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);
+ }
+
+ function from(input, scheduler) {
+ return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+ }
+
+ function of() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var scheduler = popScheduler(args);
+ return from(args, scheduler);
+ }
+
+ 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);
+ }
+
+ (function (NotificationKind) {
+ NotificationKind["NEXT"] = "N";
+ NotificationKind["ERROR"] = "E";
+ NotificationKind["COMPLETE"] = "C";
+ })(exports.NotificationKind || (exports.NotificationKind = {}));
+ var Notification = (function () {
+ function Notification(kind, value, error) {
+ this.kind = kind;
+ this.value = value;
+ this.error = error;
+ this.hasValue = kind === 'N';
+ }
+ Notification.prototype.observe = function (observer) {
+ return observeNotification(this, observer);
+ };
+ Notification.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();
+ };
+ Notification.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);
+ };
+ Notification.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;
+ };
+ Notification.createNext = function (value) {
+ return new Notification('N', value);
+ };
+ Notification.createError = function (err) {
+ return new Notification('E', undefined, err);
+ };
+ Notification.createComplete = function () {
+ return Notification.completeNotification;
+ };
+ Notification.completeNotification = new Notification('C');
+ return Notification;
+ }());
+ 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);
+ }
+
+ function isObservable(obj) {
+ return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe)));
+ }
+
+ var EmptyError = createErrorClass(function (_super) {
+ return function EmptyErrorImpl() {
+ _super(this);
+ this.name = 'EmptyError';
+ this.message = 'no elements in sequence';
+ };
+ });
+
+ function lastValueFrom(source, config) {
+ var hasConfig = typeof config === 'object';
+ return new Promise(function (resolve, reject) {
+ var _hasValue = false;
+ var _value;
+ source.subscribe({
+ next: function (value) {
+ _value = value;
+ _hasValue = true;
+ },
+ error: reject,
+ complete: function () {
+ if (_hasValue) {
+ resolve(_value);
+ }
+ else if (hasConfig) {
+ resolve(config.defaultValue);
+ }
+ else {
+ reject(new EmptyError());
+ }
+ },
+ });
+ });
+ }
+
+ function firstValueFrom(source, config) {
+ var hasConfig = typeof config === 'object';
+ return new Promise(function (resolve, reject) {
+ var subscriber = new SafeSubscriber({
+ next: function (value) {
+ resolve(value);
+ subscriber.unsubscribe();
+ },
+ error: reject,
+ complete: function () {
+ if (hasConfig) {
+ resolve(config.defaultValue);
+ }
+ else {
+ reject(new EmptyError());
+ }
+ },
+ });
+ source.subscribe(subscriber);
+ });
+ }
+
+ var ArgumentOutOfRangeError = createErrorClass(function (_super) {
+ return function ArgumentOutOfRangeErrorImpl() {
+ _super(this);
+ this.name = 'ArgumentOutOfRangeError';
+ this.message = 'argument out of range';
+ };
+ });
+
+ var NotFoundError = createErrorClass(function (_super) {
+ return function NotFoundErrorImpl(message) {
+ _super(this);
+ this.name = 'NotFoundError';
+ this.message = message;
+ };
+ });
+
+ var SequenceError = createErrorClass(function (_super) {
+ return function SequenceErrorImpl(message) {
+ _super(this);
+ this.name = 'SequenceError';
+ this.message = message;
+ };
+ });
+
+ function isValidDate(value) {
+ return value instanceof Date && !isNaN(value);
+ }
+
+ 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(config, schedulerArg) {
+ var _a = (isValidDate(config) ? { first: config } : typeof config === 'number' ? { each: config } : config), first = _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 (first == 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 (delay) {
+ timerSubscription = executeSchedule(subscriber, scheduler, function () {
+ try {
+ originalSourceSubscription.unsubscribe();
+ innerFrom(_with({
+ meta: meta,
+ lastValue: lastValue,
+ seen: seen,
+ })).subscribe(subscriber);
+ }
+ catch (err) {
+ subscriber.error(err);
+ }
+ }, delay);
+ };
+ 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);
+ }, undefined, undefined, function () {
+ if (!(timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.closed)) {
+ timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
+ }
+ lastValue = null;
+ }));
+ !seen && startTimer(first != null ? (typeof first === 'number' ? first : +first - scheduler.now()) : each);
+ });
+ }
+ function timeoutErrorFactory(info) {
+ throw new TimeoutError(info);
+ }
+
+ 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++));
+ }));
+ });
+ }
+
+ var isArray = Array.isArray;
+ function callOrApply(fn, args) {
+ return isArray(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
+ }
+ function mapOneOrManyArgs(fn) {
+ return map(function (args) { return callOrApply(fn, args); });
+ }
+
+ function bindCallbackInternals(isNodeStyle, callbackFunc, resultSelector, scheduler) {
+ if (resultSelector) {
+ if (isScheduler(resultSelector)) {
+ scheduler = resultSelector;
+ }
+ else {
+ return function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return bindCallbackInternals(isNodeStyle, callbackFunc, scheduler)
+ .apply(this, args)
+ .pipe(mapOneOrManyArgs(resultSelector));
+ };
+ }
+ }
+ if (scheduler) {
+ return function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return bindCallbackInternals(isNodeStyle, callbackFunc)
+ .apply(this, args)
+ .pipe(subscribeOn(scheduler), observeOn(scheduler));
+ };
+ }
+ return function () {
+ var _this = this;
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var subject = new AsyncSubject();
+ var uninitialized = true;
+ return new Observable(function (subscriber) {
+ var subs = subject.subscribe(subscriber);
+ if (uninitialized) {
+ uninitialized = false;
+ var isAsync_1 = false;
+ var isComplete_1 = false;
+ callbackFunc.apply(_this, __spreadArray(__spreadArray([], __read(args)), [
+ function () {
+ var results = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ results[_i] = arguments[_i];
+ }
+ if (isNodeStyle) {
+ var err = results.shift();
+ if (err != null) {
+ subject.error(err);
+ return;
+ }
+ }
+ subject.next(1 < results.length ? results : results[0]);
+ isComplete_1 = true;
+ if (isAsync_1) {
+ subject.complete();
+ }
+ },
+ ]));
+ if (isComplete_1) {
+ subject.complete();
+ }
+ isAsync_1 = true;
+ }
+ return subs;
+ });
+ };
+ }
+
+ function bindCallback(callbackFunc, resultSelector, scheduler) {
+ return bindCallbackInternals(false, callbackFunc, resultSelector, scheduler);
+ }
+
+ function bindNodeCallback(callbackFunc, resultSelector, scheduler) {
+ return bindCallbackInternals(true, callbackFunc, resultSelector, scheduler);
+ }
+
+ var isArray$1 = Array.isArray;
+ var getPrototypeOf = Object.getPrototypeOf, objectProto = Object.prototype, getKeys = Object.keys;
+ function argsArgArrayOrObject(args) {
+ if (args.length === 1) {
+ var first_1 = args[0];
+ if (isArray$1(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: keys,
+ };
+ }
+ }
+ return { args: args, keys: null };
+ }
+ function isPOJO(obj) {
+ return obj && typeof obj === 'object' && getPrototypeOf(obj) === objectProto;
+ }
+
+ function createObject(keys, values) {
+ return keys.reduce(function (result, key, i) { return ((result[key] = values[i]), result); }, {});
+ }
+
+ 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 (i) {
+ maybeSchedule(scheduler, function () {
+ var source = from(observables[i], scheduler);
+ var hasFirstValue = false;
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+ values[i] = 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();
+ }
+ }
+
+ function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+ var buffer = [];
+ var active = 0;
+ var index = 0;
+ var isComplete = false;
+ var checkComplete = function () {
+ if (isComplete && !buffer.length && !active) {
+ subscriber.complete();
+ }
+ };
+ var outerNext = function (value) { return (active < concurrent ? doInnerSub(value) : buffer.push(value)); };
+ var doInnerSub = function (value) {
+ expand && subscriber.next(value);
+ active++;
+ var innerComplete = false;
+ innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function (innerValue) {
+ onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
+ if (expand) {
+ outerNext(innerValue);
+ }
+ else {
+ subscriber.next(innerValue);
+ }
+ }, function () {
+ innerComplete = true;
+ }, undefined, function () {
+ if (innerComplete) {
+ try {
+ active--;
+ var _loop_1 = function () {
+ var bufferedValue = buffer.shift();
+ if (innerSubScheduler) {
+ executeSchedule(subscriber, innerSubScheduler, function () { return doInnerSub(bufferedValue); });
+ }
+ else {
+ doInnerSub(bufferedValue);
+ }
+ };
+ while (buffer.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();
+ };
+ }
+
+ 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); });
+ }
+
+ function mergeAll(concurrent) {
+ if (concurrent === void 0) { concurrent = Infinity; }
+ return mergeMap(identity, concurrent);
+ }
+
+ function concatAll() {
+ return mergeAll(1);
+ }
+
+ function concat() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return concatAll()(from(args, popScheduler(args)));
+ }
+
+ function defer(observableFactory) {
+ return new Observable(function (subscriber) {
+ innerFrom(observableFactory()).subscribe(subscriber);
+ });
+ }
+
+ var DEFAULT_CONFIG = {
+ connector: function () { return new Subject(); },
+ resetOnDisconnect: true,
+ };
+ function connectable(source, config) {
+ if (config === void 0) { config = DEFAULT_CONFIG; }
+ var connection = null;
+ var connector = config.connector, _a = config.resetOnDisconnect, resetOnDisconnect = _a === void 0 ? true : _a;
+ var subject = connector();
+ var result = new Observable(function (subscriber) {
+ return subject.subscribe(subscriber);
+ });
+ result.connect = function () {
+ if (!connection || connection.closed) {
+ connection = defer(function () { return source; }).subscribe(subject);
+ if (resetOnDisconnect) {
+ connection.add(function () { return (subject = connector()); });
+ }
+ }
+ return connection;
+ };
+ return result;
+ }
+
+ function forkJoin() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var resultSelector = popResultSelector(args);
+ var _a = argsArgArrayOrObject(args), sources = _a.args, keys = _a.keys;
+ var result = new Observable(function (subscriber) {
+ var length = sources.length;
+ if (!length) {
+ subscriber.complete();
+ return;
+ }
+ var values = new Array(length);
+ var remainingCompletions = length;
+ var remainingEmissions = length;
+ var _loop_1 = function (sourceIndex) {
+ var hasValue = false;
+ innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, function (value) {
+ if (!hasValue) {
+ hasValue = true;
+ remainingEmissions--;
+ }
+ values[sourceIndex] = value;
+ }, function () { return remainingCompletions--; }, undefined, function () {
+ if (!remainingCompletions || !hasValue) {
+ if (!remainingEmissions) {
+ subscriber.next(keys ? createObject(keys, values) : values);
+ }
+ subscriber.complete();
+ }
+ }));
+ };
+ for (var sourceIndex = 0; sourceIndex < length; sourceIndex++) {
+ _loop_1(sourceIndex);
+ }
+ });
+ return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+ }
+
+ var nodeEventEmitterMethods = ['addListener', 'removeListener'];
+ var eventTargetMethods = ['addEventListener', 'removeEventListener'];
+ var jqueryMethods = ['on', 'off'];
+ function fromEvent(target, eventName, options, resultSelector) {
+ if (isFunction(options)) {
+ resultSelector = options;
+ options = undefined;
+ }
+ if (resultSelector) {
+ return fromEvent(target, eventName, options).pipe(mapOneOrManyArgs(resultSelector));
+ }
+ var _a = __read(isEventTarget(target)
+ ? eventTargetMethods.map(function (methodName) { return function (handler) { return target[methodName](eventName, handler, options); }; })
+ :
+ isNodeStyleEventEmitter(target)
+ ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName))
+ : isJQueryStyleEventEmitter(target)
+ ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName))
+ : [], 2), add = _a[0], remove = _a[1];
+ if (!add) {
+ if (isArrayLike(target)) {
+ return mergeMap(function (subTarget) { return fromEvent(subTarget, eventName, options); })(innerFrom(target));
+ }
+ }
+ if (!add) {
+ throw new TypeError('Invalid event target');
+ }
+ return new Observable(function (subscriber) {
+ var handler = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return subscriber.next(1 < args.length ? args : args[0]);
+ };
+ add(handler);
+ return function () { return remove(handler); };
+ });
+ }
+ function toCommonHandlerRegistry(target, eventName) {
+ return function (methodName) { return function (handler) { return target[methodName](eventName, handler); }; };
+ }
+ function isNodeStyleEventEmitter(target) {
+ return isFunction(target.addListener) && isFunction(target.removeListener);
+ }
+ function isJQueryStyleEventEmitter(target) {
+ return isFunction(target.on) && isFunction(target.off);
+ }
+ function isEventTarget(target) {
+ return isFunction(target.addEventListener) && isFunction(target.removeEventListener);
+ }
+
+ function fromEventPattern(addHandler, removeHandler, resultSelector) {
+ if (resultSelector) {
+ return fromEventPattern(addHandler, removeHandler).pipe(mapOneOrManyArgs(resultSelector));
+ }
+ return new Observable(function (subscriber) {
+ var handler = function () {
+ var e = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ e[_i] = arguments[_i];
+ }
+ return subscriber.next(e.length === 1 ? e[0] : e);
+ };
+ var retValue = addHandler(handler);
+ return isFunction(removeHandler) ? function () { return removeHandler(handler, retValue); } : undefined;
+ });
+ }
+
+ function generate(initialStateOrOptions, condition, iterate, resultSelectorOrScheduler, scheduler) {
+ var _a, _b;
+ var resultSelector;
+ var initialState;
+ if (arguments.length === 1) {
+ (_a = initialStateOrOptions, initialState = _a.initialState, condition = _a.condition, iterate = _a.iterate, _b = _a.resultSelector, resultSelector = _b === void 0 ? identity : _b, scheduler = _a.scheduler);
+ }
+ else {
+ initialState = initialStateOrOptions;
+ if (!resultSelectorOrScheduler || isScheduler(resultSelectorOrScheduler)) {
+ resultSelector = identity;
+ scheduler = resultSelectorOrScheduler;
+ }
+ else {
+ resultSelector = resultSelectorOrScheduler;
+ }
+ }
+ function gen() {
+ var state;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ state = initialState;
+ _a.label = 1;
+ case 1:
+ if (!(!condition || condition(state))) return [3, 4];
+ return [4, resultSelector(state)];
+ case 2:
+ _a.sent();
+ _a.label = 3;
+ case 3:
+ state = iterate(state);
+ return [3, 1];
+ case 4: return [2];
+ }
+ });
+ }
+ return defer((scheduler
+ ?
+ function () { return scheduleIterable(gen(), scheduler); }
+ :
+ gen));
+ }
+
+ function iif(condition, trueResult, falseResult) {
+ return defer(function () { return (condition() ? trueResult : falseResult); });
+ }
+
+ 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(undefined, intervalDuration);
+ }
+ else {
+ subscriber.complete();
+ }
+ }
+ }, due);
+ });
+ }
+
+ 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);
+ }
+
+ 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);
+ var sources = args;
+ return !sources.length
+ ?
+ EMPTY
+ : sources.length === 1
+ ?
+ innerFrom(sources[0])
+ :
+ mergeAll(concurrent)(from(sources, scheduler));
+ }
+
+ var NEVER = new Observable(noop);
+ function never() {
+ return NEVER;
+ }
+
+ var isArray$2 = Array.isArray;
+ function argsOrArgArray(args) {
+ return args.length === 1 && isArray$2(args[0]) ? args[0] : args;
+ }
+
+ 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, undefined, noop, noop);
+ nextSource.subscribe(innerSubscriber);
+ innerSubscriber.add(subscribeNext);
+ }
+ else {
+ subscriber.complete();
+ }
+ };
+ subscribeNext();
+ });
+ }
+
+ function pairs(obj, scheduler) {
+ return from(Object.entries(obj), scheduler);
+ }
+
+ function not(pred, thisArg) {
+ return function (value, index) { return !pred.call(thisArg, value, index); };
+ }
+
+ 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); }));
+ });
+ }
+
+ function partition(source, predicate, thisArg) {
+ return [filter(predicate, thisArg)(innerFrom(source)), filter(not(predicate, thisArg))(innerFrom(source))];
+ }
+
+ 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 (i) {
+ subscriptions.push(innerFrom(sources[i]).subscribe(createOperatorSubscriber(subscriber, function (value) {
+ if (subscriptions) {
+ for (var s = 0; s < subscriptions.length; s++) {
+ s !== i && subscriptions[s].unsubscribe();
+ }
+ subscriptions = null;
+ }
+ subscriber.next(value);
+ })));
+ };
+ for (var i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {
+ _loop_1(i);
+ }
+ };
+ }
+
+ function range(start, count, scheduler) {
+ if (count == null) {
+ count = start;
+ start = 0;
+ }
+ if (count <= 0) {
+ return EMPTY;
+ }
+ var end = count + start;
+ return new Observable(scheduler
+ ?
+ function (subscriber) {
+ var n = start;
+ return scheduler.schedule(function () {
+ if (n < end) {
+ subscriber.next(n++);
+ this.schedule();
+ }
+ else {
+ subscriber.complete();
+ }
+ });
+ }
+ :
+ function (subscriber) {
+ var n = start;
+ while (n < end && !subscriber.closed) {
+ subscriber.next(n++);
+ }
+ subscriber.complete();
+ });
+ }
+
+ function using(resourceFactory, observableFactory) {
+ return new Observable(function (subscriber) {
+ var resource = resourceFactory();
+ var result = observableFactory(resource);
+ var source = result ? innerFrom(result) : EMPTY;
+ source.subscribe(subscriber);
+ return function () {
+ if (resource) {
+ resource.unsubscribe();
+ }
+ };
+ });
+ }
+
+ 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 (sourceIndex) {
+ innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, function (value) {
+ buffers[sourceIndex].push(value);
+ if (buffers.every(function (buffer) { return buffer.length; })) {
+ var result = buffers.map(function (buffer) { return buffer.shift(); });
+ subscriber.next(resultSelector ? resultSelector.apply(void 0, __spreadArray([], __read(result))) : result);
+ if (buffers.some(function (buffer, i) { return !buffer.length && completed[i]; })) {
+ subscriber.complete();
+ }
+ }
+ }, function () {
+ completed[sourceIndex] = true;
+ !buffers[sourceIndex].length && subscriber.complete();
+ }));
+ };
+ for (var sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
+ _loop_1(sourceIndex);
+ }
+ return function () {
+ buffers = completed = null;
+ };
+ })
+ : EMPTY;
+ }
+
+ 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();
+ }));
+ });
+ }
+
+ function auditTime(duration, scheduler) {
+ if (scheduler === void 0) { scheduler = asyncScheduler; }
+ return audit(function () { return timer(duration, scheduler); });
+ }
+
+ 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;
+ };
+ });
+ }
+
+ 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 count = 0;
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+ var e_1, _a, e_2, _b;
+ var toEmit = null;
+ if (count++ % 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 buffer = buffers_1_1.value;
+ buffer.push(value);
+ if (bufferSize <= buffer.length) {
+ toEmit = toEmit !== null && toEmit !== void 0 ? toEmit : [];
+ toEmit.push(buffer);
+ }
+ }
+ }
+ 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 buffer = toEmit_1_1.value;
+ arrRemove(buffers, buffer);
+ subscriber.next(buffer);
+ }
+ }
+ 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 buffer = buffers_2_1.value;
+ subscriber.next(buffer);
+ }
+ }
+ 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();
+ }, undefined, function () {
+ buffers = null;
+ }));
+ });
+ }
+
+ 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 buffer = record.buffer, subs = record.subs;
+ subs.unsubscribe();
+ arrRemove(bufferRecords, record);
+ subscriber.next(buffer);
+ restartOnEmit && startBuffer();
+ };
+ var startBuffer = function () {
+ if (bufferRecords) {
+ var subs = new Subscription();
+ subscriber.add(subs);
+ var buffer = [];
+ var record_1 = {
+ buffer: buffer,
+ subs: 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, _a;
+ 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 buffer = record.buffer;
+ buffer.push(value);
+ maxBufferSize <= buffer.length && emit(record);
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (recordsCopy_1_1 && !recordsCopy_1_1.done && (_a = recordsCopy_1.return)) _a.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();
+ }, undefined, function () { return (bufferRecords = null); });
+ source.subscribe(bufferTimeSubscriber);
+ });
+ }
+
+ function bufferToggle(openings, closingSelector) {
+ return operate(function (source, subscriber) {
+ var buffers = [];
+ innerFrom(openings).subscribe(createOperatorSubscriber(subscriber, function (openValue) {
+ var buffer = [];
+ buffers.push(buffer);
+ var closingSubscription = new Subscription();
+ var emitBuffer = function () {
+ arrRemove(buffers, buffer);
+ subscriber.next(buffer);
+ 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 buffer = buffers_1_1.value;
+ buffer.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();
+ }));
+ });
+ }
+
+ function bufferWhen(closingSelector) {
+ return operate(function (source, subscriber) {
+ var buffer = null;
+ var closingSubscriber = null;
+ var openBuffer = function () {
+ closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
+ var b = buffer;
+ buffer = [];
+ b && subscriber.next(b);
+ innerFrom(closingSelector()).subscribe((closingSubscriber = createOperatorSubscriber(subscriber, openBuffer, noop)));
+ };
+ openBuffer();
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) { return buffer === null || buffer === void 0 ? void 0 : buffer.push(value); }, function () {
+ buffer && subscriber.next(buffer);
+ subscriber.complete();
+ }, undefined, function () { return (buffer = closingSubscriber = null); }));
+ });
+ }
+
+ function catchError(selector) {
+ return operate(function (source, subscriber) {
+ var innerSub = null;
+ var syncUnsub = false;
+ var handledResult;
+ innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, undefined, 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);
+ }
+ });
+ }
+
+ 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();
+ })));
+ };
+ }
+
+ function reduce(accumulator, seed) {
+ return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true));
+ }
+
+ var arrReducer = function (arr, value) { return (arr.push(value), arr); };
+ function toArray() {
+ return operate(function (source, subscriber) {
+ reduce(arrReducer, [])(source).subscribe(subscriber);
+ });
+ }
+
+ function joinAllInternals(joinFn, project) {
+ return pipe(toArray(), mergeMap(function (sources) { return joinFn(sources); }), project ? mapOneOrManyArgs(project) : identity);
+ }
+
+ function combineLatestAll(project) {
+ return joinAllInternals(combineLatest, project);
+ }
+
+ var combineAll = combineLatestAll;
+
+ function combineLatest$1() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var resultSelector = popResultSelector(args);
+ return resultSelector
+ ? pipe(combineLatest$1.apply(void 0, __spreadArray([], __read(args))), mapOneOrManyArgs(resultSelector))
+ : operate(function (source, subscriber) {
+ combineLatestInit(__spreadArray([source], __read(argsOrArgArray(args))))(subscriber);
+ });
+ }
+
+ function combineLatestWith() {
+ var otherSources = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ otherSources[_i] = arguments[_i];
+ }
+ return combineLatest$1.apply(void 0, __spreadArray([], __read(otherSources)));
+ }
+
+ function concatMap(project, resultSelector) {
+ return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
+ }
+
+ function concatMapTo(innerObservable, resultSelector) {
+ return isFunction(resultSelector) ? concatMap(function () { return innerObservable; }, resultSelector) : concatMap(function () { return innerObservable; });
+ }
+
+ function concat$1() {
+ 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);
+ });
+ }
+
+ function concatWith() {
+ var otherSources = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ otherSources[_i] = arguments[_i];
+ }
+ return concat$1.apply(void 0, __spreadArray([], __read(otherSources)));
+ }
+
+ function fromSubscribable(subscribable) {
+ return new Observable(function (subscriber) { return subscribable.subscribe(subscriber); });
+ }
+
+ var DEFAULT_CONFIG$1 = {
+ connector: function () { return new Subject(); },
+ };
+ function connect(selector, config) {
+ if (config === void 0) { config = DEFAULT_CONFIG$1; }
+ var connector = config.connector;
+ return operate(function (source, subscriber) {
+ var subject = connector();
+ innerFrom(selector(fromSubscribable(subject))).subscribe(subscriber);
+ subscriber.add(source.subscribe(subject));
+ });
+ }
+
+ function count(predicate) {
+ return reduce(function (total, value, i) { return (!predicate || predicate(value, i) ? total + 1 : total); }, 0);
+ }
+
+ 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();
+ }, undefined, function () {
+ lastValue = durationSubscriber = null;
+ }));
+ });
+ }
+
+ 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(undefined, 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();
+ }, undefined, function () {
+ lastValue = activeTask = null;
+ }));
+ });
+ }
+
+ 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();
+ }));
+ });
+ }
+
+ function take(count) {
+ return count <= 0
+ ?
+ function () { return EMPTY; }
+ : operate(function (source, subscriber) {
+ var seen = 0;
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+ if (++seen <= count) {
+ subscriber.next(value);
+ if (count <= seen) {
+ subscriber.complete();
+ }
+ }
+ }));
+ });
+ }
+
+ function ignoreElements() {
+ return operate(function (source, subscriber) {
+ source.subscribe(createOperatorSubscriber(subscriber, noop));
+ });
+ }
+
+ function mapTo(value) {
+ return map(function () { return value; });
+ }
+
+ 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)); });
+ }
+
+ function delay(due, scheduler) {
+ if (scheduler === void 0) { scheduler = asyncScheduler; }
+ var duration = timer(due, scheduler);
+ return delayWhen(function () { return duration; });
+ }
+
+ function dematerialize() {
+ return operate(function (source, subscriber) {
+ source.subscribe(createOperatorSubscriber(subscriber, function (notification) { return observeNotification(notification, subscriber); }));
+ });
+ }
+
+ function distinct(keySelector, flushes) {
+ return operate(function (source, subscriber) {
+ var distinctKeys = 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));
+ });
+ }
+
+ 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 first = true;
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+ var currentKey = keySelector(value);
+ if (first || !comparator(previousKey, currentKey)) {
+ first = false;
+ previousKey = currentKey;
+ subscriber.next(value);
+ }
+ }));
+ });
+ }
+ function defaultCompare(a, b) {
+ return a === b;
+ }
+
+ function distinctUntilKeyChanged(key, compare) {
+ return distinctUntilChanged(function (x, y) { return (compare ? compare(x[key], y[key]) : x[key] === y[key]); });
+ }
+
+ 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();
+ }
+
+ 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(); }));
+ };
+ }
+
+ 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)))); };
+ }
+
+ 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();
+ }));
+ });
+ }
+
+ 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, undefined, function () {
+ innerSub = null;
+ isComplete && subscriber.complete();
+ });
+ innerFrom(project(outerValue, index++)).subscribe(innerSub);
+ }
+ }, function () {
+ isComplete = true;
+ !innerSub && subscriber.complete();
+ }));
+ });
+ }
+
+ function exhaustAll() {
+ return exhaustMap(identity);
+ }
+
+ var exhaust = exhaustAll;
+
+ 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, undefined, true, scheduler);
+ });
+ }
+
+ function finalize(callback) {
+ return operate(function (source, subscriber) {
+ try {
+ source.subscribe(subscriber);
+ }
+ finally {
+ subscriber.add(callback);
+ }
+ });
+ }
+
+ function find(predicate, thisArg) {
+ return operate(createFind(predicate, thisArg, 'value'));
+ }
+ function createFind(predicate, thisArg, emit) {
+ var findIndex = 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(findIndex ? i : value);
+ subscriber.complete();
+ }
+ }, function () {
+ subscriber.next(findIndex ? -1 : undefined);
+ subscriber.complete();
+ }));
+ };
+ }
+
+ function findIndex(predicate, thisArg) {
+ return operate(createFind(predicate, thisArg, 'index'));
+ }
+
+ 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(); }));
+ };
+ }
+
+ 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 = 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();
+ }, undefined, undefined, 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;
+ }
+ });
+ }
+
+ function isEmpty() {
+ return operate(function (source, subscriber) {
+ source.subscribe(createOperatorSubscriber(subscriber, function () {
+ subscriber.next(false);
+ subscriber.complete();
+ }, function () {
+ subscriber.next(true);
+ subscriber.complete();
+ }));
+ });
+ }
+
+ function takeLast(count) {
+ return count <= 0
+ ? function () { return EMPTY; }
+ : operate(function (source, subscriber) {
+ var buffer = [];
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+ buffer.push(value);
+ count < buffer.length && buffer.shift();
+ }, function () {
+ var e_1, _a;
+ try {
+ for (var buffer_1 = __values(buffer), 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();
+ }, undefined, function () {
+ buffer = null;
+ }));
+ });
+ }
+
+ function last$1(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(); }));
+ };
+ }
+
+ 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();
+ }));
+ });
+ }
+
+ 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); });
+ }
+
+ var flatMap = mergeMap;
+
+ 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);
+ }
+
+ 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, undefined, function () { return (state = null); });
+ });
+ }
+
+ function merge$1() {
+ 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);
+ });
+ }
+
+ function mergeWith() {
+ var otherSources = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ otherSources[_i] = arguments[_i];
+ }
+ return merge$1.apply(void 0, __spreadArray([], __read(otherSources)));
+ }
+
+ 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); });
+ }
+
+ 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); };
+ }
+
+ 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 onErrorResumeNext$1 = onErrorResumeNextWith;
+
+ 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;
+ }));
+ });
+ }
+
+ 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 undefined;
+ }
+ }
+ return currentProp;
+ });
+ }
+
+ function publish(selector) {
+ return selector ? function (source) { return connect(selector)(source); } : function (source) { return multicast(new Subject())(source); };
+ }
+
+ function publishBehavior(initialValue) {
+ return function (source) {
+ var subject = new BehaviorSubject(initialValue);
+ return new ConnectableObservable(source, function () { return subject; });
+ };
+ }
+
+ function publishLast() {
+ return function (source) {
+ var subject = new AsyncSubject();
+ return new ConnectableObservable(source, function () { return subject; });
+ };
+ }
+
+ function publishReplay(bufferSize, windowTime, selectorOrScheduler, timestampProvider) {
+ if (selectorOrScheduler && !isFunction(selectorOrScheduler)) {
+ timestampProvider = selectorOrScheduler;
+ }
+ var selector = isFunction(selectorOrScheduler) ? selectorOrScheduler : undefined;
+ return function (source) { return multicast(new ReplaySubject(bufferSize, windowTime, timestampProvider), selector)(source); };
+ }
+
+ 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);
+ });
+ }
+
+ function repeat(countOrConfig) {
+ var _a;
+ var count = Infinity;
+ var delay;
+ if (countOrConfig != null) {
+ if (typeof countOrConfig === 'object') {
+ (_a = countOrConfig.count, count = _a === void 0 ? Infinity : _a, delay = countOrConfig.delay);
+ }
+ else {
+ count = countOrConfig;
+ }
+ }
+ return count <= 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 (delay != null) {
+ var notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(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, undefined, function () {
+ if (++soFar < count) {
+ if (sourceSub) {
+ resubscribe();
+ }
+ else {
+ syncUnsub = true;
+ }
+ }
+ else {
+ subscriber.complete();
+ }
+ }));
+ if (syncUnsub) {
+ resubscribe();
+ }
+ };
+ subscribeToSource();
+ });
+ }
+
+ 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, undefined, function () {
+ isMainComplete = true;
+ !checkComplete() && getCompletionSubject().next();
+ }));
+ if (syncResub) {
+ innerSub.unsubscribe();
+ innerSub = null;
+ syncResub = false;
+ subscribeForRepeatWhen();
+ }
+ };
+ subscribeForRepeatWhen();
+ });
+ }
+
+ function retry(configOrCount) {
+ if (configOrCount === void 0) { configOrCount = Infinity; }
+ var config;
+ if (configOrCount && typeof configOrCount === 'object') {
+ config = configOrCount;
+ }
+ else {
+ config = {
+ count: configOrCount,
+ };
+ }
+ var _a = config.count, count = _a === void 0 ? Infinity : _a, delay = config.delay, _b = config.resetOnSuccess, resetOnSuccess = _b === void 0 ? false : _b;
+ return count <= 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);
+ }, undefined, function (err) {
+ if (soFar++ < count) {
+ var resub_1 = function () {
+ if (innerSub) {
+ innerSub.unsubscribe();
+ innerSub = null;
+ subscribeForRetry();
+ }
+ else {
+ syncUnsub = true;
+ }
+ };
+ if (delay != null) {
+ var notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(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();
+ });
+ }
+
+ function retryWhen(notifier) {
+ return operate(function (source, subscriber) {
+ var innerSub;
+ var syncResub = false;
+ var errors$;
+ var subscribeForRetryWhen = function () {
+ innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, undefined, 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();
+ });
+ }
+
+ 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));
+ });
+ }
+
+ function sampleTime(period, scheduler) {
+ if (scheduler === void 0) { scheduler = asyncScheduler; }
+ return sample(interval(period, scheduler));
+ }
+
+ function scan(accumulator, seed) {
+ return operate(scanInternals(accumulator, seed, arguments.length >= 2, true));
+ }
+
+ 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 buffer = otherState.buffer, complete = otherState.complete;
+ if (buffer.length === 0) {
+ complete ? emit(false) : selfState.buffer.push(a);
+ }
+ else {
+ !comparator(a, buffer.shift()) && emit(false);
+ }
+ }, function () {
+ selfState.complete = true;
+ var complete = otherState.complete, buffer = otherState.buffer;
+ complete && emit(buffer.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,
+ };
+ }
+
+ 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 refCount = 0;
+ var hasCompleted = false;
+ var hasErrored = false;
+ var cancelReset = function () {
+ resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
+ resetConnection = undefined;
+ };
+ var reset = function () {
+ cancelReset();
+ connection = subject = undefined;
+ hasCompleted = hasErrored = false;
+ };
+ var resetAndUnsubscribe = function () {
+ var conn = connection;
+ reset();
+ conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
+ };
+ return operate(function (source, subscriber) {
+ refCount++;
+ if (!hasErrored && !hasCompleted) {
+ cancelReset();
+ }
+ var dest = (subject = subject !== null && subject !== void 0 ? subject : connector());
+ subscriber.add(function () {
+ refCount--;
+ if (refCount === 0 && !hasErrored && !hasCompleted) {
+ resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+ }
+ });
+ dest.subscribe(subscriber);
+ if (!connection &&
+ refCount > 0) {
+ connection = new 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);
+ }
+
+ function shareReplay(configOrBufferSize, windowTime, scheduler) {
+ var _a, _b, _c;
+ var bufferSize;
+ var refCount = false;
+ if (configOrBufferSize && typeof configOrBufferSize === 'object') {
+ (_a = configOrBufferSize.bufferSize, bufferSize = _a === void 0 ? Infinity : _a, _b = configOrBufferSize.windowTime, windowTime = _b === void 0 ? Infinity : _b, _c = configOrBufferSize.refCount, refCount = _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, windowTime, scheduler); },
+ resetOnError: true,
+ resetOnComplete: false,
+ resetOnRefCountZero: refCount,
+ });
+ }
+
+ 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());
+ }
+ }));
+ });
+ }
+
+ function skip(count) {
+ return filter(function (_, index) { return count <= index; });
+ }
+
+ 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;
+ };
+ });
+ }
+
+ 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); }));
+ });
+ }
+
+ 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); }));
+ });
+ }
+
+ 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);
+ });
+ }
+
+ 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();
+ }));
+ });
+ }
+
+ function switchAll() {
+ return switchMap(identity);
+ }
+
+ function switchMapTo(innerObservable, resultSelector) {
+ return isFunction(resultSelector) ? switchMap(function () { return innerObservable; }, resultSelector) : switchMap(function () { return innerObservable; });
+ }
+
+ 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;
+ };
+ });
+ }
+
+ function takeUntil(notifier) {
+ return operate(function (source, subscriber) {
+ innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function () { return subscriber.complete(); }, noop));
+ !subscriber.closed && source.subscribe(subscriber);
+ });
+ }
+
+ 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();
+ }));
+ });
+ }
+
+ function tap(observerOrNext, error, complete) {
+ var tapObserver = isFunction(observerOrNext) || error || complete
+ ?
+ { next: observerOrNext, error: error, complete: 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 _a;
+ (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+ subscriber.next(value);
+ }, function () {
+ var _a;
+ isUnsub = false;
+ (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+ subscriber.complete();
+ }, function (err) {
+ var _a;
+ isUnsub = false;
+ (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+ subscriber.error(err);
+ }, function () {
+ var _a, _b;
+ if (isUnsub) {
+ (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+ }
+ (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+ }));
+ })
+ :
+ identity;
+ }
+
+ function throttle(durationSelector, config) {
+ return operate(function (source, subscriber) {
+ var _a = config !== null && config !== void 0 ? config : {}, _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();
+ }));
+ });
+ }
+
+ function throttleTime(duration, scheduler, config) {
+ if (scheduler === void 0) { scheduler = asyncScheduler; }
+ var duration$ = timer(duration, scheduler);
+ return throttle(function () { return duration$; }, config);
+ }
+
+ function timeInterval(scheduler) {
+ if (scheduler === void 0) { scheduler = asyncScheduler; }
+ return operate(function (source, subscriber) {
+ var last = scheduler.now();
+ source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+ var now = scheduler.now();
+ var interval = now - last;
+ last = now;
+ subscriber.next(new TimeInterval(value, interval));
+ }));
+ });
+ }
+ var TimeInterval = (function () {
+ function TimeInterval(value, interval) {
+ this.value = value;
+ this.interval = interval;
+ }
+ return TimeInterval;
+ }());
+
+ function timeoutWith(due, withObservable, scheduler) {
+ var first;
+ var each;
+ var _with;
+ scheduler = scheduler !== null && scheduler !== void 0 ? scheduler : async;
+ if (isValidDate(due)) {
+ first = 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 (first == null && each == null) {
+ throw new TypeError('No timeout provided.');
+ }
+ return timeout({
+ first: first,
+ each: each,
+ scheduler: scheduler,
+ with: _with,
+ });
+ }
+
+ function timestamp(timestampProvider) {
+ if (timestampProvider === void 0) { timestampProvider = dateTimestampProvider; }
+ return map(function (value) { return ({ value: value, timestamp: timestampProvider.now() }); });
+ }
+
+ 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;
+ };
+ });
+ }
+
+ 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 count = 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 = count - windowSize + 1;
+ if (c >= 0 && c % startEvery === 0) {
+ windows.shift().complete();
+ }
+ if (++count % 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 () {
+ windows = null;
+ }));
+ });
+ }
+
+ 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 window = record.window, subs = record.subs;
+ window.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: 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 (_a) {
+ var window = _a.window;
+ return cb(window);
+ });
+ 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;
+ };
+ });
+ }
+
+ 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 window = new Subject();
+ windows.push(window);
+ var closingSubscription = new Subscription();
+ var closeWindow = function () {
+ arrRemove(windows, window);
+ window.complete();
+ closingSubscription.unsubscribe();
+ };
+ var closingNotifier;
+ try {
+ closingNotifier = innerFrom(closingSelector(openValue));
+ }
+ catch (err) {
+ handleError(err);
+ return;
+ }
+ subscriber.next(window.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();
+ }
+ }));
+ });
+ }
+
+ function windowWhen(closingSelector) {
+ return operate(function (source, subscriber) {
+ var window;
+ var closingSubscriber;
+ var handleError = function (err) {
+ window.error(err);
+ subscriber.error(err);
+ };
+ var openWindow = function () {
+ closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
+ window === null || window === void 0 ? void 0 : window.complete();
+ window = new Subject();
+ subscriber.next(window.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 window.next(value); }, function () {
+ window.complete();
+ subscriber.complete();
+ }, handleError, function () {
+ closingSubscriber === null || closingSubscriber === void 0 ? void 0 : closingSubscriber.unsubscribe();
+ window = null;
+ }));
+ });
+ }
+
+ 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 (i) {
+ innerFrom(inputs[i]).subscribe(createOperatorSubscriber(subscriber, function (value) {
+ otherValues[i] = value;
+ if (!ready && !hasValue[i]) {
+ hasValue[i] = 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);
+ }
+ }));
+ });
+ }
+
+ function zipAll(project) {
+ return joinAllInternals(zip, project);
+ }
+
+ function zip$1() {
+ 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);
+ });
+ }
+
+ function zipWith() {
+ var otherInputs = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ otherInputs[_i] = arguments[_i];
+ }
+ return zip$1.apply(void 0, __spreadArray([], __read(otherInputs)));
+ }
+
+ function partition$1(predicate, thisArg) {
+ return function (source) {
+ return [filter(predicate, thisArg)(source), filter(not(predicate, thisArg))(source)];
+ };
+ }
+
+ function race$1() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return raceWith.apply(void 0, __spreadArray([], __read(argsOrArgArray(args))));
+ }
+
+
+
+ var _operators = /*#__PURE__*/Object.freeze({
+ audit: audit,
+ auditTime: auditTime,
+ buffer: buffer,
+ bufferCount: bufferCount,
+ bufferTime: bufferTime,
+ bufferToggle: bufferToggle,
+ bufferWhen: bufferWhen,
+ catchError: catchError,
+ combineAll: combineAll,
+ combineLatestAll: combineLatestAll,
+ combineLatest: combineLatest$1,
+ combineLatestWith: combineLatestWith,
+ concat: concat$1,
+ concatAll: concatAll,
+ concatMap: concatMap,
+ concatMapTo: concatMapTo,
+ concatWith: concatWith,
+ connect: connect,
+ count: count,
+ debounce: debounce,
+ debounceTime: debounceTime,
+ defaultIfEmpty: defaultIfEmpty,
+ delay: delay,
+ delayWhen: delayWhen,
+ dematerialize: dematerialize,
+ distinct: distinct,
+ distinctUntilChanged: distinctUntilChanged,
+ distinctUntilKeyChanged: distinctUntilKeyChanged,
+ elementAt: elementAt,
+ endWith: endWith,
+ every: every,
+ exhaust: exhaust,
+ exhaustAll: exhaustAll,
+ exhaustMap: exhaustMap,
+ expand: expand,
+ filter: filter,
+ finalize: finalize,
+ find: find,
+ findIndex: findIndex,
+ first: first,
+ groupBy: groupBy,
+ ignoreElements: ignoreElements,
+ isEmpty: isEmpty,
+ last: last$1,
+ map: map,
+ mapTo: mapTo,
+ materialize: materialize,
+ max: max,
+ merge: merge$1,
+ mergeAll: mergeAll,
+ flatMap: flatMap,
+ mergeMap: mergeMap,
+ mergeMapTo: mergeMapTo,
+ mergeScan: mergeScan,
+ mergeWith: mergeWith,
+ min: min,
+ multicast: multicast,
+ observeOn: observeOn,
+ onErrorResumeNext: onErrorResumeNext$1,
+ pairwise: pairwise,
+ partition: partition$1,
+ pluck: pluck,
+ publish: publish,
+ publishBehavior: publishBehavior,
+ publishLast: publishLast,
+ publishReplay: publishReplay,
+ race: race$1,
+ raceWith: raceWith,
+ reduce: reduce,
+ repeat: repeat,
+ repeatWhen: repeatWhen,
+ retry: retry,
+ retryWhen: retryWhen,
+ refCount: refCount,
+ sample: sample,
+ sampleTime: sampleTime,
+ scan: scan,
+ sequenceEqual: sequenceEqual,
+ share: share,
+ shareReplay: shareReplay,
+ single: single,
+ skip: skip,
+ skipLast: skipLast,
+ skipUntil: skipUntil,
+ skipWhile: skipWhile,
+ startWith: startWith,
+ subscribeOn: subscribeOn,
+ switchAll: switchAll,
+ switchMap: switchMap,
+ switchMapTo: switchMapTo,
+ switchScan: switchScan,
+ take: take,
+ takeLast: takeLast,
+ takeUntil: takeUntil,
+ takeWhile: takeWhile,
+ tap: tap,
+ throttle: throttle,
+ throttleTime: throttleTime,
+ throwIfEmpty: throwIfEmpty,
+ timeInterval: timeInterval,
+ timeout: timeout,
+ timeoutWith: timeoutWith,
+ timestamp: timestamp,
+ toArray: toArray,
+ window: window,
+ windowCount: windowCount,
+ windowTime: windowTime,
+ windowToggle: windowToggle,
+ windowWhen: windowWhen,
+ withLatestFrom: withLatestFrom,
+ zip: zip$1,
+ zipAll: zipAll,
+ zipWith: zipWith
+ });
+
+ var SubscriptionLog = (function () {
+ function SubscriptionLog(subscribedFrame, unsubscribedFrame) {
+ if (unsubscribedFrame === void 0) { unsubscribedFrame = Infinity; }
+ this.subscribedFrame = subscribedFrame;
+ this.unsubscribedFrame = unsubscribedFrame;
+ }
+ return SubscriptionLog;
+ }());
+
+ var SubscriptionLoggable = (function () {
+ function SubscriptionLoggable() {
+ this.subscriptions = [];
+ }
+ SubscriptionLoggable.prototype.logSubscribedFrame = function () {
+ this.subscriptions.push(new SubscriptionLog(this.scheduler.now()));
+ return this.subscriptions.length - 1;
+ };
+ SubscriptionLoggable.prototype.logUnsubscribedFrame = function (index) {
+ var subscriptionLogs = this.subscriptions;
+ var oldSubscriptionLog = subscriptionLogs[index];
+ subscriptionLogs[index] = new SubscriptionLog(oldSubscriptionLog.subscribedFrame, this.scheduler.now());
+ };
+ return SubscriptionLoggable;
+ }());
+
+ function applyMixins(derivedCtor, baseCtors) {
+ for (var i = 0, len = baseCtors.length; i < len; i++) {
+ var baseCtor = baseCtors[i];
+ var propertyKeys = Object.getOwnPropertyNames(baseCtor.prototype);
+ for (var j = 0, len2 = propertyKeys.length; j < len2; j++) {
+ var name_1 = propertyKeys[j];
+ derivedCtor.prototype[name_1] = baseCtor.prototype[name_1];
+ }
+ }
+ }
+
+ var ColdObservable = (function (_super) {
+ __extends(ColdObservable, _super);
+ function ColdObservable(messages, scheduler) {
+ var _this = _super.call(this, function (subscriber) {
+ var observable = this;
+ var index = observable.logSubscribedFrame();
+ var subscription = new Subscription();
+ subscription.add(new Subscription(function () {
+ observable.logUnsubscribedFrame(index);
+ }));
+ observable.scheduleMessages(subscriber);
+ return subscription;
+ }) || this;
+ _this.messages = messages;
+ _this.subscriptions = [];
+ _this.scheduler = scheduler;
+ return _this;
+ }
+ ColdObservable.prototype.scheduleMessages = function (subscriber) {
+ var messagesLength = this.messages.length;
+ for (var i = 0; i < messagesLength; i++) {
+ var message = this.messages[i];
+ subscriber.add(this.scheduler.schedule(function (state) {
+ var _a = state, notification = _a.message.notification, destination = _a.subscriber;
+ observeNotification(notification, destination);
+ }, message.frame, { message: message, subscriber: subscriber }));
+ }
+ };
+ return ColdObservable;
+ }(Observable));
+ applyMixins(ColdObservable, [SubscriptionLoggable]);
+
+ var HotObservable = (function (_super) {
+ __extends(HotObservable, _super);
+ function HotObservable(messages, scheduler) {
+ var _this = _super.call(this) || this;
+ _this.messages = messages;
+ _this.subscriptions = [];
+ _this.scheduler = scheduler;
+ return _this;
+ }
+ HotObservable.prototype._subscribe = function (subscriber) {
+ var subject = this;
+ var index = subject.logSubscribedFrame();
+ var subscription = new Subscription();
+ subscription.add(new Subscription(function () {
+ subject.logUnsubscribedFrame(index);
+ }));
+ subscription.add(_super.prototype._subscribe.call(this, subscriber));
+ return subscription;
+ };
+ HotObservable.prototype.setup = function () {
+ var subject = this;
+ var messagesLength = subject.messages.length;
+ var _loop_1 = function (i) {
+ (function () {
+ var _a = subject.messages[i], notification = _a.notification, frame = _a.frame;
+ subject.scheduler.schedule(function () {
+ observeNotification(notification, subject);
+ }, frame);
+ })();
+ };
+ for (var i = 0; i < messagesLength; i++) {
+ _loop_1(i);
+ }
+ };
+ return HotObservable;
+ }(Subject));
+ applyMixins(HotObservable, [SubscriptionLoggable]);
+
+ var defaultMaxFrame = 750;
+ var TestScheduler = (function (_super) {
+ __extends(TestScheduler, _super);
+ function TestScheduler(assertDeepEqual) {
+ var _this = _super.call(this, VirtualAction, defaultMaxFrame) || this;
+ _this.assertDeepEqual = assertDeepEqual;
+ _this.hotObservables = [];
+ _this.coldObservables = [];
+ _this.flushTests = [];
+ _this.runMode = false;
+ return _this;
+ }
+ TestScheduler.prototype.createTime = function (marbles) {
+ var indexOf = this.runMode ? marbles.trim().indexOf('|') : marbles.indexOf('|');
+ if (indexOf === -1) {
+ throw new Error('marble diagram for time should have a completion marker "|"');
+ }
+ return indexOf * TestScheduler.frameTimeFactor;
+ };
+ TestScheduler.prototype.createColdObservable = function (marbles, values, error) {
+ if (marbles.indexOf('^') !== -1) {
+ throw new Error('cold observable cannot have subscription offset "^"');
+ }
+ if (marbles.indexOf('!') !== -1) {
+ throw new Error('cold observable cannot have unsubscription marker "!"');
+ }
+ var messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode);
+ var cold = new ColdObservable(messages, this);
+ this.coldObservables.push(cold);
+ return cold;
+ };
+ TestScheduler.prototype.createHotObservable = function (marbles, values, error) {
+ if (marbles.indexOf('!') !== -1) {
+ throw new Error('hot observable cannot have unsubscription marker "!"');
+ }
+ var messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode);
+ var subject = new HotObservable(messages, this);
+ this.hotObservables.push(subject);
+ return subject;
+ };
+ TestScheduler.prototype.materializeInnerObservable = function (observable, outerFrame) {
+ var _this = this;
+ var messages = [];
+ observable.subscribe({
+ next: function (value) {
+ messages.push({ frame: _this.frame - outerFrame, notification: nextNotification(value) });
+ },
+ error: function (error) {
+ messages.push({ frame: _this.frame - outerFrame, notification: errorNotification(error) });
+ },
+ complete: function () {
+ messages.push({ frame: _this.frame - outerFrame, notification: COMPLETE_NOTIFICATION });
+ },
+ });
+ return messages;
+ };
+ TestScheduler.prototype.expectObservable = function (observable, subscriptionMarbles) {
+ var _this = this;
+ if (subscriptionMarbles === void 0) { subscriptionMarbles = null; }
+ var actual = [];
+ var flushTest = { actual: actual, ready: false };
+ var subscriptionParsed = TestScheduler.parseMarblesAsSubscriptions(subscriptionMarbles, this.runMode);
+ var subscriptionFrame = subscriptionParsed.subscribedFrame === Infinity ? 0 : subscriptionParsed.subscribedFrame;
+ var unsubscriptionFrame = subscriptionParsed.unsubscribedFrame;
+ var subscription;
+ this.schedule(function () {
+ subscription = observable.subscribe({
+ next: function (x) {
+ var value = x instanceof Observable ? _this.materializeInnerObservable(x, _this.frame) : x;
+ actual.push({ frame: _this.frame, notification: nextNotification(value) });
+ },
+ error: function (error) {
+ actual.push({ frame: _this.frame, notification: errorNotification(error) });
+ },
+ complete: function () {
+ actual.push({ frame: _this.frame, notification: COMPLETE_NOTIFICATION });
+ },
+ });
+ }, subscriptionFrame);
+ if (unsubscriptionFrame !== Infinity) {
+ this.schedule(function () { return subscription.unsubscribe(); }, unsubscriptionFrame);
+ }
+ this.flushTests.push(flushTest);
+ var runMode = this.runMode;
+ return {
+ toBe: function (marbles, values, errorValue) {
+ flushTest.ready = true;
+ flushTest.expected = TestScheduler.parseMarbles(marbles, values, errorValue, true, runMode);
+ },
+ toEqual: function (other) {
+ flushTest.ready = true;
+ flushTest.expected = [];
+ _this.schedule(function () {
+ subscription = other.subscribe({
+ next: function (x) {
+ var value = x instanceof Observable ? _this.materializeInnerObservable(x, _this.frame) : x;
+ flushTest.expected.push({ frame: _this.frame, notification: nextNotification(value) });
+ },
+ error: function (error) {
+ flushTest.expected.push({ frame: _this.frame, notification: errorNotification(error) });
+ },
+ complete: function () {
+ flushTest.expected.push({ frame: _this.frame, notification: COMPLETE_NOTIFICATION });
+ },
+ });
+ }, subscriptionFrame);
+ },
+ };
+ };
+ TestScheduler.prototype.expectSubscriptions = function (actualSubscriptionLogs) {
+ var flushTest = { actual: actualSubscriptionLogs, ready: false };
+ this.flushTests.push(flushTest);
+ var runMode = this.runMode;
+ return {
+ toBe: function (marblesOrMarblesArray) {
+ var marblesArray = typeof marblesOrMarblesArray === 'string' ? [marblesOrMarblesArray] : marblesOrMarblesArray;
+ flushTest.ready = true;
+ flushTest.expected = marblesArray
+ .map(function (marbles) { return TestScheduler.parseMarblesAsSubscriptions(marbles, runMode); })
+ .filter(function (marbles) { return marbles.subscribedFrame !== Infinity; });
+ },
+ };
+ };
+ TestScheduler.prototype.flush = function () {
+ var _this = this;
+ var hotObservables = this.hotObservables;
+ while (hotObservables.length > 0) {
+ hotObservables.shift().setup();
+ }
+ _super.prototype.flush.call(this);
+ this.flushTests = this.flushTests.filter(function (test) {
+ if (test.ready) {
+ _this.assertDeepEqual(test.actual, test.expected);
+ return false;
+ }
+ return true;
+ });
+ };
+ TestScheduler.parseMarblesAsSubscriptions = function (marbles, runMode) {
+ var _this = this;
+ if (runMode === void 0) { runMode = false; }
+ if (typeof marbles !== 'string') {
+ return new SubscriptionLog(Infinity);
+ }
+ var characters = __spreadArray([], __read(marbles));
+ var len = characters.length;
+ var groupStart = -1;
+ var subscriptionFrame = Infinity;
+ var unsubscriptionFrame = Infinity;
+ var frame = 0;
+ var _loop_1 = function (i) {
+ var nextFrame = frame;
+ var advanceFrameBy = function (count) {
+ nextFrame += count * _this.frameTimeFactor;
+ };
+ var c = characters[i];
+ switch (c) {
+ case ' ':
+ if (!runMode) {
+ advanceFrameBy(1);
+ }
+ break;
+ case '-':
+ advanceFrameBy(1);
+ break;
+ case '(':
+ groupStart = frame;
+ advanceFrameBy(1);
+ break;
+ case ')':
+ groupStart = -1;
+ advanceFrameBy(1);
+ break;
+ case '^':
+ if (subscriptionFrame !== Infinity) {
+ throw new Error("found a second subscription point '^' in a " + 'subscription marble diagram. There can only be one.');
+ }
+ subscriptionFrame = groupStart > -1 ? groupStart : frame;
+ advanceFrameBy(1);
+ break;
+ case '!':
+ if (unsubscriptionFrame !== Infinity) {
+ throw new Error("found a second unsubscription point '!' in a " + 'subscription marble diagram. There can only be one.');
+ }
+ unsubscriptionFrame = groupStart > -1 ? groupStart : frame;
+ break;
+ default:
+ if (runMode && c.match(/^[0-9]$/)) {
+ if (i === 0 || characters[i - 1] === ' ') {
+ var buffer = characters.slice(i).join('');
+ var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
+ if (match) {
+ i += match[0].length - 1;
+ var duration = parseFloat(match[1]);
+ var unit = match[2];
+ var durationInMs = void 0;
+ switch (unit) {
+ case 'ms':
+ durationInMs = duration;
+ break;
+ case 's':
+ durationInMs = duration * 1000;
+ break;
+ case 'm':
+ durationInMs = duration * 1000 * 60;
+ break;
+ default:
+ break;
+ }
+ advanceFrameBy(durationInMs / this_1.frameTimeFactor);
+ break;
+ }
+ }
+ }
+ throw new Error("there can only be '^' and '!' markers in a " + "subscription marble diagram. Found instead '" + c + "'.");
+ }
+ frame = nextFrame;
+ out_i_1 = i;
+ };
+ var this_1 = this, out_i_1;
+ for (var i = 0; i < len; i++) {
+ _loop_1(i);
+ i = out_i_1;
+ }
+ if (unsubscriptionFrame < 0) {
+ return new SubscriptionLog(subscriptionFrame);
+ }
+ else {
+ return new SubscriptionLog(subscriptionFrame, unsubscriptionFrame);
+ }
+ };
+ TestScheduler.parseMarbles = function (marbles, values, errorValue, materializeInnerObservables, runMode) {
+ var _this = this;
+ if (materializeInnerObservables === void 0) { materializeInnerObservables = false; }
+ if (runMode === void 0) { runMode = false; }
+ if (marbles.indexOf('!') !== -1) {
+ throw new Error('conventional marble diagrams cannot have the ' + 'unsubscription marker "!"');
+ }
+ var characters = __spreadArray([], __read(marbles));
+ var len = characters.length;
+ var testMessages = [];
+ var subIndex = runMode ? marbles.replace(/^[ ]+/, '').indexOf('^') : marbles.indexOf('^');
+ var frame = subIndex === -1 ? 0 : subIndex * -this.frameTimeFactor;
+ var getValue = typeof values !== 'object'
+ ? function (x) { return x; }
+ : function (x) {
+ if (materializeInnerObservables && values[x] instanceof ColdObservable) {
+ return values[x].messages;
+ }
+ return values[x];
+ };
+ var groupStart = -1;
+ var _loop_2 = function (i) {
+ var nextFrame = frame;
+ var advanceFrameBy = function (count) {
+ nextFrame += count * _this.frameTimeFactor;
+ };
+ var notification = void 0;
+ var c = characters[i];
+ switch (c) {
+ case ' ':
+ if (!runMode) {
+ advanceFrameBy(1);
+ }
+ break;
+ case '-':
+ advanceFrameBy(1);
+ break;
+ case '(':
+ groupStart = frame;
+ advanceFrameBy(1);
+ break;
+ case ')':
+ groupStart = -1;
+ advanceFrameBy(1);
+ break;
+ case '|':
+ notification = COMPLETE_NOTIFICATION;
+ advanceFrameBy(1);
+ break;
+ case '^':
+ advanceFrameBy(1);
+ break;
+ case '#':
+ notification = errorNotification(errorValue || 'error');
+ advanceFrameBy(1);
+ break;
+ default:
+ if (runMode && c.match(/^[0-9]$/)) {
+ if (i === 0 || characters[i - 1] === ' ') {
+ var buffer = characters.slice(i).join('');
+ var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
+ if (match) {
+ i += match[0].length - 1;
+ var duration = parseFloat(match[1]);
+ var unit = match[2];
+ var durationInMs = void 0;
+ switch (unit) {
+ case 'ms':
+ durationInMs = duration;
+ break;
+ case 's':
+ durationInMs = duration * 1000;
+ break;
+ case 'm':
+ durationInMs = duration * 1000 * 60;
+ break;
+ default:
+ break;
+ }
+ advanceFrameBy(durationInMs / this_2.frameTimeFactor);
+ break;
+ }
+ }
+ }
+ notification = nextNotification(getValue(c));
+ advanceFrameBy(1);
+ break;
+ }
+ if (notification) {
+ testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification: notification });
+ }
+ frame = nextFrame;
+ out_i_2 = i;
+ };
+ var this_2 = this, out_i_2;
+ for (var i = 0; i < len; i++) {
+ _loop_2(i);
+ i = out_i_2;
+ }
+ return testMessages;
+ };
+ TestScheduler.prototype.createAnimator = function () {
+ var _this = this;
+ if (!this.runMode) {
+ throw new Error('animate() must only be used in run mode');
+ }
+ var lastHandle = 0;
+ var map;
+ var delegate = {
+ requestAnimationFrame: function (callback) {
+ if (!map) {
+ throw new Error('animate() was not called within run()');
+ }
+ var handle = ++lastHandle;
+ map.set(handle, callback);
+ return handle;
+ },
+ cancelAnimationFrame: function (handle) {
+ if (!map) {
+ throw new Error('animate() was not called within run()');
+ }
+ map.delete(handle);
+ },
+ };
+ var animate = function (marbles) {
+ var e_1, _a;
+ if (map) {
+ throw new Error('animate() must not be called more than once within run()');
+ }
+ if (/[|#]/.test(marbles)) {
+ throw new Error('animate() must not complete or error');
+ }
+ map = new Map();
+ var messages = TestScheduler.parseMarbles(marbles, undefined, undefined, undefined, true);
+ try {
+ for (var messages_1 = __values(messages), messages_1_1 = messages_1.next(); !messages_1_1.done; messages_1_1 = messages_1.next()) {
+ var message = messages_1_1.value;
+ _this.schedule(function () {
+ var e_2, _a;
+ var now = _this.now();
+ var callbacks = Array.from(map.values());
+ map.clear();
+ try {
+ for (var callbacks_1 = (e_2 = void 0, __values(callbacks)), callbacks_1_1 = callbacks_1.next(); !callbacks_1_1.done; callbacks_1_1 = callbacks_1.next()) {
+ var callback = callbacks_1_1.value;
+ callback(now);
+ }
+ }
+ catch (e_2_1) { e_2 = { error: e_2_1 }; }
+ finally {
+ try {
+ if (callbacks_1_1 && !callbacks_1_1.done && (_a = callbacks_1.return)) _a.call(callbacks_1);
+ }
+ finally { if (e_2) throw e_2.error; }
+ }
+ }, message.frame);
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return)) _a.call(messages_1);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ };
+ return { animate: animate, delegate: delegate };
+ };
+ TestScheduler.prototype.createDelegates = function () {
+ var _this = this;
+ var lastHandle = 0;
+ var scheduleLookup = new Map();
+ var run = function () {
+ var now = _this.now();
+ var scheduledRecords = Array.from(scheduleLookup.values());
+ var scheduledRecordsDue = scheduledRecords.filter(function (_a) {
+ var due = _a.due;
+ return due <= now;
+ });
+ var dueImmediates = scheduledRecordsDue.filter(function (_a) {
+ var type = _a.type;
+ return type === 'immediate';
+ });
+ if (dueImmediates.length > 0) {
+ var _a = dueImmediates[0], handle = _a.handle, handler = _a.handler;
+ scheduleLookup.delete(handle);
+ handler();
+ return;
+ }
+ var dueIntervals = scheduledRecordsDue.filter(function (_a) {
+ var type = _a.type;
+ return type === 'interval';
+ });
+ if (dueIntervals.length > 0) {
+ var firstDueInterval = dueIntervals[0];
+ var duration = firstDueInterval.duration, handler = firstDueInterval.handler;
+ firstDueInterval.due = now + duration;
+ firstDueInterval.subscription = _this.schedule(run, duration);
+ handler();
+ return;
+ }
+ var dueTimeouts = scheduledRecordsDue.filter(function (_a) {
+ var type = _a.type;
+ return type === 'timeout';
+ });
+ if (dueTimeouts.length > 0) {
+ var _b = dueTimeouts[0], handle = _b.handle, handler = _b.handler;
+ scheduleLookup.delete(handle);
+ handler();
+ return;
+ }
+ throw new Error('Expected a due immediate or interval');
+ };
+ var immediate = {
+ setImmediate: function (handler) {
+ var handle = ++lastHandle;
+ scheduleLookup.set(handle, {
+ due: _this.now(),
+ duration: 0,
+ handle: handle,
+ handler: handler,
+ subscription: _this.schedule(run, 0),
+ type: 'immediate',
+ });
+ return handle;
+ },
+ clearImmediate: function (handle) {
+ var value = scheduleLookup.get(handle);
+ if (value) {
+ value.subscription.unsubscribe();
+ scheduleLookup.delete(handle);
+ }
+ },
+ };
+ var interval = {
+ setInterval: function (handler, duration) {
+ if (duration === void 0) { duration = 0; }
+ var handle = ++lastHandle;
+ scheduleLookup.set(handle, {
+ due: _this.now() + duration,
+ duration: duration,
+ handle: handle,
+ handler: handler,
+ subscription: _this.schedule(run, duration),
+ type: 'interval',
+ });
+ return handle;
+ },
+ clearInterval: function (handle) {
+ var value = scheduleLookup.get(handle);
+ if (value) {
+ value.subscription.unsubscribe();
+ scheduleLookup.delete(handle);
+ }
+ },
+ };
+ var timeout = {
+ setTimeout: function (handler, duration) {
+ if (duration === void 0) { duration = 0; }
+ var handle = ++lastHandle;
+ scheduleLookup.set(handle, {
+ due: _this.now() + duration,
+ duration: duration,
+ handle: handle,
+ handler: handler,
+ subscription: _this.schedule(run, duration),
+ type: 'timeout',
+ });
+ return handle;
+ },
+ clearTimeout: function (handle) {
+ var value = scheduleLookup.get(handle);
+ if (value) {
+ value.subscription.unsubscribe();
+ scheduleLookup.delete(handle);
+ }
+ },
+ };
+ return { immediate: immediate, interval: interval, timeout: timeout };
+ };
+ TestScheduler.prototype.run = function (callback) {
+ var prevFrameTimeFactor = TestScheduler.frameTimeFactor;
+ var prevMaxFrames = this.maxFrames;
+ TestScheduler.frameTimeFactor = 1;
+ this.maxFrames = Infinity;
+ this.runMode = true;
+ var animator = this.createAnimator();
+ var delegates = this.createDelegates();
+ animationFrameProvider.delegate = animator.delegate;
+ dateTimestampProvider.delegate = this;
+ immediateProvider.delegate = delegates.immediate;
+ intervalProvider.delegate = delegates.interval;
+ timeoutProvider.delegate = delegates.timeout;
+ performanceTimestampProvider.delegate = this;
+ var helpers = {
+ cold: this.createColdObservable.bind(this),
+ hot: this.createHotObservable.bind(this),
+ flush: this.flush.bind(this),
+ time: this.createTime.bind(this),
+ expectObservable: this.expectObservable.bind(this),
+ expectSubscriptions: this.expectSubscriptions.bind(this),
+ animate: animator.animate,
+ };
+ try {
+ var ret = callback(helpers);
+ this.flush();
+ return ret;
+ }
+ finally {
+ TestScheduler.frameTimeFactor = prevFrameTimeFactor;
+ this.maxFrames = prevMaxFrames;
+ this.runMode = false;
+ animationFrameProvider.delegate = undefined;
+ dateTimestampProvider.delegate = undefined;
+ immediateProvider.delegate = undefined;
+ intervalProvider.delegate = undefined;
+ timeoutProvider.delegate = undefined;
+ performanceTimestampProvider.delegate = undefined;
+ }
+ };
+ TestScheduler.frameTimeFactor = 10;
+ return TestScheduler;
+ }(VirtualTimeScheduler));
+
+
+
+ var _testing = /*#__PURE__*/Object.freeze({
+ TestScheduler: TestScheduler
+ });
+
+ function getXHRResponse(xhr) {
+ switch (xhr.responseType) {
+ case 'json': {
+ if ('response' in xhr) {
+ return xhr.response;
+ }
+ else {
+ var ieXHR = xhr;
+ return JSON.parse(ieXHR.responseText);
+ }
+ }
+ case 'document':
+ return xhr.responseXML;
+ case 'text':
+ default: {
+ if ('response' in xhr) {
+ return xhr.response;
+ }
+ else {
+ var ieXHR = xhr;
+ return ieXHR.responseText;
+ }
+ }
+ }
+ }
+
+ var AjaxResponse = (function () {
+ function AjaxResponse(originalEvent, xhr, request, type) {
+ if (type === void 0) { type = 'download_load'; }
+ this.originalEvent = originalEvent;
+ this.xhr = xhr;
+ this.request = request;
+ this.type = type;
+ var status = xhr.status, responseType = xhr.responseType;
+ this.status = status !== null && status !== void 0 ? status : 0;
+ this.responseType = responseType !== null && responseType !== void 0 ? responseType : '';
+ var allHeaders = xhr.getAllResponseHeaders();
+ this.responseHeaders = allHeaders
+ ?
+ allHeaders.split('\n').reduce(function (headers, line) {
+ var index = line.indexOf(': ');
+ headers[line.slice(0, index)] = line.slice(index + 2);
+ return headers;
+ }, {})
+ : {};
+ this.response = getXHRResponse(xhr);
+ var loaded = originalEvent.loaded, total = originalEvent.total;
+ this.loaded = loaded;
+ this.total = total;
+ }
+ return AjaxResponse;
+ }());
+
+ var AjaxError = createErrorClass(function (_super) {
+ return function AjaxErrorImpl(message, xhr, request) {
+ this.message = message;
+ this.name = 'AjaxError';
+ this.xhr = xhr;
+ this.request = request;
+ this.status = xhr.status;
+ this.responseType = xhr.responseType;
+ var response;
+ try {
+ response = getXHRResponse(xhr);
+ }
+ catch (err) {
+ response = xhr.responseText;
+ }
+ this.response = response;
+ };
+ });
+ var AjaxTimeoutError = (function () {
+ function AjaxTimeoutErrorImpl(xhr, request) {
+ AjaxError.call(this, 'ajax timeout', xhr, request);
+ this.name = 'AjaxTimeoutError';
+ return this;
+ }
+ AjaxTimeoutErrorImpl.prototype = Object.create(AjaxError.prototype);
+ return AjaxTimeoutErrorImpl;
+ })();
+
+ function ajaxGet(url, headers) {
+ return ajax({ method: 'GET', url: url, headers: headers });
+ }
+ function ajaxPost(url, body, headers) {
+ return ajax({ method: 'POST', url: url, body: body, headers: headers });
+ }
+ function ajaxDelete(url, headers) {
+ return ajax({ method: 'DELETE', url: url, headers: headers });
+ }
+ function ajaxPut(url, body, headers) {
+ return ajax({ method: 'PUT', url: url, body: body, headers: headers });
+ }
+ function ajaxPatch(url, body, headers) {
+ return ajax({ method: 'PATCH', url: url, body: body, headers: headers });
+ }
+ var mapResponse = map(function (x) { return x.response; });
+ function ajaxGetJSON(url, headers) {
+ return mapResponse(ajax({
+ method: 'GET',
+ url: url,
+ headers: headers,
+ }));
+ }
+ var ajax = (function () {
+ var create = function (urlOrConfig) {
+ var config = typeof urlOrConfig === 'string'
+ ? {
+ url: urlOrConfig,
+ }
+ : urlOrConfig;
+ return fromAjax(config);
+ };
+ create.get = ajaxGet;
+ create.post = ajaxPost;
+ create.delete = ajaxDelete;
+ create.put = ajaxPut;
+ create.patch = ajaxPatch;
+ create.getJSON = ajaxGetJSON;
+ return create;
+ })();
+ var UPLOAD = 'upload';
+ var DOWNLOAD = 'download';
+ var LOADSTART = 'loadstart';
+ var PROGRESS = 'progress';
+ var LOAD = 'load';
+ function fromAjax(init) {
+ return new Observable(function (destination) {
+ var _a, _b;
+ var config = __assign({ async: true, crossDomain: false, withCredentials: false, method: 'GET', timeout: 0, responseType: 'json' }, init);
+ var queryParams = config.queryParams, configuredBody = config.body, configuredHeaders = config.headers;
+ var url = config.url;
+ if (!url) {
+ throw new TypeError('url is required');
+ }
+ if (queryParams) {
+ var searchParams_1;
+ if (url.includes('?')) {
+ var parts = url.split('?');
+ if (2 < parts.length) {
+ throw new TypeError('invalid url');
+ }
+ searchParams_1 = new URLSearchParams(parts[1]);
+ new URLSearchParams(queryParams).forEach(function (value, key) { return searchParams_1.set(key, value); });
+ url = parts[0] + '?' + searchParams_1;
+ }
+ else {
+ searchParams_1 = new URLSearchParams(queryParams);
+ url = url + '?' + searchParams_1;
+ }
+ }
+ var headers = {};
+ if (configuredHeaders) {
+ for (var key in configuredHeaders) {
+ if (configuredHeaders.hasOwnProperty(key)) {
+ headers[key.toLowerCase()] = configuredHeaders[key];
+ }
+ }
+ }
+ var crossDomain = config.crossDomain;
+ if (!crossDomain && !('x-requested-with' in headers)) {
+ headers['x-requested-with'] = 'XMLHttpRequest';
+ }
+ var withCredentials = config.withCredentials, xsrfCookieName = config.xsrfCookieName, xsrfHeaderName = config.xsrfHeaderName;
+ if ((withCredentials || !crossDomain) && xsrfCookieName && xsrfHeaderName) {
+ var xsrfCookie = (_b = (_a = document === null || document === void 0 ? void 0 : document.cookie.match(new RegExp("(^|;\\s*)(" + xsrfCookieName + ")=([^;]*)"))) === null || _a === void 0 ? void 0 : _a.pop()) !== null && _b !== void 0 ? _b : '';
+ if (xsrfCookie) {
+ headers[xsrfHeaderName] = xsrfCookie;
+ }
+ }
+ var body = extractContentTypeAndMaybeSerializeBody(configuredBody, headers);
+ var _request = __assign(__assign({}, config), { url: url,
+ headers: headers,
+ body: body });
+ var xhr;
+ xhr = init.createXHR ? init.createXHR() : new XMLHttpRequest();
+ {
+ var progressSubscriber_1 = init.progressSubscriber, _c = init.includeDownloadProgress, includeDownloadProgress = _c === void 0 ? false : _c, _d = init.includeUploadProgress, includeUploadProgress = _d === void 0 ? false : _d;
+ var addErrorEvent = function (type, errorFactory) {
+ xhr.addEventListener(type, function () {
+ var _a;
+ var error = errorFactory();
+ (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.error) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1, error);
+ destination.error(error);
+ });
+ };
+ addErrorEvent('timeout', function () { return new AjaxTimeoutError(xhr, _request); });
+ addErrorEvent('abort', function () { return new AjaxError('aborted', xhr, _request); });
+ var createResponse_1 = function (direction, event) {
+ return new AjaxResponse(event, xhr, _request, direction + "_" + event.type);
+ };
+ var addProgressEvent_1 = function (target, type, direction) {
+ target.addEventListener(type, function (event) {
+ destination.next(createResponse_1(direction, event));
+ });
+ };
+ if (includeUploadProgress) {
+ [LOADSTART, PROGRESS, LOAD].forEach(function (type) { return addProgressEvent_1(xhr.upload, type, UPLOAD); });
+ }
+ if (progressSubscriber_1) {
+ [LOADSTART, PROGRESS].forEach(function (type) { return xhr.upload.addEventListener(type, function (e) { var _a; return (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.next) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1, e); }); });
+ }
+ if (includeDownloadProgress) {
+ [LOADSTART, PROGRESS].forEach(function (type) { return addProgressEvent_1(xhr, type, DOWNLOAD); });
+ }
+ var emitError_1 = function (status) {
+ var msg = 'ajax error' + (status ? ' ' + status : '');
+ destination.error(new AjaxError(msg, xhr, _request));
+ };
+ xhr.addEventListener('error', function (e) {
+ var _a;
+ (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.error) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1, e);
+ emitError_1();
+ });
+ xhr.addEventListener(LOAD, function (event) {
+ var _a, _b;
+ var status = xhr.status;
+ if (status < 400) {
+ (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.complete) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1);
+ var response = void 0;
+ try {
+ response = createResponse_1(DOWNLOAD, event);
+ }
+ catch (err) {
+ destination.error(err);
+ return;
+ }
+ destination.next(response);
+ destination.complete();
+ }
+ else {
+ (_b = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.error) === null || _b === void 0 ? void 0 : _b.call(progressSubscriber_1, event);
+ emitError_1(status);
+ }
+ });
+ }
+ var user = _request.user, method = _request.method, async = _request.async;
+ if (user) {
+ xhr.open(method, url, async, user, _request.password);
+ }
+ else {
+ xhr.open(method, url, async);
+ }
+ if (async) {
+ xhr.timeout = _request.timeout;
+ xhr.responseType = _request.responseType;
+ }
+ if ('withCredentials' in xhr) {
+ xhr.withCredentials = _request.withCredentials;
+ }
+ for (var key in headers) {
+ if (headers.hasOwnProperty(key)) {
+ xhr.setRequestHeader(key, headers[key]);
+ }
+ }
+ if (body) {
+ xhr.send(body);
+ }
+ else {
+ xhr.send();
+ }
+ return function () {
+ if (xhr && xhr.readyState !== 4) {
+ xhr.abort();
+ }
+ };
+ });
+ }
+ function extractContentTypeAndMaybeSerializeBody(body, headers) {
+ var _a;
+ if (!body ||
+ typeof body === 'string' ||
+ isFormData(body) ||
+ isURLSearchParams(body) ||
+ isArrayBuffer(body) ||
+ isFile(body) ||
+ isBlob(body) ||
+ isReadableStream(body)) {
+ return body;
+ }
+ if (isArrayBufferView(body)) {
+ return body.buffer;
+ }
+ if (typeof body === 'object') {
+ headers['content-type'] = (_a = headers['content-type']) !== null && _a !== void 0 ? _a : 'application/json;charset=utf-8';
+ return JSON.stringify(body);
+ }
+ throw new TypeError('Unknown body type');
+ }
+ var _toString = Object.prototype.toString;
+ function toStringCheck(obj, name) {
+ return _toString.call(obj) === "[object " + name + "]";
+ }
+ function isArrayBuffer(body) {
+ return toStringCheck(body, 'ArrayBuffer');
+ }
+ function isFile(body) {
+ return toStringCheck(body, 'File');
+ }
+ function isBlob(body) {
+ return toStringCheck(body, 'Blob');
+ }
+ function isArrayBufferView(body) {
+ return typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(body);
+ }
+ function isFormData(body) {
+ return typeof FormData !== 'undefined' && body instanceof FormData;
+ }
+ function isURLSearchParams(body) {
+ return typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams;
+ }
+ function isReadableStream(body) {
+ return typeof ReadableStream !== 'undefined' && body instanceof ReadableStream;
+ }
+
+
+
+ var _ajax = /*#__PURE__*/Object.freeze({
+ ajax: ajax,
+ AjaxError: AjaxError,
+ AjaxTimeoutError: AjaxTimeoutError,
+ AjaxResponse: AjaxResponse
+ });
+
+ var DEFAULT_WEBSOCKET_CONFIG = {
+ url: '',
+ deserializer: function (e) { return JSON.parse(e.data); },
+ serializer: function (value) { return JSON.stringify(value); },
+ };
+ var WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT = 'WebSocketSubject.error must be called with an object with an error code, and an optional reason: { code: number, reason: string }';
+ var WebSocketSubject = (function (_super) {
+ __extends(WebSocketSubject, _super);
+ function WebSocketSubject(urlConfigOrSource, destination) {
+ var _this = _super.call(this) || this;
+ _this._socket = null;
+ if (urlConfigOrSource instanceof Observable) {
+ _this.destination = destination;
+ _this.source = urlConfigOrSource;
+ }
+ else {
+ var config = (_this._config = __assign({}, DEFAULT_WEBSOCKET_CONFIG));
+ _this._output = new Subject();
+ if (typeof urlConfigOrSource === 'string') {
+ config.url = urlConfigOrSource;
+ }
+ else {
+ for (var key in urlConfigOrSource) {
+ if (urlConfigOrSource.hasOwnProperty(key)) {
+ config[key] = urlConfigOrSource[key];
+ }
+ }
+ }
+ if (!config.WebSocketCtor && WebSocket) {
+ config.WebSocketCtor = WebSocket;
+ }
+ else if (!config.WebSocketCtor) {
+ throw new Error('no WebSocket constructor can be found');
+ }
+ _this.destination = new ReplaySubject();
+ }
+ return _this;
+ }
+ WebSocketSubject.prototype.lift = function (operator) {
+ var sock = new WebSocketSubject(this._config, this.destination);
+ sock.operator = operator;
+ sock.source = this;
+ return sock;
+ };
+ WebSocketSubject.prototype._resetState = function () {
+ this._socket = null;
+ if (!this.source) {
+ this.destination = new ReplaySubject();
+ }
+ this._output = new Subject();
+ };
+ WebSocketSubject.prototype.multiplex = function (subMsg, unsubMsg, messageFilter) {
+ var self = this;
+ return new Observable(function (observer) {
+ try {
+ self.next(subMsg());
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ var subscription = self.subscribe({
+ next: function (x) {
+ try {
+ if (messageFilter(x)) {
+ observer.next(x);
+ }
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ },
+ error: function (err) { return observer.error(err); },
+ complete: function () { return observer.complete(); },
+ });
+ return function () {
+ try {
+ self.next(unsubMsg());
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ subscription.unsubscribe();
+ };
+ });
+ };
+ WebSocketSubject.prototype._connectSocket = function () {
+ var _this = this;
+ var _a = this._config, WebSocketCtor = _a.WebSocketCtor, protocol = _a.protocol, url = _a.url, binaryType = _a.binaryType;
+ var observer = this._output;
+ var socket = null;
+ try {
+ socket = protocol ? new WebSocketCtor(url, protocol) : new WebSocketCtor(url);
+ this._socket = socket;
+ if (binaryType) {
+ this._socket.binaryType = binaryType;
+ }
+ }
+ catch (e) {
+ observer.error(e);
+ return;
+ }
+ var subscription = new Subscription(function () {
+ _this._socket = null;
+ if (socket && socket.readyState === 1) {
+ socket.close();
+ }
+ });
+ socket.onopen = function (evt) {
+ var _socket = _this._socket;
+ if (!_socket) {
+ socket.close();
+ _this._resetState();
+ return;
+ }
+ var openObserver = _this._config.openObserver;
+ if (openObserver) {
+ openObserver.next(evt);
+ }
+ var queue = _this.destination;
+ _this.destination = Subscriber.create(function (x) {
+ if (socket.readyState === 1) {
+ try {
+ var serializer = _this._config.serializer;
+ socket.send(serializer(x));
+ }
+ catch (e) {
+ _this.destination.error(e);
+ }
+ }
+ }, function (err) {
+ var closingObserver = _this._config.closingObserver;
+ if (closingObserver) {
+ closingObserver.next(undefined);
+ }
+ if (err && err.code) {
+ socket.close(err.code, err.reason);
+ }
+ else {
+ observer.error(new TypeError(WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT));
+ }
+ _this._resetState();
+ }, function () {
+ var closingObserver = _this._config.closingObserver;
+ if (closingObserver) {
+ closingObserver.next(undefined);
+ }
+ socket.close();
+ _this._resetState();
+ });
+ if (queue && queue instanceof ReplaySubject) {
+ subscription.add(queue.subscribe(_this.destination));
+ }
+ };
+ socket.onerror = function (e) {
+ _this._resetState();
+ observer.error(e);
+ };
+ socket.onclose = function (e) {
+ if (socket === _this._socket) {
+ _this._resetState();
+ }
+ var closeObserver = _this._config.closeObserver;
+ if (closeObserver) {
+ closeObserver.next(e);
+ }
+ if (e.wasClean) {
+ observer.complete();
+ }
+ else {
+ observer.error(e);
+ }
+ };
+ socket.onmessage = function (e) {
+ try {
+ var deserializer = _this._config.deserializer;
+ observer.next(deserializer(e));
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ };
+ };
+ WebSocketSubject.prototype._subscribe = function (subscriber) {
+ var _this = this;
+ var source = this.source;
+ if (source) {
+ return source.subscribe(subscriber);
+ }
+ if (!this._socket) {
+ this._connectSocket();
+ }
+ this._output.subscribe(subscriber);
+ subscriber.add(function () {
+ var _socket = _this._socket;
+ if (_this._output.observers.length === 0) {
+ if (_socket && (_socket.readyState === 1 || _socket.readyState === 0)) {
+ _socket.close();
+ }
+ _this._resetState();
+ }
+ });
+ return subscriber;
+ };
+ WebSocketSubject.prototype.unsubscribe = function () {
+ var _socket = this._socket;
+ if (_socket && (_socket.readyState === 1 || _socket.readyState === 0)) {
+ _socket.close();
+ }
+ this._resetState();
+ _super.prototype.unsubscribe.call(this);
+ };
+ return WebSocketSubject;
+ }(AnonymousSubject));
+
+ function webSocket(urlConfigOrSource) {
+ return new WebSocketSubject(urlConfigOrSource);
+ }
+
+
+
+ var _webSocket = /*#__PURE__*/Object.freeze({
+ webSocket: webSocket,
+ WebSocketSubject: WebSocketSubject
+ });
+
+ function fromFetch(input, initWithSelector) {
+ if (initWithSelector === void 0) { initWithSelector = {}; }
+ var selector = initWithSelector.selector, init = __rest(initWithSelector, ["selector"]);
+ return new Observable(function (subscriber) {
+ var controller = new AbortController();
+ var signal = controller.signal;
+ var abortable = true;
+ var outerSignal = init.signal;
+ if (outerSignal) {
+ if (outerSignal.aborted) {
+ controller.abort();
+ }
+ else {
+ var outerSignalHandler_1 = function () {
+ if (!signal.aborted) {
+ controller.abort();
+ }
+ };
+ outerSignal.addEventListener('abort', outerSignalHandler_1);
+ subscriber.add(function () { return outerSignal.removeEventListener('abort', outerSignalHandler_1); });
+ }
+ }
+ var perSubscriberInit = __assign(__assign({}, init), { signal: signal });
+ var handleError = function (err) {
+ abortable = false;
+ subscriber.error(err);
+ };
+ fetch(input, perSubscriberInit)
+ .then(function (response) {
+ if (selector) {
+ innerFrom(selector(response)).subscribe(createOperatorSubscriber(subscriber, undefined, function () {
+ abortable = false;
+ subscriber.complete();
+ }, handleError));
+ }
+ else {
+ abortable = false;
+ subscriber.next(response);
+ subscriber.complete();
+ }
+ })
+ .catch(handleError);
+ return function () {
+ if (abortable) {
+ controller.abort();
+ }
+ };
+ });
+ }
+
+
+
+ var _fetch = /*#__PURE__*/Object.freeze({
+ fromFetch: fromFetch
+ });
+
+ var operators = _operators;
+ var testing = _testing;
+ var ajax$1 = _ajax;
+ var webSocket$1 = _webSocket;
+ var fetch$1 = _fetch;
+
+ exports.operators = operators;
+ exports.testing = testing;
+ exports.ajax = ajax$1;
+ exports.webSocket = webSocket$1;
+ exports.fetch = fetch$1;
+ exports.Observable = Observable;
+ exports.ConnectableObservable = ConnectableObservable;
+ exports.observable = observable;
+ exports.animationFrames = animationFrames;
+ exports.Subject = Subject;
+ exports.BehaviorSubject = BehaviorSubject;
+ exports.ReplaySubject = ReplaySubject;
+ exports.AsyncSubject = AsyncSubject;
+ exports.asap = asap;
+ exports.asapScheduler = asapScheduler;
+ exports.async = async;
+ exports.asyncScheduler = asyncScheduler;
+ exports.queue = queue;
+ exports.queueScheduler = queueScheduler;
+ exports.animationFrame = animationFrame;
+ exports.animationFrameScheduler = animationFrameScheduler;
+ exports.VirtualTimeScheduler = VirtualTimeScheduler;
+ exports.VirtualAction = VirtualAction;
+ exports.Scheduler = Scheduler;
+ exports.Subscription = Subscription;
+ exports.Subscriber = Subscriber;
+ exports.Notification = Notification;
+ exports.pipe = pipe;
+ exports.noop = noop;
+ exports.identity = identity;
+ exports.isObservable = isObservable;
+ exports.lastValueFrom = lastValueFrom;
+ exports.firstValueFrom = firstValueFrom;
+ exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;
+ exports.EmptyError = EmptyError;
+ exports.NotFoundError = NotFoundError;
+ exports.ObjectUnsubscribedError = ObjectUnsubscribedError;
+ exports.SequenceError = SequenceError;
+ exports.TimeoutError = TimeoutError;
+ exports.UnsubscriptionError = UnsubscriptionError;
+ exports.bindCallback = bindCallback;
+ exports.bindNodeCallback = bindNodeCallback;
+ exports.combineLatest = combineLatest;
+ exports.concat = concat;
+ exports.connectable = connectable;
+ exports.defer = defer;
+ exports.empty = empty;
+ exports.forkJoin = forkJoin;
+ exports.from = from;
+ exports.fromEvent = fromEvent;
+ exports.fromEventPattern = fromEventPattern;
+ exports.generate = generate;
+ exports.iif = iif;
+ exports.interval = interval;
+ exports.merge = merge;
+ exports.never = never;
+ exports.of = of;
+ exports.onErrorResumeNext = onErrorResumeNext;
+ exports.pairs = pairs;
+ exports.partition = partition;
+ exports.race = race;
+ exports.range = range;
+ exports.throwError = throwError;
+ exports.timer = timer;
+ exports.using = using;
+ exports.zip = zip;
+ exports.scheduled = scheduled;
+ exports.EMPTY = EMPTY;
+ exports.NEVER = NEVER;
+ exports.config = config;
+ exports.audit = audit;
+ exports.auditTime = auditTime;
+ exports.buffer = buffer;
+ exports.bufferCount = bufferCount;
+ exports.bufferTime = bufferTime;
+ exports.bufferToggle = bufferToggle;
+ exports.bufferWhen = bufferWhen;
+ exports.catchError = catchError;
+ exports.combineAll = combineAll;
+ exports.combineLatestAll = combineLatestAll;
+ exports.combineLatestWith = combineLatestWith;
+ exports.concatAll = concatAll;
+ exports.concatMap = concatMap;
+ exports.concatMapTo = concatMapTo;
+ exports.concatWith = concatWith;
+ exports.connect = connect;
+ exports.count = count;
+ exports.debounce = debounce;
+ exports.debounceTime = debounceTime;
+ exports.defaultIfEmpty = defaultIfEmpty;
+ exports.delay = delay;
+ exports.delayWhen = delayWhen;
+ exports.dematerialize = dematerialize;
+ exports.distinct = distinct;
+ exports.distinctUntilChanged = distinctUntilChanged;
+ exports.distinctUntilKeyChanged = distinctUntilKeyChanged;
+ exports.elementAt = elementAt;
+ exports.endWith = endWith;
+ exports.every = every;
+ exports.exhaust = exhaust;
+ exports.exhaustAll = exhaustAll;
+ exports.exhaustMap = exhaustMap;
+ exports.expand = expand;
+ exports.filter = filter;
+ exports.finalize = finalize;
+ exports.find = find;
+ exports.findIndex = findIndex;
+ exports.first = first;
+ exports.groupBy = groupBy;
+ exports.ignoreElements = ignoreElements;
+ exports.isEmpty = isEmpty;
+ exports.last = last$1;
+ exports.map = map;
+ exports.mapTo = mapTo;
+ exports.materialize = materialize;
+ exports.max = max;
+ exports.mergeAll = mergeAll;
+ exports.flatMap = flatMap;
+ exports.mergeMap = mergeMap;
+ exports.mergeMapTo = mergeMapTo;
+ exports.mergeScan = mergeScan;
+ exports.mergeWith = mergeWith;
+ exports.min = min;
+ exports.multicast = multicast;
+ exports.observeOn = observeOn;
+ exports.onErrorResumeNextWith = onErrorResumeNextWith;
+ exports.pairwise = pairwise;
+ exports.pluck = pluck;
+ exports.publish = publish;
+ exports.publishBehavior = publishBehavior;
+ exports.publishLast = publishLast;
+ exports.publishReplay = publishReplay;
+ exports.raceWith = raceWith;
+ exports.reduce = reduce;
+ exports.repeat = repeat;
+ exports.repeatWhen = repeatWhen;
+ exports.retry = retry;
+ exports.retryWhen = retryWhen;
+ exports.refCount = refCount;
+ exports.sample = sample;
+ exports.sampleTime = sampleTime;
+ exports.scan = scan;
+ exports.sequenceEqual = sequenceEqual;
+ exports.share = share;
+ exports.shareReplay = shareReplay;
+ exports.single = single;
+ exports.skip = skip;
+ exports.skipLast = skipLast;
+ exports.skipUntil = skipUntil;
+ exports.skipWhile = skipWhile;
+ exports.startWith = startWith;
+ exports.subscribeOn = subscribeOn;
+ exports.switchAll = switchAll;
+ exports.switchMap = switchMap;
+ exports.switchMapTo = switchMapTo;
+ exports.switchScan = switchScan;
+ exports.take = take;
+ exports.takeLast = takeLast;
+ exports.takeUntil = takeUntil;
+ exports.takeWhile = takeWhile;
+ exports.tap = tap;
+ exports.throttle = throttle;
+ exports.throttleTime = throttleTime;
+ exports.throwIfEmpty = throwIfEmpty;
+ exports.timeInterval = timeInterval;
+ exports.timeout = timeout;
+ exports.timeoutWith = timeoutWith;
+ exports.timestamp = timestamp;
+ exports.toArray = toArray;
+ exports.window = window;
+ exports.windowCount = windowCount;
+ exports.windowTime = windowTime;
+ exports.windowToggle = windowToggle;
+ exports.windowWhen = windowWhen;
+ exports.withLatestFrom = withLatestFrom;
+ exports.zipAll = zipAll;
+ exports.zipWith = zipWith;
+
+ Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+//# sourceMappingURL=rxjs.umd.js.map
+
send patches to the email below
yukais@pinapelz.com
include the subject [PATCH repo_name]
pinapelz.com
homepage