From 94dd77a12606f69e4dee603035e2a3ace4360150 Mon Sep 17 00:00:00 2001 From: Vikram Subramanian Date: Wed, 9 Mar 2016 16:28:52 -0800 Subject: [PATCH] v2.0.0-beta.9 --- 2.0.0-beta.9/Rx.js | 11615 +++++ 2.0.0-beta.9/Rx.min.js | 417 + 2.0.0-beta.9/Rx.min.js.map | 1 + 2.0.0-beta.9/Rx.umd.js | 10274 +++++ 2.0.0-beta.9/Rx.umd.min.js | 748 + 2.0.0-beta.9/Rx.umd.min.js.map | 8 + 2.0.0-beta.9/angular2-all-testing.umd.dev.js | 40111 +++++++++++++++++ 2.0.0-beta.9/angular2-all.umd.dev.js | 37910 ++++++++++++++++ 2.0.0-beta.9/angular2-all.umd.js | 37909 ++++++++++++++++ 2.0.0-beta.9/angular2-all.umd.min.js | 19 + 2.0.0-beta.9/angular2-polyfills.js | 3324 ++ 2.0.0-beta.9/angular2-polyfills.min.js | 1 + 2.0.0-beta.9/angular2.dev.js | 25355 +++++++++++ 2.0.0-beta.9/angular2.js | 25355 +++++++++++ 2.0.0-beta.9/angular2.min.js | 19 + 2.0.0-beta.9/http.dev.js | 1091 + 2.0.0-beta.9/http.js | 1091 + 2.0.0-beta.9/http.min.js | 1 + 2.0.0-beta.9/overview.md | 92 + 2.0.0-beta.9/router.dev.js | 3295 ++ 2.0.0-beta.9/router.js | 3295 ++ 2.0.0-beta.9/router.min.js | 3 + 2.0.0-beta.9/testing.dev.js | 2133 + 2.0.0-beta.9/testing.dev.js.map | 1 + 2.0.0-beta.9/upgrade.dev.js | 777 + 2.0.0-beta.9/upgrade.js | 777 + 2.0.0-beta.9/upgrade.min.js | 1 + 2.0.0-beta.9/web_worker/ui.dev.js | 23777 ++++++++++ 2.0.0-beta.9/web_worker/worker.dev.js | 39337 ++++++++++++++++ 29 files changed, 268737 insertions(+) create mode 100644 2.0.0-beta.9/Rx.js create mode 100644 2.0.0-beta.9/Rx.min.js create mode 100644 2.0.0-beta.9/Rx.min.js.map create mode 100644 2.0.0-beta.9/Rx.umd.js create mode 100644 2.0.0-beta.9/Rx.umd.min.js create mode 100644 2.0.0-beta.9/Rx.umd.min.js.map create mode 100644 2.0.0-beta.9/angular2-all-testing.umd.dev.js create mode 100644 2.0.0-beta.9/angular2-all.umd.dev.js create mode 100644 2.0.0-beta.9/angular2-all.umd.js create mode 100644 2.0.0-beta.9/angular2-all.umd.min.js create mode 100644 2.0.0-beta.9/angular2-polyfills.js create mode 100644 2.0.0-beta.9/angular2-polyfills.min.js create mode 100644 2.0.0-beta.9/angular2.dev.js create mode 100644 2.0.0-beta.9/angular2.js create mode 100644 2.0.0-beta.9/angular2.min.js create mode 100644 2.0.0-beta.9/http.dev.js create mode 100644 2.0.0-beta.9/http.js create mode 100644 2.0.0-beta.9/http.min.js create mode 100644 2.0.0-beta.9/overview.md create mode 100644 2.0.0-beta.9/router.dev.js create mode 100644 2.0.0-beta.9/router.js create mode 100644 2.0.0-beta.9/router.min.js create mode 100644 2.0.0-beta.9/testing.dev.js create mode 100644 2.0.0-beta.9/testing.dev.js.map create mode 100644 2.0.0-beta.9/upgrade.dev.js create mode 100644 2.0.0-beta.9/upgrade.js create mode 100644 2.0.0-beta.9/upgrade.min.js create mode 100644 2.0.0-beta.9/web_worker/ui.dev.js create mode 100644 2.0.0-beta.9/web_worker/worker.dev.js diff --git a/2.0.0-beta.9/Rx.js b/2.0.0-beta.9/Rx.js new file mode 100644 index 0000000000..4b25956721 --- /dev/null +++ b/2.0.0-beta.9/Rx.js @@ -0,0 +1,11615 @@ +/** + 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 2015-2016 Netflix, Inc. + + 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 2015-2016 Netflix, Inc. + + 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. + + **/ +"format register"; +System.register("rxjs/util/root", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var objectTypes = { + 'boolean': false, + 'function': true, + 'object': true, + 'number': false, + 'string': false, + 'undefined': false + }; + exports.root = (objectTypes[typeof self] && self) || (objectTypes[typeof window] && window); + var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; + var freeModule = objectTypes[typeof module] && module && !module.nodeType && module; + var freeGlobal = objectTypes[typeof global] && global; + if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) { + exports.root = freeGlobal; + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/SymbolShim", ["rxjs/util/root"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var root_1 = require("rxjs/util/root"); + function polyfillSymbol(root) { + var Symbol = ensureSymbol(root); + ensureIterator(Symbol, root); + ensureObservable(Symbol); + ensureFor(Symbol); + return Symbol; + } + exports.polyfillSymbol = polyfillSymbol; + function ensureFor(Symbol) { + if (!Symbol.for) { + Symbol.for = symbolForPolyfill; + } + } + exports.ensureFor = ensureFor; + var id = 0; + function ensureSymbol(root) { + if (!root.Symbol) { + root.Symbol = function symbolFuncPolyfill(description) { + return "@@Symbol(" + description + "):" + id++; + }; + } + return root.Symbol; + } + exports.ensureSymbol = ensureSymbol; + function symbolForPolyfill(key) { + return '@@' + key; + } + exports.symbolForPolyfill = symbolForPolyfill; + function ensureIterator(Symbol, root) { + if (!Symbol.iterator) { + if (typeof Symbol.for === 'function') { + Symbol.iterator = Symbol.for('iterator'); + } else if (root.Set && typeof new root.Set()['@@iterator'] === 'function') { + Symbol.iterator = '@@iterator'; + } else if (root.Map) { + var keys = Object.getOwnPropertyNames(root.Map.prototype); + for (var i = 0; i < keys.length; ++i) { + var key = keys[i]; + if (key !== 'entries' && key !== 'size' && root.Map.prototype[key] === root.Map.prototype['entries']) { + Symbol.iterator = key; + break; + } + } + } else { + Symbol.iterator = '@@iterator'; + } + } + } + exports.ensureIterator = ensureIterator; + function ensureObservable(Symbol) { + if (!Symbol.observable) { + if (typeof Symbol.for === 'function') { + Symbol.observable = Symbol.for('observable'); + } else { + Symbol.observable = '@@observable'; + } + } + } + exports.ensureObservable = ensureObservable; + exports.SymbolShim = polyfillSymbol(root_1.root); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/isFunction", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function isFunction(x) { + return typeof x === 'function'; + } + exports.isFunction = isFunction; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/isArray", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + exports.isArray = Array.isArray || (function(x) { + return x && typeof x.length === 'number'; + }); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/isObject", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function isObject(x) { + return x != null && typeof x === 'object'; + } + exports.isObject = isObject; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/errorObject", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + exports.errorObject = {e: {}}; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/symbol/rxSubscriber", ["rxjs/util/SymbolShim"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var SymbolShim_1 = require("rxjs/util/SymbolShim"); + exports.rxSubscriber = SymbolShim_1.SymbolShim.for('rxSubscriber'); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Observer", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + exports.empty = { + isUnsubscribed: true, + next: function(value) {}, + error: function(err) { + throw err; + }, + complete: function() {} + }; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/subject/SubjectSubscription", ["rxjs/Subscription"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscription_1 = require("rxjs/Subscription"); + var SubjectSubscription = (function(_super) { + __extends(SubjectSubscription, _super); + function SubjectSubscription(subject, observer) { + _super.call(this); + this.subject = subject; + this.observer = observer; + this.isUnsubscribed = false; + } + SubjectSubscription.prototype.unsubscribe = function() { + if (this.isUnsubscribed) { + return ; + } + this.isUnsubscribed = true; + var subject = this.subject; + var observers = subject.observers; + this.subject = null; + if (!observers || observers.length === 0 || subject.isUnsubscribed) { + return ; + } + var subscriberIndex = observers.indexOf(this.observer); + if (subscriberIndex !== -1) { + observers.splice(subscriberIndex, 1); + } + }; + return SubjectSubscription; + }(Subscription_1.Subscription)); + exports.SubjectSubscription = SubjectSubscription; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/throwError", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function throwError(e) { + throw e; + } + exports.throwError = throwError; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/ObjectUnsubscribedError", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var ObjectUnsubscribedError = (function(_super) { + __extends(ObjectUnsubscribedError, _super); + function ObjectUnsubscribedError() { + _super.call(this, 'object unsubscribed'); + this.name = 'ObjectUnsubscribedError'; + } + return ObjectUnsubscribedError; + }(Error)); + exports.ObjectUnsubscribedError = ObjectUnsubscribedError; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/ScalarObservable", ["rxjs/Observable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var ScalarObservable = (function(_super) { + __extends(ScalarObservable, _super); + function ScalarObservable(value, scheduler) { + _super.call(this); + this.value = value; + this.scheduler = scheduler; + this._isScalar = true; + } + ScalarObservable.create = function(value, scheduler) { + return new ScalarObservable(value, scheduler); + }; + ScalarObservable.dispatch = function(state) { + var done = state.done, + value = state.value, + subscriber = state.subscriber; + if (done) { + subscriber.complete(); + return ; + } + subscriber.next(value); + if (subscriber.isUnsubscribed) { + return ; + } + state.done = true; + this.schedule(state); + }; + ScalarObservable.prototype._subscribe = function(subscriber) { + var value = this.value; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(ScalarObservable.dispatch, 0, { + done: false, + value: value, + subscriber: subscriber + }); + } else { + subscriber.next(value); + if (!subscriber.isUnsubscribed) { + subscriber.complete(); + } + } + }; + return ScalarObservable; + }(Observable_1.Observable)); + exports.ScalarObservable = ScalarObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/EmptyObservable", ["rxjs/Observable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var EmptyObservable = (function(_super) { + __extends(EmptyObservable, _super); + function EmptyObservable(scheduler) { + _super.call(this); + this.scheduler = scheduler; + } + EmptyObservable.create = function(scheduler) { + return new EmptyObservable(scheduler); + }; + EmptyObservable.dispatch = function(_a) { + var subscriber = _a.subscriber; + subscriber.complete(); + }; + EmptyObservable.prototype._subscribe = function(subscriber) { + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(EmptyObservable.dispatch, 0, {subscriber: subscriber}); + } else { + subscriber.complete(); + } + }; + return EmptyObservable; + }(Observable_1.Observable)); + exports.EmptyObservable = EmptyObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/isScheduler", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function isScheduler(value) { + return value && typeof value.schedule === 'function'; + } + exports.isScheduler = isScheduler; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/OuterSubscriber", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var OuterSubscriber = (function(_super) { + __extends(OuterSubscriber, _super); + function OuterSubscriber() { + _super.apply(this, arguments); + } + OuterSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.destination.next(innerValue); + }; + OuterSubscriber.prototype.notifyError = function(error, innerSub) { + this.destination.error(error); + }; + OuterSubscriber.prototype.notifyComplete = function(innerSub) { + this.destination.complete(); + }; + return OuterSubscriber; + }(Subscriber_1.Subscriber)); + exports.OuterSubscriber = OuterSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/isPromise", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function isPromise(value) { + return value && typeof value.subscribe !== 'function' && typeof value.then === 'function'; + } + exports.isPromise = isPromise; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/InnerSubscriber", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var InnerSubscriber = (function(_super) { + __extends(InnerSubscriber, _super); + function InnerSubscriber(parent, outerValue, outerIndex) { + _super.call(this); + this.parent = parent; + this.outerValue = outerValue; + this.outerIndex = outerIndex; + this.index = 0; + } + InnerSubscriber.prototype._next = function(value) { + this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this); + }; + InnerSubscriber.prototype._error = function(error) { + this.parent.notifyError(error, this); + this.unsubscribe(); + }; + InnerSubscriber.prototype._complete = function() { + this.parent.notifyComplete(this); + this.unsubscribe(); + }; + return InnerSubscriber; + }(Subscriber_1.Subscriber)); + exports.InnerSubscriber = InnerSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/mergeAll", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function mergeAll(concurrent) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + return this.lift(new MergeAllOperator(concurrent)); + } + exports.mergeAll = mergeAll; + var MergeAllOperator = (function() { + function MergeAllOperator(concurrent) { + this.concurrent = concurrent; + } + MergeAllOperator.prototype.call = function(observer) { + return new MergeAllSubscriber(observer, this.concurrent); + }; + return MergeAllOperator; + }()); + exports.MergeAllOperator = MergeAllOperator; + var MergeAllSubscriber = (function(_super) { + __extends(MergeAllSubscriber, _super); + function MergeAllSubscriber(destination, concurrent) { + _super.call(this, destination); + this.concurrent = concurrent; + this.hasCompleted = false; + this.buffer = []; + this.active = 0; + } + MergeAllSubscriber.prototype._next = function(observable) { + if (this.active < this.concurrent) { + this.active++; + this.add(subscribeToResult_1.subscribeToResult(this, observable)); + } else { + this.buffer.push(observable); + } + }; + MergeAllSubscriber.prototype._complete = function() { + this.hasCompleted = true; + if (this.active === 0 && this.buffer.length === 0) { + this.destination.complete(); + } + }; + MergeAllSubscriber.prototype.notifyComplete = function(innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer.length > 0) { + this._next(buffer.shift()); + } else if (this.active === 0 && this.hasCompleted) { + this.destination.complete(); + } + }; + return MergeAllSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + exports.MergeAllSubscriber = MergeAllSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/merge", ["rxjs/observable/ArrayObservable", "rxjs/operator/mergeAll", "rxjs/util/isScheduler"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + var mergeAll_1 = require("rxjs/operator/mergeAll"); + var isScheduler_1 = require("rxjs/util/isScheduler"); + function merge() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + observables.unshift(this); + return mergeStatic.apply(this, observables); + } + exports.merge = merge; + function mergeStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var concurrent = Number.POSITIVE_INFINITY; + var scheduler = null; + var last = observables[observables.length - 1]; + if (isScheduler_1.isScheduler(last)) { + scheduler = observables.pop(); + if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') { + concurrent = observables.pop(); + } + } else if (typeof last === 'number') { + concurrent = observables.pop(); + } + if (observables.length === 1) { + return observables[0]; + } + return new ArrayObservable_1.ArrayObservable(observables, scheduler).lift(new mergeAll_1.MergeAllOperator(concurrent)); + } + exports.mergeStatic = mergeStatic; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/race", ["rxjs/util/isArray", "rxjs/observable/ArrayObservable", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var isArray_1 = require("rxjs/util/isArray"); + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function race() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + if (observables.length === 1 && isArray_1.isArray(observables[0])) { + observables = observables[0]; + } + observables.unshift(this); + return raceStatic.apply(this, observables); + } + exports.race = race; + function raceStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + if (observables.length === 1) { + if (isArray_1.isArray(observables[0])) { + observables = observables[0]; + } else { + return observables[0]; + } + } + return new ArrayObservable_1.ArrayObservable(observables).lift(new RaceOperator()); + } + exports.raceStatic = raceStatic; + var RaceOperator = (function() { + function RaceOperator() {} + RaceOperator.prototype.call = function(subscriber) { + return new RaceSubscriber(subscriber); + }; + return RaceOperator; + }()); + exports.RaceOperator = RaceOperator; + var RaceSubscriber = (function(_super) { + __extends(RaceSubscriber, _super); + function RaceSubscriber(destination) { + _super.call(this, destination); + this.hasFirst = false; + this.observables = []; + this.subscriptions = []; + } + RaceSubscriber.prototype._next = function(observable) { + this.observables.push(observable); + }; + RaceSubscriber.prototype._complete = function() { + var observables = this.observables; + var len = observables.length; + if (len === 0) { + this.destination.complete(); + } else { + for (var i = 0; i < len; i++) { + var observable = observables[i]; + var subscription = subscribeToResult_1.subscribeToResult(this, observable, observable, i); + this.subscriptions.push(subscription); + this.add(subscription); + } + this.observables = null; + } + }; + RaceSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (!this.hasFirst) { + this.hasFirst = true; + for (var i = 0; i < this.subscriptions.length; i++) { + if (i !== outerIndex) { + var subscription = this.subscriptions[i]; + subscription.unsubscribe(); + this.remove(subscription); + } + } + this.subscriptions = null; + } + this.destination.next(innerValue); + }; + return RaceSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + exports.RaceSubscriber = RaceSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/subject/AsyncSubject", ["rxjs/Subject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subject_1 = require("rxjs/Subject"); + var AsyncSubject = (function(_super) { + __extends(AsyncSubject, _super); + function AsyncSubject() { + _super.apply(this, arguments); + this.value = null; + this.hasNext = false; + } + AsyncSubject.prototype._subscribe = function(subscriber) { + if (this.hasCompleted && this.hasNext) { + subscriber.next(this.value); + } + return _super.prototype._subscribe.call(this, subscriber); + }; + AsyncSubject.prototype._next = function(value) { + this.value = value; + this.hasNext = true; + }; + AsyncSubject.prototype._complete = function() { + var index = -1; + var observers = this.observers; + var len = observers.length; + this.isUnsubscribed = true; + if (this.hasNext) { + while (++index < len) { + var o = observers[index]; + o.next(this.value); + o.complete(); + } + } else { + while (++index < len) { + observers[index].complete(); + } + } + this.isUnsubscribed = false; + this.unsubscribe(); + }; + return AsyncSubject; + }(Subject_1.Subject)); + exports.AsyncSubject = AsyncSubject; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/BoundNodeCallbackObservable", ["rxjs/Observable", "rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/subject/AsyncSubject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var AsyncSubject_1 = require("rxjs/subject/AsyncSubject"); + var BoundNodeCallbackObservable = (function(_super) { + __extends(BoundNodeCallbackObservable, _super); + function BoundNodeCallbackObservable(callbackFunc, selector, args, scheduler) { + _super.call(this); + this.callbackFunc = callbackFunc; + this.selector = selector; + this.args = args; + this.scheduler = scheduler; + } + BoundNodeCallbackObservable.create = function(callbackFunc, selector, scheduler) { + if (selector === void 0) { + selector = undefined; + } + return function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + return new BoundNodeCallbackObservable(callbackFunc, selector, args, scheduler); + }; + }; + BoundNodeCallbackObservable.prototype._subscribe = function(subscriber) { + var callbackFunc = this.callbackFunc; + var args = this.args; + var scheduler = this.scheduler; + var subject = this.subject; + if (!scheduler) { + if (!subject) { + subject = this.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, + subject = source.subject; + var err = innerArgs.shift(); + if (err) { + subject.error(err); + } else if (selector) { + var result_1 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_1 === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } else { + subject.next(result_1); + subject.complete(); + } + } else { + subject.next(innerArgs.length === 1 ? innerArgs[0] : innerArgs); + subject.complete(); + } + }; + handler.source = this; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + return subject.subscribe(subscriber); + } else { + return scheduler.schedule(dispatch, 0, { + source: this, + subscriber: subscriber + }); + } + }; + return BoundNodeCallbackObservable; + }(Observable_1.Observable)); + exports.BoundNodeCallbackObservable = BoundNodeCallbackObservable; + function dispatch(state) { + var self = this; + var source = state.source, + subscriber = state.subscriber; + var callbackFunc = source.callbackFunc, + args = source.args, + scheduler = source.scheduler; + var subject = source.subject; + if (!subject) { + subject = source.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, + subject = source.subject; + var err = innerArgs.shift(); + if (err) { + subject.error(err); + } else if (selector) { + var result_2 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_2 === errorObject_1.errorObject) { + self.add(scheduler.schedule(dispatchError, 0, { + err: errorObject_1.errorObject.e, + subject: subject + })); + } else { + self.add(scheduler.schedule(dispatchNext, 0, { + value: result_2, + subject: subject + })); + } + } else { + var value = innerArgs.length === 1 ? innerArgs[0] : innerArgs; + self.add(scheduler.schedule(dispatchNext, 0, { + value: value, + subject: subject + })); + } + }; + handler.source = source; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + self.add(subject.subscribe(subscriber)); + } + function dispatchNext(_a) { + var value = _a.value, + subject = _a.subject; + subject.next(value); + subject.complete(); + } + function dispatchError(_a) { + var err = _a.err, + subject = _a.subject; + subject.error(err); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/DeferObservable", ["rxjs/Observable", "rxjs/util/tryCatch", "rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var DeferObservable = (function(_super) { + __extends(DeferObservable, _super); + function DeferObservable(observableFactory) { + _super.call(this); + this.observableFactory = observableFactory; + } + DeferObservable.create = function(observableFactory) { + return new DeferObservable(observableFactory); + }; + DeferObservable.prototype._subscribe = function(subscriber) { + var result = tryCatch_1.tryCatch(this.observableFactory)(); + if (result === errorObject_1.errorObject) { + subscriber.error(errorObject_1.errorObject.e); + } else { + result.subscribe(subscriber); + } + }; + return DeferObservable; + }(Observable_1.Observable)); + exports.DeferObservable = DeferObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/empty", ["rxjs/Observable", "rxjs/observable/EmptyObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + Observable_1.Observable.empty = EmptyObservable_1.EmptyObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/PromiseObservable", ["rxjs/util/root", "rxjs/Observable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var root_1 = require("rxjs/util/root"); + var Observable_1 = require("rxjs/Observable"); + var PromiseObservable = (function(_super) { + __extends(PromiseObservable, _super); + function PromiseObservable(promise, scheduler) { + if (scheduler === void 0) { + scheduler = null; + } + _super.call(this); + this.promise = promise; + this.scheduler = scheduler; + } + PromiseObservable.create = function(promise, scheduler) { + if (scheduler === void 0) { + scheduler = null; + } + return new PromiseObservable(promise, scheduler); + }; + PromiseObservable.prototype._subscribe = function(subscriber) { + var _this = this; + var promise = this.promise; + var scheduler = this.scheduler; + if (scheduler == null) { + if (this._isScalar) { + if (!subscriber.isUnsubscribed) { + subscriber.next(this.value); + subscriber.complete(); + } + } else { + promise.then(function(value) { + _this.value = value; + _this._isScalar = true; + if (!subscriber.isUnsubscribed) { + subscriber.next(value); + subscriber.complete(); + } + }, function(err) { + if (!subscriber.isUnsubscribed) { + subscriber.error(err); + } + }).then(null, function(err) { + root_1.root.setTimeout(function() { + throw err; + }); + }); + } + } else { + if (this._isScalar) { + if (!subscriber.isUnsubscribed) { + return scheduler.schedule(dispatchNext, 0, { + value: this.value, + subscriber: subscriber + }); + } + } else { + promise.then(function(value) { + _this.value = value; + _this._isScalar = true; + if (!subscriber.isUnsubscribed) { + subscriber.add(scheduler.schedule(dispatchNext, 0, { + value: value, + subscriber: subscriber + })); + } + }, function(err) { + if (!subscriber.isUnsubscribed) { + subscriber.add(scheduler.schedule(dispatchError, 0, { + err: err, + subscriber: subscriber + })); + } + }).then(null, function(err) { + root_1.root.setTimeout(function() { + throw err; + }); + }); + } + } + }; + return PromiseObservable; + }(Observable_1.Observable)); + exports.PromiseObservable = PromiseObservable; + function dispatchNext(_a) { + var value = _a.value, + subscriber = _a.subscriber; + if (!subscriber.isUnsubscribed) { + subscriber.next(value); + subscriber.complete(); + } + } + function dispatchError(_a) { + var err = _a.err, + subscriber = _a.subscriber; + if (!subscriber.isUnsubscribed) { + subscriber.error(err); + } + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/IteratorObservable", ["rxjs/util/root", "rxjs/util/isObject", "rxjs/util/tryCatch", "rxjs/Observable", "rxjs/util/isFunction", "rxjs/util/SymbolShim", "rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var root_1 = require("rxjs/util/root"); + var isObject_1 = require("rxjs/util/isObject"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var Observable_1 = require("rxjs/Observable"); + var isFunction_1 = require("rxjs/util/isFunction"); + var SymbolShim_1 = require("rxjs/util/SymbolShim"); + var errorObject_1 = require("rxjs/util/errorObject"); + var IteratorObservable = (function(_super) { + __extends(IteratorObservable, _super); + function IteratorObservable(iterator, project, thisArg, scheduler) { + _super.call(this); + if (iterator == null) { + throw new Error('iterator cannot be null.'); + } + if (isObject_1.isObject(project)) { + this.thisArg = project; + this.scheduler = thisArg; + } else if (isFunction_1.isFunction(project)) { + this.project = project; + this.thisArg = thisArg; + this.scheduler = scheduler; + } else if (project != null) { + throw new Error('When provided, `project` must be a function.'); + } + this.iterator = getIterator(iterator); + } + IteratorObservable.create = function(iterator, project, thisArg, scheduler) { + return new IteratorObservable(iterator, project, thisArg, scheduler); + }; + IteratorObservable.dispatch = function(state) { + var index = state.index, + hasError = state.hasError, + thisArg = state.thisArg, + project = state.project, + iterator = state.iterator, + subscriber = state.subscriber; + if (hasError) { + subscriber.error(state.error); + return ; + } + var result = iterator.next(); + if (result.done) { + subscriber.complete(); + return ; + } + if (project) { + result = tryCatch_1.tryCatch(project).call(thisArg, result.value, index); + if (result === errorObject_1.errorObject) { + state.error = errorObject_1.errorObject.e; + state.hasError = true; + } else { + subscriber.next(result); + state.index = index + 1; + } + } else { + subscriber.next(result.value); + state.index = index + 1; + } + if (subscriber.isUnsubscribed) { + return ; + } + this.schedule(state); + }; + IteratorObservable.prototype._subscribe = function(subscriber) { + var index = 0; + var _a = this, + iterator = _a.iterator, + project = _a.project, + thisArg = _a.thisArg, + scheduler = _a.scheduler; + if (scheduler) { + return scheduler.schedule(IteratorObservable.dispatch, 0, { + index: index, + thisArg: thisArg, + project: project, + iterator: iterator, + subscriber: subscriber + }); + } else { + do { + var result = iterator.next(); + if (result.done) { + subscriber.complete(); + break; + } else if (project) { + result = tryCatch_1.tryCatch(project).call(thisArg, result.value, index++); + if (result === errorObject_1.errorObject) { + subscriber.error(errorObject_1.errorObject.e); + break; + } + subscriber.next(result); + } else { + subscriber.next(result.value); + } + if (subscriber.isUnsubscribed) { + break; + } + } while (true); + } + }; + return IteratorObservable; + }(Observable_1.Observable)); + exports.IteratorObservable = IteratorObservable; + var StringIterator = (function() { + function StringIterator(str, idx, len) { + if (idx === void 0) { + idx = 0; + } + if (len === void 0) { + len = str.length; + } + this.str = str; + this.idx = idx; + this.len = len; + } + StringIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function() { + return (this); + }; + StringIterator.prototype.next = function() { + return this.idx < this.len ? { + done: false, + value: this.str.charAt(this.idx++) + } : { + done: true, + value: undefined + }; + }; + return StringIterator; + }()); + var ArrayIterator = (function() { + function ArrayIterator(arr, idx, len) { + if (idx === void 0) { + idx = 0; + } + if (len === void 0) { + len = toLength(arr); + } + this.arr = arr; + this.idx = idx; + this.len = len; + } + ArrayIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function() { + return this; + }; + ArrayIterator.prototype.next = function() { + return this.idx < this.len ? { + done: false, + value: this.arr[this.idx++] + } : { + done: true, + value: undefined + }; + }; + return ArrayIterator; + }()); + function getIterator(obj) { + var i = obj[SymbolShim_1.SymbolShim.iterator]; + if (!i && typeof obj === 'string') { + return new StringIterator(obj); + } + if (!i && obj.length !== undefined) { + return new ArrayIterator(obj); + } + if (!i) { + throw new TypeError('Object is not iterable'); + } + return obj[SymbolShim_1.SymbolShim.iterator](); + } + var maxSafeInteger = Math.pow(2, 53) - 1; + function toLength(o) { + var len = +o.length; + if (isNaN(len)) { + return 0; + } + if (len === 0 || !numberIsFinite(len)) { + return len; + } + len = sign(len) * Math.floor(Math.abs(len)); + if (len <= 0) { + return 0; + } + if (len > maxSafeInteger) { + return maxSafeInteger; + } + return len; + } + function numberIsFinite(value) { + return typeof value === 'number' && root_1.root.isFinite(value); + } + function sign(value) { + var valueAsNumber = +value; + if (valueAsNumber === 0) { + return valueAsNumber; + } + if (isNaN(valueAsNumber)) { + return valueAsNumber; + } + return valueAsNumber < 0 ? -1 : 1; + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/ArrayLikeObservable", ["rxjs/Observable", "rxjs/observable/ScalarObservable", "rxjs/observable/EmptyObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var ScalarObservable_1 = require("rxjs/observable/ScalarObservable"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + var ArrayLikeObservable = (function(_super) { + __extends(ArrayLikeObservable, _super); + function ArrayLikeObservable(arrayLike, mapFn, thisArg, scheduler) { + _super.call(this); + this.arrayLike = arrayLike; + this.scheduler = scheduler; + if (!mapFn && !scheduler && arrayLike.length === 1) { + this._isScalar = true; + this.value = arrayLike[0]; + } + if (mapFn) { + this.mapFn = mapFn.bind(thisArg); + } + } + ArrayLikeObservable.create = function(arrayLike, mapFn, thisArg, scheduler) { + var length = arrayLike.length; + if (length === 0) { + return new EmptyObservable_1.EmptyObservable(); + } else if (length === 1 && !mapFn) { + return new ScalarObservable_1.ScalarObservable(arrayLike[0], scheduler); + } else { + return new ArrayLikeObservable(arrayLike, mapFn, thisArg, scheduler); + } + }; + ArrayLikeObservable.dispatch = function(state) { + var arrayLike = state.arrayLike, + index = state.index, + length = state.length, + mapFn = state.mapFn, + subscriber = state.subscriber; + if (subscriber.isUnsubscribed) { + return ; + } + if (index >= length) { + subscriber.complete(); + return ; + } + var result = mapFn ? mapFn(arrayLike[index], index) : arrayLike[index]; + subscriber.next(result); + state.index = index + 1; + this.schedule(state); + }; + ArrayLikeObservable.prototype._subscribe = function(subscriber) { + var index = 0; + var _a = this, + arrayLike = _a.arrayLike, + mapFn = _a.mapFn, + scheduler = _a.scheduler; + var length = arrayLike.length; + if (scheduler) { + return scheduler.schedule(ArrayLikeObservable.dispatch, 0, { + arrayLike: arrayLike, + index: index, + length: length, + mapFn: mapFn, + subscriber: subscriber + }); + } else { + for (var i = 0; i < length && !subscriber.isUnsubscribed; i++) { + var result = mapFn ? mapFn(arrayLike[i], i) : arrayLike[i]; + subscriber.next(result); + } + subscriber.complete(); + } + }; + return ArrayLikeObservable; + }(Observable_1.Observable)); + exports.ArrayLikeObservable = ArrayLikeObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Notification", ["rxjs/Observable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var Notification = (function() { + function Notification(kind, value, exception) { + this.kind = kind; + this.value = value; + this.exception = exception; + this.hasValue = kind === 'N'; + } + Notification.prototype.observe = function(observer) { + switch (this.kind) { + case 'N': + return observer.next && observer.next(this.value); + case 'E': + return observer.error && observer.error(this.exception); + case 'C': + return observer.complete && observer.complete(); + } + }; + Notification.prototype.do = function(next, error, complete) { + var kind = this.kind; + switch (kind) { + case 'N': + return next && next(this.value); + case 'E': + return error && error(this.exception); + case 'C': + return complete && complete(); + } + }; + Notification.prototype.accept = function(nextOrObserver, error, complete) { + if (nextOrObserver && typeof nextOrObserver.next === 'function') { + return this.observe(nextOrObserver); + } else { + return this.do(nextOrObserver, error, complete); + } + }; + Notification.prototype.toObservable = function() { + var kind = this.kind; + switch (kind) { + case 'N': + return Observable_1.Observable.of(this.value); + case 'E': + return Observable_1.Observable.throw(this.exception); + case 'C': + return Observable_1.Observable.empty(); + } + }; + Notification.createNext = function(value) { + if (typeof value !== 'undefined') { + return new Notification('N', value); + } + return this.undefinedValueNotification; + }; + Notification.createError = function(err) { + return new Notification('E', undefined, err); + }; + Notification.createComplete = function() { + return this.completeNotification; + }; + Notification.completeNotification = new Notification('C'); + Notification.undefinedValueNotification = new Notification('N', undefined); + return Notification; + }()); + exports.Notification = Notification; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/fromArray", ["rxjs/Observable", "rxjs/observable/ArrayObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + Observable_1.Observable.fromArray = ArrayObservable_1.ArrayObservable.create; + Observable_1.Observable.of = ArrayObservable_1.ArrayObservable.of; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/FromEventObservable", ["rxjs/Observable", "rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/Subscription"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var Subscription_1 = require("rxjs/Subscription"); + function isNodeStyleEventEmmitter(sourceObj) { + return !!sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function'; + } + function isJQueryStyleEventEmitter(sourceObj) { + return !!sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function'; + } + function isNodeList(sourceObj) { + return !!sourceObj && sourceObj.toString() === '[object NodeList]'; + } + function isHTMLCollection(sourceObj) { + return !!sourceObj && sourceObj.toString() === '[object HTMLCollection]'; + } + function isEventTarget(sourceObj) { + return !!sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function'; + } + var FromEventObservable = (function(_super) { + __extends(FromEventObservable, _super); + function FromEventObservable(sourceObj, eventName, selector) { + _super.call(this); + this.sourceObj = sourceObj; + this.eventName = eventName; + this.selector = selector; + } + FromEventObservable.create = function(sourceObj, eventName, selector) { + return new FromEventObservable(sourceObj, eventName, selector); + }; + FromEventObservable.setupSubscription = function(sourceObj, eventName, handler, subscriber) { + var unsubscribe; + if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) { + for (var i = 0, + len = sourceObj.length; i < len; i++) { + FromEventObservable.setupSubscription(sourceObj[i], eventName, handler, subscriber); + } + } else if (isEventTarget(sourceObj)) { + sourceObj.addEventListener(eventName, handler); + unsubscribe = function() { + return sourceObj.removeEventListener(eventName, handler); + }; + } else if (isJQueryStyleEventEmitter(sourceObj)) { + sourceObj.on(eventName, handler); + unsubscribe = function() { + return sourceObj.off(eventName, handler); + }; + } else if (isNodeStyleEventEmmitter(sourceObj)) { + sourceObj.addListener(eventName, handler); + unsubscribe = function() { + return sourceObj.removeListener(eventName, handler); + }; + } + subscriber.add(new Subscription_1.Subscription(unsubscribe)); + }; + FromEventObservable.prototype._subscribe = function(subscriber) { + var sourceObj = this.sourceObj; + var eventName = this.eventName; + var selector = this.selector; + var handler = selector ? function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + var result = tryCatch_1.tryCatch(selector).apply(void 0, args); + if (result === errorObject_1.errorObject) { + subscriber.error(errorObject_1.errorObject.e); + } else { + subscriber.next(result); + } + } : function(e) { + return subscriber.next(e); + }; + FromEventObservable.setupSubscription(sourceObj, eventName, handler, subscriber); + }; + return FromEventObservable; + }(Observable_1.Observable)); + exports.FromEventObservable = FromEventObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/FromEventPatternObservable", ["rxjs/Observable", "rxjs/Subscription", "rxjs/util/tryCatch", "rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var Subscription_1 = require("rxjs/Subscription"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var FromEventPatternObservable = (function(_super) { + __extends(FromEventPatternObservable, _super); + function FromEventPatternObservable(addHandler, removeHandler, selector) { + _super.call(this); + this.addHandler = addHandler; + this.removeHandler = removeHandler; + this.selector = selector; + } + FromEventPatternObservable.create = function(addHandler, removeHandler, selector) { + return new FromEventPatternObservable(addHandler, removeHandler, selector); + }; + FromEventPatternObservable.prototype._subscribe = function(subscriber) { + var addHandler = this.addHandler; + var removeHandler = this.removeHandler; + var selector = this.selector; + var handler = selector ? function(e) { + var result = tryCatch_1.tryCatch(selector).apply(null, arguments); + if (result === errorObject_1.errorObject) { + subscriber.error(result.e); + } else { + subscriber.next(result); + } + } : function(e) { + subscriber.next(e); + }; + var result = tryCatch_1.tryCatch(addHandler)(handler); + if (result === errorObject_1.errorObject) { + subscriber.error(result.e); + } + subscriber.add(new Subscription_1.Subscription(function() { + removeHandler(handler); + })); + }; + return FromEventPatternObservable; + }(Observable_1.Observable)); + exports.FromEventPatternObservable = FromEventPatternObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/fromPromise", ["rxjs/Observable", "rxjs/observable/PromiseObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var PromiseObservable_1 = require("rxjs/observable/PromiseObservable"); + Observable_1.Observable.fromPromise = PromiseObservable_1.PromiseObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/isNumeric", ["rxjs/util/isArray"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var isArray_1 = require("rxjs/util/isArray"); + function isNumeric(val) { + return !isArray_1.isArray(val) && (val - parseFloat(val) + 1) >= 0; + } + exports.isNumeric = isNumeric; + ; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/Immediate", ["rxjs/util/root"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var root_1 = require("rxjs/util/root"); + var ImmediateDefinition = (function() { + function ImmediateDefinition(root) { + this.root = root; + if (root.setImmediate && typeof root.setImmediate === 'function') { + this.setImmediate = root.setImmediate.bind(root); + this.clearImmediate = root.clearImmediate.bind(root); + } else { + this.nextHandle = 1; + this.tasksByHandle = {}; + this.currentlyRunningATask = false; + if (this.canUseProcessNextTick()) { + this.setImmediate = this.createProcessNextTickSetImmediate(); + } else if (this.canUsePostMessage()) { + this.setImmediate = this.createPostMessageSetImmediate(); + } else if (this.canUseMessageChannel()) { + this.setImmediate = this.createMessageChannelSetImmediate(); + } else if (this.canUseReadyStateChange()) { + this.setImmediate = this.createReadyStateChangeSetImmediate(); + } else { + this.setImmediate = this.createSetTimeoutSetImmediate(); + } + var ci = function clearImmediate(handle) { + delete clearImmediate.instance.tasksByHandle[handle]; + }; + ci.instance = this; + this.clearImmediate = ci; + } + } + ImmediateDefinition.prototype.identify = function(o) { + return this.root.Object.prototype.toString.call(o); + }; + ImmediateDefinition.prototype.canUseProcessNextTick = function() { + return this.identify(this.root.process) === '[object process]'; + }; + ImmediateDefinition.prototype.canUseMessageChannel = function() { + return Boolean(this.root.MessageChannel); + }; + ImmediateDefinition.prototype.canUseReadyStateChange = function() { + var document = this.root.document; + return Boolean(document && 'onreadystatechange' in document.createElement('script')); + }; + ImmediateDefinition.prototype.canUsePostMessage = function() { + var root = this.root; + if (root.postMessage && !root.importScripts) { + var postMessageIsAsynchronous_1 = true; + var oldOnMessage = root.onmessage; + root.onmessage = function() { + postMessageIsAsynchronous_1 = false; + }; + root.postMessage('', '*'); + root.onmessage = oldOnMessage; + return postMessageIsAsynchronous_1; + } + return false; + }; + ImmediateDefinition.prototype.partiallyApplied = function(handler) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + var fn = function result() { + var _a = result, + handler = _a.handler, + args = _a.args; + if (typeof handler === 'function') { + handler.apply(undefined, args); + } else { + (new Function('' + handler))(); + } + }; + fn.handler = handler; + fn.args = args; + return fn; + }; + ImmediateDefinition.prototype.addFromSetImmediateArguments = function(args) { + this.tasksByHandle[this.nextHandle] = this.partiallyApplied.apply(undefined, args); + return this.nextHandle++; + }; + ImmediateDefinition.prototype.createProcessNextTickSetImmediate = function() { + var fn = function setImmediate() { + var instance = setImmediate.instance; + var handle = instance.addFromSetImmediateArguments(arguments); + instance.root.process.nextTick(instance.partiallyApplied(instance.runIfPresent, handle)); + return handle; + }; + fn.instance = this; + return fn; + }; + ImmediateDefinition.prototype.createPostMessageSetImmediate = function() { + var root = this.root; + var messagePrefix = 'setImmediate$' + root.Math.random() + '$'; + var onGlobalMessage = function globalMessageHandler(event) { + var instance = globalMessageHandler.instance; + if (event.source === root && typeof event.data === 'string' && event.data.indexOf(messagePrefix) === 0) { + instance.runIfPresent(+event.data.slice(messagePrefix.length)); + } + }; + onGlobalMessage.instance = this; + root.addEventListener('message', onGlobalMessage, false); + var fn = function setImmediate() { + var _a = setImmediate, + messagePrefix = _a.messagePrefix, + instance = _a.instance; + var handle = instance.addFromSetImmediateArguments(arguments); + instance.root.postMessage(messagePrefix + handle, '*'); + return handle; + }; + fn.instance = this; + fn.messagePrefix = messagePrefix; + return fn; + }; + ImmediateDefinition.prototype.runIfPresent = function(handle) { + if (this.currentlyRunningATask) { + this.root.setTimeout(this.partiallyApplied(this.runIfPresent, handle), 0); + } else { + var task = this.tasksByHandle[handle]; + if (task) { + this.currentlyRunningATask = true; + try { + task(); + } finally { + this.clearImmediate(handle); + this.currentlyRunningATask = false; + } + } + } + }; + ImmediateDefinition.prototype.createMessageChannelSetImmediate = function() { + var _this = this; + var channel = new this.root.MessageChannel(); + channel.port1.onmessage = function(event) { + var handle = event.data; + _this.runIfPresent(handle); + }; + var fn = function setImmediate() { + var _a = setImmediate, + channel = _a.channel, + instance = _a.instance; + var handle = instance.addFromSetImmediateArguments(arguments); + channel.port2.postMessage(handle); + return handle; + }; + fn.channel = channel; + fn.instance = this; + return fn; + }; + ImmediateDefinition.prototype.createReadyStateChangeSetImmediate = function() { + var fn = function setImmediate() { + var instance = setImmediate.instance; + var root = instance.root; + var doc = root.document; + var html = doc.documentElement; + var handle = instance.addFromSetImmediateArguments(arguments); + var script = doc.createElement('script'); + script.onreadystatechange = function() { + instance.runIfPresent(handle); + script.onreadystatechange = null; + html.removeChild(script); + script = null; + }; + html.appendChild(script); + return handle; + }; + fn.instance = this; + return fn; + }; + ImmediateDefinition.prototype.createSetTimeoutSetImmediate = function() { + var fn = function setImmediate() { + var instance = setImmediate.instance; + var handle = instance.addFromSetImmediateArguments(arguments); + instance.root.setTimeout(instance.partiallyApplied(instance.runIfPresent, handle), 0); + return handle; + }; + fn.instance = this; + return fn; + }; + return ImmediateDefinition; + }()); + exports.ImmediateDefinition = ImmediateDefinition; + exports.Immediate = new ImmediateDefinition(root_1.root); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/scheduler/FutureAction", ["rxjs/util/root", "rxjs/Subscription"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var root_1 = require("rxjs/util/root"); + var Subscription_1 = require("rxjs/Subscription"); + var FutureAction = (function(_super) { + __extends(FutureAction, _super); + function FutureAction(scheduler, work) { + _super.call(this); + this.scheduler = scheduler; + this.work = work; + } + FutureAction.prototype.execute = function() { + if (this.isUnsubscribed) { + throw new Error('How did did we execute a canceled Action?'); + } + this.work(this.state); + }; + FutureAction.prototype.schedule = function(state, delay) { + if (delay === void 0) { + delay = 0; + } + if (this.isUnsubscribed) { + return this; + } + return this._schedule(state, delay); + }; + FutureAction.prototype._schedule = function(state, delay) { + var _this = this; + if (delay === void 0) { + delay = 0; + } + this.delay = delay; + this.state = state; + var id = this.id; + if (id != null) { + this.id = undefined; + root_1.root.clearTimeout(id); + } + this.id = root_1.root.setTimeout(function() { + _this.id = null; + var scheduler = _this.scheduler; + scheduler.actions.push(_this); + scheduler.flush(); + }, delay); + return this; + }; + FutureAction.prototype._unsubscribe = function() { + var _a = this, + id = _a.id, + scheduler = _a.scheduler; + var actions = scheduler.actions; + var index = actions.indexOf(this); + if (id != null) { + this.id = null; + root_1.root.clearTimeout(id); + } + if (index !== -1) { + actions.splice(index, 1); + } + this.work = null; + this.state = null; + this.scheduler = null; + }; + return FutureAction; + }(Subscription_1.Subscription)); + exports.FutureAction = FutureAction; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/scheduler/QueueAction", ["rxjs/scheduler/FutureAction"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var FutureAction_1 = require("rxjs/scheduler/FutureAction"); + var QueueAction = (function(_super) { + __extends(QueueAction, _super); + function QueueAction() { + _super.apply(this, arguments); + } + 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; + var scheduler = this.scheduler; + scheduler.actions.push(this); + scheduler.flush(); + return this; + }; + return QueueAction; + }(FutureAction_1.FutureAction)); + exports.QueueAction = QueueAction; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/noop", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function noop() {} + exports.noop = noop; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/RangeObservable", ["rxjs/Observable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var RangeObservable = (function(_super) { + __extends(RangeObservable, _super); + function RangeObservable(start, end, scheduler) { + _super.call(this); + this.start = start; + this.end = end; + this.scheduler = scheduler; + } + RangeObservable.create = function(start, end, scheduler) { + if (start === void 0) { + start = 0; + } + if (end === void 0) { + end = 0; + } + return new RangeObservable(start, end, scheduler); + }; + RangeObservable.dispatch = function(state) { + var start = state.start, + index = state.index, + end = state.end, + subscriber = state.subscriber; + if (index >= end) { + subscriber.complete(); + return ; + } + subscriber.next(start); + if (subscriber.isUnsubscribed) { + return ; + } + state.index = index + 1; + state.start = start + 1; + this.schedule(state); + }; + RangeObservable.prototype._subscribe = function(subscriber) { + var index = 0; + var start = this.start; + var end = this.end; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(RangeObservable.dispatch, 0, { + index: index, + end: end, + start: start, + subscriber: subscriber + }); + } else { + do { + if (index++ >= end) { + subscriber.complete(); + break; + } + subscriber.next(start++); + if (subscriber.isUnsubscribed) { + break; + } + } while (true); + } + }; + return RangeObservable; + }(Observable_1.Observable)); + exports.RangeObservable = RangeObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/ErrorObservable", ["rxjs/Observable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var ErrorObservable = (function(_super) { + __extends(ErrorObservable, _super); + function ErrorObservable(error, scheduler) { + _super.call(this); + this.error = error; + this.scheduler = scheduler; + } + ErrorObservable.create = function(error, scheduler) { + return new ErrorObservable(error, scheduler); + }; + ErrorObservable.dispatch = function(_a) { + var error = _a.error, + subscriber = _a.subscriber; + subscriber.error(error); + }; + ErrorObservable.prototype._subscribe = function(subscriber) { + var error = this.error; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(ErrorObservable.dispatch, 0, { + error: error, + subscriber: subscriber + }); + } else { + subscriber.error(error); + } + }; + return ErrorObservable; + }(Observable_1.Observable)); + exports.ErrorObservable = ErrorObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/isDate", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function isDate(value) { + return value instanceof Date && !isNaN(+value); + } + exports.isDate = isDate; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/zip", ["rxjs/observable/ArrayObservable", "rxjs/util/isArray", "rxjs/Subscriber", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult", "rxjs/util/SymbolShim"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + var isArray_1 = require("rxjs/util/isArray"); + var Subscriber_1 = require("rxjs/Subscriber"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + var SymbolShim_1 = require("rxjs/util/SymbolShim"); + function zipProto() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + observables.unshift(this); + return zipStatic.apply(this, observables); + } + exports.zipProto = zipProto; + function zipStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var project = observables[observables.length - 1]; + if (typeof project === 'function') { + observables.pop(); + } + return new ArrayObservable_1.ArrayObservable(observables).lift(new ZipOperator(project)); + } + exports.zipStatic = zipStatic; + var ZipOperator = (function() { + function ZipOperator(project) { + this.project = project; + } + ZipOperator.prototype.call = function(subscriber) { + return new ZipSubscriber(subscriber, this.project); + }; + return ZipOperator; + }()); + exports.ZipOperator = ZipOperator; + var ZipSubscriber = (function(_super) { + __extends(ZipSubscriber, _super); + function ZipSubscriber(destination, project, values) { + if (values === void 0) { + values = Object.create(null); + } + _super.call(this, destination); + this.index = 0; + this.iterators = []; + this.active = 0; + this.project = (typeof project === 'function') ? project : null; + this.values = values; + } + ZipSubscriber.prototype._next = function(value) { + var iterators = this.iterators; + var index = this.index++; + if (isArray_1.isArray(value)) { + iterators.push(new StaticArrayIterator(value)); + } else if (typeof value[SymbolShim_1.SymbolShim.iterator] === 'function') { + iterators.push(new StaticIterator(value[SymbolShim_1.SymbolShim.iterator]())); + } else { + iterators.push(new ZipBufferIterator(this.destination, this, value, index)); + } + }; + ZipSubscriber.prototype._complete = function() { + var iterators = this.iterators; + var len = iterators.length; + this.active = len; + for (var i = 0; i < len; i++) { + var iterator = iterators[i]; + if (iterator.stillUnsubscribed) { + this.add(iterator.subscribe(iterator, i)); + } else { + this.active--; + } + } + }; + ZipSubscriber.prototype.notifyInactive = function() { + this.active--; + if (this.active === 0) { + this.destination.complete(); + } + }; + ZipSubscriber.prototype.checkIterators = function() { + var iterators = this.iterators; + var len = iterators.length; + var destination = this.destination; + for (var i = 0; i < len; i++) { + var iterator = iterators[i]; + if (typeof iterator.hasValue === 'function' && !iterator.hasValue()) { + return ; + } + } + var shouldComplete = false; + var args = []; + for (var i = 0; i < len; i++) { + var iterator = iterators[i]; + var result = iterator.next(); + if (iterator.hasCompleted()) { + shouldComplete = true; + } + if (result.done) { + destination.complete(); + return ; + } + args.push(result.value); + } + if (this.project) { + this._tryProject(args); + } else { + destination.next(args); + } + if (shouldComplete) { + destination.complete(); + } + }; + ZipSubscriber.prototype._tryProject = function(args) { + var result; + try { + result = this.project.apply(this, args); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.next(result); + }; + return ZipSubscriber; + }(Subscriber_1.Subscriber)); + exports.ZipSubscriber = ZipSubscriber; + var StaticIterator = (function() { + function StaticIterator(iterator) { + this.iterator = iterator; + this.nextResult = iterator.next(); + } + StaticIterator.prototype.hasValue = function() { + return true; + }; + StaticIterator.prototype.next = function() { + var result = this.nextResult; + this.nextResult = this.iterator.next(); + return result; + }; + StaticIterator.prototype.hasCompleted = function() { + var nextResult = this.nextResult; + return nextResult && nextResult.done; + }; + return StaticIterator; + }()); + var StaticArrayIterator = (function() { + function StaticArrayIterator(array) { + this.array = array; + this.index = 0; + this.length = 0; + this.length = array.length; + } + StaticArrayIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function() { + return this; + }; + StaticArrayIterator.prototype.next = function(value) { + var i = this.index++; + var array = this.array; + return i < this.length ? { + value: array[i], + done: false + } : {done: true}; + }; + StaticArrayIterator.prototype.hasValue = function() { + return this.array.length > this.index; + }; + StaticArrayIterator.prototype.hasCompleted = function() { + return this.array.length === this.index; + }; + return StaticArrayIterator; + }()); + var ZipBufferIterator = (function(_super) { + __extends(ZipBufferIterator, _super); + function ZipBufferIterator(destination, parent, observable, index) { + _super.call(this, destination); + this.parent = parent; + this.observable = observable; + this.index = index; + this.stillUnsubscribed = true; + this.buffer = []; + this.isComplete = false; + } + ZipBufferIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function() { + return this; + }; + ZipBufferIterator.prototype.next = function() { + var buffer = this.buffer; + if (buffer.length === 0 && this.isComplete) { + return {done: true}; + } else { + return { + value: buffer.shift(), + done: false + }; + } + }; + ZipBufferIterator.prototype.hasValue = function() { + return this.buffer.length > 0; + }; + ZipBufferIterator.prototype.hasCompleted = function() { + return this.buffer.length === 0 && this.isComplete; + }; + ZipBufferIterator.prototype.notifyComplete = function() { + if (this.buffer.length > 0) { + this.isComplete = true; + this.parent.notifyInactive(); + } else { + this.destination.complete(); + } + }; + ZipBufferIterator.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.buffer.push(innerValue); + this.parent.checkIterators(); + }; + ZipBufferIterator.prototype.subscribe = function(value, index) { + return subscribeToResult_1.subscribeToResult(this, this.observable, this, index); + }; + return ZipBufferIterator; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/buffer", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function buffer(closingNotifier) { + return this.lift(new BufferOperator(closingNotifier)); + } + exports.buffer = buffer; + var BufferOperator = (function() { + function BufferOperator(closingNotifier) { + this.closingNotifier = closingNotifier; + } + BufferOperator.prototype.call = function(subscriber) { + return new BufferSubscriber(subscriber, this.closingNotifier); + }; + return BufferOperator; + }()); + var BufferSubscriber = (function(_super) { + __extends(BufferSubscriber, _super); + function BufferSubscriber(destination, closingNotifier) { + _super.call(this, destination); + this.buffer = []; + this.add(subscribeToResult_1.subscribeToResult(this, closingNotifier)); + } + BufferSubscriber.prototype._next = function(value) { + this.buffer.push(value); + }; + BufferSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var buffer = this.buffer; + this.buffer = []; + this.destination.next(buffer); + }; + return BufferSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/bufferCount", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function bufferCount(bufferSize, startBufferEvery) { + if (startBufferEvery === void 0) { + startBufferEvery = null; + } + return this.lift(new BufferCountOperator(bufferSize, startBufferEvery)); + } + exports.bufferCount = bufferCount; + var BufferCountOperator = (function() { + function BufferCountOperator(bufferSize, startBufferEvery) { + this.bufferSize = bufferSize; + this.startBufferEvery = startBufferEvery; + } + BufferCountOperator.prototype.call = function(subscriber) { + return new BufferCountSubscriber(subscriber, this.bufferSize, this.startBufferEvery); + }; + return BufferCountOperator; + }()); + var BufferCountSubscriber = (function(_super) { + __extends(BufferCountSubscriber, _super); + function BufferCountSubscriber(destination, bufferSize, startBufferEvery) { + _super.call(this, destination); + this.bufferSize = bufferSize; + this.startBufferEvery = startBufferEvery; + this.buffers = [[]]; + this.count = 0; + } + BufferCountSubscriber.prototype._next = function(value) { + var count = (this.count += 1); + var destination = this.destination; + var bufferSize = this.bufferSize; + var startBufferEvery = (this.startBufferEvery == null) ? bufferSize : this.startBufferEvery; + var buffers = this.buffers; + var len = buffers.length; + var remove = -1; + if (count % startBufferEvery === 0) { + buffers.push([]); + } + for (var i = 0; i < len; i++) { + var buffer = buffers[i]; + buffer.push(value); + if (buffer.length === bufferSize) { + remove = i; + destination.next(buffer); + } + } + if (remove !== -1) { + buffers.splice(remove, 1); + } + }; + BufferCountSubscriber.prototype._complete = function() { + var destination = this.destination; + var buffers = this.buffers; + while (buffers.length > 0) { + var buffer = buffers.shift(); + if (buffer.length > 0) { + destination.next(buffer); + } + } + _super.prototype._complete.call(this); + }; + return BufferCountSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/bufferTime", ["rxjs/Subscriber", "rxjs/scheduler/asap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var asap_1 = require("rxjs/scheduler/asap"); + function bufferTime(bufferTimeSpan, bufferCreationInterval, scheduler) { + if (bufferCreationInterval === void 0) { + bufferCreationInterval = null; + } + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return this.lift(new BufferTimeOperator(bufferTimeSpan, bufferCreationInterval, scheduler)); + } + exports.bufferTime = bufferTime; + var BufferTimeOperator = (function() { + function BufferTimeOperator(bufferTimeSpan, bufferCreationInterval, scheduler) { + this.bufferTimeSpan = bufferTimeSpan; + this.bufferCreationInterval = bufferCreationInterval; + this.scheduler = scheduler; + } + BufferTimeOperator.prototype.call = function(subscriber) { + return new BufferTimeSubscriber(subscriber, this.bufferTimeSpan, this.bufferCreationInterval, this.scheduler); + }; + return BufferTimeOperator; + }()); + var BufferTimeSubscriber = (function(_super) { + __extends(BufferTimeSubscriber, _super); + function BufferTimeSubscriber(destination, bufferTimeSpan, bufferCreationInterval, scheduler) { + _super.call(this, destination); + this.bufferTimeSpan = bufferTimeSpan; + this.bufferCreationInterval = bufferCreationInterval; + this.scheduler = scheduler; + this.buffers = []; + var buffer = this.openBuffer(); + if (bufferCreationInterval !== null && bufferCreationInterval >= 0) { + var closeState = { + subscriber: this, + buffer: buffer + }; + var creationState = { + bufferTimeSpan: bufferTimeSpan, + bufferCreationInterval: bufferCreationInterval, + subscriber: this, + scheduler: scheduler + }; + this.add(scheduler.schedule(dispatchBufferClose, bufferTimeSpan, closeState)); + this.add(scheduler.schedule(dispatchBufferCreation, bufferCreationInterval, creationState)); + } else { + var timeSpanOnlyState = { + subscriber: this, + buffer: buffer, + bufferTimeSpan: bufferTimeSpan + }; + this.add(scheduler.schedule(dispatchBufferTimeSpanOnly, bufferTimeSpan, timeSpanOnlyState)); + } + } + BufferTimeSubscriber.prototype._next = function(value) { + var buffers = this.buffers; + var len = buffers.length; + for (var i = 0; i < len; i++) { + buffers[i].push(value); + } + }; + BufferTimeSubscriber.prototype._error = function(err) { + this.buffers.length = 0; + _super.prototype._error.call(this, err); + }; + BufferTimeSubscriber.prototype._complete = function() { + var _a = this, + buffers = _a.buffers, + destination = _a.destination; + while (buffers.length > 0) { + destination.next(buffers.shift()); + } + _super.prototype._complete.call(this); + }; + BufferTimeSubscriber.prototype._unsubscribe = function() { + this.buffers = null; + }; + BufferTimeSubscriber.prototype.openBuffer = function() { + var buffer = []; + this.buffers.push(buffer); + return buffer; + }; + BufferTimeSubscriber.prototype.closeBuffer = function(buffer) { + this.destination.next(buffer); + var buffers = this.buffers; + buffers.splice(buffers.indexOf(buffer), 1); + }; + return BufferTimeSubscriber; + }(Subscriber_1.Subscriber)); + function dispatchBufferTimeSpanOnly(state) { + var subscriber = state.subscriber; + var prevBuffer = state.buffer; + if (prevBuffer) { + subscriber.closeBuffer(prevBuffer); + } + state.buffer = subscriber.openBuffer(); + if (!subscriber.isUnsubscribed) { + this.schedule(state, state.bufferTimeSpan); + } + } + function dispatchBufferCreation(state) { + var bufferCreationInterval = state.bufferCreationInterval, + bufferTimeSpan = state.bufferTimeSpan, + subscriber = state.subscriber, + scheduler = state.scheduler; + var buffer = subscriber.openBuffer(); + var action = this; + if (!subscriber.isUnsubscribed) { + action.add(scheduler.schedule(dispatchBufferClose, bufferTimeSpan, { + subscriber: subscriber, + buffer: buffer + })); + action.schedule(state, bufferCreationInterval); + } + } + function dispatchBufferClose(_a) { + var subscriber = _a.subscriber, + buffer = _a.buffer; + subscriber.closeBuffer(buffer); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/bufferToggle", ["rxjs/Subscriber", "rxjs/Subscription", "rxjs/util/tryCatch", "rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Subscription_1 = require("rxjs/Subscription"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + function bufferToggle(openings, closingSelector) { + return this.lift(new BufferToggleOperator(openings, closingSelector)); + } + exports.bufferToggle = bufferToggle; + var BufferToggleOperator = (function() { + function BufferToggleOperator(openings, closingSelector) { + this.openings = openings; + this.closingSelector = closingSelector; + } + BufferToggleOperator.prototype.call = function(subscriber) { + return new BufferToggleSubscriber(subscriber, this.openings, this.closingSelector); + }; + return BufferToggleOperator; + }()); + var BufferToggleSubscriber = (function(_super) { + __extends(BufferToggleSubscriber, _super); + function BufferToggleSubscriber(destination, openings, closingSelector) { + _super.call(this, destination); + this.openings = openings; + this.closingSelector = closingSelector; + this.contexts = []; + this.add(this.openings.subscribe(new BufferToggleOpeningsSubscriber(this))); + } + BufferToggleSubscriber.prototype._next = function(value) { + var contexts = this.contexts; + var len = contexts.length; + for (var i = 0; i < len; i++) { + contexts[i].buffer.push(value); + } + }; + BufferToggleSubscriber.prototype._error = function(err) { + var contexts = this.contexts; + while (contexts.length > 0) { + var context = contexts.shift(); + context.subscription.unsubscribe(); + context.buffer = null; + context.subscription = null; + } + this.contexts = null; + _super.prototype._error.call(this, err); + }; + BufferToggleSubscriber.prototype._complete = function() { + var contexts = this.contexts; + while (contexts.length > 0) { + var context = contexts.shift(); + this.destination.next(context.buffer); + context.subscription.unsubscribe(); + context.buffer = null; + context.subscription = null; + } + this.contexts = null; + _super.prototype._complete.call(this); + }; + BufferToggleSubscriber.prototype.openBuffer = function(value) { + var closingSelector = this.closingSelector; + var contexts = this.contexts; + var closingNotifier = tryCatch_1.tryCatch(closingSelector)(value); + if (closingNotifier === errorObject_1.errorObject) { + this._error(errorObject_1.errorObject.e); + } else { + var context = { + buffer: [], + subscription: new Subscription_1.Subscription() + }; + contexts.push(context); + var subscriber = new BufferToggleClosingsSubscriber(this, context); + var subscription = closingNotifier.subscribe(subscriber); + context.subscription.add(subscription); + this.add(subscription); + } + }; + BufferToggleSubscriber.prototype.closeBuffer = function(context) { + var contexts = this.contexts; + if (contexts === null) { + return ; + } + var buffer = context.buffer, + subscription = context.subscription; + this.destination.next(buffer); + contexts.splice(contexts.indexOf(context), 1); + this.remove(subscription); + subscription.unsubscribe(); + }; + return BufferToggleSubscriber; + }(Subscriber_1.Subscriber)); + var BufferToggleOpeningsSubscriber = (function(_super) { + __extends(BufferToggleOpeningsSubscriber, _super); + function BufferToggleOpeningsSubscriber(parent) { + _super.call(this, null); + this.parent = parent; + } + BufferToggleOpeningsSubscriber.prototype._next = function(value) { + this.parent.openBuffer(value); + }; + BufferToggleOpeningsSubscriber.prototype._error = function(err) { + this.parent.error(err); + }; + BufferToggleOpeningsSubscriber.prototype._complete = function() {}; + return BufferToggleOpeningsSubscriber; + }(Subscriber_1.Subscriber)); + var BufferToggleClosingsSubscriber = (function(_super) { + __extends(BufferToggleClosingsSubscriber, _super); + function BufferToggleClosingsSubscriber(parent, context) { + _super.call(this, null); + this.parent = parent; + this.context = context; + } + BufferToggleClosingsSubscriber.prototype._next = function() { + this.parent.closeBuffer(this.context); + }; + BufferToggleClosingsSubscriber.prototype._error = function(err) { + this.parent.error(err); + }; + BufferToggleClosingsSubscriber.prototype._complete = function() { + this.parent.closeBuffer(this.context); + }; + return BufferToggleClosingsSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/bufferWhen", ["rxjs/Subscription", "rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscription_1 = require("rxjs/Subscription"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function bufferWhen(closingSelector) { + return this.lift(new BufferWhenOperator(closingSelector)); + } + exports.bufferWhen = bufferWhen; + var BufferWhenOperator = (function() { + function BufferWhenOperator(closingSelector) { + this.closingSelector = closingSelector; + } + BufferWhenOperator.prototype.call = function(subscriber) { + return new BufferWhenSubscriber(subscriber, this.closingSelector); + }; + return BufferWhenOperator; + }()); + var BufferWhenSubscriber = (function(_super) { + __extends(BufferWhenSubscriber, _super); + function BufferWhenSubscriber(destination, closingSelector) { + _super.call(this, destination); + this.closingSelector = closingSelector; + this.subscribing = false; + this.openBuffer(); + } + BufferWhenSubscriber.prototype._next = function(value) { + this.buffer.push(value); + }; + BufferWhenSubscriber.prototype._complete = function() { + var buffer = this.buffer; + if (buffer) { + this.destination.next(buffer); + } + _super.prototype._complete.call(this); + }; + BufferWhenSubscriber.prototype._unsubscribe = function() { + this.buffer = null; + this.subscribing = false; + }; + BufferWhenSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.openBuffer(); + }; + BufferWhenSubscriber.prototype.notifyComplete = function() { + if (this.subscribing) { + this.complete(); + } else { + this.openBuffer(); + } + }; + BufferWhenSubscriber.prototype.openBuffer = function() { + var closingSubscription = this.closingSubscription; + if (closingSubscription) { + this.remove(closingSubscription); + closingSubscription.unsubscribe(); + } + var buffer = this.buffer; + if (this.buffer) { + this.destination.next(buffer); + } + this.buffer = []; + var closingNotifier = tryCatch_1.tryCatch(this.closingSelector)(); + if (closingNotifier === errorObject_1.errorObject) { + this.error(errorObject_1.errorObject.e); + } else { + closingSubscription = new Subscription_1.Subscription(); + this.closingSubscription = closingSubscription; + this.add(closingSubscription); + this.subscribing = true; + closingSubscription.add(subscribeToResult_1.subscribeToResult(this, closingNotifier)); + this.subscribing = false; + } + }; + return BufferWhenSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/scheduler/queue", ["rxjs/scheduler/QueueScheduler"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var QueueScheduler_1 = require("rxjs/scheduler/QueueScheduler"); + exports.queue = new QueueScheduler_1.QueueScheduler(); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/ConnectableObservable", ["rxjs/Observable", "rxjs/Subscriber", "rxjs/Subscription"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var Subscriber_1 = require("rxjs/Subscriber"); + var Subscription_1 = require("rxjs/Subscription"); + var ConnectableObservable = (function(_super) { + __extends(ConnectableObservable, _super); + function ConnectableObservable(source, subjectFactory) { + _super.call(this); + this.source = source; + this.subjectFactory = subjectFactory; + } + ConnectableObservable.prototype._subscribe = function(subscriber) { + return this.getSubject().subscribe(subscriber); + }; + ConnectableObservable.prototype.getSubject = function() { + var subject = this.subject; + if (subject && !subject.isUnsubscribed) { + return subject; + } + return (this.subject = this.subjectFactory()); + }; + ConnectableObservable.prototype.connect = function() { + var source = this.source; + var subscription = this.subscription; + if (subscription && !subscription.isUnsubscribed) { + return subscription; + } + subscription = source.subscribe(this.getSubject()); + subscription.add(new ConnectableSubscription(this)); + return (this.subscription = subscription); + }; + ConnectableObservable.prototype.refCount = function() { + return new RefCountObservable(this); + }; + ConnectableObservable.prototype._closeSubscription = function() { + this.subject = null; + this.subscription = null; + }; + return ConnectableObservable; + }(Observable_1.Observable)); + exports.ConnectableObservable = ConnectableObservable; + var ConnectableSubscription = (function(_super) { + __extends(ConnectableSubscription, _super); + function ConnectableSubscription(connectable) { + _super.call(this); + this.connectable = connectable; + } + ConnectableSubscription.prototype._unsubscribe = function() { + var connectable = this.connectable; + connectable._closeSubscription(); + this.connectable = null; + }; + return ConnectableSubscription; + }(Subscription_1.Subscription)); + var RefCountObservable = (function(_super) { + __extends(RefCountObservable, _super); + function RefCountObservable(connectable, refCount) { + if (refCount === void 0) { + refCount = 0; + } + _super.call(this); + this.connectable = connectable; + this.refCount = refCount; + } + RefCountObservable.prototype._subscribe = function(subscriber) { + var connectable = this.connectable; + var refCountSubscriber = new RefCountSubscriber(subscriber, this); + var subscription = connectable.subscribe(refCountSubscriber); + if (!subscription.isUnsubscribed && ++this.refCount === 1) { + refCountSubscriber.connection = this.connection = connectable.connect(); + } + return subscription; + }; + return RefCountObservable; + }(Observable_1.Observable)); + var RefCountSubscriber = (function(_super) { + __extends(RefCountSubscriber, _super); + function RefCountSubscriber(destination, refCountObservable) { + _super.call(this, null); + this.destination = destination; + this.refCountObservable = refCountObservable; + this.connection = refCountObservable.connection; + destination.add(this); + } + RefCountSubscriber.prototype._next = function(value) { + this.destination.next(value); + }; + RefCountSubscriber.prototype._error = function(err) { + this._resetConnectable(); + this.destination.error(err); + }; + RefCountSubscriber.prototype._complete = function() { + this._resetConnectable(); + this.destination.complete(); + }; + RefCountSubscriber.prototype._resetConnectable = function() { + var observable = this.refCountObservable; + var obsConnection = observable.connection; + var subConnection = this.connection; + if (subConnection && subConnection === obsConnection) { + observable.refCount = 0; + obsConnection.unsubscribe(); + observable.connection = null; + this.unsubscribe(); + } + }; + RefCountSubscriber.prototype._unsubscribe = function() { + var observable = this.refCountObservable; + if (observable.refCount === 0) { + return ; + } + if (--observable.refCount === 0) { + var obsConnection = observable.connection; + var subConnection = this.connection; + if (subConnection && subConnection === obsConnection) { + obsConnection.unsubscribe(); + observable.connection = null; + } + } + }; + return RefCountSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/catch", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function _catch(selector) { + var operator = new CatchOperator(selector); + var caught = this.lift(operator); + return (operator.caught = caught); + } + exports._catch = _catch; + var CatchOperator = (function() { + function CatchOperator(selector) { + this.selector = selector; + } + CatchOperator.prototype.call = function(subscriber) { + return new CatchSubscriber(subscriber, this.selector, this.caught); + }; + return CatchOperator; + }()); + var CatchSubscriber = (function(_super) { + __extends(CatchSubscriber, _super); + function CatchSubscriber(destination, selector, caught) { + _super.call(this, destination); + this.selector = selector; + this.caught = caught; + } + CatchSubscriber.prototype.error = function(err) { + if (!this.isStopped) { + var result = void 0; + try { + result = this.selector(err, this.caught); + } catch (err) { + this.destination.error(err); + return ; + } + this._innerSub(result); + } + }; + CatchSubscriber.prototype._innerSub = function(result) { + this.unsubscribe(); + this.destination.remove(this); + result.subscribe(this.destination); + }; + return CatchSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/combineAll", ["rxjs/operator/combineLatest"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var combineLatest_1 = require("rxjs/operator/combineLatest"); + function combineAll(project) { + return this.lift(new combineLatest_1.CombineLatestOperator(project)); + } + exports.combineAll = combineAll; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/combineLatest", ["rxjs/Observable", "rxjs/operator/combineLatest"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var combineLatest_1 = require("rxjs/operator/combineLatest"); + Observable_1.Observable.prototype.combineLatest = combineLatest_1.combineLatest; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/concat", ["rxjs/Observable", "rxjs/operator/concat"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var concat_1 = require("rxjs/operator/concat"); + Observable_1.Observable.prototype.concat = concat_1.concat; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/concatAll", ["rxjs/operator/mergeAll"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var mergeAll_1 = require("rxjs/operator/mergeAll"); + function concatAll() { + return this.lift(new mergeAll_1.MergeAllOperator(1)); + } + exports.concatAll = concatAll; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/mergeMap", ["rxjs/util/subscribeToResult", "rxjs/OuterSubscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + function mergeMap(project, resultSelector, concurrent) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + return this.lift(new MergeMapOperator(project, resultSelector, concurrent)); + } + exports.mergeMap = mergeMap; + var MergeMapOperator = (function() { + function MergeMapOperator(project, resultSelector, concurrent) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + this.project = project; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + } + MergeMapOperator.prototype.call = function(observer) { + return new MergeMapSubscriber(observer, this.project, this.resultSelector, this.concurrent); + }; + return MergeMapOperator; + }()); + exports.MergeMapOperator = MergeMapOperator; + var MergeMapSubscriber = (function(_super) { + __extends(MergeMapSubscriber, _super); + function MergeMapSubscriber(destination, project, resultSelector, concurrent) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + _super.call(this, destination); + this.project = project; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + this.hasCompleted = false; + this.buffer = []; + this.active = 0; + this.index = 0; + } + MergeMapSubscriber.prototype._next = function(value) { + if (this.active < this.concurrent) { + this._tryNext(value); + } else { + this.buffer.push(value); + } + }; + MergeMapSubscriber.prototype._tryNext = function(value) { + var result; + var index = this.index++; + try { + result = this.project(value, index); + } catch (err) { + this.destination.error(err); + return ; + } + this.active++; + this._innerSub(result, value, index); + }; + MergeMapSubscriber.prototype._innerSub = function(ish, value, index) { + this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index)); + }; + MergeMapSubscriber.prototype._complete = function() { + this.hasCompleted = true; + if (this.active === 0 && this.buffer.length === 0) { + this.destination.complete(); + } + }; + MergeMapSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (this.resultSelector) { + this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex); + } else { + this.destination.next(innerValue); + } + }; + MergeMapSubscriber.prototype._notifyResultSelector = function(outerValue, innerValue, outerIndex, innerIndex) { + var result; + try { + result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.next(result); + }; + MergeMapSubscriber.prototype.notifyComplete = function(innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer.length > 0) { + this._next(buffer.shift()); + } else if (this.active === 0 && this.hasCompleted) { + this.destination.complete(); + } + }; + return MergeMapSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + exports.MergeMapSubscriber = MergeMapSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/mergeMapTo", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function mergeMapTo(observable, resultSelector, concurrent) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + return this.lift(new MergeMapToOperator(observable, resultSelector, concurrent)); + } + exports.mergeMapTo = mergeMapTo; + var MergeMapToOperator = (function() { + function MergeMapToOperator(ish, resultSelector, concurrent) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + this.ish = ish; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + } + MergeMapToOperator.prototype.call = function(observer) { + return new MergeMapToSubscriber(observer, this.ish, this.resultSelector, this.concurrent); + }; + return MergeMapToOperator; + }()); + exports.MergeMapToOperator = MergeMapToOperator; + var MergeMapToSubscriber = (function(_super) { + __extends(MergeMapToSubscriber, _super); + function MergeMapToSubscriber(destination, ish, resultSelector, concurrent) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + _super.call(this, destination); + this.ish = ish; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + this.hasCompleted = false; + this.buffer = []; + this.active = 0; + this.index = 0; + } + MergeMapToSubscriber.prototype._next = function(value) { + if (this.active < this.concurrent) { + var resultSelector = this.resultSelector; + var index = this.index++; + var ish = this.ish; + var destination = this.destination; + this.active++; + this._innerSub(ish, destination, resultSelector, value, index); + } else { + this.buffer.push(value); + } + }; + MergeMapToSubscriber.prototype._innerSub = function(ish, destination, resultSelector, value, index) { + this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index)); + }; + MergeMapToSubscriber.prototype._complete = function() { + this.hasCompleted = true; + if (this.active === 0 && this.buffer.length === 0) { + this.destination.complete(); + } + }; + MergeMapToSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var _a = this, + resultSelector = _a.resultSelector, + destination = _a.destination; + if (resultSelector) { + this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex); + } else { + destination.next(innerValue); + } + }; + MergeMapToSubscriber.prototype.trySelectResult = function(outerValue, innerValue, outerIndex, innerIndex) { + var _a = this, + resultSelector = _a.resultSelector, + destination = _a.destination; + var result; + try { + result = resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } catch (err) { + destination.error(err); + return ; + } + destination.next(result); + }; + MergeMapToSubscriber.prototype.notifyError = function(err) { + this.destination.error(err); + }; + MergeMapToSubscriber.prototype.notifyComplete = function(innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer.length > 0) { + this._next(buffer.shift()); + } else if (this.active === 0 && this.hasCompleted) { + this.destination.complete(); + } + }; + return MergeMapToSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + exports.MergeMapToSubscriber = MergeMapToSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/count", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function count(predicate) { + return this.lift(new CountOperator(predicate, this)); + } + exports.count = count; + var CountOperator = (function() { + function CountOperator(predicate, source) { + this.predicate = predicate; + this.source = source; + } + CountOperator.prototype.call = function(subscriber) { + return new CountSubscriber(subscriber, this.predicate, this.source); + }; + return CountOperator; + }()); + var CountSubscriber = (function(_super) { + __extends(CountSubscriber, _super); + function CountSubscriber(destination, predicate, source) { + _super.call(this, destination); + this.predicate = predicate; + this.source = source; + this.count = 0; + this.index = 0; + } + CountSubscriber.prototype._next = function(value) { + if (this.predicate) { + this._tryPredicate(value); + } else { + this.count++; + } + }; + CountSubscriber.prototype._tryPredicate = function(value) { + var result; + try { + result = this.predicate(value, this.index++, this.source); + } catch (err) { + this.destination.error(err); + return ; + } + if (result) { + this.count++; + } + }; + CountSubscriber.prototype._complete = function() { + this.destination.next(this.count); + this.destination.complete(); + }; + return CountSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/dematerialize", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function dematerialize() { + return this.lift(new DeMaterializeOperator()); + } + exports.dematerialize = dematerialize; + var DeMaterializeOperator = (function() { + function DeMaterializeOperator() {} + DeMaterializeOperator.prototype.call = function(subscriber) { + return new DeMaterializeSubscriber(subscriber); + }; + return DeMaterializeOperator; + }()); + var DeMaterializeSubscriber = (function(_super) { + __extends(DeMaterializeSubscriber, _super); + function DeMaterializeSubscriber(destination) { + _super.call(this, destination); + } + DeMaterializeSubscriber.prototype._next = function(value) { + value.observe(this.destination); + }; + return DeMaterializeSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/debounce", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function debounce(durationSelector) { + return this.lift(new DebounceOperator(durationSelector)); + } + exports.debounce = debounce; + var DebounceOperator = (function() { + function DebounceOperator(durationSelector) { + this.durationSelector = durationSelector; + } + DebounceOperator.prototype.call = function(subscriber) { + return new DebounceSubscriber(subscriber, this.durationSelector); + }; + return DebounceOperator; + }()); + var DebounceSubscriber = (function(_super) { + __extends(DebounceSubscriber, _super); + function DebounceSubscriber(destination, durationSelector) { + _super.call(this, destination); + this.durationSelector = durationSelector; + this.hasValue = false; + this.durationSubscription = null; + } + DebounceSubscriber.prototype._next = function(value) { + try { + var result = this.durationSelector.call(this, value); + if (result) { + this._tryNext(value, result); + } + } catch (err) { + this.destination.error(err); + } + }; + DebounceSubscriber.prototype._complete = function() { + this.emitValue(); + this.destination.complete(); + }; + DebounceSubscriber.prototype._tryNext = function(value, duration) { + var subscription = this.durationSubscription; + this.value = value; + this.hasValue = true; + if (subscription) { + subscription.unsubscribe(); + this.remove(subscription); + } + subscription = subscribeToResult_1.subscribeToResult(this, duration); + if (!subscription.isUnsubscribed) { + this.add(this.durationSubscription = subscription); + } + }; + DebounceSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.emitValue(); + }; + DebounceSubscriber.prototype.notifyComplete = function() { + this.emitValue(); + }; + DebounceSubscriber.prototype.emitValue = function() { + if (this.hasValue) { + var value = this.value; + var subscription = this.durationSubscription; + if (subscription) { + this.durationSubscription = null; + subscription.unsubscribe(); + this.remove(subscription); + } + this.value = null; + this.hasValue = false; + _super.prototype._next.call(this, value); + } + }; + return DebounceSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/debounceTime", ["rxjs/Subscriber", "rxjs/scheduler/asap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var asap_1 = require("rxjs/scheduler/asap"); + function debounceTime(dueTime, scheduler) { + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return this.lift(new DebounceTimeOperator(dueTime, scheduler)); + } + exports.debounceTime = debounceTime; + var DebounceTimeOperator = (function() { + function DebounceTimeOperator(dueTime, scheduler) { + this.dueTime = dueTime; + this.scheduler = scheduler; + } + DebounceTimeOperator.prototype.call = function(subscriber) { + return new DebounceTimeSubscriber(subscriber, this.dueTime, this.scheduler); + }; + return DebounceTimeOperator; + }()); + var DebounceTimeSubscriber = (function(_super) { + __extends(DebounceTimeSubscriber, _super); + function DebounceTimeSubscriber(destination, dueTime, scheduler) { + _super.call(this, destination); + this.dueTime = dueTime; + this.scheduler = scheduler; + this.debouncedSubscription = null; + this.lastValue = null; + this.hasValue = false; + } + DebounceTimeSubscriber.prototype._next = function(value) { + this.clearDebounce(); + this.lastValue = value; + this.hasValue = true; + this.add(this.debouncedSubscription = this.scheduler.schedule(dispatchNext, this.dueTime, this)); + }; + DebounceTimeSubscriber.prototype._complete = function() { + this.debouncedNext(); + this.destination.complete(); + }; + DebounceTimeSubscriber.prototype.debouncedNext = function() { + this.clearDebounce(); + if (this.hasValue) { + this.destination.next(this.lastValue); + this.lastValue = null; + this.hasValue = false; + } + }; + DebounceTimeSubscriber.prototype.clearDebounce = function() { + var debouncedSubscription = this.debouncedSubscription; + if (debouncedSubscription !== null) { + this.remove(debouncedSubscription); + debouncedSubscription.unsubscribe(); + this.debouncedSubscription = null; + } + }; + return DebounceTimeSubscriber; + }(Subscriber_1.Subscriber)); + function dispatchNext(subscriber) { + subscriber.debouncedNext(); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/defaultIfEmpty", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function defaultIfEmpty(defaultValue) { + if (defaultValue === void 0) { + defaultValue = null; + } + return this.lift(new DefaultIfEmptyOperator(defaultValue)); + } + exports.defaultIfEmpty = defaultIfEmpty; + var DefaultIfEmptyOperator = (function() { + function DefaultIfEmptyOperator(defaultValue) { + this.defaultValue = defaultValue; + } + DefaultIfEmptyOperator.prototype.call = function(subscriber) { + return new DefaultIfEmptySubscriber(subscriber, this.defaultValue); + }; + return DefaultIfEmptyOperator; + }()); + var DefaultIfEmptySubscriber = (function(_super) { + __extends(DefaultIfEmptySubscriber, _super); + function DefaultIfEmptySubscriber(destination, defaultValue) { + _super.call(this, destination); + this.defaultValue = defaultValue; + this.isEmpty = true; + } + DefaultIfEmptySubscriber.prototype._next = function(value) { + this.isEmpty = false; + this.destination.next(value); + }; + DefaultIfEmptySubscriber.prototype._complete = function() { + if (this.isEmpty) { + this.destination.next(this.defaultValue); + } + this.destination.complete(); + }; + return DefaultIfEmptySubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/delay", ["rxjs/scheduler/asap", "rxjs/util/isDate", "rxjs/Subscriber", "rxjs/Notification"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var asap_1 = require("rxjs/scheduler/asap"); + var isDate_1 = require("rxjs/util/isDate"); + var Subscriber_1 = require("rxjs/Subscriber"); + var Notification_1 = require("rxjs/Notification"); + function delay(delay, scheduler) { + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + var absoluteDelay = isDate_1.isDate(delay); + var delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay); + return this.lift(new DelayOperator(delayFor, scheduler)); + } + exports.delay = delay; + var DelayOperator = (function() { + function DelayOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + DelayOperator.prototype.call = function(subscriber) { + return new DelaySubscriber(subscriber, this.delay, this.scheduler); + }; + return DelayOperator; + }()); + var DelaySubscriber = (function(_super) { + __extends(DelaySubscriber, _super); + function DelaySubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + this.queue = []; + this.active = false; + this.errored = false; + } + DelaySubscriber.dispatch = function(state) { + var source = state.source; + var queue = source.queue; + var scheduler = state.scheduler; + var destination = state.destination; + while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) { + queue.shift().notification.observe(destination); + } + if (queue.length > 0) { + var delay_1 = Math.max(0, queue[0].time - scheduler.now()); + this.schedule(state, delay_1); + } else { + source.active = false; + } + }; + DelaySubscriber.prototype._schedule = function(scheduler) { + this.active = true; + this.add(scheduler.schedule(DelaySubscriber.dispatch, this.delay, { + source: this, + destination: this.destination, + scheduler: scheduler + })); + }; + DelaySubscriber.prototype.scheduleNotification = function(notification) { + if (this.errored === true) { + return ; + } + var scheduler = this.scheduler; + var message = new DelayMessage(scheduler.now() + this.delay, notification); + this.queue.push(message); + if (this.active === false) { + this._schedule(scheduler); + } + }; + DelaySubscriber.prototype._next = function(value) { + this.scheduleNotification(Notification_1.Notification.createNext(value)); + }; + DelaySubscriber.prototype._error = function(err) { + this.errored = true; + this.queue = []; + this.destination.error(err); + }; + DelaySubscriber.prototype._complete = function() { + this.scheduleNotification(Notification_1.Notification.createComplete()); + }; + return DelaySubscriber; + }(Subscriber_1.Subscriber)); + var DelayMessage = (function() { + function DelayMessage(time, notification) { + this.time = time; + this.notification = notification; + } + return DelayMessage; + }()); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/delayWhen", ["rxjs/Subscriber", "rxjs/Observable", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Observable_1 = require("rxjs/Observable"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function delayWhen(delayDurationSelector, subscriptionDelay) { + if (subscriptionDelay) { + return new SubscriptionDelayObservable(this, subscriptionDelay).lift(new DelayWhenOperator(delayDurationSelector)); + } + return this.lift(new DelayWhenOperator(delayDurationSelector)); + } + exports.delayWhen = delayWhen; + var DelayWhenOperator = (function() { + function DelayWhenOperator(delayDurationSelector) { + this.delayDurationSelector = delayDurationSelector; + } + DelayWhenOperator.prototype.call = function(subscriber) { + return new DelayWhenSubscriber(subscriber, this.delayDurationSelector); + }; + return DelayWhenOperator; + }()); + var DelayWhenSubscriber = (function(_super) { + __extends(DelayWhenSubscriber, _super); + function DelayWhenSubscriber(destination, delayDurationSelector) { + _super.call(this, destination); + this.delayDurationSelector = delayDurationSelector; + this.completed = false; + this.delayNotifierSubscriptions = []; + this.values = []; + } + DelayWhenSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.destination.next(outerValue); + this.removeSubscription(innerSub); + this.tryComplete(); + }; + DelayWhenSubscriber.prototype.notifyError = function(error, innerSub) { + this._error(error); + }; + DelayWhenSubscriber.prototype.notifyComplete = function(innerSub) { + var value = this.removeSubscription(innerSub); + if (value) { + this.destination.next(value); + } + this.tryComplete(); + }; + DelayWhenSubscriber.prototype._next = function(value) { + try { + var delayNotifier = this.delayDurationSelector(value); + if (delayNotifier) { + this.tryDelay(delayNotifier, value); + } + } catch (err) { + this.destination.error(err); + } + }; + DelayWhenSubscriber.prototype._complete = function() { + this.completed = true; + this.tryComplete(); + }; + DelayWhenSubscriber.prototype.removeSubscription = function(subscription) { + subscription.unsubscribe(); + var subscriptionIdx = this.delayNotifierSubscriptions.indexOf(subscription); + var value = null; + if (subscriptionIdx !== -1) { + value = this.values[subscriptionIdx]; + this.delayNotifierSubscriptions.splice(subscriptionIdx, 1); + this.values.splice(subscriptionIdx, 1); + } + return value; + }; + DelayWhenSubscriber.prototype.tryDelay = function(delayNotifier, value) { + var notifierSubscription = subscribeToResult_1.subscribeToResult(this, delayNotifier, value); + this.add(notifierSubscription); + this.delayNotifierSubscriptions.push(notifierSubscription); + this.values.push(value); + }; + DelayWhenSubscriber.prototype.tryComplete = function() { + if (this.completed && this.delayNotifierSubscriptions.length === 0) { + this.destination.complete(); + } + }; + return DelayWhenSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + var SubscriptionDelayObservable = (function(_super) { + __extends(SubscriptionDelayObservable, _super); + function SubscriptionDelayObservable(source, subscriptionDelay) { + _super.call(this); + this.source = source; + this.subscriptionDelay = subscriptionDelay; + } + SubscriptionDelayObservable.prototype._subscribe = function(subscriber) { + this.subscriptionDelay.subscribe(new SubscriptionDelaySubscriber(subscriber, this.source)); + }; + return SubscriptionDelayObservable; + }(Observable_1.Observable)); + var SubscriptionDelaySubscriber = (function(_super) { + __extends(SubscriptionDelaySubscriber, _super); + function SubscriptionDelaySubscriber(parent, source) { + _super.call(this); + this.parent = parent; + this.source = source; + this.sourceSubscribed = false; + } + SubscriptionDelaySubscriber.prototype._next = function(unused) { + this.subscribeToSource(); + }; + SubscriptionDelaySubscriber.prototype._error = function(err) { + this.unsubscribe(); + this.parent.error(err); + }; + SubscriptionDelaySubscriber.prototype._complete = function() { + this.subscribeToSource(); + }; + SubscriptionDelaySubscriber.prototype.subscribeToSource = function() { + if (!this.sourceSubscribed) { + this.sourceSubscribed = true; + this.unsubscribe(); + this.source.subscribe(this.parent); + } + }; + return SubscriptionDelaySubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/distinctUntilChanged", ["rxjs/Subscriber", "rxjs/util/tryCatch", "rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + function distinctUntilChanged(compare, keySelector) { + return this.lift(new DistinctUntilChangedOperator(compare, keySelector)); + } + exports.distinctUntilChanged = distinctUntilChanged; + var DistinctUntilChangedOperator = (function() { + function DistinctUntilChangedOperator(compare, keySelector) { + this.compare = compare; + this.keySelector = keySelector; + } + DistinctUntilChangedOperator.prototype.call = function(subscriber) { + return new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector); + }; + return DistinctUntilChangedOperator; + }()); + var DistinctUntilChangedSubscriber = (function(_super) { + __extends(DistinctUntilChangedSubscriber, _super); + function DistinctUntilChangedSubscriber(destination, compare, keySelector) { + _super.call(this, destination); + this.keySelector = keySelector; + this.hasKey = false; + if (typeof compare === 'function') { + this.compare = compare; + } + } + DistinctUntilChangedSubscriber.prototype.compare = function(x, y) { + return x === y; + }; + DistinctUntilChangedSubscriber.prototype._next = function(value) { + var keySelector = this.keySelector; + var key = value; + if (keySelector) { + key = tryCatch_1.tryCatch(this.keySelector)(value); + if (key === errorObject_1.errorObject) { + return this.destination.error(errorObject_1.errorObject.e); + } + } + var result = false; + if (this.hasKey) { + result = tryCatch_1.tryCatch(this.compare)(this.key, key); + if (result === errorObject_1.errorObject) { + return this.destination.error(errorObject_1.errorObject.e); + } + } else { + this.hasKey = true; + } + if (Boolean(result) === false) { + this.key = key; + this.destination.next(value); + } + }; + return DistinctUntilChangedSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/do", ["rxjs/Subscriber", "rxjs/util/noop"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var noop_1 = require("rxjs/util/noop"); + function _do(nextOrObserver, error, complete) { + var next; + if (nextOrObserver && typeof nextOrObserver === 'object') { + next = nextOrObserver.next; + error = nextOrObserver.error; + complete = nextOrObserver.complete; + } else { + next = nextOrObserver; + } + return this.lift(new DoOperator(next || noop_1.noop, error || noop_1.noop, complete || noop_1.noop)); + } + exports._do = _do; + var DoOperator = (function() { + function DoOperator(next, error, complete) { + this.next = next; + this.error = error; + this.complete = complete; + } + DoOperator.prototype.call = function(subscriber) { + return new DoSubscriber(subscriber, this.next, this.error, this.complete); + }; + return DoOperator; + }()); + var DoSubscriber = (function(_super) { + __extends(DoSubscriber, _super); + function DoSubscriber(destination, next, error, complete) { + _super.call(this, destination); + this.__next = next; + this.__error = error; + this.__complete = complete; + } + DoSubscriber.prototype._next = function(value) { + try { + this.__next(value); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.next(value); + }; + DoSubscriber.prototype._error = function(err) { + try { + this.__error(err); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.error(err); + }; + DoSubscriber.prototype._complete = function() { + try { + this.__complete(); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.complete(); + }; + return DoSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/expand", ["rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function expand(project, concurrent, scheduler) { + if (concurrent === void 0) { + concurrent = Number.POSITIVE_INFINITY; + } + if (scheduler === void 0) { + scheduler = undefined; + } + concurrent = (concurrent || 0) < 1 ? Number.POSITIVE_INFINITY : concurrent; + return this.lift(new ExpandOperator(project, concurrent, scheduler)); + } + exports.expand = expand; + var ExpandOperator = (function() { + function ExpandOperator(project, concurrent, scheduler) { + this.project = project; + this.concurrent = concurrent; + this.scheduler = scheduler; + } + ExpandOperator.prototype.call = function(subscriber) { + return new ExpandSubscriber(subscriber, this.project, this.concurrent, this.scheduler); + }; + return ExpandOperator; + }()); + exports.ExpandOperator = ExpandOperator; + var ExpandSubscriber = (function(_super) { + __extends(ExpandSubscriber, _super); + function ExpandSubscriber(destination, project, concurrent, scheduler) { + _super.call(this, destination); + this.project = project; + this.concurrent = concurrent; + this.scheduler = scheduler; + this.index = 0; + this.active = 0; + this.hasCompleted = false; + if (concurrent < Number.POSITIVE_INFINITY) { + this.buffer = []; + } + } + ExpandSubscriber.dispatch = function(_a) { + var subscriber = _a.subscriber, + result = _a.result, + value = _a.value, + index = _a.index; + subscriber.subscribeToProjection(result, value, index); + }; + ExpandSubscriber.prototype._next = function(value) { + var destination = this.destination; + if (destination.isUnsubscribed) { + this._complete(); + return ; + } + var index = this.index++; + if (this.active < this.concurrent) { + destination.next(value); + var result = tryCatch_1.tryCatch(this.project)(value, index); + if (result === errorObject_1.errorObject) { + destination.error(errorObject_1.errorObject.e); + } else if (!this.scheduler) { + this.subscribeToProjection(result, value, index); + } else { + var state = { + subscriber: this, + result: result, + value: value, + index: index + }; + this.add(this.scheduler.schedule(ExpandSubscriber.dispatch, 0, state)); + } + } else { + this.buffer.push(value); + } + }; + ExpandSubscriber.prototype.subscribeToProjection = function(result, value, index) { + this.active++; + this.add(subscribeToResult_1.subscribeToResult(this, result, value, index)); + }; + ExpandSubscriber.prototype._complete = function() { + this.hasCompleted = true; + if (this.hasCompleted && this.active === 0) { + this.destination.complete(); + } + }; + ExpandSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this._next(innerValue); + }; + ExpandSubscriber.prototype.notifyComplete = function(innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer && buffer.length > 0) { + this._next(buffer.shift()); + } + if (this.hasCompleted && this.active === 0) { + this.destination.complete(); + } + }; + return ExpandSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + exports.ExpandSubscriber = ExpandSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/filter", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function filter(select, thisArg) { + return this.lift(new FilterOperator(select, thisArg)); + } + exports.filter = filter; + var FilterOperator = (function() { + function FilterOperator(select, thisArg) { + this.select = select; + this.thisArg = thisArg; + } + FilterOperator.prototype.call = function(subscriber) { + return new FilterSubscriber(subscriber, this.select, this.thisArg); + }; + return FilterOperator; + }()); + var FilterSubscriber = (function(_super) { + __extends(FilterSubscriber, _super); + function FilterSubscriber(destination, select, thisArg) { + _super.call(this, destination); + this.select = select; + this.thisArg = thisArg; + this.count = 0; + this.select = select; + } + FilterSubscriber.prototype._next = function(value) { + var result; + try { + result = this.select.call(this.thisArg, value, this.count++); + } catch (err) { + this.destination.error(err); + return ; + } + if (result) { + this.destination.next(value); + } + }; + return FilterSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/finally", ["rxjs/Subscriber", "rxjs/Subscription"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Subscription_1 = require("rxjs/Subscription"); + function _finally(finallySelector) { + return this.lift(new FinallyOperator(finallySelector)); + } + exports._finally = _finally; + var FinallyOperator = (function() { + function FinallyOperator(finallySelector) { + this.finallySelector = finallySelector; + } + FinallyOperator.prototype.call = function(subscriber) { + return new FinallySubscriber(subscriber, this.finallySelector); + }; + return FinallyOperator; + }()); + var FinallySubscriber = (function(_super) { + __extends(FinallySubscriber, _super); + function FinallySubscriber(destination, finallySelector) { + _super.call(this, destination); + this.add(new Subscription_1.Subscription(finallySelector)); + } + return FinallySubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/EmptyError", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var EmptyError = (function(_super) { + __extends(EmptyError, _super); + function EmptyError() { + _super.call(this, 'no elements in sequence'); + this.name = 'EmptyError'; + } + return EmptyError; + }(Error)); + exports.EmptyError = EmptyError; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Operator", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Subscriber_1 = require("rxjs/Subscriber"); + var Operator = (function() { + function Operator() {} + Operator.prototype.call = function(subscriber) { + return new Subscriber_1.Subscriber(subscriber); + }; + return Operator; + }()); + exports.Operator = Operator; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/MapPolyfill", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var MapPolyfill = (function() { + function MapPolyfill() { + this.size = 0; + this._values = []; + this._keys = []; + } + MapPolyfill.prototype.get = function(key) { + var i = this._keys.indexOf(key); + return i === -1 ? undefined : this._values[i]; + }; + MapPolyfill.prototype.set = function(key, value) { + var i = this._keys.indexOf(key); + if (i === -1) { + this._keys.push(key); + this._values.push(value); + this.size++; + } else { + this._values[i] = value; + } + return this; + }; + MapPolyfill.prototype.delete = function(key) { + var i = this._keys.indexOf(key); + if (i === -1) { + return false; + } + this._values.splice(i, 1); + this._keys.splice(i, 1); + this.size--; + return true; + }; + MapPolyfill.prototype.clear = function() { + this._keys.length = 0; + this._values.length = 0; + this.size = 0; + }; + MapPolyfill.prototype.forEach = function(cb, thisArg) { + for (var i = 0; i < this.size; i++) { + cb.call(thisArg, this._values[i], this._keys[i]); + } + }; + return MapPolyfill; + }()); + exports.MapPolyfill = MapPolyfill; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/FastMap", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var FastMap = (function() { + function FastMap() { + this.values = {}; + } + FastMap.prototype.delete = function(key) { + this.values[key] = null; + return true; + }; + FastMap.prototype.set = function(key, value) { + this.values[key] = value; + return this; + }; + FastMap.prototype.get = function(key) { + return this.values[key]; + }; + FastMap.prototype.forEach = function(cb, thisArg) { + var values = this.values; + for (var key in values) { + if (values.hasOwnProperty(key) && values[key] !== null) { + cb.call(thisArg, values[key], key); + } + } + }; + FastMap.prototype.clear = function() { + this.values = {}; + }; + return FastMap; + }()); + exports.FastMap = FastMap; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/ignoreElements", ["rxjs/Subscriber", "rxjs/util/noop"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var noop_1 = require("rxjs/util/noop"); + function ignoreElements() { + return this.lift(new IgnoreElementsOperator()); + } + exports.ignoreElements = ignoreElements; + ; + var IgnoreElementsOperator = (function() { + function IgnoreElementsOperator() {} + IgnoreElementsOperator.prototype.call = function(subscriber) { + return new IgnoreElementsSubscriber(subscriber); + }; + return IgnoreElementsOperator; + }()); + var IgnoreElementsSubscriber = (function(_super) { + __extends(IgnoreElementsSubscriber, _super); + function IgnoreElementsSubscriber() { + _super.apply(this, arguments); + } + IgnoreElementsSubscriber.prototype._next = function(unused) { + noop_1.noop(); + }; + return IgnoreElementsSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/inspect", ["rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function inspect(durationSelector) { + return this.lift(new InspectOperator(durationSelector)); + } + exports.inspect = inspect; + var InspectOperator = (function() { + function InspectOperator(durationSelector) { + this.durationSelector = durationSelector; + } + InspectOperator.prototype.call = function(subscriber) { + return new InspectSubscriber(subscriber, this.durationSelector); + }; + return InspectOperator; + }()); + var InspectSubscriber = (function(_super) { + __extends(InspectSubscriber, _super); + function InspectSubscriber(destination, durationSelector) { + _super.call(this, destination); + this.durationSelector = durationSelector; + this.hasValue = false; + } + InspectSubscriber.prototype._next = function(value) { + this.value = value; + this.hasValue = true; + if (!this.throttled) { + var duration = tryCatch_1.tryCatch(this.durationSelector)(value); + if (duration === errorObject_1.errorObject) { + this.destination.error(errorObject_1.errorObject.e); + } else { + this.add(this.throttled = subscribeToResult_1.subscribeToResult(this, duration)); + } + } + }; + InspectSubscriber.prototype.clearThrottle = function() { + var _a = this, + value = _a.value, + hasValue = _a.hasValue, + throttled = _a.throttled; + if (throttled) { + this.remove(throttled); + this.throttled = null; + throttled.unsubscribe(); + } + if (hasValue) { + this.value = null; + this.hasValue = false; + this.destination.next(value); + } + }; + InspectSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex) { + this.clearThrottle(); + }; + InspectSubscriber.prototype.notifyComplete = function() { + this.clearThrottle(); + }; + return InspectSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/inspectTime", ["rxjs/scheduler/asap", "rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var asap_1 = require("rxjs/scheduler/asap"); + var Subscriber_1 = require("rxjs/Subscriber"); + function inspectTime(delay, scheduler) { + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return this.lift(new InspectTimeOperator(delay, scheduler)); + } + exports.inspectTime = inspectTime; + var InspectTimeOperator = (function() { + function InspectTimeOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + InspectTimeOperator.prototype.call = function(subscriber) { + return new InspectTimeSubscriber(subscriber, this.delay, this.scheduler); + }; + return InspectTimeOperator; + }()); + var InspectTimeSubscriber = (function(_super) { + __extends(InspectTimeSubscriber, _super); + function InspectTimeSubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + this.hasValue = false; + } + InspectTimeSubscriber.prototype._next = function(value) { + this.value = value; + this.hasValue = true; + if (!this.throttled) { + this.add(this.throttled = this.scheduler.schedule(dispatchNext, this.delay, this)); + } + }; + InspectTimeSubscriber.prototype.clearThrottle = function() { + var _a = this, + value = _a.value, + hasValue = _a.hasValue, + throttled = _a.throttled; + if (throttled) { + this.remove(throttled); + this.throttled = null; + throttled.unsubscribe(); + } + if (hasValue) { + this.value = null; + this.hasValue = false; + this.destination.next(value); + } + }; + return InspectTimeSubscriber; + }(Subscriber_1.Subscriber)); + function dispatchNext(subscriber) { + subscriber.clearThrottle(); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/every", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function every(predicate, thisArg) { + var source = this; + return source.lift(new EveryOperator(predicate, thisArg, source)); + } + exports.every = every; + var EveryOperator = (function() { + function EveryOperator(predicate, thisArg, source) { + this.predicate = predicate; + this.thisArg = thisArg; + this.source = source; + } + EveryOperator.prototype.call = function(observer) { + return new EverySubscriber(observer, this.predicate, this.thisArg, this.source); + }; + return EveryOperator; + }()); + var EverySubscriber = (function(_super) { + __extends(EverySubscriber, _super); + function EverySubscriber(destination, predicate, thisArg, source) { + _super.call(this, destination); + this.predicate = predicate; + this.thisArg = thisArg; + this.source = source; + this.index = 0; + this.thisArg = thisArg || this; + } + EverySubscriber.prototype.notifyComplete = function(everyValueMatch) { + this.destination.next(everyValueMatch); + this.destination.complete(); + }; + EverySubscriber.prototype._next = function(value) { + var result = false; + try { + result = this.predicate.call(this.thisArg, value, this.index++, this.source); + } catch (err) { + this.destination.error(err); + return ; + } + if (!result) { + this.notifyComplete(false); + } + }; + EverySubscriber.prototype._complete = function() { + this.notifyComplete(true); + }; + return EverySubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/last", ["rxjs/Subscriber", "rxjs/util/EmptyError"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var EmptyError_1 = require("rxjs/util/EmptyError"); + function last(predicate, resultSelector, defaultValue) { + return this.lift(new LastOperator(predicate, resultSelector, defaultValue, this)); + } + exports.last = last; + var LastOperator = (function() { + function LastOperator(predicate, resultSelector, defaultValue, source) { + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + } + LastOperator.prototype.call = function(observer) { + return new LastSubscriber(observer, this.predicate, this.resultSelector, this.defaultValue, this.source); + }; + return LastOperator; + }()); + var LastSubscriber = (function(_super) { + __extends(LastSubscriber, _super); + function LastSubscriber(destination, predicate, resultSelector, defaultValue, source) { + _super.call(this, destination); + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + this.hasValue = false; + this.index = 0; + if (typeof defaultValue !== 'undefined') { + this.lastValue = defaultValue; + this.hasValue = true; + } + } + LastSubscriber.prototype._next = function(value) { + var index = this.index++; + if (this.predicate) { + this._tryPredicate(value, index); + } else { + if (this.resultSelector) { + this._tryResultSelector(value, index); + return ; + } + this.lastValue = value; + this.hasValue = true; + } + }; + LastSubscriber.prototype._tryPredicate = function(value, index) { + var result; + try { + result = this.predicate(value, index, this.source); + } catch (err) { + this.destination.error(err); + return ; + } + if (result) { + if (this.resultSelector) { + this._tryResultSelector(value, index); + return ; + } + this.lastValue = value; + this.hasValue = true; + } + }; + LastSubscriber.prototype._tryResultSelector = function(value, index) { + var result; + try { + result = this.resultSelector(value, index); + } catch (err) { + this.destination.error(err); + return ; + } + this.lastValue = result; + this.hasValue = true; + }; + LastSubscriber.prototype._complete = function() { + var destination = this.destination; + if (this.hasValue) { + destination.next(this.lastValue); + destination.complete(); + } else { + destination.error(new EmptyError_1.EmptyError); + } + }; + return LastSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/let", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function letProto(func) { + return func(this); + } + exports.letProto = letProto; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/map", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function map(project, thisArg) { + if (typeof project !== 'function') { + throw new TypeError('argument is not a function. Are you looking for `mapTo()`?'); + } + return this.lift(new MapOperator(project, thisArg)); + } + exports.map = map; + var MapOperator = (function() { + function MapOperator(project, thisArg) { + this.project = project; + this.thisArg = thisArg; + } + MapOperator.prototype.call = function(subscriber) { + return new MapSubscriber(subscriber, this.project, this.thisArg); + }; + return MapOperator; + }()); + var MapSubscriber = (function(_super) { + __extends(MapSubscriber, _super); + function MapSubscriber(destination, project, thisArg) { + _super.call(this, destination); + this.project = project; + this.count = 0; + this.thisArg = thisArg || this; + } + MapSubscriber.prototype._next = function(value) { + var result; + try { + result = this.project.call(this.thisArg, value, this.count++); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.next(result); + }; + return MapSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/mapTo", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function mapTo(value) { + return this.lift(new MapToOperator(value)); + } + exports.mapTo = mapTo; + var MapToOperator = (function() { + function MapToOperator(value) { + this.value = value; + } + MapToOperator.prototype.call = function(subscriber) { + return new MapToSubscriber(subscriber, this.value); + }; + return MapToOperator; + }()); + var MapToSubscriber = (function(_super) { + __extends(MapToSubscriber, _super); + function MapToSubscriber(destination, value) { + _super.call(this, destination); + this.value = value; + } + MapToSubscriber.prototype._next = function(x) { + this.destination.next(this.value); + }; + return MapToSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/materialize", ["rxjs/Subscriber", "rxjs/Notification"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Notification_1 = require("rxjs/Notification"); + function materialize() { + return this.lift(new MaterializeOperator()); + } + exports.materialize = materialize; + var MaterializeOperator = (function() { + function MaterializeOperator() {} + MaterializeOperator.prototype.call = function(subscriber) { + return new MaterializeSubscriber(subscriber); + }; + return MaterializeOperator; + }()); + var MaterializeSubscriber = (function(_super) { + __extends(MaterializeSubscriber, _super); + function MaterializeSubscriber(destination) { + _super.call(this, destination); + } + MaterializeSubscriber.prototype._next = function(value) { + this.destination.next(Notification_1.Notification.createNext(value)); + }; + MaterializeSubscriber.prototype._error = function(err) { + var destination = this.destination; + destination.next(Notification_1.Notification.createError(err)); + destination.complete(); + }; + MaterializeSubscriber.prototype._complete = function() { + var destination = this.destination; + destination.next(Notification_1.Notification.createComplete()); + destination.complete(); + }; + return MaterializeSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/merge", ["rxjs/Observable", "rxjs/operator/merge"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var merge_1 = require("rxjs/operator/merge"); + Observable_1.Observable.prototype.merge = merge_1.merge; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/mergeAll", ["rxjs/Observable", "rxjs/operator/mergeAll"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var mergeAll_1 = require("rxjs/operator/mergeAll"); + Observable_1.Observable.prototype.mergeAll = mergeAll_1.mergeAll; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/mergeMap", ["rxjs/Observable", "rxjs/operator/mergeMap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var mergeMap_1 = require("rxjs/operator/mergeMap"); + Observable_1.Observable.prototype.mergeMap = mergeMap_1.mergeMap; + Observable_1.Observable.prototype.flatMap = mergeMap_1.mergeMap; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/mergeMapTo", ["rxjs/Observable", "rxjs/operator/mergeMapTo"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var mergeMapTo_1 = require("rxjs/operator/mergeMapTo"); + Observable_1.Observable.prototype.mergeMapTo = mergeMapTo_1.mergeMapTo; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/multicast", ["rxjs/Observable", "rxjs/operator/multicast"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var multicast_1 = require("rxjs/operator/multicast"); + Observable_1.Observable.prototype.multicast = multicast_1.multicast; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/observeOn", ["rxjs/Observable", "rxjs/operator/observeOn"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var observeOn_1 = require("rxjs/operator/observeOn"); + Observable_1.Observable.prototype.observeOn = observeOn_1.observeOn; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/not", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + function not(pred, thisArg) { + function notPred() { + return !(notPred.pred.apply(notPred.thisArg, arguments)); + } + notPred.pred = pred; + notPred.thisArg = thisArg; + return notPred; + } + exports.not = not; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/pluck", ["rxjs/operator/map"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var map_1 = require("rxjs/operator/map"); + function pluck() { + var properties = []; + for (var _i = 0; _i < arguments.length; _i++) { + properties[_i - 0] = arguments[_i]; + } + var length = properties.length; + if (length === 0) { + throw new Error('List of properties cannot be empty.'); + } + return map_1.map.call(this, plucker(properties, length)); + } + exports.pluck = pluck; + function plucker(props, length) { + var mapper = function(x) { + var currentProp = x; + for (var i = 0; i < length; i++) { + var p = currentProp[props[i]]; + if (typeof p !== 'undefined') { + currentProp = p; + } else { + return undefined; + } + } + return currentProp; + }; + return mapper; + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/publish", ["rxjs/Subject", "rxjs/operator/multicast"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Subject_1 = require("rxjs/Subject"); + var multicast_1 = require("rxjs/operator/multicast"); + function publish() { + return multicast_1.multicast.call(this, new Subject_1.Subject()); + } + exports.publish = publish; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/subject/BehaviorSubject", ["rxjs/Subject", "rxjs/util/throwError", "rxjs/util/ObjectUnsubscribedError"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subject_1 = require("rxjs/Subject"); + var throwError_1 = require("rxjs/util/throwError"); + var ObjectUnsubscribedError_1 = require("rxjs/util/ObjectUnsubscribedError"); + var BehaviorSubject = (function(_super) { + __extends(BehaviorSubject, _super); + function BehaviorSubject(_value) { + _super.call(this); + this._value = _value; + } + BehaviorSubject.prototype.getValue = function() { + if (this.hasErrored) { + throwError_1.throwError(this.errorValue); + } else if (this.isUnsubscribed) { + throwError_1.throwError(new ObjectUnsubscribedError_1.ObjectUnsubscribedError()); + } else { + return this._value; + } + }; + Object.defineProperty(BehaviorSubject.prototype, "value", { + get: function() { + return this.getValue(); + }, + enumerable: true, + configurable: true + }); + BehaviorSubject.prototype._subscribe = function(subscriber) { + var subscription = _super.prototype._subscribe.call(this, subscriber); + if (subscription && !subscription.isUnsubscribed) { + subscriber.next(this._value); + } + return subscription; + }; + BehaviorSubject.prototype._next = function(value) { + _super.prototype._next.call(this, this._value = value); + }; + BehaviorSubject.prototype._error = function(err) { + this.hasErrored = true; + _super.prototype._error.call(this, this.errorValue = err); + }; + return BehaviorSubject; + }(Subject_1.Subject)); + exports.BehaviorSubject = BehaviorSubject; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/publishReplay", ["rxjs/Observable", "rxjs/operator/publishReplay"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var publishReplay_1 = require("rxjs/operator/publishReplay"); + Observable_1.Observable.prototype.publishReplay = publishReplay_1.publishReplay; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/publishLast", ["rxjs/subject/AsyncSubject", "rxjs/operator/multicast"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var AsyncSubject_1 = require("rxjs/subject/AsyncSubject"); + var multicast_1 = require("rxjs/operator/multicast"); + function publishLast() { + return multicast_1.multicast.call(this, new AsyncSubject_1.AsyncSubject()); + } + exports.publishLast = publishLast; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/race", ["rxjs/Observable", "rxjs/operator/race"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var race_1 = require("rxjs/operator/race"); + Observable_1.Observable.prototype.race = race_1.race; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/reduce", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function reduce(project, seed) { + return this.lift(new ReduceOperator(project, seed)); + } + exports.reduce = reduce; + var ReduceOperator = (function() { + function ReduceOperator(project, seed) { + this.project = project; + this.seed = seed; + } + ReduceOperator.prototype.call = function(subscriber) { + return new ReduceSubscriber(subscriber, this.project, this.seed); + }; + return ReduceOperator; + }()); + exports.ReduceOperator = ReduceOperator; + var ReduceSubscriber = (function(_super) { + __extends(ReduceSubscriber, _super); + function ReduceSubscriber(destination, project, seed) { + _super.call(this, destination); + this.hasValue = false; + this.acc = seed; + this.project = project; + this.hasSeed = typeof seed !== 'undefined'; + } + ReduceSubscriber.prototype._next = function(value) { + if (this.hasValue || (this.hasValue = this.hasSeed)) { + this._tryReduce(value); + } else { + this.acc = value; + this.hasValue = true; + } + }; + ReduceSubscriber.prototype._tryReduce = function(value) { + var result; + try { + result = this.project(this.acc, value); + } catch (err) { + this.destination.error(err); + return ; + } + this.acc = result; + }; + ReduceSubscriber.prototype._complete = function() { + if (this.hasValue || this.hasSeed) { + this.destination.next(this.acc); + } + this.destination.complete(); + }; + return ReduceSubscriber; + }(Subscriber_1.Subscriber)); + exports.ReduceSubscriber = ReduceSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/repeat", ["rxjs/Subscriber", "rxjs/observable/EmptyObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + function repeat(count) { + if (count === void 0) { + count = -1; + } + if (count === 0) { + return new EmptyObservable_1.EmptyObservable(); + } else if (count < 0) { + return this.lift(new RepeatOperator(-1, this)); + } else { + return this.lift(new RepeatOperator(count - 1, this)); + } + } + exports.repeat = repeat; + var RepeatOperator = (function() { + function RepeatOperator(count, source) { + this.count = count; + this.source = source; + } + RepeatOperator.prototype.call = function(subscriber) { + return new RepeatSubscriber(subscriber, this.count, this.source); + }; + return RepeatOperator; + }()); + var RepeatSubscriber = (function(_super) { + __extends(RepeatSubscriber, _super); + function RepeatSubscriber(destination, count, source) { + _super.call(this, destination); + this.count = count; + this.source = source; + } + RepeatSubscriber.prototype.complete = function() { + if (!this.isStopped) { + var _a = this, + source = _a.source, + count = _a.count; + if (count === 0) { + return _super.prototype.complete.call(this); + } else if (count > -1) { + this.count = count - 1; + } + this.unsubscribe(); + this.isStopped = false; + this.isUnsubscribed = false; + source.subscribe(this); + } + }; + return RepeatSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/retry", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function retry(count) { + if (count === void 0) { + count = -1; + } + return this.lift(new RetryOperator(count, this)); + } + exports.retry = retry; + var RetryOperator = (function() { + function RetryOperator(count, source) { + this.count = count; + this.source = source; + } + RetryOperator.prototype.call = function(subscriber) { + return new RetrySubscriber(subscriber, this.count, this.source); + }; + return RetryOperator; + }()); + var RetrySubscriber = (function(_super) { + __extends(RetrySubscriber, _super); + function RetrySubscriber(destination, count, source) { + _super.call(this, destination); + this.count = count; + this.source = source; + } + RetrySubscriber.prototype.error = function(err) { + if (!this.isStopped) { + var _a = this, + source = _a.source, + count = _a.count; + if (count === 0) { + return _super.prototype.error.call(this, err); + } else if (count > -1) { + this.count = count - 1; + } + this.unsubscribe(); + this.isStopped = false; + this.isUnsubscribed = false; + source.subscribe(this); + } + }; + return RetrySubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/retryWhen", ["rxjs/Subject", "rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subject_1 = require("rxjs/Subject"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function retryWhen(notifier) { + return this.lift(new RetryWhenOperator(notifier, this)); + } + exports.retryWhen = retryWhen; + var RetryWhenOperator = (function() { + function RetryWhenOperator(notifier, source) { + this.notifier = notifier; + this.source = source; + } + RetryWhenOperator.prototype.call = function(subscriber) { + return new RetryWhenSubscriber(subscriber, this.notifier, this.source); + }; + return RetryWhenOperator; + }()); + var RetryWhenSubscriber = (function(_super) { + __extends(RetryWhenSubscriber, _super); + function RetryWhenSubscriber(destination, notifier, source) { + _super.call(this, destination); + this.notifier = notifier; + this.source = source; + } + RetryWhenSubscriber.prototype.error = function(err) { + if (!this.isStopped) { + var errors = this.errors; + var retries = this.retries; + var retriesSubscription = this.retriesSubscription; + if (!retries) { + errors = new Subject_1.Subject(); + retries = tryCatch_1.tryCatch(this.notifier)(errors); + if (retries === errorObject_1.errorObject) { + return _super.prototype.error.call(this, errorObject_1.errorObject.e); + } + retriesSubscription = subscribeToResult_1.subscribeToResult(this, retries); + } else { + this.errors = null; + this.retriesSubscription = null; + } + this.unsubscribe(); + this.isUnsubscribed = false; + this.errors = errors; + this.retries = retries; + this.retriesSubscription = retriesSubscription; + errors.next(err); + } + }; + RetryWhenSubscriber.prototype._unsubscribe = function() { + var _a = this, + errors = _a.errors, + retriesSubscription = _a.retriesSubscription; + if (errors) { + errors.unsubscribe(); + this.errors = null; + } + if (retriesSubscription) { + retriesSubscription.unsubscribe(); + this.retriesSubscription = null; + } + this.retries = null; + }; + RetryWhenSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var _a = this, + errors = _a.errors, + retries = _a.retries, + retriesSubscription = _a.retriesSubscription; + this.errors = null; + this.retries = null; + this.retriesSubscription = null; + this.unsubscribe(); + this.isStopped = false; + this.isUnsubscribed = false; + this.errors = errors; + this.retries = retries; + this.retriesSubscription = retriesSubscription; + this.source.subscribe(this); + }; + return RetryWhenSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/sample", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function sample(notifier) { + return this.lift(new SampleOperator(notifier)); + } + exports.sample = sample; + var SampleOperator = (function() { + function SampleOperator(notifier) { + this.notifier = notifier; + } + SampleOperator.prototype.call = function(subscriber) { + return new SampleSubscriber(subscriber, this.notifier); + }; + return SampleOperator; + }()); + var SampleSubscriber = (function(_super) { + __extends(SampleSubscriber, _super); + function SampleSubscriber(destination, notifier) { + _super.call(this, destination); + this.hasValue = false; + this.add(subscribeToResult_1.subscribeToResult(this, notifier)); + } + SampleSubscriber.prototype._next = function(value) { + this.value = value; + this.hasValue = true; + }; + SampleSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.emitValue(); + }; + SampleSubscriber.prototype.notifyComplete = function() { + this.emitValue(); + }; + SampleSubscriber.prototype.emitValue = function() { + if (this.hasValue) { + this.hasValue = false; + this.destination.next(this.value); + } + }; + return SampleSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/sampleTime", ["rxjs/Subscriber", "rxjs/scheduler/asap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var asap_1 = require("rxjs/scheduler/asap"); + function sampleTime(delay, scheduler) { + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return this.lift(new SampleTimeOperator(delay, scheduler)); + } + exports.sampleTime = sampleTime; + var SampleTimeOperator = (function() { + function SampleTimeOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + SampleTimeOperator.prototype.call = function(subscriber) { + return new SampleTimeSubscriber(subscriber, this.delay, this.scheduler); + }; + return SampleTimeOperator; + }()); + var SampleTimeSubscriber = (function(_super) { + __extends(SampleTimeSubscriber, _super); + function SampleTimeSubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + this.hasValue = false; + this.add(scheduler.schedule(dispatchNotification, delay, { + subscriber: this, + delay: delay + })); + } + SampleTimeSubscriber.prototype._next = function(value) { + this.lastValue = value; + this.hasValue = true; + }; + SampleTimeSubscriber.prototype.notifyNext = function() { + if (this.hasValue) { + this.hasValue = false; + this.destination.next(this.lastValue); + } + }; + return SampleTimeSubscriber; + }(Subscriber_1.Subscriber)); + function dispatchNotification(state) { + var subscriber = state.subscriber, + delay = state.delay; + subscriber.notifyNext(); + this.schedule(state, delay); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/scan", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function scan(accumulator, seed) { + return this.lift(new ScanOperator(accumulator, seed)); + } + exports.scan = scan; + var ScanOperator = (function() { + function ScanOperator(accumulator, seed) { + this.accumulator = accumulator; + this.seed = seed; + } + ScanOperator.prototype.call = function(subscriber) { + return new ScanSubscriber(subscriber, this.accumulator, this.seed); + }; + return ScanOperator; + }()); + var ScanSubscriber = (function(_super) { + __extends(ScanSubscriber, _super); + function ScanSubscriber(destination, accumulator, seed) { + _super.call(this, destination); + this.accumulator = accumulator; + this.accumulatorSet = false; + this.seed = seed; + this.accumulator = accumulator; + this.accumulatorSet = typeof seed !== 'undefined'; + } + Object.defineProperty(ScanSubscriber.prototype, "seed", { + get: function() { + return this._seed; + }, + set: function(value) { + this.accumulatorSet = true; + this._seed = value; + }, + enumerable: true, + configurable: true + }); + ScanSubscriber.prototype._next = function(value) { + if (!this.accumulatorSet) { + this.seed = value; + this.destination.next(value); + } else { + return this._tryNext(value); + } + }; + ScanSubscriber.prototype._tryNext = function(value) { + var result; + try { + result = this.accumulator(this.seed, value); + } catch (err) { + this.destination.error(err); + } + this.seed = result; + this.destination.next(result); + }; + return ScanSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/share", ["rxjs/operator/multicast", "rxjs/Subject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var multicast_1 = require("rxjs/operator/multicast"); + var Subject_1 = require("rxjs/Subject"); + function shareSubjectFactory() { + return new Subject_1.Subject(); + } + function share() { + return multicast_1.multicast.call(this, shareSubjectFactory).refCount(); + } + exports.share = share; + ; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/single", ["rxjs/Subscriber", "rxjs/util/EmptyError"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var EmptyError_1 = require("rxjs/util/EmptyError"); + function single(predicate) { + return this.lift(new SingleOperator(predicate, this)); + } + exports.single = single; + var SingleOperator = (function() { + function SingleOperator(predicate, source) { + this.predicate = predicate; + this.source = source; + } + SingleOperator.prototype.call = function(subscriber) { + return new SingleSubscriber(subscriber, this.predicate, this.source); + }; + return SingleOperator; + }()); + var SingleSubscriber = (function(_super) { + __extends(SingleSubscriber, _super); + function SingleSubscriber(destination, predicate, source) { + _super.call(this, destination); + this.predicate = predicate; + this.source = source; + this.seenValue = false; + this.index = 0; + } + SingleSubscriber.prototype.applySingleValue = function(value) { + if (this.seenValue) { + this.destination.error('Sequence contains more than one element'); + } else { + this.seenValue = true; + this.singleValue = value; + } + }; + SingleSubscriber.prototype._next = function(value) { + var predicate = this.predicate; + this.index++; + if (predicate) { + this.tryNext(value); + } else { + this.applySingleValue(value); + } + }; + SingleSubscriber.prototype.tryNext = function(value) { + try { + var result = this.predicate(value, this.index, this.source); + if (result) { + this.applySingleValue(value); + } + } catch (err) { + this.destination.error(err); + } + }; + SingleSubscriber.prototype._complete = function() { + var destination = this.destination; + if (this.index > 0) { + destination.next(this.seenValue ? this.singleValue : undefined); + destination.complete(); + } else { + destination.error(new EmptyError_1.EmptyError); + } + }; + return SingleSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/skip", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function skip(total) { + return this.lift(new SkipOperator(total)); + } + exports.skip = skip; + var SkipOperator = (function() { + function SkipOperator(total) { + this.total = total; + } + SkipOperator.prototype.call = function(subscriber) { + return new SkipSubscriber(subscriber, this.total); + }; + return SkipOperator; + }()); + var SkipSubscriber = (function(_super) { + __extends(SkipSubscriber, _super); + function SkipSubscriber(destination, total) { + _super.call(this, destination); + this.total = total; + this.count = 0; + } + SkipSubscriber.prototype._next = function(x) { + if (++this.count > this.total) { + this.destination.next(x); + } + }; + return SkipSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/skipUntil", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function skipUntil(notifier) { + return this.lift(new SkipUntilOperator(notifier)); + } + exports.skipUntil = skipUntil; + var SkipUntilOperator = (function() { + function SkipUntilOperator(notifier) { + this.notifier = notifier; + } + SkipUntilOperator.prototype.call = function(subscriber) { + return new SkipUntilSubscriber(subscriber, this.notifier); + }; + return SkipUntilOperator; + }()); + var SkipUntilSubscriber = (function(_super) { + __extends(SkipUntilSubscriber, _super); + function SkipUntilSubscriber(destination, notifier) { + _super.call(this, destination); + this.hasValue = false; + this.isInnerStopped = false; + this.add(subscribeToResult_1.subscribeToResult(this, notifier)); + } + SkipUntilSubscriber.prototype._next = function(value) { + if (this.hasValue) { + _super.prototype._next.call(this, value); + } + }; + SkipUntilSubscriber.prototype._complete = function() { + if (this.isInnerStopped) { + _super.prototype._complete.call(this); + } else { + this.unsubscribe(); + } + }; + SkipUntilSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.hasValue = true; + }; + SkipUntilSubscriber.prototype.notifyComplete = function() { + this.isInnerStopped = true; + if (this.isStopped) { + _super.prototype._complete.call(this); + } + }; + return SkipUntilSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/skipWhile", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function skipWhile(predicate) { + return this.lift(new SkipWhileOperator(predicate)); + } + exports.skipWhile = skipWhile; + var SkipWhileOperator = (function() { + function SkipWhileOperator(predicate) { + this.predicate = predicate; + } + SkipWhileOperator.prototype.call = function(subscriber) { + return new SkipWhileSubscriber(subscriber, this.predicate); + }; + return SkipWhileOperator; + }()); + var SkipWhileSubscriber = (function(_super) { + __extends(SkipWhileSubscriber, _super); + function SkipWhileSubscriber(destination, predicate) { + _super.call(this, destination); + this.predicate = predicate; + this.skipping = true; + this.index = 0; + } + SkipWhileSubscriber.prototype._next = function(value) { + var destination = this.destination; + if (this.skipping) { + this.tryCallPredicate(value); + } + if (!this.skipping) { + destination.next(value); + } + }; + SkipWhileSubscriber.prototype.tryCallPredicate = function(value) { + try { + var result = this.predicate(value, this.index++); + this.skipping = Boolean(result); + } catch (err) { + this.destination.error(err); + } + }; + return SkipWhileSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/startWith", ["rxjs/observable/ArrayObservable", "rxjs/observable/ScalarObservable", "rxjs/observable/EmptyObservable", "rxjs/operator/concat", "rxjs/util/isScheduler"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + var ScalarObservable_1 = require("rxjs/observable/ScalarObservable"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + var concat_1 = require("rxjs/operator/concat"); + var isScheduler_1 = require("rxjs/util/isScheduler"); + function startWith() { + var array = []; + for (var _i = 0; _i < arguments.length; _i++) { + array[_i - 0] = arguments[_i]; + } + var scheduler = array[array.length - 1]; + if (isScheduler_1.isScheduler(scheduler)) { + array.pop(); + } else { + scheduler = null; + } + var len = array.length; + if (len === 1) { + return concat_1.concatStatic(new ScalarObservable_1.ScalarObservable(array[0], scheduler), this); + } else if (len > 1) { + return concat_1.concatStatic(new ArrayObservable_1.ArrayObservable(array, scheduler), this); + } else { + return concat_1.concatStatic(new EmptyObservable_1.EmptyObservable(scheduler), this); + } + } + exports.startWith = startWith; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/SubscribeOnObservable", ["rxjs/Observable", "rxjs/scheduler/asap", "rxjs/util/isNumeric"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var asap_1 = require("rxjs/scheduler/asap"); + var isNumeric_1 = require("rxjs/util/isNumeric"); + var SubscribeOnObservable = (function(_super) { + __extends(SubscribeOnObservable, _super); + function SubscribeOnObservable(source, delayTime, scheduler) { + if (delayTime === void 0) { + delayTime = 0; + } + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + _super.call(this); + this.source = source; + this.delayTime = delayTime; + this.scheduler = scheduler; + if (!isNumeric_1.isNumeric(delayTime) || delayTime < 0) { + this.delayTime = 0; + } + if (!scheduler || typeof scheduler.schedule !== 'function') { + this.scheduler = asap_1.asap; + } + } + SubscribeOnObservable.create = function(source, delay, scheduler) { + if (delay === void 0) { + delay = 0; + } + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return new SubscribeOnObservable(source, delay, scheduler); + }; + SubscribeOnObservable.dispatch = function(_a) { + var source = _a.source, + subscriber = _a.subscriber; + return source.subscribe(subscriber); + }; + SubscribeOnObservable.prototype._subscribe = function(subscriber) { + var delay = this.delayTime; + var source = this.source; + var scheduler = this.scheduler; + return scheduler.schedule(SubscribeOnObservable.dispatch, delay, { + source: source, + subscriber: subscriber + }); + }; + return SubscribeOnObservable; + }(Observable_1.Observable)); + exports.SubscribeOnObservable = SubscribeOnObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/switch", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function _switch() { + return this.lift(new SwitchOperator()); + } + exports._switch = _switch; + var SwitchOperator = (function() { + function SwitchOperator() {} + SwitchOperator.prototype.call = function(subscriber) { + return new SwitchSubscriber(subscriber); + }; + return SwitchOperator; + }()); + var SwitchSubscriber = (function(_super) { + __extends(SwitchSubscriber, _super); + function SwitchSubscriber(destination) { + _super.call(this, destination); + this.active = 0; + this.hasCompleted = false; + } + SwitchSubscriber.prototype._next = function(value) { + this.unsubscribeInner(); + this.active++; + this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, value)); + }; + SwitchSubscriber.prototype._complete = function() { + this.hasCompleted = true; + if (this.active === 0) { + this.destination.complete(); + } + }; + SwitchSubscriber.prototype.unsubscribeInner = function() { + this.active = this.active > 0 ? this.active - 1 : 0; + var innerSubscription = this.innerSubscription; + if (innerSubscription) { + innerSubscription.unsubscribe(); + this.remove(innerSubscription); + } + }; + SwitchSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.destination.next(innerValue); + }; + SwitchSubscriber.prototype.notifyError = function(err) { + this.destination.error(err); + }; + SwitchSubscriber.prototype.notifyComplete = function() { + this.unsubscribeInner(); + if (this.hasCompleted && this.active === 0) { + this.destination.complete(); + } + }; + return SwitchSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/switchMap", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function switchMap(project, resultSelector) { + return this.lift(new SwitchMapOperator(project, resultSelector)); + } + exports.switchMap = switchMap; + var SwitchMapOperator = (function() { + function SwitchMapOperator(project, resultSelector) { + this.project = project; + this.resultSelector = resultSelector; + } + SwitchMapOperator.prototype.call = function(subscriber) { + return new SwitchMapSubscriber(subscriber, this.project, this.resultSelector); + }; + return SwitchMapOperator; + }()); + var SwitchMapSubscriber = (function(_super) { + __extends(SwitchMapSubscriber, _super); + function SwitchMapSubscriber(destination, project, resultSelector) { + _super.call(this, destination); + this.project = project; + this.resultSelector = resultSelector; + this.index = 0; + } + SwitchMapSubscriber.prototype._next = function(value) { + var result; + var index = this.index++; + try { + result = this.project(value, index); + } catch (error) { + this.destination.error(error); + return ; + } + this._innerSub(result, value, index); + }; + SwitchMapSubscriber.prototype._innerSub = function(result, value, index) { + var innerSubscription = this.innerSubscription; + if (innerSubscription) { + innerSubscription.unsubscribe(); + } + this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, result, value, index)); + }; + SwitchMapSubscriber.prototype._complete = function() { + var innerSubscription = this.innerSubscription; + if (!innerSubscription || innerSubscription.isUnsubscribed) { + _super.prototype._complete.call(this); + } + }; + SwitchMapSubscriber.prototype._unsubscribe = function() { + this.innerSubscription = null; + }; + SwitchMapSubscriber.prototype.notifyComplete = function(innerSub) { + this.remove(innerSub); + this.innerSubscription = null; + if (this.isStopped) { + _super.prototype._complete.call(this); + } + }; + SwitchMapSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (this.resultSelector) { + this._tryNotifyNext(outerValue, innerValue, outerIndex, innerIndex); + } else { + this.destination.next(innerValue); + } + }; + SwitchMapSubscriber.prototype._tryNotifyNext = function(outerValue, innerValue, outerIndex, innerIndex) { + var result; + try { + result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.next(result); + }; + return SwitchMapSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/switchMapTo", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function switchMapTo(observable, resultSelector) { + return this.lift(new SwitchMapToOperator(observable, resultSelector)); + } + exports.switchMapTo = switchMapTo; + var SwitchMapToOperator = (function() { + function SwitchMapToOperator(observable, resultSelector) { + this.observable = observable; + this.resultSelector = resultSelector; + } + SwitchMapToOperator.prototype.call = function(subscriber) { + return new SwitchMapToSubscriber(subscriber, this.observable, this.resultSelector); + }; + return SwitchMapToOperator; + }()); + var SwitchMapToSubscriber = (function(_super) { + __extends(SwitchMapToSubscriber, _super); + function SwitchMapToSubscriber(destination, inner, resultSelector) { + _super.call(this, destination); + this.inner = inner; + this.resultSelector = resultSelector; + this.index = 0; + } + SwitchMapToSubscriber.prototype._next = function(value) { + var innerSubscription = this.innerSubscription; + if (innerSubscription) { + innerSubscription.unsubscribe(); + } + this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, this.inner, value, this.index++)); + }; + SwitchMapToSubscriber.prototype._complete = function() { + var innerSubscription = this.innerSubscription; + if (!innerSubscription || innerSubscription.isUnsubscribed) { + _super.prototype._complete.call(this); + } + }; + SwitchMapToSubscriber.prototype._unsubscribe = function() { + this.innerSubscription = null; + }; + SwitchMapToSubscriber.prototype.notifyComplete = function(innerSub) { + this.remove(innerSub); + this.innerSubscription = null; + if (this.isStopped) { + _super.prototype._complete.call(this); + } + }; + SwitchMapToSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var _a = this, + resultSelector = _a.resultSelector, + destination = _a.destination; + if (resultSelector) { + this.tryResultSelector(outerValue, innerValue, outerIndex, innerIndex); + } else { + destination.next(innerValue); + } + }; + SwitchMapToSubscriber.prototype.tryResultSelector = function(outerValue, innerValue, outerIndex, innerIndex) { + var _a = this, + resultSelector = _a.resultSelector, + destination = _a.destination; + var result; + try { + result = resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } catch (err) { + destination.error(err); + return ; + } + destination.next(result); + }; + return SwitchMapToSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/ArgumentOutOfRangeError", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var ArgumentOutOfRangeError = (function(_super) { + __extends(ArgumentOutOfRangeError, _super); + function ArgumentOutOfRangeError() { + _super.call(this, 'argument out of range'); + this.name = 'ArgumentOutOfRangeError'; + } + return ArgumentOutOfRangeError; + }(Error)); + exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/takeLast", ["rxjs/Subscriber", "rxjs/util/ArgumentOutOfRangeError", "rxjs/observable/EmptyObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var ArgumentOutOfRangeError_1 = require("rxjs/util/ArgumentOutOfRangeError"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + function takeLast(total) { + if (total === 0) { + return new EmptyObservable_1.EmptyObservable(); + } else { + return this.lift(new TakeLastOperator(total)); + } + } + exports.takeLast = takeLast; + var TakeLastOperator = (function() { + function TakeLastOperator(total) { + this.total = total; + if (this.total < 0) { + throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError; + } + } + TakeLastOperator.prototype.call = function(subscriber) { + return new TakeLastSubscriber(subscriber, this.total); + }; + return TakeLastOperator; + }()); + var TakeLastSubscriber = (function(_super) { + __extends(TakeLastSubscriber, _super); + function TakeLastSubscriber(destination, total) { + _super.call(this, destination); + this.total = total; + this.count = 0; + this.index = 0; + this.ring = new Array(total); + } + TakeLastSubscriber.prototype._next = function(value) { + var index = this.index; + var ring = this.ring; + var total = this.total; + var count = this.count; + if (total > 1) { + if (count < total) { + this.count = count + 1; + this.index = index + 1; + } else if (index === 0) { + this.index = ++index; + } else if (index < total) { + this.index = index + 1; + } else { + this.index = index = 0; + } + } else if (count < total) { + this.count = total; + } + ring[index] = value; + }; + TakeLastSubscriber.prototype._complete = function() { + var iter = -1; + var _a = this, + ring = _a.ring, + count = _a.count, + total = _a.total, + destination = _a.destination; + var index = (total === 1 || count < total) ? 0 : this.index - 1; + while (++iter < count) { + if (iter + index === total) { + index = total - iter; + } + destination.next(ring[iter + index]); + } + destination.complete(); + }; + return TakeLastSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/takeUntil", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function takeUntil(notifier) { + return this.lift(new TakeUntilOperator(notifier)); + } + exports.takeUntil = takeUntil; + var TakeUntilOperator = (function() { + function TakeUntilOperator(notifier) { + this.notifier = notifier; + } + TakeUntilOperator.prototype.call = function(subscriber) { + return new TakeUntilSubscriber(subscriber, this.notifier); + }; + return TakeUntilOperator; + }()); + var TakeUntilSubscriber = (function(_super) { + __extends(TakeUntilSubscriber, _super); + function TakeUntilSubscriber(destination, notifier) { + _super.call(this, destination); + this.notifier = notifier; + this.add(subscribeToResult_1.subscribeToResult(this, notifier)); + } + TakeUntilSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.complete(); + }; + TakeUntilSubscriber.prototype.notifyComplete = function() {}; + return TakeUntilSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/takeWhile", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function takeWhile(predicate) { + return this.lift(new TakeWhileOperator(predicate)); + } + exports.takeWhile = takeWhile; + var TakeWhileOperator = (function() { + function TakeWhileOperator(predicate) { + this.predicate = predicate; + } + TakeWhileOperator.prototype.call = function(subscriber) { + return new TakeWhileSubscriber(subscriber, this.predicate); + }; + return TakeWhileOperator; + }()); + var TakeWhileSubscriber = (function(_super) { + __extends(TakeWhileSubscriber, _super); + function TakeWhileSubscriber(destination, predicate) { + _super.call(this, destination); + this.predicate = predicate; + this.index = 0; + } + TakeWhileSubscriber.prototype._next = function(value) { + var destination = this.destination; + var result; + try { + result = this.predicate(value, this.index++); + } catch (err) { + destination.error(err); + return ; + } + this.nextOrComplete(value, result); + }; + TakeWhileSubscriber.prototype.nextOrComplete = function(value, predicateResult) { + var destination = this.destination; + if (Boolean(predicateResult)) { + destination.next(value); + } else { + destination.complete(); + } + }; + return TakeWhileSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/throttle", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function throttle(durationSelector) { + return this.lift(new ThrottleOperator(durationSelector)); + } + exports.throttle = throttle; + var ThrottleOperator = (function() { + function ThrottleOperator(durationSelector) { + this.durationSelector = durationSelector; + } + ThrottleOperator.prototype.call = function(subscriber) { + return new ThrottleSubscriber(subscriber, this.durationSelector); + }; + return ThrottleOperator; + }()); + var ThrottleSubscriber = (function(_super) { + __extends(ThrottleSubscriber, _super); + function ThrottleSubscriber(destination, durationSelector) { + _super.call(this, destination); + this.destination = destination; + this.durationSelector = durationSelector; + } + ThrottleSubscriber.prototype._next = function(value) { + if (!this.throttled) { + this.tryDurationSelector(value); + } + }; + ThrottleSubscriber.prototype.tryDurationSelector = function(value) { + var duration = null; + try { + duration = this.durationSelector(value); + } catch (err) { + this.destination.error(err); + return ; + } + this.emitAndThrottle(value, duration); + }; + ThrottleSubscriber.prototype.emitAndThrottle = function(value, duration) { + this.add(this.throttled = subscribeToResult_1.subscribeToResult(this, duration)); + this.destination.next(value); + }; + ThrottleSubscriber.prototype._unsubscribe = function() { + var throttled = this.throttled; + if (throttled) { + this.remove(throttled); + this.throttled = null; + throttled.unsubscribe(); + } + }; + ThrottleSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this._unsubscribe(); + }; + ThrottleSubscriber.prototype.notifyComplete = function() { + this._unsubscribe(); + }; + return ThrottleSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/throttleTime", ["rxjs/Subscriber", "rxjs/scheduler/asap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var asap_1 = require("rxjs/scheduler/asap"); + function throttleTime(delay, scheduler) { + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return this.lift(new ThrottleTimeOperator(delay, scheduler)); + } + exports.throttleTime = throttleTime; + var ThrottleTimeOperator = (function() { + function ThrottleTimeOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + ThrottleTimeOperator.prototype.call = function(subscriber) { + return new ThrottleTimeSubscriber(subscriber, this.delay, this.scheduler); + }; + return ThrottleTimeOperator; + }()); + var ThrottleTimeSubscriber = (function(_super) { + __extends(ThrottleTimeSubscriber, _super); + function ThrottleTimeSubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + } + ThrottleTimeSubscriber.prototype._next = function(value) { + if (!this.throttled) { + this.add(this.throttled = this.scheduler.schedule(dispatchNext, this.delay, {subscriber: this})); + this.destination.next(value); + } + }; + ThrottleTimeSubscriber.prototype.clearThrottle = function() { + var throttled = this.throttled; + if (throttled) { + throttled.unsubscribe(); + this.remove(throttled); + this.throttled = null; + } + }; + return ThrottleTimeSubscriber; + }(Subscriber_1.Subscriber)); + function dispatchNext(_a) { + var subscriber = _a.subscriber; + subscriber.clearThrottle(); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/timeout", ["rxjs/scheduler/asap", "rxjs/util/isDate", "rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var asap_1 = require("rxjs/scheduler/asap"); + var isDate_1 = require("rxjs/util/isDate"); + var Subscriber_1 = require("rxjs/Subscriber"); + function timeout(due, errorToSend, scheduler) { + if (errorToSend === void 0) { + errorToSend = null; + } + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + var absoluteTimeout = isDate_1.isDate(due); + var waitFor = absoluteTimeout ? (+due - scheduler.now()) : Math.abs(due); + return this.lift(new TimeoutOperator(waitFor, absoluteTimeout, errorToSend, scheduler)); + } + exports.timeout = timeout; + var TimeoutOperator = (function() { + function TimeoutOperator(waitFor, absoluteTimeout, errorToSend, scheduler) { + this.waitFor = waitFor; + this.absoluteTimeout = absoluteTimeout; + this.errorToSend = errorToSend; + this.scheduler = scheduler; + } + TimeoutOperator.prototype.call = function(subscriber) { + return new TimeoutSubscriber(subscriber, this.absoluteTimeout, this.waitFor, this.errorToSend, this.scheduler); + }; + return TimeoutOperator; + }()); + var TimeoutSubscriber = (function(_super) { + __extends(TimeoutSubscriber, _super); + function TimeoutSubscriber(destination, absoluteTimeout, waitFor, errorToSend, scheduler) { + _super.call(this, destination); + this.absoluteTimeout = absoluteTimeout; + this.waitFor = waitFor; + this.errorToSend = errorToSend; + this.scheduler = scheduler; + this.index = 0; + this._previousIndex = 0; + this._hasCompleted = false; + this.scheduleTimeout(); + } + Object.defineProperty(TimeoutSubscriber.prototype, "previousIndex", { + get: function() { + return this._previousIndex; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TimeoutSubscriber.prototype, "hasCompleted", { + get: function() { + return this._hasCompleted; + }, + enumerable: true, + configurable: true + }); + TimeoutSubscriber.dispatchTimeout = function(state) { + var source = state.subscriber; + var currentIndex = state.index; + if (!source.hasCompleted && source.previousIndex === currentIndex) { + source.notifyTimeout(); + } + }; + TimeoutSubscriber.prototype.scheduleTimeout = function() { + var currentIndex = this.index; + this.scheduler.schedule(TimeoutSubscriber.dispatchTimeout, this.waitFor, { + subscriber: this, + index: currentIndex + }); + this.index++; + this._previousIndex = currentIndex; + }; + TimeoutSubscriber.prototype._next = function(value) { + this.destination.next(value); + if (!this.absoluteTimeout) { + this.scheduleTimeout(); + } + }; + TimeoutSubscriber.prototype._error = function(err) { + this.destination.error(err); + this._hasCompleted = true; + }; + TimeoutSubscriber.prototype._complete = function() { + this.destination.complete(); + this._hasCompleted = true; + }; + TimeoutSubscriber.prototype.notifyTimeout = function() { + this.error(this.errorToSend || new Error('timeout')); + }; + return TimeoutSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/timeoutWith", ["rxjs/scheduler/asap", "rxjs/util/isDate", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var asap_1 = require("rxjs/scheduler/asap"); + var isDate_1 = require("rxjs/util/isDate"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function timeoutWith(due, withObservable, scheduler) { + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + var absoluteTimeout = isDate_1.isDate(due); + var waitFor = absoluteTimeout ? (+due - scheduler.now()) : Math.abs(due); + return this.lift(new TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler)); + } + exports.timeoutWith = timeoutWith; + var TimeoutWithOperator = (function() { + function TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler) { + this.waitFor = waitFor; + this.absoluteTimeout = absoluteTimeout; + this.withObservable = withObservable; + this.scheduler = scheduler; + } + TimeoutWithOperator.prototype.call = function(subscriber) { + return new TimeoutWithSubscriber(subscriber, this.absoluteTimeout, this.waitFor, this.withObservable, this.scheduler); + }; + return TimeoutWithOperator; + }()); + var TimeoutWithSubscriber = (function(_super) { + __extends(TimeoutWithSubscriber, _super); + function TimeoutWithSubscriber(destination, absoluteTimeout, waitFor, withObservable, scheduler) { + _super.call(this); + this.destination = destination; + this.absoluteTimeout = absoluteTimeout; + this.waitFor = waitFor; + this.withObservable = withObservable; + this.scheduler = scheduler; + this.timeoutSubscription = undefined; + this.index = 0; + this._previousIndex = 0; + this._hasCompleted = false; + destination.add(this); + this.scheduleTimeout(); + } + Object.defineProperty(TimeoutWithSubscriber.prototype, "previousIndex", { + get: function() { + return this._previousIndex; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TimeoutWithSubscriber.prototype, "hasCompleted", { + get: function() { + return this._hasCompleted; + }, + enumerable: true, + configurable: true + }); + TimeoutWithSubscriber.dispatchTimeout = function(state) { + var source = state.subscriber; + var currentIndex = state.index; + if (!source.hasCompleted && source.previousIndex === currentIndex) { + source.handleTimeout(); + } + }; + TimeoutWithSubscriber.prototype.scheduleTimeout = function() { + var currentIndex = this.index; + var timeoutState = { + subscriber: this, + index: currentIndex + }; + this.scheduler.schedule(TimeoutWithSubscriber.dispatchTimeout, this.waitFor, timeoutState); + this.index++; + this._previousIndex = currentIndex; + }; + TimeoutWithSubscriber.prototype._next = function(value) { + this.destination.next(value); + if (!this.absoluteTimeout) { + this.scheduleTimeout(); + } + }; + TimeoutWithSubscriber.prototype._error = function(err) { + this.destination.error(err); + this._hasCompleted = true; + }; + TimeoutWithSubscriber.prototype._complete = function() { + this.destination.complete(); + this._hasCompleted = true; + }; + TimeoutWithSubscriber.prototype.handleTimeout = function() { + if (!this.isUnsubscribed) { + var withObservable = this.withObservable; + this.unsubscribe(); + this.destination.add(this.timeoutSubscription = subscribeToResult_1.subscribeToResult(this, withObservable)); + } + }; + return TimeoutWithSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/toArray", ["rxjs/Subscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + function toArray() { + return this.lift(new ToArrayOperator()); + } + exports.toArray = toArray; + var ToArrayOperator = (function() { + function ToArrayOperator() {} + ToArrayOperator.prototype.call = function(subscriber) { + return new ToArraySubscriber(subscriber); + }; + return ToArrayOperator; + }()); + var ToArraySubscriber = (function(_super) { + __extends(ToArraySubscriber, _super); + function ToArraySubscriber(destination) { + _super.call(this, destination); + this.array = []; + } + ToArraySubscriber.prototype._next = function(x) { + this.array.push(x); + }; + ToArraySubscriber.prototype._complete = function() { + this.destination.next(this.array); + this.destination.complete(); + }; + return ToArraySubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/toPromise", ["rxjs/util/root"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var root_1 = require("rxjs/util/root"); + function toPromise(PromiseCtor) { + var _this = this; + if (!PromiseCtor) { + if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) { + PromiseCtor = root_1.root.Rx.config.Promise; + } else if (root_1.root.Promise) { + PromiseCtor = root_1.root.Promise; + } + } + if (!PromiseCtor) { + throw new Error('no Promise impl found'); + } + return new PromiseCtor(function(resolve, reject) { + var value; + _this.subscribe(function(x) { + return value = x; + }, function(err) { + return reject(err); + }, function() { + return resolve(value); + }); + }); + } + exports.toPromise = toPromise; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/window", ["rxjs/Subject", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subject_1 = require("rxjs/Subject"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function window(closingNotifier) { + return this.lift(new WindowOperator(closingNotifier)); + } + exports.window = window; + var WindowOperator = (function() { + function WindowOperator(closingNotifier) { + this.closingNotifier = closingNotifier; + } + WindowOperator.prototype.call = function(subscriber) { + return new WindowSubscriber(subscriber, this.closingNotifier); + }; + return WindowOperator; + }()); + var WindowSubscriber = (function(_super) { + __extends(WindowSubscriber, _super); + function WindowSubscriber(destination, closingNotifier) { + _super.call(this, destination); + this.destination = destination; + this.closingNotifier = closingNotifier; + this.add(subscribeToResult_1.subscribeToResult(this, closingNotifier)); + this.openWindow(); + } + WindowSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.openWindow(); + }; + WindowSubscriber.prototype.notifyError = function(error, innerSub) { + this._error(error); + }; + WindowSubscriber.prototype.notifyComplete = function(innerSub) { + this._complete(); + }; + WindowSubscriber.prototype._next = function(value) { + this.window.next(value); + }; + WindowSubscriber.prototype._error = function(err) { + this.window.error(err); + this.destination.error(err); + }; + WindowSubscriber.prototype._complete = function() { + this.window.complete(); + this.destination.complete(); + }; + WindowSubscriber.prototype.openWindow = function() { + var prevWindow = this.window; + if (prevWindow) { + prevWindow.complete(); + } + var destination = this.destination; + var newWindow = this.window = new Subject_1.Subject(); + destination.add(newWindow); + destination.next(newWindow); + }; + return WindowSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/windowCount", ["rxjs/Subscriber", "rxjs/Subject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Subject_1 = require("rxjs/Subject"); + function windowCount(windowSize, startWindowEvery) { + if (startWindowEvery === void 0) { + startWindowEvery = 0; + } + return this.lift(new WindowCountOperator(windowSize, startWindowEvery)); + } + exports.windowCount = windowCount; + var WindowCountOperator = (function() { + function WindowCountOperator(windowSize, startWindowEvery) { + this.windowSize = windowSize; + this.startWindowEvery = startWindowEvery; + } + WindowCountOperator.prototype.call = function(subscriber) { + return new WindowCountSubscriber(subscriber, this.windowSize, this.startWindowEvery); + }; + return WindowCountOperator; + }()); + var WindowCountSubscriber = (function(_super) { + __extends(WindowCountSubscriber, _super); + function WindowCountSubscriber(destination, windowSize, startWindowEvery) { + _super.call(this, destination); + this.destination = destination; + this.windowSize = windowSize; + this.startWindowEvery = startWindowEvery; + this.windows = [new Subject_1.Subject()]; + this.count = 0; + var firstWindow = this.windows[0]; + destination.add(firstWindow); + destination.next(firstWindow); + } + WindowCountSubscriber.prototype._next = function(value) { + var startWindowEvery = (this.startWindowEvery > 0) ? this.startWindowEvery : this.windowSize; + var destination = this.destination; + var windowSize = this.windowSize; + var windows = this.windows; + var len = windows.length; + for (var i = 0; i < len; i++) { + windows[i].next(value); + } + var c = this.count - windowSize + 1; + if (c >= 0 && c % startWindowEvery === 0) { + windows.shift().complete(); + } + if (++this.count % startWindowEvery === 0) { + var window_1 = new Subject_1.Subject(); + windows.push(window_1); + destination.add(window_1); + destination.next(window_1); + } + }; + WindowCountSubscriber.prototype._error = function(err) { + var windows = this.windows; + while (windows.length > 0) { + windows.shift().error(err); + } + this.destination.error(err); + }; + WindowCountSubscriber.prototype._complete = function() { + var windows = this.windows; + while (windows.length > 0) { + windows.shift().complete(); + } + this.destination.complete(); + }; + return WindowCountSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/windowTime", ["rxjs/Subscriber", "rxjs/Subject", "rxjs/scheduler/asap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Subject_1 = require("rxjs/Subject"); + var asap_1 = require("rxjs/scheduler/asap"); + function windowTime(windowTimeSpan, windowCreationInterval, scheduler) { + if (windowCreationInterval === void 0) { + windowCreationInterval = null; + } + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return this.lift(new WindowTimeOperator(windowTimeSpan, windowCreationInterval, scheduler)); + } + exports.windowTime = windowTime; + var WindowTimeOperator = (function() { + function WindowTimeOperator(windowTimeSpan, windowCreationInterval, scheduler) { + this.windowTimeSpan = windowTimeSpan; + this.windowCreationInterval = windowCreationInterval; + this.scheduler = scheduler; + } + WindowTimeOperator.prototype.call = function(subscriber) { + return new WindowTimeSubscriber(subscriber, this.windowTimeSpan, this.windowCreationInterval, this.scheduler); + }; + return WindowTimeOperator; + }()); + var WindowTimeSubscriber = (function(_super) { + __extends(WindowTimeSubscriber, _super); + function WindowTimeSubscriber(destination, windowTimeSpan, windowCreationInterval, scheduler) { + _super.call(this, destination); + this.destination = destination; + this.windowTimeSpan = windowTimeSpan; + this.windowCreationInterval = windowCreationInterval; + this.scheduler = scheduler; + this.windows = []; + if (windowCreationInterval !== null && windowCreationInterval >= 0) { + var window_1 = this.openWindow(); + var closeState = { + subscriber: this, + window: window_1, + context: null + }; + var creationState = { + windowTimeSpan: windowTimeSpan, + windowCreationInterval: windowCreationInterval, + subscriber: this, + scheduler: scheduler + }; + this.add(scheduler.schedule(dispatchWindowClose, windowTimeSpan, closeState)); + this.add(scheduler.schedule(dispatchWindowCreation, windowCreationInterval, creationState)); + } else { + var window_2 = this.openWindow(); + var timeSpanOnlyState = { + subscriber: this, + window: window_2, + windowTimeSpan: windowTimeSpan + }; + this.add(scheduler.schedule(dispatchWindowTimeSpanOnly, windowTimeSpan, timeSpanOnlyState)); + } + } + WindowTimeSubscriber.prototype._next = function(value) { + var windows = this.windows; + var len = windows.length; + for (var i = 0; i < len; i++) { + var window_3 = windows[i]; + if (!window_3.isUnsubscribed) { + window_3.next(value); + } + } + }; + WindowTimeSubscriber.prototype._error = function(err) { + var windows = this.windows; + while (windows.length > 0) { + windows.shift().error(err); + } + this.destination.error(err); + }; + WindowTimeSubscriber.prototype._complete = function() { + var windows = this.windows; + while (windows.length > 0) { + var window_4 = windows.shift(); + if (!window_4.isUnsubscribed) { + window_4.complete(); + } + } + this.destination.complete(); + }; + WindowTimeSubscriber.prototype.openWindow = function() { + var window = new Subject_1.Subject(); + this.windows.push(window); + var destination = this.destination; + destination.add(window); + destination.next(window); + return window; + }; + WindowTimeSubscriber.prototype.closeWindow = function(window) { + window.complete(); + var windows = this.windows; + windows.splice(windows.indexOf(window), 1); + }; + return WindowTimeSubscriber; + }(Subscriber_1.Subscriber)); + function dispatchWindowTimeSpanOnly(state) { + var subscriber = state.subscriber, + windowTimeSpan = state.windowTimeSpan, + window = state.window; + if (window) { + window.complete(); + } + state.window = subscriber.openWindow(); + this.schedule(state, windowTimeSpan); + } + function dispatchWindowCreation(state) { + var windowTimeSpan = state.windowTimeSpan, + subscriber = state.subscriber, + scheduler = state.scheduler, + windowCreationInterval = state.windowCreationInterval; + var window = subscriber.openWindow(); + var action = this; + var context = { + action: action, + subscription: null + }; + var timeSpanState = { + subscriber: subscriber, + window: window, + context: context + }; + context.subscription = scheduler.schedule(dispatchWindowClose, windowTimeSpan, timeSpanState); + action.add(context.subscription); + action.schedule(state, windowCreationInterval); + } + function dispatchWindowClose(_a) { + var subscriber = _a.subscriber, + window = _a.window, + context = _a.context; + if (context && context.action && context.subscription) { + context.action.remove(context.subscription); + } + subscriber.closeWindow(window); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/windowToggle", ["rxjs/Subject", "rxjs/Subscription", "rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subject_1 = require("rxjs/Subject"); + var Subscription_1 = require("rxjs/Subscription"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function windowToggle(openings, closingSelector) { + return this.lift(new WindowToggleOperator(openings, closingSelector)); + } + exports.windowToggle = windowToggle; + var WindowToggleOperator = (function() { + function WindowToggleOperator(openings, closingSelector) { + this.openings = openings; + this.closingSelector = closingSelector; + } + WindowToggleOperator.prototype.call = function(subscriber) { + return new WindowToggleSubscriber(subscriber, this.openings, this.closingSelector); + }; + return WindowToggleOperator; + }()); + var WindowToggleSubscriber = (function(_super) { + __extends(WindowToggleSubscriber, _super); + function WindowToggleSubscriber(destination, openings, closingSelector) { + _super.call(this, destination); + this.openings = openings; + this.closingSelector = closingSelector; + this.contexts = []; + this.add(this.openSubscription = subscribeToResult_1.subscribeToResult(this, openings, openings)); + } + WindowToggleSubscriber.prototype._next = function(value) { + var contexts = this.contexts; + if (contexts) { + var len = contexts.length; + for (var i = 0; i < len; i++) { + contexts[i].window.next(value); + } + } + }; + WindowToggleSubscriber.prototype._error = function(err) { + var contexts = this.contexts; + this.contexts = null; + if (contexts) { + var len = contexts.length; + var index = -1; + while (++index < len) { + var context = contexts[index]; + context.window.error(err); + context.subscription.unsubscribe(); + } + } + _super.prototype._error.call(this, err); + }; + WindowToggleSubscriber.prototype._complete = function() { + var contexts = this.contexts; + this.contexts = null; + if (contexts) { + var len = contexts.length; + var index = -1; + while (++index < len) { + var context = contexts[index]; + context.window.complete(); + context.subscription.unsubscribe(); + } + } + _super.prototype._complete.call(this); + }; + WindowToggleSubscriber.prototype._unsubscribe = function() { + var contexts = this.contexts; + this.contexts = null; + if (contexts) { + var len = contexts.length; + var index = -1; + while (++index < len) { + var context = contexts[index]; + context.window.unsubscribe(); + context.subscription.unsubscribe(); + } + } + }; + WindowToggleSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (outerValue === this.openings) { + var closingSelector = this.closingSelector; + var closingNotifier = tryCatch_1.tryCatch(closingSelector)(innerValue); + if (closingNotifier === errorObject_1.errorObject) { + return this.error(errorObject_1.errorObject.e); + } else { + var window_1 = new Subject_1.Subject(); + var subscription = new Subscription_1.Subscription(); + var context = { + window: window_1, + subscription: subscription + }; + this.contexts.push(context); + var innerSubscription = subscribeToResult_1.subscribeToResult(this, closingNotifier, context); + innerSubscription.context = context; + subscription.add(innerSubscription); + this.destination.next(window_1); + } + } else { + this.closeWindow(this.contexts.indexOf(outerValue)); + } + }; + WindowToggleSubscriber.prototype.notifyError = function(err) { + this.error(err); + }; + WindowToggleSubscriber.prototype.notifyComplete = function(inner) { + if (inner !== this.openSubscription) { + this.closeWindow(this.contexts.indexOf(inner.context)); + } + }; + WindowToggleSubscriber.prototype.closeWindow = function(index) { + var contexts = this.contexts; + var context = contexts[index]; + var window = context.window, + subscription = context.subscription; + contexts.splice(index, 1); + window.complete(); + subscription.unsubscribe(); + }; + return WindowToggleSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/windowWhen", ["rxjs/Subject", "rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subject_1 = require("rxjs/Subject"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function windowWhen(closingSelector) { + return this.lift(new WindowOperator(closingSelector)); + } + exports.windowWhen = windowWhen; + var WindowOperator = (function() { + function WindowOperator(closingSelector) { + this.closingSelector = closingSelector; + } + WindowOperator.prototype.call = function(subscriber) { + return new WindowSubscriber(subscriber, this.closingSelector); + }; + return WindowOperator; + }()); + var WindowSubscriber = (function(_super) { + __extends(WindowSubscriber, _super); + function WindowSubscriber(destination, closingSelector) { + _super.call(this, destination); + this.destination = destination; + this.closingSelector = closingSelector; + this.openWindow(); + } + WindowSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.openWindow(innerSub); + }; + WindowSubscriber.prototype.notifyError = function(error, innerSub) { + this._error(error); + }; + WindowSubscriber.prototype.notifyComplete = function(innerSub) { + this.openWindow(innerSub); + }; + WindowSubscriber.prototype._next = function(value) { + this.window.next(value); + }; + WindowSubscriber.prototype._error = function(err) { + this.window.error(err); + this.destination.error(err); + this.unsubscribeClosingNotification(); + }; + WindowSubscriber.prototype._complete = function() { + this.window.complete(); + this.destination.complete(); + this.unsubscribeClosingNotification(); + }; + WindowSubscriber.prototype.unsubscribeClosingNotification = function() { + if (this.closingNotification) { + this.closingNotification.unsubscribe(); + } + }; + WindowSubscriber.prototype.openWindow = function(innerSub) { + if (innerSub === void 0) { + innerSub = null; + } + if (innerSub) { + this.remove(innerSub); + innerSub.unsubscribe(); + } + var prevWindow = this.window; + if (prevWindow) { + prevWindow.complete(); + } + var window = this.window = new Subject_1.Subject(); + this.destination.next(window); + var closingNotifier = tryCatch_1.tryCatch(this.closingSelector)(); + if (closingNotifier === errorObject_1.errorObject) { + var err = errorObject_1.errorObject.e; + this.destination.error(err); + this.window.error(err); + } else { + this.add(this.closingNotification = subscribeToResult_1.subscribeToResult(this, closingNotifier)); + this.add(window); + } + }; + return WindowSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/withLatestFrom", ["rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function withLatestFrom() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + var project; + if (typeof args[args.length - 1] === 'function') { + project = args.pop(); + } + var observables = args; + return this.lift(new WithLatestFromOperator(observables, project)); + } + exports.withLatestFrom = withLatestFrom; + var WithLatestFromOperator = (function() { + function WithLatestFromOperator(observables, project) { + this.observables = observables; + this.project = project; + } + WithLatestFromOperator.prototype.call = function(subscriber) { + return new WithLatestFromSubscriber(subscriber, this.observables, this.project); + }; + return WithLatestFromOperator; + }()); + var WithLatestFromSubscriber = (function(_super) { + __extends(WithLatestFromSubscriber, _super); + function WithLatestFromSubscriber(destination, observables, project) { + _super.call(this, destination); + this.observables = observables; + this.project = project; + this.toRespond = []; + var len = observables.length; + this.values = new Array(len); + for (var i = 0; i < len; i++) { + this.toRespond.push(i); + } + for (var i = 0; i < len; i++) { + var observable = observables[i]; + this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i)); + } + } + WithLatestFromSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.values[outerIndex] = innerValue; + var toRespond = this.toRespond; + if (toRespond.length > 0) { + var found = toRespond.indexOf(outerIndex); + if (found !== -1) { + toRespond.splice(found, 1); + } + } + }; + WithLatestFromSubscriber.prototype.notifyComplete = function() {}; + WithLatestFromSubscriber.prototype._next = function(value) { + if (this.toRespond.length === 0) { + var args = [value].concat(this.values); + if (this.project) { + this._tryProject(args); + } else { + this.destination.next(args); + } + } + }; + WithLatestFromSubscriber.prototype._tryProject = function(args) { + var result; + try { + result = this.project.apply(this, args); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.next(result); + }; + return WithLatestFromSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/zip", ["rxjs/Observable", "rxjs/operator/zip"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var zip_1 = require("rxjs/operator/zip"); + Observable_1.Observable.prototype.zip = zip_1.zipProto; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/zipAll", ["rxjs/operator/zip"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var zip_1 = require("rxjs/operator/zip"); + function zipAll(project) { + return this.lift(new zip_1.ZipOperator(project)); + } + exports.zipAll = zipAll; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/tryCatch", ["rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var errorObject_1 = require("rxjs/util/errorObject"); + var tryCatchTarget; + function tryCatcher() { + try { + return tryCatchTarget.apply(this, arguments); + } catch (e) { + errorObject_1.errorObject.e = e; + return errorObject_1.errorObject; + } + } + function tryCatch(fn) { + tryCatchTarget = fn; + return tryCatcher; + } + exports.tryCatch = tryCatch; + ; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/ArrayObservable", ["rxjs/Observable", "rxjs/observable/ScalarObservable", "rxjs/observable/EmptyObservable", "rxjs/util/isScheduler"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var ScalarObservable_1 = require("rxjs/observable/ScalarObservable"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + var isScheduler_1 = require("rxjs/util/isScheduler"); + var ArrayObservable = (function(_super) { + __extends(ArrayObservable, _super); + function ArrayObservable(array, scheduler) { + _super.call(this); + this.array = array; + this.scheduler = scheduler; + if (!scheduler && array.length === 1) { + this._isScalar = true; + this.value = array[0]; + } + } + ArrayObservable.create = function(array, scheduler) { + return new ArrayObservable(array, scheduler); + }; + ArrayObservable.of = function() { + var array = []; + for (var _i = 0; _i < arguments.length; _i++) { + array[_i - 0] = arguments[_i]; + } + var scheduler = array[array.length - 1]; + if (isScheduler_1.isScheduler(scheduler)) { + array.pop(); + } else { + scheduler = null; + } + var len = array.length; + if (len > 1) { + return new ArrayObservable(array, scheduler); + } else if (len === 1) { + return new ScalarObservable_1.ScalarObservable(array[0], scheduler); + } else { + return new EmptyObservable_1.EmptyObservable(scheduler); + } + }; + ArrayObservable.dispatch = function(state) { + var array = state.array, + index = state.index, + count = state.count, + subscriber = state.subscriber; + if (index >= count) { + subscriber.complete(); + return ; + } + subscriber.next(array[index]); + if (subscriber.isUnsubscribed) { + return ; + } + state.index = index + 1; + this.schedule(state); + }; + ArrayObservable.prototype._subscribe = function(subscriber) { + var index = 0; + var array = this.array; + var count = array.length; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(ArrayObservable.dispatch, 0, { + array: array, + index: index, + count: count, + subscriber: subscriber + }); + } else { + for (var i = 0; i < count && !subscriber.isUnsubscribed; i++) { + subscriber.next(array[i]); + } + subscriber.complete(); + } + }; + return ArrayObservable; + }(Observable_1.Observable)); + exports.ArrayObservable = ArrayObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/subscribeToResult", ["rxjs/util/root", "rxjs/util/isArray", "rxjs/util/isPromise", "rxjs/Observable", "rxjs/util/SymbolShim", "rxjs/InnerSubscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var root_1 = require("rxjs/util/root"); + var isArray_1 = require("rxjs/util/isArray"); + var isPromise_1 = require("rxjs/util/isPromise"); + var Observable_1 = require("rxjs/Observable"); + var SymbolShim_1 = require("rxjs/util/SymbolShim"); + var InnerSubscriber_1 = require("rxjs/InnerSubscriber"); + function subscribeToResult(outerSubscriber, result, outerValue, outerIndex) { + var destination = new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex); + if (destination.isUnsubscribed) { + return ; + } + if (result instanceof Observable_1.Observable) { + if (result._isScalar) { + destination.next(result.value); + destination.complete(); + return ; + } else { + return result.subscribe(destination); + } + } + if (isArray_1.isArray(result)) { + for (var i = 0, + len = result.length; i < len && !destination.isUnsubscribed; i++) { + destination.next(result[i]); + } + if (!destination.isUnsubscribed) { + destination.complete(); + } + } else if (isPromise_1.isPromise(result)) { + result.then(function(value) { + if (!destination.isUnsubscribed) { + destination.next(value); + destination.complete(); + } + }, function(err) { + return destination.error(err); + }).then(null, function(err) { + root_1.root.setTimeout(function() { + throw err; + }); + }); + return destination; + } else if (typeof result[SymbolShim_1.SymbolShim.iterator] === 'function') { + for (var _i = 0, + result_1 = result; _i < result_1.length; _i++) { + var item = result_1[_i]; + destination.next(item); + if (destination.isUnsubscribed) { + break; + } + } + if (!destination.isUnsubscribed) { + destination.complete(); + } + } else if (typeof result[SymbolShim_1.SymbolShim.observable] === 'function') { + var obs = result[SymbolShim_1.SymbolShim.observable](); + if (typeof obs.subscribe !== 'function') { + destination.error('invalid observable'); + } else { + return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex)); + } + } else { + destination.error(new TypeError('unknown type returned')); + } + } + exports.subscribeToResult = subscribeToResult; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/concat", ["rxjs/util/isScheduler", "rxjs/observable/ArrayObservable", "rxjs/operator/mergeAll"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var isScheduler_1 = require("rxjs/util/isScheduler"); + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + var mergeAll_1 = require("rxjs/operator/mergeAll"); + function concat() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + return concatStatic.apply(void 0, [this].concat(observables)); + } + exports.concat = concat; + function concatStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var scheduler = null; + var args = observables; + if (isScheduler_1.isScheduler(args[observables.length - 1])) { + scheduler = args.pop(); + } + return new ArrayObservable_1.ArrayObservable(observables, scheduler).lift(new mergeAll_1.MergeAllOperator(1)); + } + exports.concatStatic = concatStatic; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/merge", ["rxjs/Observable", "rxjs/operator/merge"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var merge_1 = require("rxjs/operator/merge"); + Observable_1.Observable.merge = merge_1.mergeStatic; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/race", ["rxjs/Observable", "rxjs/operator/race"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var race_1 = require("rxjs/operator/race"); + Observable_1.Observable.race = race_1.raceStatic; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/BoundCallbackObservable", ["rxjs/Observable", "rxjs/util/tryCatch", "rxjs/util/errorObject", "rxjs/subject/AsyncSubject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var AsyncSubject_1 = require("rxjs/subject/AsyncSubject"); + var BoundCallbackObservable = (function(_super) { + __extends(BoundCallbackObservable, _super); + function BoundCallbackObservable(callbackFunc, selector, args, scheduler) { + _super.call(this); + this.callbackFunc = callbackFunc; + this.selector = selector; + this.args = args; + this.scheduler = scheduler; + } + BoundCallbackObservable.create = function(callbackFunc, selector, scheduler) { + if (selector === void 0) { + selector = undefined; + } + return function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + return new BoundCallbackObservable(callbackFunc, selector, args, scheduler); + }; + }; + BoundCallbackObservable.prototype._subscribe = function(subscriber) { + var callbackFunc = this.callbackFunc; + var args = this.args; + var scheduler = this.scheduler; + var subject = this.subject; + if (!scheduler) { + if (!subject) { + subject = this.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, + subject = source.subject; + if (selector) { + var result_1 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_1 === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } else { + subject.next(result_1); + subject.complete(); + } + } else { + subject.next(innerArgs.length === 1 ? innerArgs[0] : innerArgs); + subject.complete(); + } + }; + handler.source = this; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + return subject.subscribe(subscriber); + } else { + return scheduler.schedule(dispatch, 0, { + source: this, + subscriber: subscriber + }); + } + }; + return BoundCallbackObservable; + }(Observable_1.Observable)); + exports.BoundCallbackObservable = BoundCallbackObservable; + function dispatch(state) { + var self = this; + var source = state.source, + subscriber = state.subscriber; + var callbackFunc = source.callbackFunc, + args = source.args, + scheduler = source.scheduler; + var subject = source.subject; + if (!subject) { + subject = source.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, + subject = source.subject; + if (selector) { + var result_2 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_2 === errorObject_1.errorObject) { + self.add(scheduler.schedule(dispatchError, 0, { + err: errorObject_1.errorObject.e, + subject: subject + })); + } else { + self.add(scheduler.schedule(dispatchNext, 0, { + value: result_2, + subject: subject + })); + } + } else { + var value = innerArgs.length === 1 ? innerArgs[0] : innerArgs; + self.add(scheduler.schedule(dispatchNext, 0, { + value: value, + subject: subject + })); + } + }; + handler.source = source; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + self.add(subject.subscribe(subscriber)); + } + function dispatchNext(_a) { + var value = _a.value, + subject = _a.subject; + subject.next(value); + subject.complete(); + } + function dispatchError(_a) { + var err = _a.err, + subject = _a.subject; + subject.error(err); + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/bindNodeCallback", ["rxjs/Observable", "rxjs/observable/BoundNodeCallbackObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var BoundNodeCallbackObservable_1 = require("rxjs/observable/BoundNodeCallbackObservable"); + Observable_1.Observable.bindNodeCallback = BoundNodeCallbackObservable_1.BoundNodeCallbackObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/defer", ["rxjs/Observable", "rxjs/observable/DeferObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var DeferObservable_1 = require("rxjs/observable/DeferObservable"); + Observable_1.Observable.defer = DeferObservable_1.DeferObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/ForkJoinObservable", ["rxjs/Observable", "rxjs/Subscriber", "rxjs/observable/PromiseObservable", "rxjs/observable/EmptyObservable", "rxjs/util/isPromise", "rxjs/util/isArray"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var Subscriber_1 = require("rxjs/Subscriber"); + var PromiseObservable_1 = require("rxjs/observable/PromiseObservable"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + var isPromise_1 = require("rxjs/util/isPromise"); + var isArray_1 = require("rxjs/util/isArray"); + var ForkJoinObservable = (function(_super) { + __extends(ForkJoinObservable, _super); + function ForkJoinObservable(sources, resultSelector) { + _super.call(this); + this.sources = sources; + this.resultSelector = resultSelector; + } + ForkJoinObservable.create = function() { + var sources = []; + for (var _i = 0; _i < arguments.length; _i++) { + sources[_i - 0] = arguments[_i]; + } + if (sources === null || arguments.length === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + var resultSelector = null; + if (typeof sources[sources.length - 1] === 'function') { + resultSelector = sources.pop(); + } + if (sources.length === 1 && isArray_1.isArray(sources[0])) { + sources = sources[0]; + } + if (sources.length === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + return new ForkJoinObservable(sources, resultSelector); + }; + ForkJoinObservable.prototype._subscribe = function(subscriber) { + var sources = this.sources; + var len = sources.length; + var context = { + completed: 0, + total: len, + values: emptyArray(len), + selector: this.resultSelector + }; + for (var i = 0; i < len; i++) { + var source = sources[i]; + if (isPromise_1.isPromise(source)) { + source = new PromiseObservable_1.PromiseObservable(source); + } + source.subscribe(new AllSubscriber(subscriber, i, context)); + } + }; + return ForkJoinObservable; + }(Observable_1.Observable)); + exports.ForkJoinObservable = ForkJoinObservable; + var AllSubscriber = (function(_super) { + __extends(AllSubscriber, _super); + function AllSubscriber(destination, index, context) { + _super.call(this, destination); + this.index = index; + this.context = context; + this._value = null; + } + AllSubscriber.prototype._next = function(value) { + this._value = value; + }; + AllSubscriber.prototype._complete = function() { + var destination = this.destination; + if (this._value == null) { + destination.complete(); + } + var context = this.context; + context.completed++; + context.values[this.index] = this._value; + var values = context.values; + if (context.completed !== values.length) { + return ; + } + if (values.every(hasValue)) { + var value = context.selector ? context.selector.apply(this, values) : values; + destination.next(value); + } + destination.complete(); + }; + return AllSubscriber; + }(Subscriber_1.Subscriber)); + function hasValue(x) { + return x !== null; + } + function emptyArray(len) { + var arr = []; + for (var i = 0; i < len; i++) { + arr.push(null); + } + return arr; + } + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/observeOn", ["rxjs/Subscriber", "rxjs/Notification"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Notification_1 = require("rxjs/Notification"); + function observeOn(scheduler, delay) { + if (delay === void 0) { + delay = 0; + } + return this.lift(new ObserveOnOperator(scheduler, delay)); + } + exports.observeOn = observeOn; + var ObserveOnOperator = (function() { + function ObserveOnOperator(scheduler, delay) { + if (delay === void 0) { + delay = 0; + } + this.scheduler = scheduler; + this.delay = delay; + } + ObserveOnOperator.prototype.call = function(subscriber) { + return new ObserveOnSubscriber(subscriber, this.scheduler, this.delay); + }; + return ObserveOnOperator; + }()); + exports.ObserveOnOperator = ObserveOnOperator; + var ObserveOnSubscriber = (function(_super) { + __extends(ObserveOnSubscriber, _super); + function ObserveOnSubscriber(destination, scheduler, delay) { + if (delay === void 0) { + delay = 0; + } + _super.call(this, destination); + this.scheduler = scheduler; + this.delay = delay; + } + ObserveOnSubscriber.dispatch = function(_a) { + var notification = _a.notification, + destination = _a.destination; + notification.observe(destination); + }; + ObserveOnSubscriber.prototype.scheduleMessage = function(notification) { + this.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination))); + }; + ObserveOnSubscriber.prototype._next = function(value) { + this.scheduleMessage(Notification_1.Notification.createNext(value)); + }; + ObserveOnSubscriber.prototype._error = function(err) { + this.scheduleMessage(Notification_1.Notification.createError(err)); + }; + ObserveOnSubscriber.prototype._complete = function() { + this.scheduleMessage(Notification_1.Notification.createComplete()); + }; + return ObserveOnSubscriber; + }(Subscriber_1.Subscriber)); + exports.ObserveOnSubscriber = ObserveOnSubscriber; + var ObserveOnMessage = (function() { + function ObserveOnMessage(notification, destination) { + this.notification = notification; + this.destination = destination; + } + return ObserveOnMessage; + }()); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/fromEvent", ["rxjs/Observable", "rxjs/observable/FromEventObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var FromEventObservable_1 = require("rxjs/observable/FromEventObservable"); + Observable_1.Observable.fromEvent = FromEventObservable_1.FromEventObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/fromEventPattern", ["rxjs/Observable", "rxjs/observable/FromEventPatternObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var FromEventPatternObservable_1 = require("rxjs/observable/FromEventPatternObservable"); + Observable_1.Observable.fromEventPattern = FromEventPatternObservable_1.FromEventPatternObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/scheduler/AsapAction", ["rxjs/util/Immediate", "rxjs/scheduler/FutureAction"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Immediate_1 = require("rxjs/util/Immediate"); + var FutureAction_1 = require("rxjs/scheduler/FutureAction"); + var AsapAction = (function(_super) { + __extends(AsapAction, _super); + function AsapAction() { + _super.apply(this, arguments); + } + AsapAction.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; + var scheduler = this.scheduler; + scheduler.actions.push(this); + if (!scheduler.scheduledId) { + scheduler.scheduledId = Immediate_1.Immediate.setImmediate(function() { + scheduler.scheduledId = null; + scheduler.flush(); + }); + } + return this; + }; + AsapAction.prototype._unsubscribe = function() { + var scheduler = this.scheduler; + var scheduledId = scheduler.scheduledId, + actions = scheduler.actions; + _super.prototype._unsubscribe.call(this); + if (actions.length === 0) { + scheduler.active = false; + if (scheduledId != null) { + scheduler.scheduledId = null; + Immediate_1.Immediate.clearImmediate(scheduledId); + } + } + }; + return AsapAction; + }(FutureAction_1.FutureAction)); + exports.AsapAction = AsapAction; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/scheduler/QueueScheduler", ["rxjs/scheduler/QueueAction", "rxjs/scheduler/FutureAction"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var QueueAction_1 = require("rxjs/scheduler/QueueAction"); + var FutureAction_1 = require("rxjs/scheduler/FutureAction"); + var QueueScheduler = (function() { + function QueueScheduler() { + this.active = false; + this.actions = []; + this.scheduledId = null; + } + QueueScheduler.prototype.now = function() { + return Date.now(); + }; + QueueScheduler.prototype.flush = function() { + if (this.active || this.scheduledId) { + return ; + } + this.active = true; + var actions = this.actions; + for (var action = void 0; action = actions.shift(); ) { + action.execute(); + } + this.active = false; + }; + QueueScheduler.prototype.schedule = function(work, delay, state) { + if (delay === void 0) { + delay = 0; + } + return (delay <= 0) ? this.scheduleNow(work, state) : this.scheduleLater(work, delay, state); + }; + QueueScheduler.prototype.scheduleNow = function(work, state) { + return new QueueAction_1.QueueAction(this, work).schedule(state); + }; + QueueScheduler.prototype.scheduleLater = function(work, delay, state) { + return new FutureAction_1.FutureAction(this, work).schedule(state, delay); + }; + return QueueScheduler; + }()); + exports.QueueScheduler = QueueScheduler; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/NeverObservable", ["rxjs/Observable", "rxjs/util/noop"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var noop_1 = require("rxjs/util/noop"); + var NeverObservable = (function(_super) { + __extends(NeverObservable, _super); + function NeverObservable() { + _super.call(this); + } + NeverObservable.create = function() { + return new NeverObservable(); + }; + NeverObservable.prototype._subscribe = function(subscriber) { + noop_1.noop(); + }; + return NeverObservable; + }(Observable_1.Observable)); + exports.NeverObservable = NeverObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/range", ["rxjs/Observable", "rxjs/observable/RangeObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var RangeObservable_1 = require("rxjs/observable/RangeObservable"); + Observable_1.Observable.range = RangeObservable_1.RangeObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/throw", ["rxjs/Observable", "rxjs/observable/ErrorObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var ErrorObservable_1 = require("rxjs/observable/ErrorObservable"); + Observable_1.Observable.throw = ErrorObservable_1.ErrorObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/TimerObservable", ["rxjs/util/isNumeric", "rxjs/Observable", "rxjs/scheduler/asap", "rxjs/util/isScheduler", "rxjs/util/isDate"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var isNumeric_1 = require("rxjs/util/isNumeric"); + var Observable_1 = require("rxjs/Observable"); + var asap_1 = require("rxjs/scheduler/asap"); + var isScheduler_1 = require("rxjs/util/isScheduler"); + var isDate_1 = require("rxjs/util/isDate"); + var TimerObservable = (function(_super) { + __extends(TimerObservable, _super); + function TimerObservable(dueTime, period, scheduler) { + if (dueTime === void 0) { + dueTime = 0; + } + _super.call(this); + this.period = -1; + this.dueTime = 0; + if (isNumeric_1.isNumeric(period)) { + this.period = Number(period) < 1 && 1 || Number(period); + } else if (isScheduler_1.isScheduler(period)) { + scheduler = period; + } + if (!isScheduler_1.isScheduler(scheduler)) { + scheduler = asap_1.asap; + } + this.scheduler = scheduler; + this.dueTime = isDate_1.isDate(dueTime) ? (+dueTime - this.scheduler.now()) : dueTime; + } + TimerObservable.create = function(dueTime, period, scheduler) { + if (dueTime === void 0) { + dueTime = 0; + } + return new TimerObservable(dueTime, period, scheduler); + }; + TimerObservable.dispatch = function(state) { + var index = state.index, + period = state.period, + subscriber = state.subscriber; + var action = this; + subscriber.next(index); + if (subscriber.isUnsubscribed) { + return ; + } else if (period === -1) { + return subscriber.complete(); + } + state.index = index + 1; + action.schedule(state, period); + }; + TimerObservable.prototype._subscribe = function(subscriber) { + var index = 0; + var _a = this, + period = _a.period, + dueTime = _a.dueTime, + scheduler = _a.scheduler; + return scheduler.schedule(TimerObservable.dispatch, dueTime, { + index: index, + period: period, + subscriber: subscriber + }); + }; + return TimerObservable; + }(Observable_1.Observable)); + exports.TimerObservable = TimerObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/zip", ["rxjs/Observable", "rxjs/operator/zip"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var zip_1 = require("rxjs/operator/zip"); + Observable_1.Observable.zip = zip_1.zipStatic; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/buffer", ["rxjs/Observable", "rxjs/operator/buffer"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var buffer_1 = require("rxjs/operator/buffer"); + Observable_1.Observable.prototype.buffer = buffer_1.buffer; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/bufferCount", ["rxjs/Observable", "rxjs/operator/bufferCount"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var bufferCount_1 = require("rxjs/operator/bufferCount"); + Observable_1.Observable.prototype.bufferCount = bufferCount_1.bufferCount; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/bufferTime", ["rxjs/Observable", "rxjs/operator/bufferTime"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var bufferTime_1 = require("rxjs/operator/bufferTime"); + Observable_1.Observable.prototype.bufferTime = bufferTime_1.bufferTime; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/bufferToggle", ["rxjs/Observable", "rxjs/operator/bufferToggle"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var bufferToggle_1 = require("rxjs/operator/bufferToggle"); + Observable_1.Observable.prototype.bufferToggle = bufferToggle_1.bufferToggle; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/bufferWhen", ["rxjs/Observable", "rxjs/operator/bufferWhen"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var bufferWhen_1 = require("rxjs/operator/bufferWhen"); + Observable_1.Observable.prototype.bufferWhen = bufferWhen_1.bufferWhen; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/subject/ReplaySubject", ["rxjs/Subject", "rxjs/scheduler/queue", "rxjs/operator/observeOn"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subject_1 = require("rxjs/Subject"); + var queue_1 = require("rxjs/scheduler/queue"); + var observeOn_1 = require("rxjs/operator/observeOn"); + var ReplaySubject = (function(_super) { + __extends(ReplaySubject, _super); + function ReplaySubject(bufferSize, windowTime, scheduler) { + if (bufferSize === void 0) { + bufferSize = Number.POSITIVE_INFINITY; + } + if (windowTime === void 0) { + windowTime = Number.POSITIVE_INFINITY; + } + _super.call(this); + this.events = []; + this.scheduler = scheduler; + this.bufferSize = bufferSize < 1 ? 1 : bufferSize; + this._windowTime = windowTime < 1 ? 1 : windowTime; + } + ReplaySubject.prototype._next = function(value) { + var now = this._getNow(); + this.events.push(new ReplayEvent(now, value)); + this._trimBufferThenGetEvents(now); + _super.prototype._next.call(this, value); + }; + ReplaySubject.prototype._subscribe = function(subscriber) { + var events = this._trimBufferThenGetEvents(this._getNow()); + var scheduler = this.scheduler; + if (scheduler) { + subscriber.add(subscriber = new observeOn_1.ObserveOnSubscriber(subscriber, scheduler)); + } + var index = -1; + var len = events.length; + while (++index < len && !subscriber.isUnsubscribed) { + subscriber.next(events[index].value); + } + return _super.prototype._subscribe.call(this, subscriber); + }; + ReplaySubject.prototype._getNow = function() { + return (this.scheduler || queue_1.queue).now(); + }; + ReplaySubject.prototype._trimBufferThenGetEvents = function(now) { + var bufferSize = this.bufferSize; + var _windowTime = this._windowTime; + var events = this.events; + var eventsCount = events.length; + var spliceCount = 0; + while (spliceCount < eventsCount) { + if ((now - events[spliceCount].time) < _windowTime) { + break; + } + spliceCount += 1; + } + if (eventsCount > bufferSize) { + spliceCount = Math.max(spliceCount, eventsCount - bufferSize); + } + if (spliceCount > 0) { + events.splice(0, spliceCount); + } + return events; + }; + return ReplaySubject; + }(Subject_1.Subject)); + exports.ReplaySubject = ReplaySubject; + var ReplayEvent = (function() { + function ReplayEvent(time, value) { + this.time = time; + this.value = value; + } + return ReplayEvent; + }()); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/multicast", ["rxjs/observable/ConnectableObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var ConnectableObservable_1 = require("rxjs/observable/ConnectableObservable"); + function multicast(subjectOrSubjectFactory) { + var subjectFactory; + if (typeof subjectOrSubjectFactory === 'function') { + subjectFactory = subjectOrSubjectFactory; + } else { + subjectFactory = function subjectFactory() { + return subjectOrSubjectFactory; + }; + } + return new ConnectableObservable_1.ConnectableObservable(this, subjectFactory); + } + exports.multicast = multicast; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/catch", ["rxjs/Observable", "rxjs/operator/catch"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var catch_1 = require("rxjs/operator/catch"); + Observable_1.Observable.prototype.catch = catch_1._catch; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/combineAll", ["rxjs/Observable", "rxjs/operator/combineAll"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var combineAll_1 = require("rxjs/operator/combineAll"); + Observable_1.Observable.prototype.combineAll = combineAll_1.combineAll; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/concatAll", ["rxjs/Observable", "rxjs/operator/concatAll"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var concatAll_1 = require("rxjs/operator/concatAll"); + Observable_1.Observable.prototype.concatAll = concatAll_1.concatAll; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/concatMap", ["rxjs/operator/mergeMap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var mergeMap_1 = require("rxjs/operator/mergeMap"); + function concatMap(project, resultSelector) { + return this.lift(new mergeMap_1.MergeMapOperator(project, resultSelector, 1)); + } + exports.concatMap = concatMap; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/concatMapTo", ["rxjs/operator/mergeMapTo"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var mergeMapTo_1 = require("rxjs/operator/mergeMapTo"); + function concatMapTo(observable, resultSelector) { + return this.lift(new mergeMapTo_1.MergeMapToOperator(observable, resultSelector, 1)); + } + exports.concatMapTo = concatMapTo; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/count", ["rxjs/Observable", "rxjs/operator/count"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var count_1 = require("rxjs/operator/count"); + Observable_1.Observable.prototype.count = count_1.count; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/dematerialize", ["rxjs/Observable", "rxjs/operator/dematerialize"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var dematerialize_1 = require("rxjs/operator/dematerialize"); + Observable_1.Observable.prototype.dematerialize = dematerialize_1.dematerialize; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/debounce", ["rxjs/Observable", "rxjs/operator/debounce"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var debounce_1 = require("rxjs/operator/debounce"); + Observable_1.Observable.prototype.debounce = debounce_1.debounce; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/debounceTime", ["rxjs/Observable", "rxjs/operator/debounceTime"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var debounceTime_1 = require("rxjs/operator/debounceTime"); + Observable_1.Observable.prototype.debounceTime = debounceTime_1.debounceTime; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/defaultIfEmpty", ["rxjs/Observable", "rxjs/operator/defaultIfEmpty"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var defaultIfEmpty_1 = require("rxjs/operator/defaultIfEmpty"); + Observable_1.Observable.prototype.defaultIfEmpty = defaultIfEmpty_1.defaultIfEmpty; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/delay", ["rxjs/Observable", "rxjs/operator/delay"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var delay_1 = require("rxjs/operator/delay"); + Observable_1.Observable.prototype.delay = delay_1.delay; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/delayWhen", ["rxjs/Observable", "rxjs/operator/delayWhen"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var delayWhen_1 = require("rxjs/operator/delayWhen"); + Observable_1.Observable.prototype.delayWhen = delayWhen_1.delayWhen; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/distinctUntilChanged", ["rxjs/Observable", "rxjs/operator/distinctUntilChanged"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var distinctUntilChanged_1 = require("rxjs/operator/distinctUntilChanged"); + Observable_1.Observable.prototype.distinctUntilChanged = distinctUntilChanged_1.distinctUntilChanged; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/do", ["rxjs/Observable", "rxjs/operator/do"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var do_1 = require("rxjs/operator/do"); + Observable_1.Observable.prototype.do = do_1._do; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/expand", ["rxjs/Observable", "rxjs/operator/expand"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var expand_1 = require("rxjs/operator/expand"); + Observable_1.Observable.prototype.expand = expand_1.expand; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/filter", ["rxjs/Observable", "rxjs/operator/filter"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var filter_1 = require("rxjs/operator/filter"); + Observable_1.Observable.prototype.filter = filter_1.filter; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/finally", ["rxjs/Observable", "rxjs/operator/finally"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var finally_1 = require("rxjs/operator/finally"); + Observable_1.Observable.prototype.finally = finally_1._finally; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/first", ["rxjs/Subscriber", "rxjs/util/EmptyError"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var EmptyError_1 = require("rxjs/util/EmptyError"); + function first(predicate, resultSelector, defaultValue) { + return this.lift(new FirstOperator(predicate, resultSelector, defaultValue, this)); + } + exports.first = first; + var FirstOperator = (function() { + function FirstOperator(predicate, resultSelector, defaultValue, source) { + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + } + FirstOperator.prototype.call = function(observer) { + return new FirstSubscriber(observer, this.predicate, this.resultSelector, this.defaultValue, this.source); + }; + return FirstOperator; + }()); + var FirstSubscriber = (function(_super) { + __extends(FirstSubscriber, _super); + function FirstSubscriber(destination, predicate, resultSelector, defaultValue, source) { + _super.call(this, destination); + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + this.index = 0; + this.hasCompleted = false; + } + FirstSubscriber.prototype._next = function(value) { + var index = this.index++; + if (this.predicate) { + this._tryPredicate(value, index); + } else { + this._emit(value, index); + } + }; + FirstSubscriber.prototype._tryPredicate = function(value, index) { + var result; + try { + result = this.predicate(value, index, this.source); + } catch (err) { + this.destination.error(err); + return ; + } + if (result) { + this._emit(value, index); + } + }; + FirstSubscriber.prototype._emit = function(value, index) { + if (this.resultSelector) { + this._tryResultSelector(value, index); + return ; + } + this._emitFinal(value); + }; + FirstSubscriber.prototype._tryResultSelector = function(value, index) { + var result; + try { + result = this.resultSelector(value, index); + } catch (err) { + this.destination.error(err); + return ; + } + this._emitFinal(result); + }; + FirstSubscriber.prototype._emitFinal = function(value) { + var destination = this.destination; + destination.next(value); + destination.complete(); + this.hasCompleted = true; + }; + FirstSubscriber.prototype._complete = function() { + var destination = this.destination; + if (!this.hasCompleted && typeof this.defaultValue !== 'undefined') { + destination.next(this.defaultValue); + destination.complete(); + } else if (!this.hasCompleted) { + destination.error(new EmptyError_1.EmptyError); + } + }; + return FirstSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/Map", ["rxjs/util/root", "rxjs/util/MapPolyfill"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var root_1 = require("rxjs/util/root"); + var MapPolyfill_1 = require("rxjs/util/MapPolyfill"); + exports.Map = root_1.root.Map || (function() { + return MapPolyfill_1.MapPolyfill; + })(); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/ignoreElements", ["rxjs/Observable", "rxjs/operator/ignoreElements"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var ignoreElements_1 = require("rxjs/operator/ignoreElements"); + Observable_1.Observable.prototype.ignoreElements = ignoreElements_1.ignoreElements; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/inspect", ["rxjs/Observable", "rxjs/operator/inspect"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var inspect_1 = require("rxjs/operator/inspect"); + Observable_1.Observable.prototype.inspect = inspect_1.inspect; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/inspectTime", ["rxjs/Observable", "rxjs/operator/inspectTime"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var inspectTime_1 = require("rxjs/operator/inspectTime"); + Observable_1.Observable.prototype.inspectTime = inspectTime_1.inspectTime; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/every", ["rxjs/Observable", "rxjs/operator/every"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var every_1 = require("rxjs/operator/every"); + Observable_1.Observable.prototype.every = every_1.every; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/last", ["rxjs/Observable", "rxjs/operator/last"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var last_1 = require("rxjs/operator/last"); + Observable_1.Observable.prototype.last = last_1.last; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/let", ["rxjs/Observable", "rxjs/operator/let"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var let_1 = require("rxjs/operator/let"); + Observable_1.Observable.prototype.let = let_1.letProto; + Observable_1.Observable.prototype.letBind = let_1.letProto; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/map", ["rxjs/Observable", "rxjs/operator/map"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var map_1 = require("rxjs/operator/map"); + Observable_1.Observable.prototype.map = map_1.map; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/mapTo", ["rxjs/Observable", "rxjs/operator/mapTo"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var mapTo_1 = require("rxjs/operator/mapTo"); + Observable_1.Observable.prototype.mapTo = mapTo_1.mapTo; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/materialize", ["rxjs/Observable", "rxjs/operator/materialize"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var materialize_1 = require("rxjs/operator/materialize"); + Observable_1.Observable.prototype.materialize = materialize_1.materialize; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/partition", ["rxjs/util/not", "rxjs/operator/filter"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var not_1 = require("rxjs/util/not"); + var filter_1 = require("rxjs/operator/filter"); + function partition(predicate, thisArg) { + return [filter_1.filter.call(this, predicate), filter_1.filter.call(this, not_1.not(predicate, thisArg))]; + } + exports.partition = partition; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/pluck", ["rxjs/Observable", "rxjs/operator/pluck"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var pluck_1 = require("rxjs/operator/pluck"); + Observable_1.Observable.prototype.pluck = pluck_1.pluck; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/publish", ["rxjs/Observable", "rxjs/operator/publish"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var publish_1 = require("rxjs/operator/publish"); + Observable_1.Observable.prototype.publish = publish_1.publish; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/publishBehavior", ["rxjs/subject/BehaviorSubject", "rxjs/operator/multicast"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var BehaviorSubject_1 = require("rxjs/subject/BehaviorSubject"); + var multicast_1 = require("rxjs/operator/multicast"); + function publishBehavior(value) { + return multicast_1.multicast.call(this, new BehaviorSubject_1.BehaviorSubject(value)); + } + exports.publishBehavior = publishBehavior; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/publishLast", ["rxjs/Observable", "rxjs/operator/publishLast"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var publishLast_1 = require("rxjs/operator/publishLast"); + Observable_1.Observable.prototype.publishLast = publishLast_1.publishLast; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/reduce", ["rxjs/Observable", "rxjs/operator/reduce"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var reduce_1 = require("rxjs/operator/reduce"); + Observable_1.Observable.prototype.reduce = reduce_1.reduce; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/repeat", ["rxjs/Observable", "rxjs/operator/repeat"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var repeat_1 = require("rxjs/operator/repeat"); + Observable_1.Observable.prototype.repeat = repeat_1.repeat; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/retry", ["rxjs/Observable", "rxjs/operator/retry"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var retry_1 = require("rxjs/operator/retry"); + Observable_1.Observable.prototype.retry = retry_1.retry; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/retryWhen", ["rxjs/Observable", "rxjs/operator/retryWhen"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var retryWhen_1 = require("rxjs/operator/retryWhen"); + Observable_1.Observable.prototype.retryWhen = retryWhen_1.retryWhen; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/sample", ["rxjs/Observable", "rxjs/operator/sample"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var sample_1 = require("rxjs/operator/sample"); + Observable_1.Observable.prototype.sample = sample_1.sample; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/sampleTime", ["rxjs/Observable", "rxjs/operator/sampleTime"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var sampleTime_1 = require("rxjs/operator/sampleTime"); + Observable_1.Observable.prototype.sampleTime = sampleTime_1.sampleTime; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/scan", ["rxjs/Observable", "rxjs/operator/scan"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var scan_1 = require("rxjs/operator/scan"); + Observable_1.Observable.prototype.scan = scan_1.scan; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/share", ["rxjs/Observable", "rxjs/operator/share"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var share_1 = require("rxjs/operator/share"); + Observable_1.Observable.prototype.share = share_1.share; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/single", ["rxjs/Observable", "rxjs/operator/single"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var single_1 = require("rxjs/operator/single"); + Observable_1.Observable.prototype.single = single_1.single; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/skip", ["rxjs/Observable", "rxjs/operator/skip"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var skip_1 = require("rxjs/operator/skip"); + Observable_1.Observable.prototype.skip = skip_1.skip; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/skipUntil", ["rxjs/Observable", "rxjs/operator/skipUntil"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var skipUntil_1 = require("rxjs/operator/skipUntil"); + Observable_1.Observable.prototype.skipUntil = skipUntil_1.skipUntil; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/skipWhile", ["rxjs/Observable", "rxjs/operator/skipWhile"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var skipWhile_1 = require("rxjs/operator/skipWhile"); + Observable_1.Observable.prototype.skipWhile = skipWhile_1.skipWhile; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/startWith", ["rxjs/Observable", "rxjs/operator/startWith"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var startWith_1 = require("rxjs/operator/startWith"); + Observable_1.Observable.prototype.startWith = startWith_1.startWith; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/subscribeOn", ["rxjs/observable/SubscribeOnObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var SubscribeOnObservable_1 = require("rxjs/observable/SubscribeOnObservable"); + function subscribeOn(scheduler, delay) { + if (delay === void 0) { + delay = 0; + } + return new SubscribeOnObservable_1.SubscribeOnObservable(this, delay, scheduler); + } + exports.subscribeOn = subscribeOn; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/switch", ["rxjs/Observable", "rxjs/operator/switch"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var switch_1 = require("rxjs/operator/switch"); + Observable_1.Observable.prototype.switch = switch_1._switch; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/switchMap", ["rxjs/Observable", "rxjs/operator/switchMap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var switchMap_1 = require("rxjs/operator/switchMap"); + Observable_1.Observable.prototype.switchMap = switchMap_1.switchMap; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/switchMapTo", ["rxjs/Observable", "rxjs/operator/switchMapTo"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var switchMapTo_1 = require("rxjs/operator/switchMapTo"); + Observable_1.Observable.prototype.switchMapTo = switchMapTo_1.switchMapTo; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/take", ["rxjs/Subscriber", "rxjs/util/ArgumentOutOfRangeError", "rxjs/observable/EmptyObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var ArgumentOutOfRangeError_1 = require("rxjs/util/ArgumentOutOfRangeError"); + var EmptyObservable_1 = require("rxjs/observable/EmptyObservable"); + function take(total) { + if (total === 0) { + return new EmptyObservable_1.EmptyObservable(); + } else { + return this.lift(new TakeOperator(total)); + } + } + exports.take = take; + var TakeOperator = (function() { + function TakeOperator(total) { + this.total = total; + if (this.total < 0) { + throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError; + } + } + TakeOperator.prototype.call = function(subscriber) { + return new TakeSubscriber(subscriber, this.total); + }; + return TakeOperator; + }()); + var TakeSubscriber = (function(_super) { + __extends(TakeSubscriber, _super); + function TakeSubscriber(destination, total) { + _super.call(this, destination); + this.total = total; + this.count = 0; + } + TakeSubscriber.prototype._next = function(value) { + var total = this.total; + if (++this.count <= total) { + this.destination.next(value); + if (this.count === total) { + this.destination.complete(); + } + } + }; + return TakeSubscriber; + }(Subscriber_1.Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/takeLast", ["rxjs/Observable", "rxjs/operator/takeLast"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var takeLast_1 = require("rxjs/operator/takeLast"); + Observable_1.Observable.prototype.takeLast = takeLast_1.takeLast; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/takeUntil", ["rxjs/Observable", "rxjs/operator/takeUntil"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var takeUntil_1 = require("rxjs/operator/takeUntil"); + Observable_1.Observable.prototype.takeUntil = takeUntil_1.takeUntil; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/takeWhile", ["rxjs/Observable", "rxjs/operator/takeWhile"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var takeWhile_1 = require("rxjs/operator/takeWhile"); + Observable_1.Observable.prototype.takeWhile = takeWhile_1.takeWhile; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/throttle", ["rxjs/Observable", "rxjs/operator/throttle"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var throttle_1 = require("rxjs/operator/throttle"); + Observable_1.Observable.prototype.throttle = throttle_1.throttle; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/throttleTime", ["rxjs/Observable", "rxjs/operator/throttleTime"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var throttleTime_1 = require("rxjs/operator/throttleTime"); + Observable_1.Observable.prototype.throttleTime = throttleTime_1.throttleTime; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/timeout", ["rxjs/Observable", "rxjs/operator/timeout"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var timeout_1 = require("rxjs/operator/timeout"); + Observable_1.Observable.prototype.timeout = timeout_1.timeout; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/timeoutWith", ["rxjs/Observable", "rxjs/operator/timeoutWith"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var timeoutWith_1 = require("rxjs/operator/timeoutWith"); + Observable_1.Observable.prototype.timeoutWith = timeoutWith_1.timeoutWith; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/toArray", ["rxjs/Observable", "rxjs/operator/toArray"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var toArray_1 = require("rxjs/operator/toArray"); + Observable_1.Observable.prototype.toArray = toArray_1.toArray; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/toPromise", ["rxjs/Observable", "rxjs/operator/toPromise"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var toPromise_1 = require("rxjs/operator/toPromise"); + Observable_1.Observable.prototype.toPromise = toPromise_1.toPromise; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/window", ["rxjs/Observable", "rxjs/operator/window"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var window_1 = require("rxjs/operator/window"); + Observable_1.Observable.prototype.window = window_1.window; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/windowCount", ["rxjs/Observable", "rxjs/operator/windowCount"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var windowCount_1 = require("rxjs/operator/windowCount"); + Observable_1.Observable.prototype.windowCount = windowCount_1.windowCount; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/windowTime", ["rxjs/Observable", "rxjs/operator/windowTime"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var windowTime_1 = require("rxjs/operator/windowTime"); + Observable_1.Observable.prototype.windowTime = windowTime_1.windowTime; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/windowToggle", ["rxjs/Observable", "rxjs/operator/windowToggle"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var windowToggle_1 = require("rxjs/operator/windowToggle"); + Observable_1.Observable.prototype.windowToggle = windowToggle_1.windowToggle; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/windowWhen", ["rxjs/Observable", "rxjs/operator/windowWhen"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var windowWhen_1 = require("rxjs/operator/windowWhen"); + Observable_1.Observable.prototype.windowWhen = windowWhen_1.windowWhen; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/withLatestFrom", ["rxjs/Observable", "rxjs/operator/withLatestFrom"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var withLatestFrom_1 = require("rxjs/operator/withLatestFrom"); + Observable_1.Observable.prototype.withLatestFrom = withLatestFrom_1.withLatestFrom; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/zipAll", ["rxjs/Observable", "rxjs/operator/zipAll"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var zipAll_1 = require("rxjs/operator/zipAll"); + Observable_1.Observable.prototype.zipAll = zipAll_1.zipAll; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Subscription", ["rxjs/util/isArray", "rxjs/util/isObject", "rxjs/util/isFunction", "rxjs/util/tryCatch", "rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var isArray_1 = require("rxjs/util/isArray"); + var isObject_1 = require("rxjs/util/isObject"); + var isFunction_1 = require("rxjs/util/isFunction"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var Subscription = (function() { + function Subscription(_unsubscribe) { + this.isUnsubscribed = false; + if (_unsubscribe) { + this._unsubscribe = _unsubscribe; + } + } + Subscription.prototype.unsubscribe = function() { + var hasErrors = false; + var errors; + if (this.isUnsubscribed) { + return ; + } + this.isUnsubscribed = true; + var _a = this, + _unsubscribe = _a._unsubscribe, + _subscriptions = _a._subscriptions; + this._subscriptions = null; + if (isFunction_1.isFunction(_unsubscribe)) { + var trial = tryCatch_1.tryCatch(_unsubscribe).call(this); + if (trial === errorObject_1.errorObject) { + hasErrors = true; + (errors = errors || []).push(errorObject_1.errorObject.e); + } + } + if (isArray_1.isArray(_subscriptions)) { + var index = -1; + var len = _subscriptions.length; + while (++index < len) { + var sub = _subscriptions[index]; + if (isObject_1.isObject(sub)) { + var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub); + if (trial === errorObject_1.errorObject) { + hasErrors = true; + errors = errors || []; + var err = errorObject_1.errorObject.e; + if (err instanceof UnsubscriptionError) { + errors = errors.concat(err.errors); + } else { + errors.push(err); + } + } + } + } + } + if (hasErrors) { + throw new UnsubscriptionError(errors); + } + }; + Subscription.prototype.add = function(subscription) { + if (!subscription || (subscription === this) || (subscription === Subscription.EMPTY)) { + return ; + } + var sub = subscription; + switch (typeof subscription) { + case 'function': + sub = new Subscription(subscription); + case 'object': + if (sub.isUnsubscribed || typeof sub.unsubscribe !== 'function') { + break; + } else if (this.isUnsubscribed) { + sub.unsubscribe(); + } else { + (this._subscriptions || (this._subscriptions = [])).push(sub); + } + break; + default: + throw new Error('Unrecognized subscription ' + subscription + ' added to Subscription.'); + } + }; + Subscription.prototype.remove = function(subscription) { + if (subscription == null || (subscription === this) || (subscription === Subscription.EMPTY)) { + return ; + } + var subscriptions = this._subscriptions; + if (subscriptions) { + var subscriptionIndex = subscriptions.indexOf(subscription); + if (subscriptionIndex !== -1) { + subscriptions.splice(subscriptionIndex, 1); + } + } + }; + Subscription.EMPTY = (function(empty) { + empty.isUnsubscribed = true; + return empty; + }(new Subscription())); + return Subscription; + }()); + exports.Subscription = Subscription; + var UnsubscriptionError = (function(_super) { + __extends(UnsubscriptionError, _super); + function UnsubscriptionError(errors) { + _super.call(this, 'unsubscriptoin error(s)'); + this.errors = errors; + this.name = 'UnsubscriptionError'; + } + return UnsubscriptionError; + }(Error)); + exports.UnsubscriptionError = UnsubscriptionError; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/combineLatest", ["rxjs/observable/ArrayObservable", "rxjs/util/isArray", "rxjs/util/isScheduler", "rxjs/OuterSubscriber", "rxjs/util/subscribeToResult"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + var isArray_1 = require("rxjs/util/isArray"); + var isScheduler_1 = require("rxjs/util/isScheduler"); + var OuterSubscriber_1 = require("rxjs/OuterSubscriber"); + var subscribeToResult_1 = require("rxjs/util/subscribeToResult"); + function combineLatest() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var project = null; + if (typeof observables[observables.length - 1] === 'function') { + project = observables.pop(); + } + if (observables.length === 1 && isArray_1.isArray(observables[0])) { + observables = observables[0]; + } + observables.unshift(this); + return new ArrayObservable_1.ArrayObservable(observables).lift(new CombineLatestOperator(project)); + } + exports.combineLatest = combineLatest; + function combineLatestStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var project = null; + var scheduler = null; + if (isScheduler_1.isScheduler(observables[observables.length - 1])) { + scheduler = observables.pop(); + } + if (typeof observables[observables.length - 1] === 'function') { + project = observables.pop(); + } + if (observables.length === 1 && isArray_1.isArray(observables[0])) { + observables = observables[0]; + } + return new ArrayObservable_1.ArrayObservable(observables, scheduler).lift(new CombineLatestOperator(project)); + } + exports.combineLatestStatic = combineLatestStatic; + var CombineLatestOperator = (function() { + function CombineLatestOperator(project) { + this.project = project; + } + CombineLatestOperator.prototype.call = function(subscriber) { + return new CombineLatestSubscriber(subscriber, this.project); + }; + return CombineLatestOperator; + }()); + exports.CombineLatestOperator = CombineLatestOperator; + var CombineLatestSubscriber = (function(_super) { + __extends(CombineLatestSubscriber, _super); + function CombineLatestSubscriber(destination, project) { + _super.call(this, destination); + this.project = project; + this.active = 0; + this.values = []; + this.observables = []; + this.toRespond = []; + } + CombineLatestSubscriber.prototype._next = function(observable) { + var toRespond = this.toRespond; + toRespond.push(toRespond.length); + this.observables.push(observable); + }; + CombineLatestSubscriber.prototype._complete = function() { + var observables = this.observables; + var len = observables.length; + if (len === 0) { + this.destination.complete(); + } else { + this.active = len; + for (var i = 0; i < len; i++) { + var observable = observables[i]; + this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i)); + } + } + }; + CombineLatestSubscriber.prototype.notifyComplete = function(unused) { + if ((this.active -= 1) === 0) { + this.destination.complete(); + } + }; + CombineLatestSubscriber.prototype.notifyNext = function(outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var values = this.values; + values[outerIndex] = innerValue; + var toRespond = this.toRespond; + if (toRespond.length > 0) { + var found = toRespond.indexOf(outerIndex); + if (found !== -1) { + toRespond.splice(found, 1); + } + } + if (toRespond.length === 0) { + if (this.project) { + this._tryProject(values); + } else { + this.destination.next(values); + } + } + }; + CombineLatestSubscriber.prototype._tryProject = function(values) { + var result; + try { + result = this.project.apply(this, values); + } catch (err) { + this.destination.error(err); + return ; + } + this.destination.next(result); + }; + return CombineLatestSubscriber; + }(OuterSubscriber_1.OuterSubscriber)); + exports.CombineLatestSubscriber = CombineLatestSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/concat", ["rxjs/Observable", "rxjs/operator/concat"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var concat_1 = require("rxjs/operator/concat"); + Observable_1.Observable.concat = concat_1.concatStatic; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/bindCallback", ["rxjs/Observable", "rxjs/observable/BoundCallbackObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var BoundCallbackObservable_1 = require("rxjs/observable/BoundCallbackObservable"); + Observable_1.Observable.bindCallback = BoundCallbackObservable_1.BoundCallbackObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/forkJoin", ["rxjs/Observable", "rxjs/observable/ForkJoinObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var ForkJoinObservable_1 = require("rxjs/observable/ForkJoinObservable"); + Observable_1.Observable.forkJoin = ForkJoinObservable_1.ForkJoinObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/FromObservable", ["rxjs/util/isArray", "rxjs/util/isFunction", "rxjs/util/isPromise", "rxjs/util/isScheduler", "rxjs/observable/PromiseObservable", "rxjs/observable/IteratorObservable", "rxjs/observable/ArrayObservable", "rxjs/observable/ArrayLikeObservable", "rxjs/util/SymbolShim", "rxjs/Observable", "rxjs/operator/observeOn"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var isArray_1 = require("rxjs/util/isArray"); + var isFunction_1 = require("rxjs/util/isFunction"); + var isPromise_1 = require("rxjs/util/isPromise"); + var isScheduler_1 = require("rxjs/util/isScheduler"); + var PromiseObservable_1 = require("rxjs/observable/PromiseObservable"); + var IteratorObservable_1 = require("rxjs/observable/IteratorObservable"); + var ArrayObservable_1 = require("rxjs/observable/ArrayObservable"); + var ArrayLikeObservable_1 = require("rxjs/observable/ArrayLikeObservable"); + var SymbolShim_1 = require("rxjs/util/SymbolShim"); + var Observable_1 = require("rxjs/Observable"); + var observeOn_1 = require("rxjs/operator/observeOn"); + var isArrayLike = (function(x) { + return x && typeof x.length === 'number'; + }); + var FromObservable = (function(_super) { + __extends(FromObservable, _super); + function FromObservable(ish, scheduler) { + _super.call(this, null); + this.ish = ish; + this.scheduler = scheduler; + } + FromObservable.create = function(ish, mapFnOrScheduler, thisArg, lastScheduler) { + var scheduler = null; + var mapFn = null; + if (isFunction_1.isFunction(mapFnOrScheduler)) { + scheduler = lastScheduler || null; + mapFn = mapFnOrScheduler; + } else if (isScheduler_1.isScheduler(scheduler)) { + scheduler = mapFnOrScheduler; + } + if (ish != null) { + if (typeof ish[SymbolShim_1.SymbolShim.observable] === 'function') { + if (ish instanceof Observable_1.Observable && !scheduler) { + return ish; + } + return new FromObservable(ish, scheduler); + } else if (isArray_1.isArray(ish)) { + return new ArrayObservable_1.ArrayObservable(ish, scheduler); + } else if (isPromise_1.isPromise(ish)) { + return new PromiseObservable_1.PromiseObservable(ish, scheduler); + } else if (typeof ish[SymbolShim_1.SymbolShim.iterator] === 'function' || typeof ish === 'string') { + return new IteratorObservable_1.IteratorObservable(ish, null, null, scheduler); + } else if (isArrayLike(ish)) { + return new ArrayLikeObservable_1.ArrayLikeObservable(ish, mapFn, thisArg, scheduler); + } + } + throw new TypeError((ish !== null && typeof ish || ish) + ' is not observable'); + }; + FromObservable.prototype._subscribe = function(subscriber) { + var ish = this.ish; + var scheduler = this.scheduler; + if (scheduler == null) { + return ish[SymbolShim_1.SymbolShim.observable]().subscribe(subscriber); + } else { + return ish[SymbolShim_1.SymbolShim.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber, scheduler, 0)); + } + }; + return FromObservable; + }(Observable_1.Observable)); + exports.FromObservable = FromObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/scheduler/AsapScheduler", ["rxjs/scheduler/AsapAction", "rxjs/scheduler/QueueScheduler"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var AsapAction_1 = require("rxjs/scheduler/AsapAction"); + var QueueScheduler_1 = require("rxjs/scheduler/QueueScheduler"); + var AsapScheduler = (function(_super) { + __extends(AsapScheduler, _super); + function AsapScheduler() { + _super.apply(this, arguments); + } + AsapScheduler.prototype.scheduleNow = function(work, state) { + return new AsapAction_1.AsapAction(this, work).schedule(state); + }; + return AsapScheduler; + }(QueueScheduler_1.QueueScheduler)); + exports.AsapScheduler = AsapScheduler; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/never", ["rxjs/Observable", "rxjs/observable/NeverObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var NeverObservable_1 = require("rxjs/observable/NeverObservable"); + Observable_1.Observable.never = NeverObservable_1.NeverObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/timer", ["rxjs/Observable", "rxjs/observable/TimerObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var TimerObservable_1 = require("rxjs/observable/TimerObservable"); + Observable_1.Observable.timer = TimerObservable_1.TimerObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/publishReplay", ["rxjs/subject/ReplaySubject", "rxjs/operator/multicast"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var ReplaySubject_1 = require("rxjs/subject/ReplaySubject"); + var multicast_1 = require("rxjs/operator/multicast"); + function publishReplay(bufferSize, windowTime, scheduler) { + if (bufferSize === void 0) { + bufferSize = Number.POSITIVE_INFINITY; + } + if (windowTime === void 0) { + windowTime = Number.POSITIVE_INFINITY; + } + return multicast_1.multicast.call(this, new ReplaySubject_1.ReplaySubject(bufferSize, windowTime, scheduler)); + } + exports.publishReplay = publishReplay; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/concatMap", ["rxjs/Observable", "rxjs/operator/concatMap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var concatMap_1 = require("rxjs/operator/concatMap"); + Observable_1.Observable.prototype.concatMap = concatMap_1.concatMap; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/concatMapTo", ["rxjs/Observable", "rxjs/operator/concatMapTo"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var concatMapTo_1 = require("rxjs/operator/concatMapTo"); + Observable_1.Observable.prototype.concatMapTo = concatMapTo_1.concatMapTo; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/first", ["rxjs/Observable", "rxjs/operator/first"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var first_1 = require("rxjs/operator/first"); + Observable_1.Observable.prototype.first = first_1.first; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/groupBy", ["rxjs/Subscriber", "rxjs/Subscription", "rxjs/Observable", "rxjs/Operator", "rxjs/Subject", "rxjs/util/Map", "rxjs/util/FastMap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Subscriber_1 = require("rxjs/Subscriber"); + var Subscription_1 = require("rxjs/Subscription"); + var Observable_1 = require("rxjs/Observable"); + var Operator_1 = require("rxjs/Operator"); + var Subject_1 = require("rxjs/Subject"); + var Map_1 = require("rxjs/util/Map"); + var FastMap_1 = require("rxjs/util/FastMap"); + function groupBy(keySelector, elementSelector, durationSelector) { + return this.lift(new GroupByOperator(this, keySelector, elementSelector, durationSelector)); + } + exports.groupBy = groupBy; + var GroupByOperator = (function(_super) { + __extends(GroupByOperator, _super); + function GroupByOperator(source, keySelector, elementSelector, durationSelector) { + _super.call(this); + this.source = source; + this.keySelector = keySelector; + this.elementSelector = elementSelector; + this.durationSelector = durationSelector; + } + GroupByOperator.prototype.call = function(subscriber) { + return new GroupBySubscriber(subscriber, this.keySelector, this.elementSelector, this.durationSelector); + }; + return GroupByOperator; + }(Operator_1.Operator)); + var GroupBySubscriber = (function(_super) { + __extends(GroupBySubscriber, _super); + function GroupBySubscriber(destination, keySelector, elementSelector, durationSelector) { + _super.call(this); + this.keySelector = keySelector; + this.elementSelector = elementSelector; + this.durationSelector = durationSelector; + this.groups = null; + this.attemptedToUnsubscribe = false; + this.count = 0; + this.destination = destination; + this.add(destination); + } + GroupBySubscriber.prototype._next = function(value) { + var key; + try { + key = this.keySelector(value); + } catch (err) { + this.error(err); + return ; + } + this._group(value, key); + }; + GroupBySubscriber.prototype._group = function(value, key) { + var groups = this.groups; + if (!groups) { + groups = this.groups = typeof key === 'string' ? new FastMap_1.FastMap() : new Map_1.Map(); + } + var group = groups.get(key); + if (!group) { + groups.set(key, group = new Subject_1.Subject()); + var groupedObservable = new GroupedObservable(key, group, this); + if (this.durationSelector) { + this._selectDuration(key, group); + } + this.destination.next(groupedObservable); + } + if (this.elementSelector) { + this._selectElement(value, group); + } else { + this.tryGroupNext(value, group); + } + }; + GroupBySubscriber.prototype._selectElement = function(value, group) { + var result; + try { + result = this.elementSelector(value); + } catch (err) { + this.error(err); + return ; + } + this.tryGroupNext(result, group); + }; + GroupBySubscriber.prototype._selectDuration = function(key, group) { + var duration; + try { + duration = this.durationSelector(new GroupedObservable(key, group)); + } catch (err) { + this.error(err); + return ; + } + this.add(duration.subscribe(new GroupDurationSubscriber(key, group, this))); + }; + GroupBySubscriber.prototype.tryGroupNext = function(value, group) { + if (!group.isUnsubscribed) { + group.next(value); + } + }; + GroupBySubscriber.prototype._error = function(err) { + var groups = this.groups; + if (groups) { + groups.forEach(function(group, key) { + group.error(err); + }); + groups.clear(); + } + this.destination.error(err); + }; + GroupBySubscriber.prototype._complete = function() { + var groups = this.groups; + if (groups) { + groups.forEach(function(group, key) { + group.complete(); + }); + groups.clear(); + } + this.destination.complete(); + }; + GroupBySubscriber.prototype.removeGroup = function(key) { + this.groups.delete(key); + }; + GroupBySubscriber.prototype.unsubscribe = function() { + if (!this.isUnsubscribed && !this.attemptedToUnsubscribe) { + this.attemptedToUnsubscribe = true; + if (this.count === 0) { + _super.prototype.unsubscribe.call(this); + } + } + }; + return GroupBySubscriber; + }(Subscriber_1.Subscriber)); + var GroupDurationSubscriber = (function(_super) { + __extends(GroupDurationSubscriber, _super); + function GroupDurationSubscriber(key, group, parent) { + _super.call(this); + this.key = key; + this.group = group; + this.parent = parent; + } + GroupDurationSubscriber.prototype._next = function(value) { + this.tryComplete(); + }; + GroupDurationSubscriber.prototype._error = function(err) { + this.tryError(err); + }; + GroupDurationSubscriber.prototype._complete = function() { + this.tryComplete(); + }; + GroupDurationSubscriber.prototype.tryError = function(err) { + var group = this.group; + if (!group.isUnsubscribed) { + group.error(err); + } + this.parent.removeGroup(this.key); + }; + GroupDurationSubscriber.prototype.tryComplete = function() { + var group = this.group; + if (!group.isUnsubscribed) { + group.complete(); + } + this.parent.removeGroup(this.key); + }; + return GroupDurationSubscriber; + }(Subscriber_1.Subscriber)); + var GroupedObservable = (function(_super) { + __extends(GroupedObservable, _super); + function GroupedObservable(key, groupSubject, refCountSubscription) { + _super.call(this); + this.key = key; + this.groupSubject = groupSubject; + this.refCountSubscription = refCountSubscription; + } + GroupedObservable.prototype._subscribe = function(subscriber) { + var subscription = new Subscription_1.Subscription(); + var _a = this, + refCountSubscription = _a.refCountSubscription, + groupSubject = _a.groupSubject; + if (refCountSubscription && !refCountSubscription.isUnsubscribed) { + subscription.add(new InnerRefCountSubscription(refCountSubscription)); + } + subscription.add(groupSubject.subscribe(subscriber)); + return subscription; + }; + return GroupedObservable; + }(Observable_1.Observable)); + exports.GroupedObservable = GroupedObservable; + var InnerRefCountSubscription = (function(_super) { + __extends(InnerRefCountSubscription, _super); + function InnerRefCountSubscription(parent) { + _super.call(this); + this.parent = parent; + parent.count++; + } + InnerRefCountSubscription.prototype.unsubscribe = function() { + var parent = this.parent; + if (!parent.isUnsubscribed && !this.isUnsubscribed) { + _super.prototype.unsubscribe.call(this); + parent.count -= 1; + if (parent.count === 0 && parent.attemptedToUnsubscribe) { + parent.unsubscribe(); + } + } + }; + return InnerRefCountSubscription; + }(Subscription_1.Subscription)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/partition", ["rxjs/Observable", "rxjs/operator/partition"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var partition_1 = require("rxjs/operator/partition"); + Observable_1.Observable.prototype.partition = partition_1.partition; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/publishBehavior", ["rxjs/Observable", "rxjs/operator/publishBehavior"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var publishBehavior_1 = require("rxjs/operator/publishBehavior"); + Observable_1.Observable.prototype.publishBehavior = publishBehavior_1.publishBehavior; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/subscribeOn", ["rxjs/Observable", "rxjs/operator/subscribeOn"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var subscribeOn_1 = require("rxjs/operator/subscribeOn"); + Observable_1.Observable.prototype.subscribeOn = subscribeOn_1.subscribeOn; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/take", ["rxjs/Observable", "rxjs/operator/take"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var take_1 = require("rxjs/operator/take"); + Observable_1.Observable.prototype.take = take_1.take; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Subscriber", ["rxjs/util/isFunction", "rxjs/Subscription", "rxjs/symbol/rxSubscriber", "rxjs/Observer"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var isFunction_1 = require("rxjs/util/isFunction"); + var Subscription_1 = require("rxjs/Subscription"); + var rxSubscriber_1 = require("rxjs/symbol/rxSubscriber"); + var Observer_1 = require("rxjs/Observer"); + var Subscriber = (function(_super) { + __extends(Subscriber, _super); + function Subscriber(destinationOrNext, error, complete) { + _super.call(this); + this.syncErrorValue = null; + this.syncErrorThrown = false; + this.syncErrorThrowable = false; + this.isStopped = false; + switch (arguments.length) { + case 0: + this.destination = Observer_1.empty; + break; + case 1: + if (!destinationOrNext) { + this.destination = Observer_1.empty; + break; + } + if (typeof destinationOrNext === 'object') { + if (destinationOrNext instanceof Subscriber) { + this.destination = destinationOrNext; + } else { + this.syncErrorThrowable = true; + this.destination = new SafeSubscriber(this, destinationOrNext); + } + break; + } + default: + this.syncErrorThrowable = true; + this.destination = new SafeSubscriber(this, destinationOrNext, error, complete); + break; + } + } + Subscriber.create = function(next, error, complete) { + var subscriber = new Subscriber(next, error, complete); + subscriber.syncErrorThrowable = false; + return subscriber; + }; + Subscriber.prototype.next = function(value) { + if (!this.isStopped) { + this._next(value); + } + }; + Subscriber.prototype.error = function(err) { + if (!this.isStopped) { + this.isStopped = true; + this._error(err); + } + }; + Subscriber.prototype.complete = function() { + if (!this.isStopped) { + this.isStopped = true; + this._complete(); + } + }; + Subscriber.prototype.unsubscribe = function() { + if (this.isUnsubscribed) { + return ; + } + this.isStopped = true; + _super.prototype.unsubscribe.call(this); + }; + Subscriber.prototype._next = function(value) { + this.destination.next(value); + }; + Subscriber.prototype._error = function(err) { + this.destination.error(err); + this.unsubscribe(); + }; + Subscriber.prototype._complete = function() { + this.destination.complete(); + this.unsubscribe(); + }; + Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function() { + return this; + }; + return Subscriber; + }(Subscription_1.Subscription)); + exports.Subscriber = Subscriber; + var SafeSubscriber = (function(_super) { + __extends(SafeSubscriber, _super); + function SafeSubscriber(_parent, observerOrNext, error, complete) { + _super.call(this); + this._parent = _parent; + var next; + var context = this; + if (isFunction_1.isFunction(observerOrNext)) { + next = observerOrNext; + } else if (observerOrNext) { + context = observerOrNext; + next = observerOrNext.next; + error = observerOrNext.error; + complete = observerOrNext.complete; + } + this._context = context; + this._next = next; + this._error = error; + this._complete = complete; + } + SafeSubscriber.prototype.next = function(value) { + if (!this.isStopped && this._next) { + var _parent = this._parent; + if (!_parent.syncErrorThrowable) { + this.__tryOrUnsub(this._next, value); + } else if (this.__tryOrSetError(_parent, this._next, value)) { + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.error = function(err) { + if (!this.isStopped) { + var _parent = this._parent; + if (this._error) { + if (!_parent.syncErrorThrowable) { + this.__tryOrUnsub(this._error, err); + this.unsubscribe(); + } else { + this.__tryOrSetError(_parent, this._error, err); + this.unsubscribe(); + } + } else if (!_parent.syncErrorThrowable) { + this.unsubscribe(); + throw err; + } else { + _parent.syncErrorValue = err; + _parent.syncErrorThrown = true; + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.complete = function() { + if (!this.isStopped) { + var _parent = this._parent; + if (this._complete) { + if (!_parent.syncErrorThrowable) { + this.__tryOrUnsub(this._complete); + this.unsubscribe(); + } else { + this.__tryOrSetError(_parent, this._complete); + this.unsubscribe(); + } + } else { + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.__tryOrUnsub = function(fn, value) { + try { + fn.call(this._context, value); + } catch (err) { + this.unsubscribe(); + throw err; + } + }; + SafeSubscriber.prototype.__tryOrSetError = function(parent, fn, value) { + try { + fn.call(this._context, value); + } catch (err) { + parent.syncErrorValue = err; + parent.syncErrorThrown = true; + return true; + } + return false; + }; + SafeSubscriber.prototype._unsubscribe = function() { + var _parent = this._parent; + this._context = null; + this._parent = null; + _parent.unsubscribe(); + }; + return SafeSubscriber; + }(Subscriber)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/combineLatest", ["rxjs/Observable", "rxjs/operator/combineLatest"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var combineLatest_1 = require("rxjs/operator/combineLatest"); + Observable_1.Observable.combineLatest = combineLatest_1.combineLatestStatic; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/from", ["rxjs/Observable", "rxjs/observable/FromObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var FromObservable_1 = require("rxjs/observable/FromObservable"); + Observable_1.Observable.from = FromObservable_1.FromObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/scheduler/asap", ["rxjs/scheduler/AsapScheduler"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var AsapScheduler_1 = require("rxjs/scheduler/AsapScheduler"); + exports.asap = new AsapScheduler_1.AsapScheduler(); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/operator/cache", ["rxjs/operator/publishReplay"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var publishReplay_1 = require("rxjs/operator/publishReplay"); + function cache(bufferSize, windowTime, scheduler) { + if (bufferSize === void 0) { + bufferSize = Number.POSITIVE_INFINITY; + } + if (windowTime === void 0) { + windowTime = Number.POSITIVE_INFINITY; + } + return publishReplay_1.publishReplay.call(this, bufferSize, windowTime, scheduler).refCount(); + } + exports.cache = cache; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/groupBy", ["rxjs/Observable", "rxjs/operator/groupBy"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var groupBy_1 = require("rxjs/operator/groupBy"); + Observable_1.Observable.prototype.groupBy = groupBy_1.groupBy; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/util/toSubscriber", ["rxjs/Subscriber", "rxjs/symbol/rxSubscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Subscriber_1 = require("rxjs/Subscriber"); + var rxSubscriber_1 = require("rxjs/symbol/rxSubscriber"); + function toSubscriber(nextOrObserver, error, complete) { + if (nextOrObserver && typeof nextOrObserver === 'object') { + if (nextOrObserver instanceof Subscriber_1.Subscriber) { + return nextOrObserver; + } else if (typeof nextOrObserver[rxSubscriber_1.rxSubscriber] === 'function') { + return nextOrObserver[rxSubscriber_1.rxSubscriber](); + } + } + return new Subscriber_1.Subscriber(nextOrObserver, error, complete); + } + exports.toSubscriber = toSubscriber; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/observable/IntervalObservable", ["rxjs/util/isNumeric", "rxjs/Observable", "rxjs/scheduler/asap"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var isNumeric_1 = require("rxjs/util/isNumeric"); + var Observable_1 = require("rxjs/Observable"); + var asap_1 = require("rxjs/scheduler/asap"); + var IntervalObservable = (function(_super) { + __extends(IntervalObservable, _super); + function IntervalObservable(period, scheduler) { + if (period === void 0) { + period = 0; + } + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + _super.call(this); + this.period = period; + this.scheduler = scheduler; + if (!isNumeric_1.isNumeric(period) || period < 0) { + this.period = 0; + } + if (!scheduler || typeof scheduler.schedule !== 'function') { + this.scheduler = asap_1.asap; + } + } + IntervalObservable.create = function(period, scheduler) { + if (period === void 0) { + period = 0; + } + if (scheduler === void 0) { + scheduler = asap_1.asap; + } + return new IntervalObservable(period, scheduler); + }; + IntervalObservable.dispatch = function(state) { + var index = state.index, + subscriber = state.subscriber, + period = state.period; + subscriber.next(index); + if (subscriber.isUnsubscribed) { + return ; + } + state.index += 1; + this.schedule(state, period); + }; + IntervalObservable.prototype._subscribe = function(subscriber) { + var index = 0; + var period = this.period; + var scheduler = this.scheduler; + subscriber.add(scheduler.schedule(IntervalObservable.dispatch, period, { + index: index, + subscriber: subscriber, + period: period + })); + }; + return IntervalObservable; + }(Observable_1.Observable)); + exports.IntervalObservable = IntervalObservable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/operator/cache", ["rxjs/Observable", "rxjs/operator/cache"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var cache_1 = require("rxjs/operator/cache"); + Observable_1.Observable.prototype.cache = cache_1.cache; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Observable", ["rxjs/util/root", "rxjs/util/SymbolShim", "rxjs/util/toSubscriber", "rxjs/util/tryCatch", "rxjs/util/errorObject"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var root_1 = require("rxjs/util/root"); + var SymbolShim_1 = require("rxjs/util/SymbolShim"); + var toSubscriber_1 = require("rxjs/util/toSubscriber"); + var tryCatch_1 = require("rxjs/util/tryCatch"); + var errorObject_1 = require("rxjs/util/errorObject"); + var Observable = (function() { + function Observable(subscribe) { + this._isScalar = false; + if (subscribe) { + this._subscribe = subscribe; + } + } + Observable.prototype.lift = function(operator) { + var observable = new Observable(); + observable.source = this; + observable.operator = operator; + return observable; + }; + Observable.prototype.subscribe = function(observerOrNext, error, complete) { + var operator = this.operator; + var subscriber = toSubscriber_1.toSubscriber(observerOrNext, error, complete); + if (operator) { + subscriber.add(this._subscribe(operator.call(subscriber))); + } else { + subscriber.add(this._subscribe(subscriber)); + } + if (subscriber.syncErrorThrowable) { + subscriber.syncErrorThrowable = false; + if (subscriber.syncErrorThrown) { + throw subscriber.syncErrorValue; + } + } + return subscriber; + }; + Observable.prototype.forEach = function(next, thisArg, PromiseCtor) { + if (!PromiseCtor) { + if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) { + PromiseCtor = root_1.root.Rx.config.Promise; + } else if (root_1.root.Promise) { + PromiseCtor = root_1.root.Promise; + } + } + if (!PromiseCtor) { + throw new Error('no Promise impl found'); + } + var source = this; + return new PromiseCtor(function(resolve, reject) { + source.subscribe(function(value) { + var result = tryCatch_1.tryCatch(next).call(thisArg, value); + if (result === errorObject_1.errorObject) { + reject(errorObject_1.errorObject.e); + } + }, reject, resolve); + }); + }; + Observable.prototype._subscribe = function(subscriber) { + return this.source.subscribe(subscriber); + }; + Observable.prototype[SymbolShim_1.SymbolShim.observable] = function() { + return this; + }; + Observable.create = function(subscribe) { + return new Observable(subscribe); + }; + return Observable; + }()); + exports.Observable = Observable; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/add/observable/interval", ["rxjs/Observable", "rxjs/observable/IntervalObservable"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Observable_1 = require("rxjs/Observable"); + var IntervalObservable_1 = require("rxjs/observable/IntervalObservable"); + Observable_1.Observable.interval = IntervalObservable_1.IntervalObservable.create; + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Subject", ["rxjs/Observable", "rxjs/Subscriber", "rxjs/Subscription", "rxjs/subject/SubjectSubscription", "rxjs/symbol/rxSubscriber", "rxjs/util/throwError", "rxjs/util/ObjectUnsubscribedError"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var __extends = (this && this.__extends) || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + var Observable_1 = require("rxjs/Observable"); + var Subscriber_1 = require("rxjs/Subscriber"); + var Subscription_1 = require("rxjs/Subscription"); + var SubjectSubscription_1 = require("rxjs/subject/SubjectSubscription"); + var rxSubscriber_1 = require("rxjs/symbol/rxSubscriber"); + var throwError_1 = require("rxjs/util/throwError"); + var ObjectUnsubscribedError_1 = require("rxjs/util/ObjectUnsubscribedError"); + var Subject = (function(_super) { + __extends(Subject, _super); + function Subject(destination, source) { + _super.call(this); + this.destination = destination; + this.source = source; + this.observers = []; + this.isUnsubscribed = false; + this.isStopped = false; + this.hasErrored = false; + this.dispatching = false; + this.hasCompleted = false; + } + Subject.prototype.lift = function(operator) { + var subject = new Subject(this.destination || this, this); + subject.operator = operator; + return subject; + }; + Subject.prototype.add = function(subscription) { + Subscription_1.Subscription.prototype.add.call(this, subscription); + }; + Subject.prototype.remove = function(subscription) { + Subscription_1.Subscription.prototype.remove.call(this, subscription); + }; + Subject.prototype.unsubscribe = function() { + Subscription_1.Subscription.prototype.unsubscribe.call(this); + }; + Subject.prototype._subscribe = function(subscriber) { + if (this.source) { + return this.source.subscribe(subscriber); + } else { + if (subscriber.isUnsubscribed) { + return ; + } else if (this.hasErrored) { + return subscriber.error(this.errorValue); + } else if (this.hasCompleted) { + return subscriber.complete(); + } + this.throwIfUnsubscribed(); + var subscription = new SubjectSubscription_1.SubjectSubscription(this, subscriber); + this.observers.push(subscriber); + return subscription; + } + }; + Subject.prototype._unsubscribe = function() { + this.source = null; + this.isStopped = true; + this.observers = null; + this.destination = null; + }; + Subject.prototype.next = function(value) { + this.throwIfUnsubscribed(); + if (this.isStopped) { + return ; + } + this.dispatching = true; + this._next(value); + this.dispatching = false; + if (this.hasErrored) { + this._error(this.errorValue); + } else if (this.hasCompleted) { + this._complete(); + } + }; + Subject.prototype.error = function(err) { + this.throwIfUnsubscribed(); + if (this.isStopped) { + return ; + } + this.isStopped = true; + this.hasErrored = true; + this.errorValue = err; + if (this.dispatching) { + return ; + } + this._error(err); + }; + Subject.prototype.complete = function() { + this.throwIfUnsubscribed(); + if (this.isStopped) { + return ; + } + this.isStopped = true; + this.hasCompleted = true; + if (this.dispatching) { + return ; + } + this._complete(); + }; + Subject.prototype.asObservable = function() { + var observable = new SubjectObservable(this); + return observable; + }; + Subject.prototype._next = function(value) { + if (this.destination) { + this.destination.next(value); + } else { + this._finalNext(value); + } + }; + Subject.prototype._finalNext = function(value) { + var index = -1; + var observers = this.observers.slice(0); + var len = observers.length; + while (++index < len) { + observers[index].next(value); + } + }; + Subject.prototype._error = function(err) { + if (this.destination) { + this.destination.error(err); + } else { + this._finalError(err); + } + }; + Subject.prototype._finalError = function(err) { + var index = -1; + var observers = this.observers; + this.observers = null; + this.isUnsubscribed = true; + if (observers) { + var len = observers.length; + while (++index < len) { + observers[index].error(err); + } + } + this.isUnsubscribed = false; + this.unsubscribe(); + }; + Subject.prototype._complete = function() { + if (this.destination) { + this.destination.complete(); + } else { + this._finalComplete(); + } + }; + Subject.prototype._finalComplete = function() { + var index = -1; + var observers = this.observers; + this.observers = null; + this.isUnsubscribed = true; + if (observers) { + var len = observers.length; + while (++index < len) { + observers[index].complete(); + } + } + this.isUnsubscribed = false; + this.unsubscribe(); + }; + Subject.prototype.throwIfUnsubscribed = function() { + if (this.isUnsubscribed) { + throwError_1.throwError(new ObjectUnsubscribedError_1.ObjectUnsubscribedError()); + } + }; + Subject.prototype[rxSubscriber_1.rxSubscriber] = function() { + return new Subscriber_1.Subscriber(this); + }; + Subject.create = function(destination, source) { + return new Subject(destination, source); + }; + return Subject; + }(Observable_1.Observable)); + exports.Subject = Subject; + var SubjectObservable = (function(_super) { + __extends(SubjectObservable, _super); + function SubjectObservable(source) { + _super.call(this); + this.source = source; + } + return SubjectObservable; + }(Observable_1.Observable)); + global.define = __define; + return module.exports; +}); + +System.register("rxjs/Rx", ["rxjs/Subject", "rxjs/Observable", "rxjs/add/observable/combineLatest", "rxjs/add/observable/concat", "rxjs/add/observable/merge", "rxjs/add/observable/race", "rxjs/add/observable/bindCallback", "rxjs/add/observable/bindNodeCallback", "rxjs/add/observable/defer", "rxjs/add/observable/empty", "rxjs/add/observable/forkJoin", "rxjs/add/observable/from", "rxjs/add/observable/fromArray", "rxjs/add/observable/fromEvent", "rxjs/add/observable/fromEventPattern", "rxjs/add/observable/fromPromise", "rxjs/add/observable/interval", "rxjs/add/observable/never", "rxjs/add/observable/range", "rxjs/add/observable/throw", "rxjs/add/observable/timer", "rxjs/add/observable/zip", "rxjs/add/operator/buffer", "rxjs/add/operator/bufferCount", "rxjs/add/operator/bufferTime", "rxjs/add/operator/bufferToggle", "rxjs/add/operator/bufferWhen", "rxjs/add/operator/cache", "rxjs/add/operator/catch", "rxjs/add/operator/combineAll", "rxjs/add/operator/combineLatest", "rxjs/add/operator/concat", "rxjs/add/operator/concatAll", "rxjs/add/operator/concatMap", "rxjs/add/operator/concatMapTo", "rxjs/add/operator/count", "rxjs/add/operator/dematerialize", "rxjs/add/operator/debounce", "rxjs/add/operator/debounceTime", "rxjs/add/operator/defaultIfEmpty", "rxjs/add/operator/delay", "rxjs/add/operator/delayWhen", "rxjs/add/operator/distinctUntilChanged", "rxjs/add/operator/do", "rxjs/add/operator/expand", "rxjs/add/operator/filter", "rxjs/add/operator/finally", "rxjs/add/operator/first", "rxjs/add/operator/groupBy", "rxjs/add/operator/ignoreElements", "rxjs/add/operator/inspect", "rxjs/add/operator/inspectTime", "rxjs/add/operator/every", "rxjs/add/operator/last", "rxjs/add/operator/let", "rxjs/add/operator/map", "rxjs/add/operator/mapTo", "rxjs/add/operator/materialize", "rxjs/add/operator/merge", "rxjs/add/operator/mergeAll", "rxjs/add/operator/mergeMap", "rxjs/add/operator/mergeMapTo", "rxjs/add/operator/multicast", "rxjs/add/operator/observeOn", "rxjs/add/operator/partition", "rxjs/add/operator/pluck", "rxjs/add/operator/publish", "rxjs/add/operator/publishBehavior", "rxjs/add/operator/publishReplay", "rxjs/add/operator/publishLast", "rxjs/add/operator/race", "rxjs/add/operator/reduce", "rxjs/add/operator/repeat", "rxjs/add/operator/retry", "rxjs/add/operator/retryWhen", "rxjs/add/operator/sample", "rxjs/add/operator/sampleTime", "rxjs/add/operator/scan", "rxjs/add/operator/share", "rxjs/add/operator/single", "rxjs/add/operator/skip", "rxjs/add/operator/skipUntil", "rxjs/add/operator/skipWhile", "rxjs/add/operator/startWith", "rxjs/add/operator/subscribeOn", "rxjs/add/operator/switch", "rxjs/add/operator/switchMap", "rxjs/add/operator/switchMapTo", "rxjs/add/operator/take", "rxjs/add/operator/takeLast", "rxjs/add/operator/takeUntil", "rxjs/add/operator/takeWhile", "rxjs/add/operator/throttle", "rxjs/add/operator/throttleTime", "rxjs/add/operator/timeout", "rxjs/add/operator/timeoutWith", "rxjs/add/operator/toArray", "rxjs/add/operator/toPromise", "rxjs/add/operator/window", "rxjs/add/operator/windowCount", "rxjs/add/operator/windowTime", "rxjs/add/operator/windowToggle", "rxjs/add/operator/windowWhen", "rxjs/add/operator/withLatestFrom", "rxjs/add/operator/zip", "rxjs/add/operator/zipAll", "rxjs/Operator", "rxjs/Subscription", "rxjs/Subscriber", "rxjs/subject/AsyncSubject", "rxjs/subject/ReplaySubject", "rxjs/subject/BehaviorSubject", "rxjs/observable/ConnectableObservable", "rxjs/Notification", "rxjs/util/EmptyError", "rxjs/util/ArgumentOutOfRangeError", "rxjs/util/ObjectUnsubscribedError", "rxjs/scheduler/asap", "rxjs/scheduler/queue", "rxjs/symbol/rxSubscriber"], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + "use strict"; + var Subject_1 = require("rxjs/Subject"); + exports.Subject = Subject_1.Subject; + var Observable_1 = require("rxjs/Observable"); + exports.Observable = Observable_1.Observable; + require("rxjs/add/observable/combineLatest"); + require("rxjs/add/observable/concat"); + require("rxjs/add/observable/merge"); + require("rxjs/add/observable/race"); + require("rxjs/add/observable/bindCallback"); + require("rxjs/add/observable/bindNodeCallback"); + require("rxjs/add/observable/defer"); + require("rxjs/add/observable/empty"); + require("rxjs/add/observable/forkJoin"); + require("rxjs/add/observable/from"); + require("rxjs/add/observable/fromArray"); + require("rxjs/add/observable/fromEvent"); + require("rxjs/add/observable/fromEventPattern"); + require("rxjs/add/observable/fromPromise"); + require("rxjs/add/observable/interval"); + require("rxjs/add/observable/never"); + require("rxjs/add/observable/range"); + require("rxjs/add/observable/throw"); + require("rxjs/add/observable/timer"); + require("rxjs/add/observable/zip"); + require("rxjs/add/operator/buffer"); + require("rxjs/add/operator/bufferCount"); + require("rxjs/add/operator/bufferTime"); + require("rxjs/add/operator/bufferToggle"); + require("rxjs/add/operator/bufferWhen"); + require("rxjs/add/operator/cache"); + require("rxjs/add/operator/catch"); + require("rxjs/add/operator/combineAll"); + require("rxjs/add/operator/combineLatest"); + require("rxjs/add/operator/concat"); + require("rxjs/add/operator/concatAll"); + require("rxjs/add/operator/concatMap"); + require("rxjs/add/operator/concatMapTo"); + require("rxjs/add/operator/count"); + require("rxjs/add/operator/dematerialize"); + require("rxjs/add/operator/debounce"); + require("rxjs/add/operator/debounceTime"); + require("rxjs/add/operator/defaultIfEmpty"); + require("rxjs/add/operator/delay"); + require("rxjs/add/operator/delayWhen"); + require("rxjs/add/operator/distinctUntilChanged"); + require("rxjs/add/operator/do"); + require("rxjs/add/operator/expand"); + require("rxjs/add/operator/filter"); + require("rxjs/add/operator/finally"); + require("rxjs/add/operator/first"); + require("rxjs/add/operator/groupBy"); + require("rxjs/add/operator/ignoreElements"); + require("rxjs/add/operator/inspect"); + require("rxjs/add/operator/inspectTime"); + require("rxjs/add/operator/every"); + require("rxjs/add/operator/last"); + require("rxjs/add/operator/let"); + require("rxjs/add/operator/map"); + require("rxjs/add/operator/mapTo"); + require("rxjs/add/operator/materialize"); + require("rxjs/add/operator/merge"); + require("rxjs/add/operator/mergeAll"); + require("rxjs/add/operator/mergeMap"); + require("rxjs/add/operator/mergeMapTo"); + require("rxjs/add/operator/multicast"); + require("rxjs/add/operator/observeOn"); + require("rxjs/add/operator/partition"); + require("rxjs/add/operator/pluck"); + require("rxjs/add/operator/publish"); + require("rxjs/add/operator/publishBehavior"); + require("rxjs/add/operator/publishReplay"); + require("rxjs/add/operator/publishLast"); + require("rxjs/add/operator/race"); + require("rxjs/add/operator/reduce"); + require("rxjs/add/operator/repeat"); + require("rxjs/add/operator/retry"); + require("rxjs/add/operator/retryWhen"); + require("rxjs/add/operator/sample"); + require("rxjs/add/operator/sampleTime"); + require("rxjs/add/operator/scan"); + require("rxjs/add/operator/share"); + require("rxjs/add/operator/single"); + require("rxjs/add/operator/skip"); + require("rxjs/add/operator/skipUntil"); + require("rxjs/add/operator/skipWhile"); + require("rxjs/add/operator/startWith"); + require("rxjs/add/operator/subscribeOn"); + require("rxjs/add/operator/switch"); + require("rxjs/add/operator/switchMap"); + require("rxjs/add/operator/switchMapTo"); + require("rxjs/add/operator/take"); + require("rxjs/add/operator/takeLast"); + require("rxjs/add/operator/takeUntil"); + require("rxjs/add/operator/takeWhile"); + require("rxjs/add/operator/throttle"); + require("rxjs/add/operator/throttleTime"); + require("rxjs/add/operator/timeout"); + require("rxjs/add/operator/timeoutWith"); + require("rxjs/add/operator/toArray"); + require("rxjs/add/operator/toPromise"); + require("rxjs/add/operator/window"); + require("rxjs/add/operator/windowCount"); + require("rxjs/add/operator/windowTime"); + require("rxjs/add/operator/windowToggle"); + require("rxjs/add/operator/windowWhen"); + require("rxjs/add/operator/withLatestFrom"); + require("rxjs/add/operator/zip"); + require("rxjs/add/operator/zipAll"); + var Operator_1 = require("rxjs/Operator"); + exports.Operator = Operator_1.Operator; + var Subscription_1 = require("rxjs/Subscription"); + exports.Subscription = Subscription_1.Subscription; + exports.UnsubscriptionError = Subscription_1.UnsubscriptionError; + var Subscriber_1 = require("rxjs/Subscriber"); + exports.Subscriber = Subscriber_1.Subscriber; + var AsyncSubject_1 = require("rxjs/subject/AsyncSubject"); + exports.AsyncSubject = AsyncSubject_1.AsyncSubject; + var ReplaySubject_1 = require("rxjs/subject/ReplaySubject"); + exports.ReplaySubject = ReplaySubject_1.ReplaySubject; + var BehaviorSubject_1 = require("rxjs/subject/BehaviorSubject"); + exports.BehaviorSubject = BehaviorSubject_1.BehaviorSubject; + var ConnectableObservable_1 = require("rxjs/observable/ConnectableObservable"); + exports.ConnectableObservable = ConnectableObservable_1.ConnectableObservable; + var Notification_1 = require("rxjs/Notification"); + exports.Notification = Notification_1.Notification; + var EmptyError_1 = require("rxjs/util/EmptyError"); + exports.EmptyError = EmptyError_1.EmptyError; + var ArgumentOutOfRangeError_1 = require("rxjs/util/ArgumentOutOfRangeError"); + exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError_1.ArgumentOutOfRangeError; + var ObjectUnsubscribedError_1 = require("rxjs/util/ObjectUnsubscribedError"); + exports.ObjectUnsubscribedError = ObjectUnsubscribedError_1.ObjectUnsubscribedError; + var asap_1 = require("rxjs/scheduler/asap"); + var queue_1 = require("rxjs/scheduler/queue"); + var rxSubscriber_1 = require("rxjs/symbol/rxSubscriber"); + var Scheduler = { + asap: asap_1.asap, + queue: queue_1.queue + }; + exports.Scheduler = Scheduler; + var Symbol = {rxSubscriber: rxSubscriber_1.rxSubscriber}; + exports.Symbol = Symbol; + global.define = __define; + return module.exports; +}); + diff --git a/2.0.0-beta.9/Rx.min.js b/2.0.0-beta.9/Rx.min.js new file mode 100644 index 0000000000..1cc83c132b --- /dev/null +++ b/2.0.0-beta.9/Rx.min.js @@ -0,0 +1,417 @@ +/** + 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 2015-2016 Netflix, Inc. + + 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 2015-2016 Netflix, Inc. + + 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. + + **/ +"format register";System.register("rxjs/util/root",[],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1};e.root=i[typeof self]&&self||i[typeof window]&&window;var o=(i[typeof e]&&e&&!e.nodeType&&e,i[typeof t]&&t&&!t.nodeType&&t,i[typeof r]&&r);return!o||o.global!==o&&o.window!==o||(e.root=o),r.define=s,t.exports}),System.register("rxjs/util/SymbolShim",["rxjs/util/root"],!0,function(require,e,t){function r(e){var t=i(e);return n(t,e),a(t),s(t),t}function s(e){e["for"]||(e["for"]=o)}function i(e){return e.Symbol||(e.Symbol=function(e){return"@@Symbol("+e+"):"+p++}),e.Symbol}function o(e){return"@@"+e}function n(e,t){if(!e.iterator)if("function"==typeof e["for"])e.iterator=e["for"]("iterator");else if(t.Set&&"function"==typeof(new t.Set)["@@iterator"])e.iterator="@@iterator";else if(t.Map)for(var r=Object.getOwnPropertyNames(t.Map.prototype),s=0;s0?this._next(t.shift()):0===this.active&&this.hasCompleted&&this.destination.complete()},t}(n.OuterSubscriber);return e.MergeAllSubscriber=c,s.define=i,t.exports}),System.register("rxjs/operator/merge",["rxjs/observable/ArrayObservable","rxjs/operator/mergeAll","rxjs/util/isScheduler"],!0,function(require,e,t){function r(){for(var e=[],t=0;t1&&"number"==typeof e[e.length-1]&&(r=e.pop())):"number"==typeof i&&(r=e.pop()),1===e.length?e[0]:new n.ArrayObservable(e,s).lift(new a.MergeAllOperator(r))}var i=System.global,o=i.define;i.define=void 0;var n=require("rxjs/observable/ArrayObservable"),a=require("rxjs/operator/mergeAll"),u=require("rxjs/util/isScheduler");return e.merge=r,e.mergeStatic=s,i.define=o,t.exports}),System.register("rxjs/operator/race",["rxjs/util/isArray","rxjs/observable/ArrayObservable","rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(){for(var e=[],t=0;tr;r++){var s=e[r],i=l.subscribeToResult(this,s,s,r);this.subscriptions.push(i),this.add(i)}this.observables=null}},t.prototype.notifyNext=function(e,t,r,s,i){if(!this.hasFirst){this.hasFirst=!0;for(var o=0;o=t?0:t>j?j:t):t}function i(e){return"number"==typeof e&&c.root.isFinite(e)}function o(e){var t=+e;return 0===t?t:isNaN(t)?t:0>t?-1:1}var n=System.global,a=n.define;n.define=void 0;var u=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},c=require("rxjs/util/root"),l=require("rxjs/util/isObject"),p=require("rxjs/util/tryCatch"),b=require("rxjs/Observable"),h=require("rxjs/util/isFunction"),f=require("rxjs/util/SymbolShim"),d=require("rxjs/util/errorObject"),v=function(e){function t(t,s,i,o){if(e.call(this),null==t)throw new Error("iterator cannot be null.");if(l.isObject(s))this.thisArg=s,this.scheduler=i;else if(h.isFunction(s))this.project=s,this.thisArg=i,this.scheduler=o;else if(null!=s)throw new Error("When provided, `project` must be a function.");this.iterator=r(t)}return u(t,e),t.create=function(e,r,s,i){return new t(e,r,s,i)},t.dispatch=function(e){var t=e.index,r=e.hasError,s=e.thisArg,i=e.project,o=e.iterator,n=e.subscriber;if(r)return void n.error(e.error);var a=o.next();return a.done?void n.complete():(i?(a=p.tryCatch(i).call(s,a.value,t),a===d.errorObject?(e.error=d.errorObject.e,e.hasError=!0):(n.next(a),e.index=t+1)):(n.next(a.value),e.index=t+1),void(n.isUnsubscribed||this.schedule(e)))},t.prototype._subscribe=function(e){var r=0,s=this,i=s.iterator,o=s.project,n=s.thisArg,a=s.scheduler;if(a)return a.schedule(t.dispatch,0,{index:r,thisArg:n,project:o,iterator:i,subscriber:e});for(;;){var u=i.next();if(u.done){e.complete();break}if(o){if(u=p.tryCatch(o).call(n,u.value,r++),u===d.errorObject){e.error(d.errorObject.e);break}e.next(u)}else e.next(u.value);if(e.isUnsubscribed)break}},t}(b.Observable);e.IteratorObservable=v;var x=function(){function e(e,t,r){void 0===t&&(t=0),void 0===r&&(r=e.length),this.str=e,this.idx=t,this.len=r}return e.prototype[f.SymbolShim.iterator]=function(){return this},e.prototype.next=function(){return this.idx=s)return void o.complete();var n=i?i(t[r],r):t[r];o.next(n),e.index=r+1,this.schedule(e)}},t.prototype._subscribe=function(e){var r=0,s=this,i=s.arrayLike,o=s.mapFn,n=s.scheduler,a=i.length;if(n)return n.schedule(t.dispatch,0,{arrayLike:i,index:r,length:a,mapFn:o,subscriber:e});for(var u=0;a>u&&!e.isUnsubscribed;u++){var c=o?o(i[u],u):i[u];e.next(c)}e.complete()},t}(o.Observable);return e.ArrayLikeObservable=u,r.define=s,t.exports}),System.register("rxjs/Notification",["rxjs/Observable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=function(){function e(e,t,r){this.kind=e,this.value=t,this.exception=r,this.hasValue="N"===e}return e.prototype.observe=function(e){switch(this.kind){case"N":return e.next&&e.next(this.value);case"E":return e.error&&e.error(this.exception);case"C":return e.complete&&e.complete()}},e.prototype["do"]=function(e,t,r){var s=this.kind;switch(s){case"N":return e&&e(this.value);case"E":return t&&t(this.exception);case"C":return r&&r()}},e.prototype.accept=function(e,t,r){return e&&"function"==typeof e.next?this.observe(e):this["do"](e,t,r)},e.prototype.toObservable=function(){var e=this.kind;switch(e){case"N":return i.Observable.of(this.value);case"E":return i.Observable["throw"](this.exception);case"C":return i.Observable.empty()}},e.createNext=function(t){return"undefined"!=typeof t?new e("N",t):this.undefinedValueNotification},e.createError=function(t){return new e("E",void 0,t)},e.createComplete=function(){return this.completeNotification},e.completeNotification=new e("C"),e.undefinedValueNotification=new e("N",void 0),e}();return e.Notification=o,r.define=s,t.exports}),System.register("rxjs/add/observable/fromArray",["rxjs/Observable","rxjs/observable/ArrayObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/ArrayObservable");return i.Observable.fromArray=o.ArrayObservable.create,i.Observable.of=o.ArrayObservable.of,r.define=s,t.exports}),System.register("rxjs/observable/FromEventObservable",["rxjs/Observable","rxjs/util/tryCatch","rxjs/util/errorObject","rxjs/Subscription"],!0,function(require,e,t){function r(e){return!!e&&"function"==typeof e.addListener&&"function"==typeof e.removeListener}function s(e){return!!e&&"function"==typeof e.on&&"function"==typeof e.off}function i(e){return!!e&&"[object NodeList]"===e.toString()}function o(e){return!!e&&"[object HTMLCollection]"===e.toString()}function n(e){return!!e&&"function"==typeof e.addEventListener&&"function"==typeof e.removeEventListener}var a=System.global,u=a.define;a.define=void 0;var c=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},l=require("rxjs/Observable"),p=require("rxjs/util/tryCatch"),b=require("rxjs/util/errorObject"),h=require("rxjs/Subscription"),f=function(e){function t(t,r,s){e.call(this),this.sourceObj=t,this.eventName=r,this.selector=s}return c(t,e),t.create=function(e,r,s){return new t(e,r,s)},t.setupSubscription=function(e,a,u,c){var l;if(i(e)||o(e))for(var p=0,b=e.length;b>p;p++)t.setupSubscription(e[p],a,u,c);else n(e)?(e.addEventListener(a,u),l=function(){return e.removeEventListener(a,u)}):s(e)?(e.on(a,u),l=function(){return e.off(a,u)}):r(e)&&(e.addListener(a,u),l=function(){return e.removeListener(a,u)});c.add(new h.Subscription(l))},t.prototype._subscribe=function(e){var r=this.sourceObj,s=this.eventName,i=this.selector,o=i?function(){for(var t=[],r=0;r=0}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/util/isArray");return e.isNumeric=r,s.define=i,t.exports}),System.register("rxjs/util/Immediate",["rxjs/util/root"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/util/root"),o=function(){function e(e){if(this.root=e,e.setImmediate&&"function"==typeof e.setImmediate)this.setImmediate=e.setImmediate.bind(e),this.clearImmediate=e.clearImmediate.bind(e);else{this.nextHandle=1,this.tasksByHandle={},this.currentlyRunningATask=!1,this.canUseProcessNextTick()?this.setImmediate=this.createProcessNextTickSetImmediate():this.canUsePostMessage()?this.setImmediate=this.createPostMessageSetImmediate():this.canUseMessageChannel()?this.setImmediate=this.createMessageChannelSetImmediate():this.canUseReadyStateChange()?this.setImmediate=this.createReadyStateChangeSetImmediate():this.setImmediate=this.createSetTimeoutSetImmediate();var t=function r(e){delete r.instance.tasksByHandle[e]};t.instance=this,this.clearImmediate=t}}return e.prototype.identify=function(e){return this.root.Object.prototype.toString.call(e)},e.prototype.canUseProcessNextTick=function(){return"[object process]"===this.identify(this.root.process)},e.prototype.canUseMessageChannel=function(){return Boolean(this.root.MessageChannel)},e.prototype.canUseReadyStateChange=function(){var e=this.root.document;return Boolean(e&&"onreadystatechange"in e.createElement("script"))},e.prototype.canUsePostMessage=function(){var e=this.root;if(e.postMessage&&!e.importScripts){var t=!0,r=e.onmessage;return e.onmessage=function(){t=!1},e.postMessage("","*"),e.onmessage=r,t}return!1},e.prototype.partiallyApplied=function(e){for(var t=[],r=1;r0)return e.prototype._schedule.call(this,t,r);this.delay=r,this.state=t;var s=this.scheduler;return s.actions.push(this),s.flush(),this},t}(o.FutureAction);return e.QueueAction=n,r.define=s,t.exports}),System.register("rxjs/util/noop",[],!0,function(require,e,t){function r(){}var s=System.global,i=s.define;return s.define=void 0,e.noop=r,s.define=i,t.exports}),System.register("rxjs/observable/RangeObservable",["rxjs/Observable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Observable"),n=function(e){function t(t,r,s){e.call(this),this.start=t,this.end=r,this.scheduler=s}return i(t,e),t.create=function(e,r,s){return void 0===e&&(e=0),void 0===r&&(r=0),new t(e,r,s)},t.dispatch=function(e){var t=e.start,r=e.index,s=e.end,i=e.subscriber;return r>=s?void i.complete():(i.next(t),void(i.isUnsubscribed||(e.index=r+1,e.start=t+1,this.schedule(e))))},t.prototype._subscribe=function(e){var r=0,s=this.start,i=this.end,o=this.scheduler;if(o)return o.schedule(t.dispatch,0,{index:r,end:i,start:s,subscriber:e});for(;;){if(r++>=i){e.complete();break}if(e.next(s++),e.isUnsubscribed)break}},t}(o.Observable);return e.RangeObservable=n,r.define=s,t.exports}),System.register("rxjs/observable/ErrorObservable",["rxjs/Observable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Observable"),n=function(e){function t(t,r){e.call(this),this.error=t,this.scheduler=r}return i(t,e),t.create=function(e,r){return new t(e,r)},t.dispatch=function(e){var t=e.error,r=e.subscriber;r.error(t)},t.prototype._subscribe=function(e){var r=this.error,s=this.scheduler;return s?s.schedule(t.dispatch,0,{error:r,subscriber:e}):void e.error(r)},t}(o.Observable);return e.ErrorObservable=n,r.define=s,t.exports}),System.register("rxjs/util/isDate",[],!0,function(require,e,t){function r(e){return e instanceof Date&&!isNaN(+e)}var s=System.global,i=s.define;return s.define=void 0,e.isDate=r,s.define=i,t.exports}),System.register("rxjs/operator/zip",["rxjs/observable/ArrayObservable","rxjs/util/isArray","rxjs/Subscriber","rxjs/OuterSubscriber","rxjs/util/subscribeToResult","rxjs/util/SymbolShim"],!0,function(require,e,t){function r(){for(var e=[],t=0;tr;r++){var s=e[r];s.stillUnsubscribed?this.add(s.subscribe(s,r)):this.active--}},t.prototype.notifyInactive=function(){this.active--,0===this.active&&this.destination.complete()},t.prototype.checkIterators=function(){for(var e=this.iterators,t=e.length,r=this.destination,s=0;t>s;s++){var i=e[s];if("function"==typeof i.hasValue&&!i.hasValue())return}for(var o=!1,n=[],s=0;t>s;s++){var i=e[s],a=i.next();if(i.hasCompleted()&&(o=!0),a.done)return void r.complete();n.push(a.value)}this.project?this._tryProject(n):r.next(n),o&&r.complete()},t.prototype._tryProject=function(e){var t;try{t=this.project.apply(this,e)}catch(r){return void this.destination.error(r)}this.destination.next(t)},t}(c.Subscriber);e.ZipSubscriber=f;var d=function(){function e(e){this.iterator=e,this.nextResult=e.next()}return e.prototype.hasValue=function(){return!0},e.prototype.next=function(){var e=this.nextResult;return this.nextResult=this.iterator.next(),e},e.prototype.hasCompleted=function(){var e=this.nextResult;return e&&e.done},e}(),v=function(){function e(e){this.array=e,this.index=0,this.length=0,this.length=e.length}return e.prototype[b.SymbolShim.iterator]=function(){return this},e.prototype.next=function(e){var t=this.index++,r=this.array;return tthis.index},e.prototype.hasCompleted=function(){return this.array.length===this.index},e}(),x=function(e){function t(t,r,s,i){e.call(this,t),this.parent=r,this.observable=s,this.index=i,this.stillUnsubscribed=!0,this.buffer=[],this.isComplete=!1}return n(t,e),t.prototype[b.SymbolShim.iterator]=function(){return this},t.prototype.next=function(){var e=this.buffer;return 0===e.length&&this.isComplete?{done:!0}:{value:e.shift(),done:!1}},t.prototype.hasValue=function(){return this.buffer.length>0},t.prototype.hasCompleted=function(){return 0===this.buffer.length&&this.isComplete},t.prototype.notifyComplete=function(){this.buffer.length>0?(this.isComplete=!0,this.parent.notifyInactive()):this.destination.complete()},t.prototype.notifyNext=function(e,t,r,s,i){this.buffer.push(t),this.parent.checkIterators()},t.prototype.subscribe=function(e,t){return p.subscribeToResult(this,this.observable,this,t)},t}(l.OuterSubscriber);return i.define=o,t.exports}),System.register("rxjs/operator/buffer",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e){return this.lift(new u(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e.buffer=r;var u=function(){function e(e){this.closingNotifier=e}return e.prototype.call=function(e){return new c(e,this.closingNotifier)},e}(),c=function(e){function t(t,r){e.call(this,t),this.buffer=[],this.add(a.subscribeToResult(this,r))}return o(t,e),t.prototype._next=function(e){this.buffer.push(e)},t.prototype.notifyNext=function(e,t,r,s,i){var o=this.buffer;this.buffer=[],this.destination.next(o)},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/operator/bufferCount",["rxjs/Subscriber"],!0,function(require,e,t){function r(e,t){return void 0===t&&(t=null),this.lift(new a(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.bufferCount=r;var a=function(){function e(e,t){this.bufferSize=e,this.startBufferEvery=t}return e.prototype.call=function(e){return new u(e,this.bufferSize,this.startBufferEvery)},e}(),u=function(e){function t(t,r,s){e.call(this,t),this.bufferSize=r,this.startBufferEvery=s,this.buffers=[[]],this.count=0}return o(t,e),t.prototype._next=function(e){var t=this.count+=1,r=this.destination,s=this.bufferSize,i=null==this.startBufferEvery?s:this.startBufferEvery,o=this.buffers,n=o.length,a=-1;t%i===0&&o.push([]);for(var u=0;n>u;u++){var c=o[u];c.push(e),c.length===s&&(a=u,r.next(c))}-1!==a&&o.splice(a,1)},t.prototype._complete=function(){for(var t=this.destination,r=this.buffers;r.length>0;){var s=r.shift();s.length>0&&t.next(s)}e.prototype._complete.call(this)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/bufferTime",["rxjs/Subscriber","rxjs/scheduler/asap"],!0,function(require,e,t){function r(e,t,r){return void 0===t&&(t=null),void 0===r&&(r=l.asap),this.lift(new p(e,t,r))}function s(e){var t=e.subscriber,r=e.buffer;r&&t.closeBuffer(r),e.buffer=t.openBuffer(),t.isUnsubscribed||this.schedule(e,e.bufferTimeSpan)}function i(e){var t=e.bufferCreationInterval,r=e.bufferTimeSpan,s=e.subscriber,i=e.scheduler,n=s.openBuffer(),a=this;s.isUnsubscribed||(a.add(i.schedule(o,r,{subscriber:s,buffer:n})),a.schedule(e,t))}function o(e){var t=e.subscriber,r=e.buffer;t.closeBuffer(r)}var n=System.global,a=n.define;n.define=void 0;var u=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},c=require("rxjs/Subscriber"),l=require("rxjs/scheduler/asap");e.bufferTime=r;var p=function(){function e(e,t,r){this.bufferTimeSpan=e,this.bufferCreationInterval=t,this.scheduler=r}return e.prototype.call=function(e){return new b(e,this.bufferTimeSpan,this.bufferCreationInterval,this.scheduler)},e}(),b=function(e){function t(t,r,n,a){e.call(this,t),this.bufferTimeSpan=r,this.bufferCreationInterval=n,this.scheduler=a,this.buffers=[];var u=this.openBuffer();if(null!==n&&n>=0){var c={subscriber:this,buffer:u},l={bufferTimeSpan:r,bufferCreationInterval:n,subscriber:this,scheduler:a};this.add(a.schedule(o,r,c)),this.add(a.schedule(i,n,l))}else{var p={subscriber:this,buffer:u,bufferTimeSpan:r};this.add(a.schedule(s,r,p))}}return u(t,e),t.prototype._next=function(e){for(var t=this.buffers,r=t.length,s=0;r>s;s++)t[s].push(e)},t.prototype._error=function(t){this.buffers.length=0,e.prototype._error.call(this,t)},t.prototype._complete=function(){for(var t=this,r=t.buffers,s=t.destination;r.length>0;)s.next(r.shift());e.prototype._complete.call(this)},t.prototype._unsubscribe=function(){this.buffers=null},t.prototype.openBuffer=function(){var e=[];return this.buffers.push(e),e},t.prototype.closeBuffer=function(e){this.destination.next(e);var t=this.buffers;t.splice(t.indexOf(e),1)},t}(c.Subscriber);return n.define=a,t.exports}),System.register("rxjs/operator/bufferToggle",["rxjs/Subscriber","rxjs/Subscription","rxjs/util/tryCatch","rxjs/util/errorObject"],!0,function(require,e,t){function r(e,t){return this.lift(new l(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/Subscription"),u=require("rxjs/util/tryCatch"),c=require("rxjs/util/errorObject");e.bufferToggle=r;var l=function(){function e(e,t){this.openings=e,this.closingSelector=t}return e.prototype.call=function(e){return new p(e,this.openings,this.closingSelector)},e}(),p=function(e){function t(t,r,s){e.call(this,t),this.openings=r,this.closingSelector=s,this.contexts=[],this.add(this.openings.subscribe(new b(this)))}return o(t,e),t.prototype._next=function(e){for(var t=this.contexts,r=t.length,s=0;r>s;s++)t[s].buffer.push(e)},t.prototype._error=function(t){for(var r=this.contexts;r.length>0;){var s=r.shift();s.subscription.unsubscribe(),s.buffer=null,s.subscription=null}this.contexts=null,e.prototype._error.call(this,t)},t.prototype._complete=function(){for(var t=this.contexts;t.length>0;){var r=t.shift();this.destination.next(r.buffer),r.subscription.unsubscribe(),r.buffer=null,r.subscription=null}this.contexts=null,e.prototype._complete.call(this)},t.prototype.openBuffer=function(e){var t=this.closingSelector,r=this.contexts,s=u.tryCatch(t)(e);if(s===c.errorObject)this._error(c.errorObject.e);else{var i={buffer:[],subscription:new a.Subscription};r.push(i);var o=new h(this,i),n=s.subscribe(o);i.subscription.add(n),this.add(n)}},t.prototype.closeBuffer=function(e){var t=this.contexts;if(null!==t){var r=e.buffer,s=e.subscription;this.destination.next(r),t.splice(t.indexOf(e),1),this.remove(s),s.unsubscribe()}},t}(n.Subscriber),b=function(e){function t(t){e.call(this,null),this.parent=t}return o(t,e),t.prototype._next=function(e){this.parent.openBuffer(e)},t.prototype._error=function(e){this.parent.error(e)},t.prototype._complete=function(){},t}(n.Subscriber),h=function(e){function t(t,r){e.call(this,null),this.parent=t,this.context=r}return o(t,e),t.prototype._next=function(){this.parent.closeBuffer(this.context)},t.prototype._error=function(e){this.parent.error(e)},t.prototype._complete=function(){this.parent.closeBuffer(this.context)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/bufferWhen",["rxjs/Subscription","rxjs/util/tryCatch","rxjs/util/errorObject","rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e){return this.lift(new p(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscription"),a=require("rxjs/util/tryCatch"),u=require("rxjs/util/errorObject"),c=require("rxjs/OuterSubscriber"),l=require("rxjs/util/subscribeToResult");e.bufferWhen=r;var p=function(){function e(e){this.closingSelector=e}return e.prototype.call=function(e){return new b(e,this.closingSelector)},e}(),b=function(e){function t(t,r){e.call(this,t),this.closingSelector=r,this.subscribing=!1,this.openBuffer()}return o(t,e),t.prototype._next=function(e){this.buffer.push(e)},t.prototype._complete=function(){var t=this.buffer;t&&this.destination.next(t),e.prototype._complete.call(this)},t.prototype._unsubscribe=function(){this.buffer=null,this.subscribing=!1},t.prototype.notifyNext=function(e,t,r,s,i){this.openBuffer()},t.prototype.notifyComplete=function(){this.subscribing?this.complete():this.openBuffer()},t.prototype.openBuffer=function(){var e=this.closingSubscription;e&&(this.remove(e),e.unsubscribe());var t=this.buffer;this.buffer&&this.destination.next(t),this.buffer=[];var r=a.tryCatch(this.closingSelector)();r===u.errorObject?this.error(u.errorObject.e):(e=new n.Subscription,this.closingSubscription=e,this.add(e),this.subscribing=!0,e.add(l.subscribeToResult(this,r)),this.subscribing=!1)},t}(c.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/scheduler/queue",["rxjs/scheduler/QueueScheduler"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/scheduler/QueueScheduler");return e.queue=new i.QueueScheduler,r.define=s,t.exports}),System.register("rxjs/observable/ConnectableObservable",["rxjs/Observable","rxjs/Subscriber","rxjs/Subscription"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Observable"),n=require("rxjs/Subscriber"),a=require("rxjs/Subscription"),u=function(e){function t(t,r){e.call(this),this.source=t,this.subjectFactory=r}return i(t,e),t.prototype._subscribe=function(e){return this.getSubject().subscribe(e)},t.prototype.getSubject=function(){var e=this.subject;return e&&!e.isUnsubscribed?e:this.subject=this.subjectFactory()},t.prototype.connect=function(){var e=this.source,t=this.subscription;return t&&!t.isUnsubscribed?t:(t=e.subscribe(this.getSubject()),t.add(new c(this)),this.subscription=t)},t.prototype.refCount=function(){return new l(this)},t.prototype._closeSubscription=function(){this.subject=null,this.subscription=null},t}(o.Observable);e.ConnectableObservable=u;var c=function(e){function t(t){e.call(this),this.connectable=t}return i(t,e),t.prototype._unsubscribe=function(){var e=this.connectable;e._closeSubscription(),this.connectable=null},t}(a.Subscription),l=function(e){function t(t,r){void 0===r&&(r=0),e.call(this),this.connectable=t,this.refCount=r}return i(t,e),t.prototype._subscribe=function(e){var t=this.connectable,r=new p(e,this),s=t.subscribe(r);return s.isUnsubscribed||1!==++this.refCount||(r.connection=this.connection=t.connect()),s},t}(o.Observable),p=function(e){function t(t,r){e.call(this,null),this.destination=t,this.refCountObservable=r,this.connection=r.connection,t.add(this)}return i(t,e),t.prototype._next=function(e){this.destination.next(e)},t.prototype._error=function(e){this._resetConnectable(),this.destination.error(e)},t.prototype._complete=function(){this._resetConnectable(),this.destination.complete()},t.prototype._resetConnectable=function(){var e=this.refCountObservable,t=e.connection,r=this.connection;r&&r===t&&(e.refCount=0,t.unsubscribe(),e.connection=null,this.unsubscribe())},t.prototype._unsubscribe=function(){var e=this.refCountObservable;if(0!==e.refCount&&0===--e.refCount){var t=e.connection,r=this.connection;r&&r===t&&(t.unsubscribe(),e.connection=null)}},t}(n.Subscriber);return r.define=s,t.exports}),System.register("rxjs/operator/catch",["rxjs/Subscriber"],!0,function(require,e,t){function r(e){var t=new a(e),r=this.lift(t);return t.caught=r}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e._catch=r;var a=function(){function e(e){this.selector=e}return e.prototype.call=function(e){return new u(e,this.selector,this.caught)},e}(),u=function(e){function t(t,r,s){e.call(this,t),this.selector=r,this.caught=s}return o(t,e),t.prototype.error=function(e){if(!this.isStopped){var t=void 0;try{t=this.selector(e,this.caught)}catch(e){return void this.destination.error(e)}this._innerSub(t)}},t.prototype._innerSub=function(e){this.unsubscribe(),this.destination.remove(this),e.subscribe(this.destination)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/combineAll",["rxjs/operator/combineLatest"],!0,function(require,e,t){function r(e){return this.lift(new o.CombineLatestOperator(e))}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/operator/combineLatest");return e.combineAll=r,s.define=i,t.exports}),System.register("rxjs/add/operator/combineLatest",["rxjs/Observable","rxjs/operator/combineLatest"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/combineLatest");return i.Observable.prototype.combineLatest=o.combineLatest,r.define=s,t.exports}),System.register("rxjs/add/operator/concat",["rxjs/Observable","rxjs/operator/concat"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/concat");return i.Observable.prototype.concat=o.concat,r.define=s,t.exports}),System.register("rxjs/operator/concatAll",["rxjs/operator/mergeAll"],!0,function(require,e,t){function r(){return this.lift(new o.MergeAllOperator(1))}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/operator/mergeAll");return e.concatAll=r,s.define=i,t.exports}),System.register("rxjs/operator/mergeMap",["rxjs/util/subscribeToResult","rxjs/OuterSubscriber"],!0,function(require,e,t){function r(e,t,r){return void 0===r&&(r=Number.POSITIVE_INFINITY),this.lift(new u(e,t,r))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/util/subscribeToResult"),a=require("rxjs/OuterSubscriber");e.mergeMap=r;var u=function(){function e(e,t,r){void 0===r&&(r=Number.POSITIVE_INFINITY),this.project=e,this.resultSelector=t,this.concurrent=r}return e.prototype.call=function(e){return new c(e,this.project,this.resultSelector,this.concurrent)},e}();e.MergeMapOperator=u;var c=function(e){function t(t,r,s,i){void 0===i&&(i=Number.POSITIVE_INFINITY),e.call(this,t),this.project=r,this.resultSelector=s,this.concurrent=i,this.hasCompleted=!1,this.buffer=[],this.active=0,this.index=0}return o(t,e),t.prototype._next=function(e){this.active0?this._next(t.shift()):0===this.active&&this.hasCompleted&&this.destination.complete()},t}(a.OuterSubscriber);return e.MergeMapSubscriber=c,s.define=i,t.exports}),System.register("rxjs/operator/mergeMapTo",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e,t,r){return void 0===r&&(r=Number.POSITIVE_INFINITY),this.lift(new u(e,t,r))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e.mergeMapTo=r;var u=function(){function e(e,t,r){void 0===r&&(r=Number.POSITIVE_INFINITY),this.ish=e,this.resultSelector=t,this.concurrent=r}return e.prototype.call=function(e){return new c(e,this.ish,this.resultSelector,this.concurrent)},e}();e.MergeMapToOperator=u;var c=function(e){function t(t,r,s,i){void 0===i&&(i=Number.POSITIVE_INFINITY),e.call(this,t),this.ish=r,this.resultSelector=s,this.concurrent=i,this.hasCompleted=!1,this.buffer=[],this.active=0,this.index=0}return o(t,e),t.prototype._next=function(e){if(this.active0?this._next(t.shift()):0===this.active&&this.hasCompleted&&this.destination.complete()},t}(n.OuterSubscriber);return e.MergeMapToSubscriber=c,s.define=i,t.exports}),System.register("rxjs/operator/count",["rxjs/Subscriber"],!0,function(require,e,t){function r(e){return this.lift(new a(e,this))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.count=r;var a=function(){function e(e,t){this.predicate=e,this.source=t}return e.prototype.call=function(e){return new u(e,this.predicate,this.source)},e}(),u=function(e){function t(t,r,s){e.call(this,t),this.predicate=r,this.source=s,this.count=0,this.index=0}return o(t,e),t.prototype._next=function(e){this.predicate?this._tryPredicate(e):this.count++},t.prototype._tryPredicate=function(e){var t;try{t=this.predicate(e,this.index++,this.source)}catch(r){return void this.destination.error(r)}t&&this.count++},t.prototype._complete=function(){this.destination.next(this.count),this.destination.complete()},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/dematerialize",["rxjs/Subscriber"],!0,function(require,e,t){function r(){return this.lift(new a)}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.dematerialize=r;var a=function(){function e(){}return e.prototype.call=function(e){return new u(e)},e}(),u=function(e){function t(t){e.call(this,t)}return o(t,e),t.prototype._next=function(e){e.observe(this.destination)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/debounce",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e){return this.lift(new u(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e.debounce=r;var u=function(){function e(e){this.durationSelector=e}return e.prototype.call=function(e){return new c(e,this.durationSelector)},e}(),c=function(e){function t(t,r){e.call(this,t),this.durationSelector=r,this.hasValue=!1,this.durationSubscription=null}return o(t,e),t.prototype._next=function(e){try{var t=this.durationSelector.call(this,e);t&&this._tryNext(e,t)}catch(r){this.destination.error(r)}},t.prototype._complete=function(){this.emitValue(),this.destination.complete()},t.prototype._tryNext=function(e,t){var r=this.durationSubscription;this.value=e,this.hasValue=!0,r&&(r.unsubscribe(),this.remove(r)),r=a.subscribeToResult(this,t),r.isUnsubscribed||this.add(this.durationSubscription=r)},t.prototype.notifyNext=function(e,t,r,s,i){this.emitValue()},t.prototype.notifyComplete=function(){this.emitValue()},t.prototype.emitValue=function(){if(this.hasValue){var t=this.value,r=this.durationSubscription;r&&(this.durationSubscription=null,r.unsubscribe(),this.remove(r)),this.value=null,this.hasValue=!1,e.prototype._next.call(this,t)}},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/operator/debounceTime",["rxjs/Subscriber","rxjs/scheduler/asap"],!0,function(require,e,t){function r(e,t){return void 0===t&&(t=u.asap),this.lift(new c(e,t))}function s(e){e.debouncedNext()}var i=System.global,o=i.define;i.define=void 0;var n=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},a=require("rxjs/Subscriber"),u=require("rxjs/scheduler/asap");e.debounceTime=r;var c=function(){function e(e,t){this.dueTime=e,this.scheduler=t}return e.prototype.call=function(e){return new l(e,this.dueTime,this.scheduler)},e}(),l=function(e){function t(t,r,s){e.call(this,t),this.dueTime=r,this.scheduler=s,this.debouncedSubscription=null,this.lastValue=null,this.hasValue=!1}return n(t,e),t.prototype._next=function(e){this.clearDebounce(),this.lastValue=e,this.hasValue=!0,this.add(this.debouncedSubscription=this.scheduler.schedule(s,this.dueTime,this))},t.prototype._complete=function(){this.debouncedNext(),this.destination.complete()},t.prototype.debouncedNext=function(){this.clearDebounce(),this.hasValue&&(this.destination.next(this.lastValue),this.lastValue=null,this.hasValue=!1)},t.prototype.clearDebounce=function(){var e=this.debouncedSubscription;null!==e&&(this.remove(e),e.unsubscribe(),this.debouncedSubscription=null)},t}(a.Subscriber);return i.define=o,t.exports}),System.register("rxjs/operator/defaultIfEmpty",["rxjs/Subscriber"],!0,function(require,e,t){function r(e){return void 0===e&&(e=null),this.lift(new a(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.defaultIfEmpty=r;var a=function(){function e(e){this.defaultValue=e}return e.prototype.call=function(e){return new u(e,this.defaultValue)},e}(),u=function(e){function t(t,r){e.call(this,t),this.defaultValue=r,this.isEmpty=!0}return o(t,e),t.prototype._next=function(e){this.isEmpty=!1,this.destination.next(e)},t.prototype._complete=function(){this.isEmpty&&this.destination.next(this.defaultValue),this.destination.complete()},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/delay",["rxjs/scheduler/asap","rxjs/util/isDate","rxjs/Subscriber","rxjs/Notification"],!0,function(require,e,t){function r(e,t){void 0===t&&(t=n.asap);var r=a.isDate(e),s=r?+e-t.now():Math.abs(e);return this.lift(new l(s,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/scheduler/asap"),a=require("rxjs/util/isDate"),u=require("rxjs/Subscriber"),c=require("rxjs/Notification");e.delay=r;var l=function(){function e(e,t){this.delay=e,this.scheduler=t}return e.prototype.call=function(e){return new p(e,this.delay,this.scheduler)},e}(),p=function(e){function t(t,r,s){e.call(this,t),this.delay=r,this.scheduler=s,this.queue=[],this.active=!1,this.errored=!1}return o(t,e),t.dispatch=function(e){for(var t=e.source,r=t.queue,s=e.scheduler,i=e.destination;r.length>0&&r[0].time-s.now()<=0;)r.shift().notification.observe(i);if(r.length>0){var o=Math.max(0,r[0].time-s.now());this.schedule(e,o)}else t.active=!1},t.prototype._schedule=function(e){this.active=!0,this.add(e.schedule(t.dispatch,this.delay,{source:this,destination:this.destination,scheduler:e}))},t.prototype.scheduleNotification=function(e){if(this.errored!==!0){var t=this.scheduler,r=new b(t.now()+this.delay,e);this.queue.push(r),this.active===!1&&this._schedule(t)}},t.prototype._next=function(e){this.scheduleNotification(c.Notification.createNext(e))},t.prototype._error=function(e){this.errored=!0,this.queue=[],this.destination.error(e)},t.prototype._complete=function(){this.scheduleNotification(c.Notification.createComplete())},t}(u.Subscriber),b=function(){function e(e,t){ +this.time=e,this.notification=t}return e}();return s.define=i,t.exports}),System.register("rxjs/operator/delayWhen",["rxjs/Subscriber","rxjs/Observable","rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e,t){return t?new b(this,t).lift(new l(e)):this.lift(new l(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/Observable"),u=require("rxjs/OuterSubscriber"),c=require("rxjs/util/subscribeToResult");e.delayWhen=r;var l=function(){function e(e){this.delayDurationSelector=e}return e.prototype.call=function(e){return new p(e,this.delayDurationSelector)},e}(),p=function(e){function t(t,r){e.call(this,t),this.delayDurationSelector=r,this.completed=!1,this.delayNotifierSubscriptions=[],this.values=[]}return o(t,e),t.prototype.notifyNext=function(e,t,r,s,i){this.destination.next(e),this.removeSubscription(i),this.tryComplete()},t.prototype.notifyError=function(e,t){this._error(e)},t.prototype.notifyComplete=function(e){var t=this.removeSubscription(e);t&&this.destination.next(t),this.tryComplete()},t.prototype._next=function(e){try{var t=this.delayDurationSelector(e);t&&this.tryDelay(t,e)}catch(r){this.destination.error(r)}},t.prototype._complete=function(){this.completed=!0,this.tryComplete()},t.prototype.removeSubscription=function(e){e.unsubscribe();var t=this.delayNotifierSubscriptions.indexOf(e),r=null;return-1!==t&&(r=this.values[t],this.delayNotifierSubscriptions.splice(t,1),this.values.splice(t,1)),r},t.prototype.tryDelay=function(e,t){var r=c.subscribeToResult(this,e,t);this.add(r),this.delayNotifierSubscriptions.push(r),this.values.push(t)},t.prototype.tryComplete=function(){this.completed&&0===this.delayNotifierSubscriptions.length&&this.destination.complete()},t}(u.OuterSubscriber),b=function(e){function t(t,r){e.call(this),this.source=t,this.subscriptionDelay=r}return o(t,e),t.prototype._subscribe=function(e){this.subscriptionDelay.subscribe(new h(e,this.source))},t}(a.Observable),h=function(e){function t(t,r){e.call(this),this.parent=t,this.source=r,this.sourceSubscribed=!1}return o(t,e),t.prototype._next=function(e){this.subscribeToSource()},t.prototype._error=function(e){this.unsubscribe(),this.parent.error(e)},t.prototype._complete=function(){this.subscribeToSource()},t.prototype.subscribeToSource=function(){this.sourceSubscribed||(this.sourceSubscribed=!0,this.unsubscribe(),this.source.subscribe(this.parent))},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/distinctUntilChanged",["rxjs/Subscriber","rxjs/util/tryCatch","rxjs/util/errorObject"],!0,function(require,e,t){function r(e,t){return this.lift(new c(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/util/tryCatch"),u=require("rxjs/util/errorObject");e.distinctUntilChanged=r;var c=function(){function e(e,t){this.compare=e,this.keySelector=t}return e.prototype.call=function(e){return new l(e,this.compare,this.keySelector)},e}(),l=function(e){function t(t,r,s){e.call(this,t),this.keySelector=s,this.hasKey=!1,"function"==typeof r&&(this.compare=r)}return o(t,e),t.prototype.compare=function(e,t){return e===t},t.prototype._next=function(e){var t=this.keySelector,r=e;if(t&&(r=a.tryCatch(this.keySelector)(e),r===u.errorObject))return this.destination.error(u.errorObject.e);var s=!1;if(this.hasKey){if(s=a.tryCatch(this.compare)(this.key,r),s===u.errorObject)return this.destination.error(u.errorObject.e)}else this.hasKey=!0;Boolean(s)===!1&&(this.key=r,this.destination.next(e))},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/do",["rxjs/Subscriber","rxjs/util/noop"],!0,function(require,e,t){function r(e,t,r){var s;return e&&"object"==typeof e?(s=e.next,t=e.error,r=e.complete):s=e,this.lift(new u(s||a.noop,t||a.noop,r||a.noop))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/util/noop");e._do=r;var u=function(){function e(e,t,r){this.next=e,this.error=t,this.complete=r}return e.prototype.call=function(e){return new c(e,this.next,this.error,this.complete)},e}(),c=function(e){function t(t,r,s,i){e.call(this,t),this.__next=r,this.__error=s,this.__complete=i}return o(t,e),t.prototype._next=function(e){try{this.__next(e)}catch(t){return void this.destination.error(t)}this.destination.next(e)},t.prototype._error=function(e){try{this.__error(e)}catch(e){return void this.destination.error(e)}this.destination.error(e)},t.prototype._complete=function(){try{this.__complete()}catch(e){return void this.destination.error(e)}this.destination.complete()},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/expand",["rxjs/util/tryCatch","rxjs/util/errorObject","rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e,t,r){return void 0===t&&(t=Number.POSITIVE_INFINITY),void 0===r&&(r=void 0),t=1>(t||0)?Number.POSITIVE_INFINITY:t,this.lift(new l(e,t,r))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/util/tryCatch"),a=require("rxjs/util/errorObject"),u=require("rxjs/OuterSubscriber"),c=require("rxjs/util/subscribeToResult");e.expand=r;var l=function(){function e(e,t,r){this.project=e,this.concurrent=t,this.scheduler=r}return e.prototype.call=function(e){return new p(e,this.project,this.concurrent,this.scheduler)},e}();e.ExpandOperator=l;var p=function(e){function t(t,r,s,i){e.call(this,t),this.project=r,this.concurrent=s,this.scheduler=i,this.index=0,this.active=0,this.hasCompleted=!1,s0&&this._next(t.shift()),this.hasCompleted&&0===this.active&&this.destination.complete()},t}(u.OuterSubscriber);return e.ExpandSubscriber=p,s.define=i,t.exports}),System.register("rxjs/operator/filter",["rxjs/Subscriber"],!0,function(require,e,t){function r(e,t){return this.lift(new a(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.filter=r;var a=function(){function e(e,t){this.select=e,this.thisArg=t}return e.prototype.call=function(e){return new u(e,this.select,this.thisArg)},e}(),u=function(e){function t(t,r,s){e.call(this,t),this.select=r,this.thisArg=s,this.count=0,this.select=r}return o(t,e),t.prototype._next=function(e){var t;try{t=this.select.call(this.thisArg,e,this.count++)}catch(r){return void this.destination.error(r)}t&&this.destination.next(e)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/finally",["rxjs/Subscriber","rxjs/Subscription"],!0,function(require,e,t){function r(e){return this.lift(new u(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/Subscription");e._finally=r;var u=function(){function e(e){this.finallySelector=e}return e.prototype.call=function(e){return new c(e,this.finallySelector)},e}(),c=function(e){function t(t,r){e.call(this,t),this.add(new a.Subscription(r))}return o(t,e),t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/util/EmptyError",[],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=function(e){function t(){e.call(this,"no elements in sequence"),this.name="EmptyError"}return i(t,e),t}(Error);return e.EmptyError=o,r.define=s,t.exports}),System.register("rxjs/Operator",["rxjs/Subscriber"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Subscriber"),o=function(){function e(){}return e.prototype.call=function(e){return new i.Subscriber(e)},e}();return e.Operator=o,r.define=s,t.exports}),System.register("rxjs/util/MapPolyfill",[],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=function(){function e(){this.size=0,this._values=[],this._keys=[]}return e.prototype.get=function(e){var t=this._keys.indexOf(e);return-1===t?void 0:this._values[t]},e.prototype.set=function(e,t){var r=this._keys.indexOf(e);return-1===r?(this._keys.push(e),this._values.push(t),this.size++):this._values[r]=t,this},e.prototype["delete"]=function(e){var t=this._keys.indexOf(e);return-1===t?!1:(this._values.splice(t,1),this._keys.splice(t,1),this.size--,!0)},e.prototype.clear=function(){this._keys.length=0,this._values.length=0,this.size=0},e.prototype.forEach=function(e,t){for(var r=0;ri;i++){var o=s[e[i]];if("undefined"==typeof o)return;s=o}return s};return r}var i=System.global,o=i.define;i.define=void 0;var n=require("rxjs/operator/map");return e.pluck=r,i.define=o,t.exports}),System.register("rxjs/operator/publish",["rxjs/Subject","rxjs/operator/multicast"],!0,function(require,e,t){function r(){return n.multicast.call(this,new o.Subject)}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/Subject"),n=require("rxjs/operator/multicast");return e.publish=r,s.define=i,t.exports}),System.register("rxjs/subject/BehaviorSubject",["rxjs/Subject","rxjs/util/throwError","rxjs/util/ObjectUnsubscribedError"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Subject"),n=require("rxjs/util/throwError"),a=require("rxjs/util/ObjectUnsubscribedError"),u=function(e){function t(t){e.call(this),this._value=t}return i(t,e),t.prototype.getValue=function(){if(this.hasErrored)n.throwError(this.errorValue);else{if(!this.isUnsubscribed)return this._value;n.throwError(new a.ObjectUnsubscribedError)}},Object.defineProperty(t.prototype,"value",{get:function(){return this.getValue()},enumerable:!0,configurable:!0}),t.prototype._subscribe=function(t){var r=e.prototype._subscribe.call(this,t);return r&&!r.isUnsubscribed&&t.next(this._value),r},t.prototype._next=function(t){e.prototype._next.call(this,this._value=t)},t.prototype._error=function(t){this.hasErrored=!0,e.prototype._error.call(this,this.errorValue=t)},t}(o.Subject);return e.BehaviorSubject=u,r.define=s,t.exports}),System.register("rxjs/add/operator/publishReplay",["rxjs/Observable","rxjs/operator/publishReplay"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/publishReplay");return i.Observable.prototype.publishReplay=o.publishReplay,r.define=s,t.exports}),System.register("rxjs/operator/publishLast",["rxjs/subject/AsyncSubject","rxjs/operator/multicast"],!0,function(require,e,t){function r(){return n.multicast.call(this,new o.AsyncSubject)}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/subject/AsyncSubject"),n=require("rxjs/operator/multicast");return e.publishLast=r,s.define=i,t.exports}),System.register("rxjs/add/operator/race",["rxjs/Observable","rxjs/operator/race"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/race");return i.Observable.prototype.race=o.race,r.define=s,t.exports}),System.register("rxjs/operator/reduce",["rxjs/Subscriber"],!0,function(require,e,t){function r(e,t){return this.lift(new a(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.reduce=r;var a=function(){function e(e,t){this.project=e,this.seed=t}return e.prototype.call=function(e){return new u(e,this.project,this.seed)},e}();e.ReduceOperator=a;var u=function(e){function t(t,r,s){e.call(this,t),this.hasValue=!1,this.acc=s,this.project=r,this.hasSeed="undefined"!=typeof s}return o(t,e),t.prototype._next=function(e){this.hasValue||(this.hasValue=this.hasSeed)?this._tryReduce(e):(this.acc=e,this.hasValue=!0)},t.prototype._tryReduce=function(e){var t;try{t=this.project(this.acc,e)}catch(r){return void this.destination.error(r)}this.acc=t},t.prototype._complete=function(){(this.hasValue||this.hasSeed)&&this.destination.next(this.acc),this.destination.complete()},t}(n.Subscriber);return e.ReduceSubscriber=u,s.define=i,t.exports}),System.register("rxjs/operator/repeat",["rxjs/Subscriber","rxjs/observable/EmptyObservable"],!0,function(require,e,t){function r(e){return void 0===e&&(e=-1),0===e?new a.EmptyObservable:0>e?this.lift(new u(-1,this)):this.lift(new u(e-1,this))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/observable/EmptyObservable");e.repeat=r;var u=function(){function e(e,t){this.count=e,this.source=t}return e.prototype.call=function(e){return new c(e,this.count,this.source)},e}(),c=function(e){function t(t,r,s){e.call(this,t),this.count=r,this.source=s}return o(t,e),t.prototype.complete=function(){if(!this.isStopped){var t=this,r=t.source,s=t.count;if(0===s)return e.prototype.complete.call(this);s>-1&&(this.count=s-1),this.unsubscribe(),this.isStopped=!1,this.isUnsubscribed=!1,r.subscribe(this)}},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/retry",["rxjs/Subscriber"],!0,function(require,e,t){function r(e){return void 0===e&&(e=-1),this.lift(new a(e,this))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.retry=r;var a=function(){function e(e,t){this.count=e,this.source=t}return e.prototype.call=function(e){return new u(e,this.count,this.source)},e}(),u=function(e){function t(t,r,s){e.call(this,t),this.count=r,this.source=s}return o(t,e),t.prototype.error=function(t){if(!this.isStopped){var r=this,s=r.source,i=r.count;if(0===i)return e.prototype.error.call(this,t);i>-1&&(this.count=i-1),this.unsubscribe(),this.isStopped=!1,this.isUnsubscribed=!1,s.subscribe(this)}},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/retryWhen",["rxjs/Subject","rxjs/util/tryCatch","rxjs/util/errorObject","rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e){return this.lift(new p(e,this))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subject"),a=require("rxjs/util/tryCatch"),u=require("rxjs/util/errorObject"),c=require("rxjs/OuterSubscriber"),l=require("rxjs/util/subscribeToResult");e.retryWhen=r;var p=function(){function e(e,t){this.notifier=e,this.source=t}return e.prototype.call=function(e){return new b(e,this.notifier,this.source)},e}(),b=function(e){function t(t,r,s){e.call(this,t),this.notifier=r,this.source=s}return o(t,e),t.prototype.error=function(t){if(!this.isStopped){var r=this.errors,s=this.retries,i=this.retriesSubscription;if(s)this.errors=null,this.retriesSubscription=null;else{if(r=new n.Subject,s=a.tryCatch(this.notifier)(r),s===u.errorObject)return e.prototype.error.call(this,u.errorObject.e);i=l.subscribeToResult(this,s)}this.unsubscribe(),this.isUnsubscribed=!1,this.errors=r,this.retries=s,this.retriesSubscription=i,r.next(t)}},t.prototype._unsubscribe=function(){var e=this,t=e.errors,r=e.retriesSubscription;t&&(t.unsubscribe(),this.errors=null),r&&(r.unsubscribe(),this.retriesSubscription=null),this.retries=null},t.prototype.notifyNext=function(e,t,r,s,i){var o=this,n=o.errors,a=o.retries,u=o.retriesSubscription;this.errors=null,this.retries=null,this.retriesSubscription=null,this.unsubscribe(),this.isStopped=!1,this.isUnsubscribed=!1,this.errors=n,this.retries=a,this.retriesSubscription=u,this.source.subscribe(this)},t}(c.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/operator/sample",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e){return this.lift(new u(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e.sample=r;var u=function(){function e(e){this.notifier=e}return e.prototype.call=function(e){return new c(e,this.notifier)},e}(),c=function(e){function t(t,r){e.call(this,t),this.hasValue=!1,this.add(a.subscribeToResult(this,r))}return o(t,e),t.prototype._next=function(e){this.value=e,this.hasValue=!0},t.prototype.notifyNext=function(e,t,r,s,i){this.emitValue()},t.prototype.notifyComplete=function(){this.emitValue()},t.prototype.emitValue=function(){this.hasValue&&(this.hasValue=!1,this.destination.next(this.value))},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/operator/sampleTime",["rxjs/Subscriber","rxjs/scheduler/asap"],!0,function(require,e,t){function r(e,t){return void 0===t&&(t=u.asap),this.lift(new c(e,t))}function s(e){var t=e.subscriber,r=e.delay;t.notifyNext(),this.schedule(e,r)}var i=System.global,o=i.define;i.define=void 0;var n=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},a=require("rxjs/Subscriber"),u=require("rxjs/scheduler/asap");e.sampleTime=r;var c=function(){function e(e,t){ +this.delay=e,this.scheduler=t}return e.prototype.call=function(e){return new l(e,this.delay,this.scheduler)},e}(),l=function(e){function t(t,r,i){e.call(this,t),this.delay=r,this.scheduler=i,this.hasValue=!1,this.add(i.schedule(s,r,{subscriber:this,delay:r}))}return n(t,e),t.prototype._next=function(e){this.lastValue=e,this.hasValue=!0},t.prototype.notifyNext=function(){this.hasValue&&(this.hasValue=!1,this.destination.next(this.lastValue))},t}(a.Subscriber);return i.define=o,t.exports}),System.register("rxjs/operator/scan",["rxjs/Subscriber"],!0,function(require,e,t){function r(e,t){return this.lift(new a(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.scan=r;var a=function(){function e(e,t){this.accumulator=e,this.seed=t}return e.prototype.call=function(e){return new u(e,this.accumulator,this.seed)},e}(),u=function(e){function t(t,r,s){e.call(this,t),this.accumulator=r,this.accumulatorSet=!1,this.seed=s,this.accumulator=r,this.accumulatorSet="undefined"!=typeof s}return o(t,e),Object.defineProperty(t.prototype,"seed",{get:function(){return this._seed},set:function(e){this.accumulatorSet=!0,this._seed=e},enumerable:!0,configurable:!0}),t.prototype._next=function(e){return this.accumulatorSet?this._tryNext(e):(this.seed=e,void this.destination.next(e))},t.prototype._tryNext=function(e){var t;try{t=this.accumulator(this.seed,e)}catch(r){this.destination.error(r)}this.seed=t,this.destination.next(t)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/share",["rxjs/operator/multicast","rxjs/Subject"],!0,function(require,e,t){function r(){return new a.Subject}function s(){return n.multicast.call(this,r).refCount()}var i=System.global,o=i.define;i.define=void 0;var n=require("rxjs/operator/multicast"),a=require("rxjs/Subject");return e.share=s,i.define=o,t.exports}),System.register("rxjs/operator/single",["rxjs/Subscriber","rxjs/util/EmptyError"],!0,function(require,e,t){function r(e){return this.lift(new u(e,this))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/util/EmptyError");e.single=r;var u=function(){function e(e,t){this.predicate=e,this.source=t}return e.prototype.call=function(e){return new c(e,this.predicate,this.source)},e}(),c=function(e){function t(t,r,s){e.call(this,t),this.predicate=r,this.source=s,this.seenValue=!1,this.index=0}return o(t,e),t.prototype.applySingleValue=function(e){this.seenValue?this.destination.error("Sequence contains more than one element"):(this.seenValue=!0,this.singleValue=e)},t.prototype._next=function(e){var t=this.predicate;this.index++,t?this.tryNext(e):this.applySingleValue(e)},t.prototype.tryNext=function(e){try{var t=this.predicate(e,this.index,this.source);t&&this.applySingleValue(e)}catch(r){this.destination.error(r)}},t.prototype._complete=function(){var e=this.destination;this.index>0?(e.next(this.seenValue?this.singleValue:void 0),e.complete()):e.error(new a.EmptyError)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/skip",["rxjs/Subscriber"],!0,function(require,e,t){function r(e){return this.lift(new a(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.skip=r;var a=function(){function e(e){this.total=e}return e.prototype.call=function(e){return new u(e,this.total)},e}(),u=function(e){function t(t,r){e.call(this,t),this.total=r,this.count=0}return o(t,e),t.prototype._next=function(e){++this.count>this.total&&this.destination.next(e)},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/skipUntil",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e){return this.lift(new u(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e.skipUntil=r;var u=function(){function e(e){this.notifier=e}return e.prototype.call=function(e){return new c(e,this.notifier)},e}(),c=function(e){function t(t,r){e.call(this,t),this.hasValue=!1,this.isInnerStopped=!1,this.add(a.subscribeToResult(this,r))}return o(t,e),t.prototype._next=function(t){this.hasValue&&e.prototype._next.call(this,t)},t.prototype._complete=function(){this.isInnerStopped?e.prototype._complete.call(this):this.unsubscribe()},t.prototype.notifyNext=function(e,t,r,s,i){this.hasValue=!0},t.prototype.notifyComplete=function(){this.isInnerStopped=!0,this.isStopped&&e.prototype._complete.call(this)},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/operator/skipWhile",["rxjs/Subscriber"],!0,function(require,e,t){function r(e){return this.lift(new a(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber");e.skipWhile=r;var a=function(){function e(e){this.predicate=e}return e.prototype.call=function(e){return new u(e,this.predicate)},e}(),u=function(e){function t(t,r){e.call(this,t),this.predicate=r,this.skipping=!0,this.index=0}return o(t,e),t.prototype._next=function(e){var t=this.destination;this.skipping&&this.tryCallPredicate(e),this.skipping||t.next(e)},t.prototype.tryCallPredicate=function(e){try{var t=this.predicate(e,this.index++);this.skipping=Boolean(t)}catch(r){this.destination.error(r)}},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/startWith",["rxjs/observable/ArrayObservable","rxjs/observable/ScalarObservable","rxjs/observable/EmptyObservable","rxjs/operator/concat","rxjs/util/isScheduler"],!0,function(require,e,t){function r(){for(var e=[],t=0;t1?u.concatStatic(new o.ArrayObservable(e,r),this):u.concatStatic(new a.EmptyObservable(r),this)}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/observable/ArrayObservable"),n=require("rxjs/observable/ScalarObservable"),a=require("rxjs/observable/EmptyObservable"),u=require("rxjs/operator/concat"),c=require("rxjs/util/isScheduler");return e.startWith=r,s.define=i,t.exports}),System.register("rxjs/observable/SubscribeOnObservable",["rxjs/Observable","rxjs/scheduler/asap","rxjs/util/isNumeric"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Observable"),n=require("rxjs/scheduler/asap"),a=require("rxjs/util/isNumeric"),u=function(e){function t(t,r,s){void 0===r&&(r=0),void 0===s&&(s=n.asap),e.call(this),this.source=t,this.delayTime=r,this.scheduler=s,(!a.isNumeric(r)||0>r)&&(this.delayTime=0),s&&"function"==typeof s.schedule||(this.scheduler=n.asap)}return i(t,e),t.create=function(e,r,s){return void 0===r&&(r=0),void 0===s&&(s=n.asap),new t(e,r,s)},t.dispatch=function(e){var t=e.source,r=e.subscriber;return t.subscribe(r)},t.prototype._subscribe=function(e){var r=this.delayTime,s=this.source,i=this.scheduler;return i.schedule(t.dispatch,r,{source:s,subscriber:e})},t}(o.Observable);return e.SubscribeOnObservable=u,r.define=s,t.exports}),System.register("rxjs/operator/switch",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(){return this.lift(new u)}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e._switch=r;var u=function(){function e(){}return e.prototype.call=function(e){return new c(e)},e}(),c=function(e){function t(t){e.call(this,t),this.active=0,this.hasCompleted=!1}return o(t,e),t.prototype._next=function(e){this.unsubscribeInner(),this.active++,this.add(this.innerSubscription=a.subscribeToResult(this,e))},t.prototype._complete=function(){this.hasCompleted=!0,0===this.active&&this.destination.complete()},t.prototype.unsubscribeInner=function(){this.active=this.active>0?this.active-1:0;var e=this.innerSubscription;e&&(e.unsubscribe(),this.remove(e))},t.prototype.notifyNext=function(e,t,r,s,i){this.destination.next(t)},t.prototype.notifyError=function(e){this.destination.error(e)},t.prototype.notifyComplete=function(){this.unsubscribeInner(),this.hasCompleted&&0===this.active&&this.destination.complete()},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/operator/switchMap",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e,t){return this.lift(new u(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e.switchMap=r;var u=function(){function e(e,t){this.project=e,this.resultSelector=t}return e.prototype.call=function(e){return new c(e,this.project,this.resultSelector)},e}(),c=function(e){function t(t,r,s){e.call(this,t),this.project=r,this.resultSelector=s,this.index=0}return o(t,e),t.prototype._next=function(e){var t,r=this.index++;try{t=this.project(e,r)}catch(s){return void this.destination.error(s)}this._innerSub(t,e,r)},t.prototype._innerSub=function(e,t,r){var s=this.innerSubscription;s&&s.unsubscribe(),this.add(this.innerSubscription=a.subscribeToResult(this,e,t,r))},t.prototype._complete=function(){var t=this.innerSubscription;(!t||t.isUnsubscribed)&&e.prototype._complete.call(this)},t.prototype._unsubscribe=function(){this.innerSubscription=null},t.prototype.notifyComplete=function(t){this.remove(t),this.innerSubscription=null,this.isStopped&&e.prototype._complete.call(this)},t.prototype.notifyNext=function(e,t,r,s,i){this.resultSelector?this._tryNotifyNext(e,t,r,s):this.destination.next(t)},t.prototype._tryNotifyNext=function(e,t,r,s){var i;try{i=this.resultSelector(e,t,r,s)}catch(o){return void this.destination.error(o)}this.destination.next(i)},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/operator/switchMapTo",["rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e,t){return this.lift(new u(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/OuterSubscriber"),a=require("rxjs/util/subscribeToResult");e.switchMapTo=r;var u=function(){function e(e,t){this.observable=e,this.resultSelector=t}return e.prototype.call=function(e){return new c(e,this.observable,this.resultSelector)},e}(),c=function(e){function t(t,r,s){e.call(this,t),this.inner=r,this.resultSelector=s,this.index=0}return o(t,e),t.prototype._next=function(e){var t=this.innerSubscription;t&&t.unsubscribe(),this.add(this.innerSubscription=a.subscribeToResult(this,this.inner,e,this.index++))},t.prototype._complete=function(){var t=this.innerSubscription;(!t||t.isUnsubscribed)&&e.prototype._complete.call(this)},t.prototype._unsubscribe=function(){this.innerSubscription=null},t.prototype.notifyComplete=function(t){this.remove(t),this.innerSubscription=null,this.isStopped&&e.prototype._complete.call(this)},t.prototype.notifyNext=function(e,t,r,s,i){var o=this,n=o.resultSelector,a=o.destination;n?this.tryResultSelector(e,t,r,s):a.next(t)},t.prototype.tryResultSelector=function(e,t,r,s){var i,o=this,n=o.resultSelector,a=o.destination;try{i=n(e,t,r,s)}catch(u){return void a.error(u)}a.next(i)},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/util/ArgumentOutOfRangeError",[],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=function(e){function t(){e.call(this,"argument out of range"),this.name="ArgumentOutOfRangeError"}return i(t,e),t}(Error);return e.ArgumentOutOfRangeError=o,r.define=s,t.exports}),System.register("rxjs/operator/takeLast",["rxjs/Subscriber","rxjs/util/ArgumentOutOfRangeError","rxjs/observable/EmptyObservable"],!0,function(require,e,t){function r(e){return 0===e?new u.EmptyObservable:this.lift(new c(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/util/ArgumentOutOfRangeError"),u=require("rxjs/observable/EmptyObservable");e.takeLast=r;var c=function(){function e(e){if(this.total=e,this.total<0)throw new a.ArgumentOutOfRangeError}return e.prototype.call=function(e){return new l(e,this.total)},e}(),l=function(e){function t(t,r){e.call(this,t),this.total=r,this.count=0,this.index=0,this.ring=new Array(r)}return o(t,e),t.prototype._next=function(e){var t=this.index,r=this.ring,s=this.total,i=this.count;s>1?s>i?(this.count=i+1,this.index=t+1):0===t?this.index=++t:s>t?this.index=t+1:this.index=t=0:s>i&&(this.count=s),r[t]=e},t.prototype._complete=function(){for(var e=-1,t=this,r=t.ring,s=t.count,i=t.total,o=t.destination,n=1===i||i>s?0:this.index-1;++e0?this.startWindowEvery:this.windowSize,r=this.destination,s=this.windowSize,i=this.windows,o=i.length,n=0;o>n;n++)i[n].next(e);var u=this.count-s+1;if(u>=0&&u%t===0&&i.shift().complete(),++this.count%t===0){var c=new a.Subject;i.push(c),r.add(c),r.next(c)}},t.prototype._error=function(e){for(var t=this.windows;t.length>0;)t.shift().error(e);this.destination.error(e)},t.prototype._complete=function(){for(var e=this.windows;e.length>0;)e.shift().complete();this.destination.complete()},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/operator/windowTime",["rxjs/Subscriber","rxjs/Subject","rxjs/scheduler/asap"],!0,function(require,e,t){function r(e,t,r){return void 0===t&&(t=null),void 0===r&&(r=p.asap),this.lift(new b(e,t,r))}function s(e){var t=e.subscriber,r=e.windowTimeSpan,s=e.window;s&&s.complete(),e.window=t.openWindow(),this.schedule(e,r)}function i(e){var t=e.windowTimeSpan,r=e.subscriber,s=e.scheduler,i=e.windowCreationInterval,n=r.openWindow(),a=this,u={action:a,subscription:null},c={subscriber:r,window:n,context:u};u.subscription=s.schedule(o,t,c),a.add(u.subscription),a.schedule(e,i)}function o(e){var t=e.subscriber,r=e.window,s=e.context;s&&s.action&&s.subscription&&s.action.remove(s.subscription),t.closeWindow(r)}var n=System.global,a=n.define;n.define=void 0;var u=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},c=require("rxjs/Subscriber"),l=require("rxjs/Subject"),p=require("rxjs/scheduler/asap");e.windowTime=r;var b=function(){function e(e,t,r){this.windowTimeSpan=e,this.windowCreationInterval=t,this.scheduler=r}return e.prototype.call=function(e){return new h(e,this.windowTimeSpan,this.windowCreationInterval,this.scheduler)},e}(),h=function(e){function t(t,r,n,a){if(e.call(this,t),this.destination=t,this.windowTimeSpan=r,this.windowCreationInterval=n,this.scheduler=a,this.windows=[],null!==n&&n>=0){var u=this.openWindow(),c={subscriber:this,window:u,context:null},l={windowTimeSpan:r,windowCreationInterval:n,subscriber:this,scheduler:a};this.add(a.schedule(o,r,c)),this.add(a.schedule(i,n,l))}else{var p=this.openWindow(),b={subscriber:this,window:p,windowTimeSpan:r};this.add(a.schedule(s,r,b))}}return u(t,e),t.prototype._next=function(e){for(var t=this.windows,r=t.length,s=0;r>s;s++){var i=t[s];i.isUnsubscribed||i.next(e)}},t.prototype._error=function(e){for(var t=this.windows;t.length>0;)t.shift().error(e);this.destination.error(e)},t.prototype._complete=function(){for(var e=this.windows;e.length>0;){var t=e.shift();t.isUnsubscribed||t.complete()}this.destination.complete()},t.prototype.openWindow=function(){var e=new l.Subject;this.windows.push(e);var t=this.destination;return t.add(e),t.next(e),e},t.prototype.closeWindow=function(e){e.complete();var t=this.windows;t.splice(t.indexOf(e),1)},t}(c.Subscriber);return n.define=a,t.exports}),System.register("rxjs/operator/windowToggle",["rxjs/Subject","rxjs/Subscription","rxjs/util/tryCatch","rxjs/util/errorObject","rxjs/OuterSubscriber","rxjs/util/subscribeToResult"],!0,function(require,e,t){function r(e,t){return this.lift(new b(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subject"),a=require("rxjs/Subscription"),u=require("rxjs/util/tryCatch"),c=require("rxjs/util/errorObject"),l=require("rxjs/OuterSubscriber"),p=require("rxjs/util/subscribeToResult");e.windowToggle=r;var b=function(){function e(e,t){this.openings=e,this.closingSelector=t}return e.prototype.call=function(e){return new h(e,this.openings,this.closingSelector)},e}(),h=function(e){function t(t,r,s){e.call(this,t),this.openings=r,this.closingSelector=s,this.contexts=[],this.add(this.openSubscription=p.subscribeToResult(this,r,r))}return o(t,e),t.prototype._next=function(e){var t=this.contexts;if(t)for(var r=t.length,s=0;r>s;s++)t[s].window.next(e)},t.prototype._error=function(t){var r=this.contexts;if(this.contexts=null,r)for(var s=r.length,i=-1;++io;o++)this.toRespond.push(o);for(var o=0;i>o;o++){var n=r[o];this.add(a.subscribeToResult(this,n,n,o))}}return o(t,e),t.prototype.notifyNext=function(e,t,r,s,i){this.values[r]=t;var o=this.toRespond;if(o.length>0){var n=o.indexOf(r);-1!==n&&o.splice(n,1)}},t.prototype.notifyComplete=function(){},t.prototype._next=function(e){if(0===this.toRespond.length){var t=[e].concat(this.values);this.project?this._tryProject(t):this.destination.next(t)}},t.prototype._tryProject=function(e){var t;try{t=this.project.apply(this,e)}catch(r){return void this.destination.error(r)}this.destination.next(t)},t}(n.OuterSubscriber);return s.define=i,t.exports}),System.register("rxjs/add/operator/zip",["rxjs/Observable","rxjs/operator/zip"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/zip");return i.Observable.prototype.zip=o.zipProto,r.define=s,t.exports}),System.register("rxjs/operator/zipAll",["rxjs/operator/zip"],!0,function(require,e,t){function r(e){return this.lift(new o.ZipOperator(e))}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/operator/zip");return e.zipAll=r,s.define=i,t.exports}),System.register("rxjs/util/tryCatch",["rxjs/util/errorObject"],!0,function(require,e,t){function r(){try{return n.apply(this,arguments)}catch(e){return a.errorObject.e=e,a.errorObject}}function s(e){return n=e,r}var i=System.global,o=i.define;i.define=void 0;var n,a=require("rxjs/util/errorObject");return e.tryCatch=s,i.define=o,t.exports}),System.register("rxjs/observable/ArrayObservable",["rxjs/Observable","rxjs/observable/ScalarObservable","rxjs/observable/EmptyObservable","rxjs/util/isScheduler"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Observable"),n=require("rxjs/observable/ScalarObservable"),a=require("rxjs/observable/EmptyObservable"),u=require("rxjs/util/isScheduler"),c=function(e){function t(t,r){e.call(this),this.array=t,this.scheduler=r,r||1!==t.length||(this._isScalar=!0,this.value=t[0])}return i(t,e),t.create=function(e,r){return new t(e,r)},t.of=function(){for(var e=[],r=0;r1?new t(e,s):1===i?new n.ScalarObservable(e[0],s):new a.EmptyObservable(s)},t.dispatch=function(e){var t=e.array,r=e.index,s=e.count,i=e.subscriber;return r>=s?void i.complete():(i.next(t[r]),void(i.isUnsubscribed||(e.index=r+1,this.schedule(e))))},t.prototype._subscribe=function(e){var r=0,s=this.array,i=s.length,o=this.scheduler;if(o)return o.schedule(t.dispatch,0,{array:s,index:r,count:i,subscriber:e});for(var n=0;i>n&&!e.isUnsubscribed;n++)e.next(s[n]);e.complete()},t}(o.Observable);return e.ArrayObservable=c,r.define=s,t.exports}),System.register("rxjs/util/subscribeToResult",["rxjs/util/root","rxjs/util/isArray","rxjs/util/isPromise","rxjs/Observable","rxjs/util/SymbolShim","rxjs/InnerSubscriber"],!0,function(require,e,t){function r(e,t,r,s){var i=new l.InnerSubscriber(e,r,s);if(!i.isUnsubscribed){if(t instanceof u.Observable)return t._isScalar?(i.next(t.value),void i.complete()):t.subscribe(i);if(n.isArray(t)){for(var p=0,b=t.length;b>p&&!i.isUnsubscribed;p++)i.next(t[p]);i.isUnsubscribed||i.complete()}else{if(a.isPromise(t))return t.then(function(e){i.isUnsubscribed||(i.next(e),i.complete())},function(e){return i.error(e)}).then(null,function(e){o.root.setTimeout(function(){throw e})}),i;if("function"==typeof t[c.SymbolShim.iterator]){for(var h=0,f=t;hr;r++)t.push(null);return t}var i=System.global,o=i.define;i.define=void 0;var n=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},a=require("rxjs/Observable"),u=require("rxjs/Subscriber"),c=require("rxjs/observable/PromiseObservable"),l=require("rxjs/observable/EmptyObservable"),p=require("rxjs/util/isPromise"),b=require("rxjs/util/isArray"),h=function(e){function t(t,r){e.call(this),this.sources=t,this.resultSelector=r}return n(t,e),t.create=function(){for(var e=[],r=0;ro;o++){var n=t[o];p.isPromise(n)&&(n=new c.PromiseObservable(n)),n.subscribe(new f(e,o,i))}},t}(a.Observable);e.ForkJoinObservable=h;var f=function(e){function t(t,r,s){e.call(this,t),this.index=r,this.context=s,this._value=null}return n(t,e),t.prototype._next=function(e){this._value=e},t.prototype._complete=function(){var e=this.destination;null==this._value&&e.complete();var t=this.context;t.completed++,t.values[this.index]=this._value;var s=t.values;if(t.completed===s.length){if(s.every(r)){var i=t.selector?t.selector.apply(this,s):s;e.next(i)}e.complete()}},t}(u.Subscriber);return i.define=o,t.exports}),System.register("rxjs/operator/observeOn",["rxjs/Subscriber","rxjs/Notification"],!0,function(require,e,t){function r(e,t){return void 0===t&&(t=0),this.lift(new u(e,t))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/Notification");e.observeOn=r;var u=function(){function e(e,t){void 0===t&&(t=0),this.scheduler=e,this.delay=t}return e.prototype.call=function(e){return new c(e,this.scheduler,this.delay)},e}();e.ObserveOnOperator=u;var c=function(e){function t(t,r,s){void 0===s&&(s=0),e.call(this,t),this.scheduler=r,this.delay=s}return o(t,e),t.dispatch=function(e){var t=e.notification,r=e.destination;t.observe(r)},t.prototype.scheduleMessage=function(e){this.add(this.scheduler.schedule(t.dispatch,this.delay,new l(e,this.destination)))},t.prototype._next=function(e){this.scheduleMessage(a.Notification.createNext(e))},t.prototype._error=function(e){this.scheduleMessage(a.Notification.createError(e))},t.prototype._complete=function(){this.scheduleMessage(a.Notification.createComplete())},t}(n.Subscriber);e.ObserveOnSubscriber=c;var l=function(){function e(e,t){this.notification=e,this.destination=t}return e}();return s.define=i,t.exports}),System.register("rxjs/add/observable/fromEvent",["rxjs/Observable","rxjs/observable/FromEventObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/FromEventObservable");return i.Observable.fromEvent=o.FromEventObservable.create,r.define=s,t.exports}),System.register("rxjs/add/observable/fromEventPattern",["rxjs/Observable","rxjs/observable/FromEventPatternObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/FromEventPatternObservable");return i.Observable.fromEventPattern=o.FromEventPatternObservable.create,r.define=s,t.exports}),System.register("rxjs/scheduler/AsapAction",["rxjs/util/Immediate","rxjs/scheduler/FutureAction"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/util/Immediate"),n=require("rxjs/scheduler/FutureAction"),a=function(e){function t(){e.apply(this,arguments)}return i(t,e),t.prototype._schedule=function(t,r){if(void 0===r&&(r=0),r>0)return e.prototype._schedule.call(this,t,r);this.delay=r,this.state=t;var s=this.scheduler;return s.actions.push(this),s.scheduledId||(s.scheduledId=o.Immediate.setImmediate(function(){s.scheduledId=null,s.flush()})),this},t.prototype._unsubscribe=function(){var t=this.scheduler,r=t.scheduledId,s=t.actions;e.prototype._unsubscribe.call(this),0===s.length&&(t.active=!1,null!=r&&(t.scheduledId=null,o.Immediate.clearImmediate(r)))},t}(n.FutureAction);return e.AsapAction=a,r.define=s,t.exports}),System.register("rxjs/scheduler/QueueScheduler",["rxjs/scheduler/QueueAction","rxjs/scheduler/FutureAction"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/scheduler/QueueAction"),o=require("rxjs/scheduler/FutureAction"),n=function(){function e(){this.active=!1,this.actions=[],this.scheduledId=null}return e.prototype.now=function(){return Date.now()},e.prototype.flush=function(){if(!this.active&&!this.scheduledId){this.active=!0;for(var e=this.actions,t=void 0;t=e.shift();)t.execute();this.active=!1}},e.prototype.schedule=function(e,t,r){return void 0===t&&(t=0),0>=t?this.scheduleNow(e,r):this.scheduleLater(e,t,r)},e.prototype.scheduleNow=function(e,t){return new i.QueueAction(this,e).schedule(t)},e.prototype.scheduleLater=function(e,t,r){return new o.FutureAction(this,e).schedule(r,t)},e}();return e.QueueScheduler=n,r.define=s,t.exports}),System.register("rxjs/observable/NeverObservable",["rxjs/Observable","rxjs/util/noop"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Observable"),n=require("rxjs/util/noop"),a=function(e){function t(){e.call(this)}return i(t,e),t.create=function(){return new t},t.prototype._subscribe=function(e){n.noop()},t}(o.Observable);return e.NeverObservable=a,r.define=s,t.exports}),System.register("rxjs/add/observable/range",["rxjs/Observable","rxjs/observable/RangeObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/RangeObservable");return i.Observable.range=o.RangeObservable.create,r.define=s,t.exports}),System.register("rxjs/add/observable/throw",["rxjs/Observable","rxjs/observable/ErrorObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/ErrorObservable");return i.Observable["throw"]=o.ErrorObservable.create,r.define=s,t.exports}),System.register("rxjs/observable/TimerObservable",["rxjs/util/isNumeric","rxjs/Observable","rxjs/scheduler/asap","rxjs/util/isScheduler","rxjs/util/isDate"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/util/isNumeric"),n=require("rxjs/Observable"),a=require("rxjs/scheduler/asap"),u=require("rxjs/util/isScheduler"),c=require("rxjs/util/isDate"),l=function(e){function t(t,r,s){void 0===t&&(t=0),e.call(this),this.period=-1,this.dueTime=0,o.isNumeric(r)?this.period=Number(r)<1&&1||Number(r):u.isScheduler(r)&&(s=r),u.isScheduler(s)||(s=a.asap),this.scheduler=s,this.dueTime=c.isDate(t)?+t-this.scheduler.now():t}return i(t,e),t.create=function(e,r,s){return void 0===e&&(e=0),new t(e,r,s)},t.dispatch=function(e){var t=e.index,r=e.period,s=e.subscriber,i=this;if(s.next(t),!s.isUnsubscribed){if(-1===r)return s.complete();e.index=t+1,i.schedule(e,r)}},t.prototype._subscribe=function(e){var r=0,s=this,i=s.period,o=s.dueTime,n=s.scheduler;return n.schedule(t.dispatch,o,{index:r,period:i,subscriber:e})},t}(n.Observable);return e.TimerObservable=l,r.define=s,t.exports}),System.register("rxjs/add/observable/zip",["rxjs/Observable","rxjs/operator/zip"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/zip");return i.Observable.zip=o.zipStatic,r.define=s,t.exports}),System.register("rxjs/add/operator/buffer",["rxjs/Observable","rxjs/operator/buffer"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/buffer");return i.Observable.prototype.buffer=o.buffer,r.define=s,t.exports}),System.register("rxjs/add/operator/bufferCount",["rxjs/Observable","rxjs/operator/bufferCount"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/bufferCount");return i.Observable.prototype.bufferCount=o.bufferCount,r.define=s,t.exports}),System.register("rxjs/add/operator/bufferTime",["rxjs/Observable","rxjs/operator/bufferTime"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/bufferTime");return i.Observable.prototype.bufferTime=o.bufferTime,r.define=s,t.exports}),System.register("rxjs/add/operator/bufferToggle",["rxjs/Observable","rxjs/operator/bufferToggle"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/bufferToggle");return i.Observable.prototype.bufferToggle=o.bufferToggle,r.define=s,t.exports}),System.register("rxjs/add/operator/bufferWhen",["rxjs/Observable","rxjs/operator/bufferWhen"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/bufferWhen");return i.Observable.prototype.bufferWhen=o.bufferWhen,r.define=s,t.exports}),System.register("rxjs/subject/ReplaySubject",["rxjs/Subject","rxjs/scheduler/queue","rxjs/operator/observeOn"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Subject"),n=require("rxjs/scheduler/queue"),a=require("rxjs/operator/observeOn"),u=function(e){function t(t,r,s){void 0===t&&(t=Number.POSITIVE_INFINITY),void 0===r&&(r=Number.POSITIVE_INFINITY),e.call(this),this.events=[],this.scheduler=s,this.bufferSize=1>t?1:t,this._windowTime=1>r?1:r}return i(t,e),t.prototype._next=function(t){var r=this._getNow();this.events.push(new c(r,t)),this._trimBufferThenGetEvents(r),e.prototype._next.call(this,t)},t.prototype._subscribe=function(t){var r=this._trimBufferThenGetEvents(this._getNow()),s=this.scheduler;s&&t.add(t=new a.ObserveOnSubscriber(t,s));for(var i=-1,o=r.length;++io&&!(e-s[o].timet&&(o=Math.max(o,i-t)),o>0&&s.splice(0,o),s},t}(o.Subject);e.ReplaySubject=u;var c=function(){function e(e,t){this.time=e,this.value=t}return e}();return r.define=s,t.exports}),System.register("rxjs/operator/multicast",["rxjs/observable/ConnectableObservable"],!0,function(require,e,t){function r(e){var t;return t="function"==typeof e?e:function(){return e},new o.ConnectableObservable(this,t)}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/observable/ConnectableObservable");return e.multicast=r,s.define=i,t.exports}),System.register("rxjs/add/operator/catch",["rxjs/Observable","rxjs/operator/catch"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/catch");return i.Observable.prototype["catch"]=o._catch,r.define=s,t.exports}),System.register("rxjs/add/operator/combineAll",["rxjs/Observable","rxjs/operator/combineAll"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/combineAll");return i.Observable.prototype.combineAll=o.combineAll,r.define=s,t.exports}),System.register("rxjs/add/operator/concatAll",["rxjs/Observable","rxjs/operator/concatAll"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/concatAll");return i.Observable.prototype.concatAll=o.concatAll,r.define=s,t.exports}),System.register("rxjs/operator/concatMap",["rxjs/operator/mergeMap"],!0,function(require,e,t){function r(e,t){return this.lift(new o.MergeMapOperator(e,t,1))}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/operator/mergeMap");return e.concatMap=r,s.define=i,t.exports}),System.register("rxjs/operator/concatMapTo",["rxjs/operator/mergeMapTo"],!0,function(require,e,t){function r(e,t){return this.lift(new o.MergeMapToOperator(e,t,1))}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/operator/mergeMapTo");return e.concatMapTo=r,s.define=i,t.exports}),System.register("rxjs/add/operator/count",["rxjs/Observable","rxjs/operator/count"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/count");return i.Observable.prototype.count=o.count,r.define=s,t.exports}),System.register("rxjs/add/operator/dematerialize",["rxjs/Observable","rxjs/operator/dematerialize"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/dematerialize");return i.Observable.prototype.dematerialize=o.dematerialize,r.define=s,t.exports}),System.register("rxjs/add/operator/debounce",["rxjs/Observable","rxjs/operator/debounce"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/debounce");return i.Observable.prototype.debounce=o.debounce,r.define=s,t.exports}),System.register("rxjs/add/operator/debounceTime",["rxjs/Observable","rxjs/operator/debounceTime"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/debounceTime");return i.Observable.prototype.debounceTime=o.debounceTime,r.define=s,t.exports}),System.register("rxjs/add/operator/defaultIfEmpty",["rxjs/Observable","rxjs/operator/defaultIfEmpty"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/defaultIfEmpty");return i.Observable.prototype.defaultIfEmpty=o.defaultIfEmpty,r.define=s,t.exports}),System.register("rxjs/add/operator/delay",["rxjs/Observable","rxjs/operator/delay"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/delay");return i.Observable.prototype.delay=o.delay,r.define=s,t.exports}),System.register("rxjs/add/operator/delayWhen",["rxjs/Observable","rxjs/operator/delayWhen"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/delayWhen");return i.Observable.prototype.delayWhen=o.delayWhen,r.define=s,t.exports}),System.register("rxjs/add/operator/distinctUntilChanged",["rxjs/Observable","rxjs/operator/distinctUntilChanged"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/distinctUntilChanged");return i.Observable.prototype.distinctUntilChanged=o.distinctUntilChanged,r.define=s,t.exports}),System.register("rxjs/add/operator/do",["rxjs/Observable","rxjs/operator/do"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/do");return i.Observable.prototype["do"]=o._do,r.define=s,t.exports}),System.register("rxjs/add/operator/expand",["rxjs/Observable","rxjs/operator/expand"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/expand");return i.Observable.prototype.expand=o.expand,r.define=s,t.exports}),System.register("rxjs/add/operator/filter",["rxjs/Observable","rxjs/operator/filter"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/filter");return i.Observable.prototype.filter=o.filter,r.define=s,t.exports}),System.register("rxjs/add/operator/finally",["rxjs/Observable","rxjs/operator/finally"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/finally");return i.Observable.prototype["finally"]=o._finally,r.define=s,t.exports}),System.register("rxjs/operator/first",["rxjs/Subscriber","rxjs/util/EmptyError"],!0,function(require,e,t){function r(e,t,r){return this.lift(new u(e,t,r,this))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/util/EmptyError");e.first=r;var u=function(){function e(e,t,r,s){this.predicate=e,this.resultSelector=t,this.defaultValue=r,this.source=s}return e.prototype.call=function(e){return new c(e,this.predicate,this.resultSelector,this.defaultValue,this.source)},e}(),c=function(e){function t(t,r,s,i,o){e.call(this,t),this.predicate=r,this.resultSelector=s,this.defaultValue=i,this.source=o,this.index=0,this.hasCompleted=!1}return o(t,e),t.prototype._next=function(e){var t=this.index++;this.predicate?this._tryPredicate(e,t):this._emit(e,t)},t.prototype._tryPredicate=function(e,t){var r;try{r=this.predicate(e,t,this.source)}catch(s){return void this.destination.error(s)}r&&this._emit(e,t)},t.prototype._emit=function(e,t){return this.resultSelector?void this._tryResultSelector(e,t):void this._emitFinal(e)},t.prototype._tryResultSelector=function(e,t){var r;try{r=this.resultSelector(e,t)}catch(s){return void this.destination.error(s)}this._emitFinal(r)},t.prototype._emitFinal=function(e){var t=this.destination;t.next(e),t.complete(),this.hasCompleted=!0},t.prototype._complete=function(){var e=this.destination;this.hasCompleted||"undefined"==typeof this.defaultValue?this.hasCompleted||e.error(new a.EmptyError):(e.next(this.defaultValue),e.complete())},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/util/Map",["rxjs/util/root","rxjs/util/MapPolyfill"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/util/root"),o=require("rxjs/util/MapPolyfill");return e.Map=i.root.Map||function(){return o.MapPolyfill}(),r.define=s,t.exports}),System.register("rxjs/add/operator/ignoreElements",["rxjs/Observable","rxjs/operator/ignoreElements"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/ignoreElements");return i.Observable.prototype.ignoreElements=o.ignoreElements,r.define=s,t.exports}),System.register("rxjs/add/operator/inspect",["rxjs/Observable","rxjs/operator/inspect"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/inspect");return i.Observable.prototype.inspect=o.inspect,r.define=s,t.exports}),System.register("rxjs/add/operator/inspectTime",["rxjs/Observable","rxjs/operator/inspectTime"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/inspectTime"); +return i.Observable.prototype.inspectTime=o.inspectTime,r.define=s,t.exports}),System.register("rxjs/add/operator/every",["rxjs/Observable","rxjs/operator/every"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/every");return i.Observable.prototype.every=o.every,r.define=s,t.exports}),System.register("rxjs/add/operator/last",["rxjs/Observable","rxjs/operator/last"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/last");return i.Observable.prototype.last=o.last,r.define=s,t.exports}),System.register("rxjs/add/operator/let",["rxjs/Observable","rxjs/operator/let"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/let");return i.Observable.prototype.let=o.letProto,i.Observable.prototype.letBind=o.letProto,r.define=s,t.exports}),System.register("rxjs/add/operator/map",["rxjs/Observable","rxjs/operator/map"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/map");return i.Observable.prototype.map=o.map,r.define=s,t.exports}),System.register("rxjs/add/operator/mapTo",["rxjs/Observable","rxjs/operator/mapTo"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/mapTo");return i.Observable.prototype.mapTo=o.mapTo,r.define=s,t.exports}),System.register("rxjs/add/operator/materialize",["rxjs/Observable","rxjs/operator/materialize"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/materialize");return i.Observable.prototype.materialize=o.materialize,r.define=s,t.exports}),System.register("rxjs/operator/partition",["rxjs/util/not","rxjs/operator/filter"],!0,function(require,e,t){function r(e,t){return[n.filter.call(this,e),n.filter.call(this,o.not(e,t))]}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/util/not"),n=require("rxjs/operator/filter");return e.partition=r,s.define=i,t.exports}),System.register("rxjs/add/operator/pluck",["rxjs/Observable","rxjs/operator/pluck"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/pluck");return i.Observable.prototype.pluck=o.pluck,r.define=s,t.exports}),System.register("rxjs/add/operator/publish",["rxjs/Observable","rxjs/operator/publish"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/publish");return i.Observable.prototype.publish=o.publish,r.define=s,t.exports}),System.register("rxjs/operator/publishBehavior",["rxjs/subject/BehaviorSubject","rxjs/operator/multicast"],!0,function(require,e,t){function r(e){return n.multicast.call(this,new o.BehaviorSubject(e))}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/subject/BehaviorSubject"),n=require("rxjs/operator/multicast");return e.publishBehavior=r,s.define=i,t.exports}),System.register("rxjs/add/operator/publishLast",["rxjs/Observable","rxjs/operator/publishLast"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/publishLast");return i.Observable.prototype.publishLast=o.publishLast,r.define=s,t.exports}),System.register("rxjs/add/operator/reduce",["rxjs/Observable","rxjs/operator/reduce"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/reduce");return i.Observable.prototype.reduce=o.reduce,r.define=s,t.exports}),System.register("rxjs/add/operator/repeat",["rxjs/Observable","rxjs/operator/repeat"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/repeat");return i.Observable.prototype.repeat=o.repeat,r.define=s,t.exports}),System.register("rxjs/add/operator/retry",["rxjs/Observable","rxjs/operator/retry"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/retry");return i.Observable.prototype.retry=o.retry,r.define=s,t.exports}),System.register("rxjs/add/operator/retryWhen",["rxjs/Observable","rxjs/operator/retryWhen"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/retryWhen");return i.Observable.prototype.retryWhen=o.retryWhen,r.define=s,t.exports}),System.register("rxjs/add/operator/sample",["rxjs/Observable","rxjs/operator/sample"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/sample");return i.Observable.prototype.sample=o.sample,r.define=s,t.exports}),System.register("rxjs/add/operator/sampleTime",["rxjs/Observable","rxjs/operator/sampleTime"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/sampleTime");return i.Observable.prototype.sampleTime=o.sampleTime,r.define=s,t.exports}),System.register("rxjs/add/operator/scan",["rxjs/Observable","rxjs/operator/scan"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/scan");return i.Observable.prototype.scan=o.scan,r.define=s,t.exports}),System.register("rxjs/add/operator/share",["rxjs/Observable","rxjs/operator/share"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/share");return i.Observable.prototype.share=o.share,r.define=s,t.exports}),System.register("rxjs/add/operator/single",["rxjs/Observable","rxjs/operator/single"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/single");return i.Observable.prototype.single=o.single,r.define=s,t.exports}),System.register("rxjs/add/operator/skip",["rxjs/Observable","rxjs/operator/skip"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/skip");return i.Observable.prototype.skip=o.skip,r.define=s,t.exports}),System.register("rxjs/add/operator/skipUntil",["rxjs/Observable","rxjs/operator/skipUntil"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/skipUntil");return i.Observable.prototype.skipUntil=o.skipUntil,r.define=s,t.exports}),System.register("rxjs/add/operator/skipWhile",["rxjs/Observable","rxjs/operator/skipWhile"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/skipWhile");return i.Observable.prototype.skipWhile=o.skipWhile,r.define=s,t.exports}),System.register("rxjs/add/operator/startWith",["rxjs/Observable","rxjs/operator/startWith"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/startWith");return i.Observable.prototype.startWith=o.startWith,r.define=s,t.exports}),System.register("rxjs/operator/subscribeOn",["rxjs/observable/SubscribeOnObservable"],!0,function(require,e,t){function r(e,t){return void 0===t&&(t=0),new o.SubscribeOnObservable(this,t,e)}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/observable/SubscribeOnObservable");return e.subscribeOn=r,s.define=i,t.exports}),System.register("rxjs/add/operator/switch",["rxjs/Observable","rxjs/operator/switch"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/switch");return i.Observable.prototype["switch"]=o._switch,r.define=s,t.exports}),System.register("rxjs/add/operator/switchMap",["rxjs/Observable","rxjs/operator/switchMap"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/switchMap");return i.Observable.prototype.switchMap=o.switchMap,r.define=s,t.exports}),System.register("rxjs/add/operator/switchMapTo",["rxjs/Observable","rxjs/operator/switchMapTo"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/switchMapTo");return i.Observable.prototype.switchMapTo=o.switchMapTo,r.define=s,t.exports}),System.register("rxjs/operator/take",["rxjs/Subscriber","rxjs/util/ArgumentOutOfRangeError","rxjs/observable/EmptyObservable"],!0,function(require,e,t){function r(e){return 0===e?new u.EmptyObservable:this.lift(new c(e))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/util/ArgumentOutOfRangeError"),u=require("rxjs/observable/EmptyObservable");e.take=r;var c=function(){function e(e){if(this.total=e,this.total<0)throw new a.ArgumentOutOfRangeError}return e.prototype.call=function(e){return new l(e,this.total)},e}(),l=function(e){function t(t,r){e.call(this,t),this.total=r,this.count=0}return o(t,e),t.prototype._next=function(e){var t=this.total;++this.count<=t&&(this.destination.next(e),this.count===t&&this.destination.complete())},t}(n.Subscriber);return s.define=i,t.exports}),System.register("rxjs/add/operator/takeLast",["rxjs/Observable","rxjs/operator/takeLast"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/takeLast");return i.Observable.prototype.takeLast=o.takeLast,r.define=s,t.exports}),System.register("rxjs/add/operator/takeUntil",["rxjs/Observable","rxjs/operator/takeUntil"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/takeUntil");return i.Observable.prototype.takeUntil=o.takeUntil,r.define=s,t.exports}),System.register("rxjs/add/operator/takeWhile",["rxjs/Observable","rxjs/operator/takeWhile"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/takeWhile");return i.Observable.prototype.takeWhile=o.takeWhile,r.define=s,t.exports}),System.register("rxjs/add/operator/throttle",["rxjs/Observable","rxjs/operator/throttle"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/throttle");return i.Observable.prototype.throttle=o.throttle,r.define=s,t.exports}),System.register("rxjs/add/operator/throttleTime",["rxjs/Observable","rxjs/operator/throttleTime"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/throttleTime");return i.Observable.prototype.throttleTime=o.throttleTime,r.define=s,t.exports}),System.register("rxjs/add/operator/timeout",["rxjs/Observable","rxjs/operator/timeout"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/timeout");return i.Observable.prototype.timeout=o.timeout,r.define=s,t.exports}),System.register("rxjs/add/operator/timeoutWith",["rxjs/Observable","rxjs/operator/timeoutWith"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/timeoutWith");return i.Observable.prototype.timeoutWith=o.timeoutWith,r.define=s,t.exports}),System.register("rxjs/add/operator/toArray",["rxjs/Observable","rxjs/operator/toArray"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/toArray");return i.Observable.prototype.toArray=o.toArray,r.define=s,t.exports}),System.register("rxjs/add/operator/toPromise",["rxjs/Observable","rxjs/operator/toPromise"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/toPromise");return i.Observable.prototype.toPromise=o.toPromise,r.define=s,t.exports}),System.register("rxjs/add/operator/window",["rxjs/Observable","rxjs/operator/window"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/window");return i.Observable.prototype.window=o.window,r.define=s,t.exports}),System.register("rxjs/add/operator/windowCount",["rxjs/Observable","rxjs/operator/windowCount"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/windowCount");return i.Observable.prototype.windowCount=o.windowCount,r.define=s,t.exports}),System.register("rxjs/add/operator/windowTime",["rxjs/Observable","rxjs/operator/windowTime"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/windowTime");return i.Observable.prototype.windowTime=o.windowTime,r.define=s,t.exports}),System.register("rxjs/add/operator/windowToggle",["rxjs/Observable","rxjs/operator/windowToggle"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/windowToggle");return i.Observable.prototype.windowToggle=o.windowToggle,r.define=s,t.exports}),System.register("rxjs/add/operator/windowWhen",["rxjs/Observable","rxjs/operator/windowWhen"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/windowWhen");return i.Observable.prototype.windowWhen=o.windowWhen,r.define=s,t.exports}),System.register("rxjs/add/operator/withLatestFrom",["rxjs/Observable","rxjs/operator/withLatestFrom"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/withLatestFrom");return i.Observable.prototype.withLatestFrom=o.withLatestFrom,r.define=s,t.exports}),System.register("rxjs/add/operator/zipAll",["rxjs/Observable","rxjs/operator/zipAll"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/zipAll");return i.Observable.prototype.zipAll=o.zipAll,r.define=s,t.exports}),System.register("rxjs/Subscription",["rxjs/util/isArray","rxjs/util/isObject","rxjs/util/isFunction","rxjs/util/tryCatch","rxjs/util/errorObject"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/util/isArray"),n=require("rxjs/util/isObject"),a=require("rxjs/util/isFunction"),u=require("rxjs/util/tryCatch"),c=require("rxjs/util/errorObject"),l=function(){function e(e){this.isUnsubscribed=!1,e&&(this._unsubscribe=e)}return e.prototype.unsubscribe=function(){var e,t=!1;if(!this.isUnsubscribed){this.isUnsubscribed=!0;var r=this,s=r._unsubscribe,i=r._subscriptions;if(this._subscriptions=null,a.isFunction(s)){var l=u.tryCatch(s).call(this);l===c.errorObject&&(t=!0,(e=e||[]).push(c.errorObject.e))}if(o.isArray(i))for(var b=-1,h=i.length;++br;r++){var s=e[r];this.add(p.subscribeToResult(this,s,s,r))}}},t.prototype.notifyComplete=function(e){0===(this.active-=1)&&this.destination.complete()},t.prototype.notifyNext=function(e,t,r,s,i){var o=this.values;o[r]=t;var n=this.toRespond;if(n.length>0){var a=n.indexOf(r);-1!==a&&n.splice(a,1)}0===n.length&&(this.project?this._tryProject(o):this.destination.next(o))},t.prototype._tryProject=function(e){var t;try{t=this.project.apply(this,e)}catch(r){return void this.destination.error(r)}this.destination.next(t)},t}(l.OuterSubscriber);return e.CombineLatestSubscriber=h,i.define=o,t.exports}),System.register("rxjs/add/observable/concat",["rxjs/Observable","rxjs/operator/concat"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/concat");return i.Observable.concat=o.concatStatic,r.define=s,t.exports}),System.register("rxjs/add/observable/bindCallback",["rxjs/Observable","rxjs/observable/BoundCallbackObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/BoundCallbackObservable");return i.Observable.bindCallback=o.BoundCallbackObservable.create,r.define=s,t.exports}),System.register("rxjs/add/observable/forkJoin",["rxjs/Observable","rxjs/observable/ForkJoinObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/ForkJoinObservable");return i.Observable.forkJoin=o.ForkJoinObservable.create,r.define=s,t.exports}),System.register("rxjs/observable/FromObservable",["rxjs/util/isArray","rxjs/util/isFunction","rxjs/util/isPromise","rxjs/util/isScheduler","rxjs/observable/PromiseObservable","rxjs/observable/IteratorObservable","rxjs/observable/ArrayObservable","rxjs/observable/ArrayLikeObservable","rxjs/util/SymbolShim","rxjs/Observable","rxjs/operator/observeOn"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/util/isArray"),n=require("rxjs/util/isFunction"),a=require("rxjs/util/isPromise"),u=require("rxjs/util/isScheduler"),c=require("rxjs/observable/PromiseObservable"),l=require("rxjs/observable/IteratorObservable"),p=require("rxjs/observable/ArrayObservable"),b=require("rxjs/observable/ArrayLikeObservable"),h=require("rxjs/util/SymbolShim"),f=require("rxjs/Observable"),d=require("rxjs/operator/observeOn"),v=function(e){return e&&"number"==typeof e.length},x=function(e){function t(t,r){e.call(this,null),this.ish=t,this.scheduler=r}return i(t,e),t.create=function(e,r,s,i){var d=null,x=null;if(n.isFunction(r)?(d=i||null,x=r):u.isScheduler(d)&&(d=r),null!=e){if("function"==typeof e[h.SymbolShim.observable])return e instanceof f.Observable&&!d?e:new t(e,d);if(o.isArray(e))return new p.ArrayObservable(e,d);if(a.isPromise(e))return new c.PromiseObservable(e,d);if("function"==typeof e[h.SymbolShim.iterator]||"string"==typeof e)return new l.IteratorObservable(e,null,null,d);if(v(e))return new b.ArrayLikeObservable(e,x,s,d)}throw new TypeError((null!==e&&typeof e||e)+" is not observable")},t.prototype._subscribe=function(e){var t=this.ish,r=this.scheduler;return null==r?t[h.SymbolShim.observable]().subscribe(e):t[h.SymbolShim.observable]().subscribe(new d.ObserveOnSubscriber(e,r,0))},t}(f.Observable);return e.FromObservable=x,r.define=s,t.exports}),System.register("rxjs/scheduler/AsapScheduler",["rxjs/scheduler/AsapAction","rxjs/scheduler/QueueScheduler"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/scheduler/AsapAction"),n=require("rxjs/scheduler/QueueScheduler"),a=function(e){function t(){e.apply(this,arguments)}return i(t,e),t.prototype.scheduleNow=function(e,t){return new o.AsapAction(this,e).schedule(t)},t}(n.QueueScheduler);return e.AsapScheduler=a,r.define=s,t.exports}),System.register("rxjs/add/observable/never",["rxjs/Observable","rxjs/observable/NeverObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/NeverObservable");return i.Observable.never=o.NeverObservable.create,r.define=s,t.exports}),System.register("rxjs/add/observable/timer",["rxjs/Observable","rxjs/observable/TimerObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/TimerObservable");return i.Observable.timer=o.TimerObservable.create,r.define=s,t.exports}),System.register("rxjs/operator/publishReplay",["rxjs/subject/ReplaySubject","rxjs/operator/multicast"],!0,function(require,e,t){function r(e,t,r){return void 0===e&&(e=Number.POSITIVE_INFINITY),void 0===t&&(t=Number.POSITIVE_INFINITY),n.multicast.call(this,new o.ReplaySubject(e,t,r))}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/subject/ReplaySubject"),n=require("rxjs/operator/multicast");return e.publishReplay=r,s.define=i,t.exports}),System.register("rxjs/add/operator/concatMap",["rxjs/Observable","rxjs/operator/concatMap"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/concatMap");return i.Observable.prototype.concatMap=o.concatMap,r.define=s,t.exports}),System.register("rxjs/add/operator/concatMapTo",["rxjs/Observable","rxjs/operator/concatMapTo"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/concatMapTo");return i.Observable.prototype.concatMapTo=o.concatMapTo,r.define=s,t.exports}),System.register("rxjs/add/operator/first",["rxjs/Observable","rxjs/operator/first"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/first");return i.Observable.prototype.first=o.first,r.define=s,t.exports}),System.register("rxjs/operator/groupBy",["rxjs/Subscriber","rxjs/Subscription","rxjs/Observable","rxjs/Operator","rxjs/Subject","rxjs/util/Map","rxjs/util/FastMap"],!0,function(require,e,t){function r(e,t,r){return this.lift(new h(this,e,t,r))}var s=System.global,i=s.define;s.define=void 0;var o=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},n=require("rxjs/Subscriber"),a=require("rxjs/Subscription"),u=require("rxjs/Observable"),c=require("rxjs/Operator"),l=require("rxjs/Subject"),p=require("rxjs/util/Map"),b=require("rxjs/util/FastMap");e.groupBy=r;var h=function(e){function t(t,r,s,i){e.call(this),this.source=t,this.keySelector=r,this.elementSelector=s,this.durationSelector=i}return o(t,e),t.prototype.call=function(e){return new f(e,this.keySelector,this.elementSelector,this.durationSelector)},t}(c.Operator),f=function(e){function t(t,r,s,i){e.call(this),this.keySelector=r,this.elementSelector=s,this.durationSelector=i,this.groups=null,this.attemptedToUnsubscribe=!1,this.count=0,this.destination=t,this.add(t)}return o(t,e),t.prototype._next=function(e){var t;try{t=this.keySelector(e)}catch(r){return void this.error(r)}this._group(e,t)},t.prototype._group=function(e,t){var r=this.groups;r||(r=this.groups="string"==typeof t?new b.FastMap:new p.Map);var s=r.get(t);if(!s){r.set(t,s=new l.Subject);var i=new v(t,s,this);this.durationSelector&&this._selectDuration(t,s),this.destination.next(i)}this.elementSelector?this._selectElement(e,s):this.tryGroupNext(e,s)},t.prototype._selectElement=function(e,t){var r;try{r=this.elementSelector(e)}catch(s){return void this.error(s)}this.tryGroupNext(r,t)},t.prototype._selectDuration=function(e,t){var r;try{r=this.durationSelector(new v(e,t))}catch(s){return void this.error(s)}this.add(r.subscribe(new d(e,t,this)))},t.prototype.tryGroupNext=function(e,t){t.isUnsubscribed||t.next(e)},t.prototype._error=function(e){var t=this.groups;t&&(t.forEach(function(t,r){t.error(e)}),t.clear()),this.destination.error(e)},t.prototype._complete=function(){var e=this.groups;e&&(e.forEach(function(e,t){e.complete()}),e.clear()),this.destination.complete()},t.prototype.removeGroup=function(e){this.groups["delete"](e)},t.prototype.unsubscribe=function(){this.isUnsubscribed||this.attemptedToUnsubscribe||(this.attemptedToUnsubscribe=!0,0===this.count&&e.prototype.unsubscribe.call(this))},t}(n.Subscriber),d=function(e){function t(t,r,s){e.call(this),this.key=t,this.group=r,this.parent=s}return o(t,e),t.prototype._next=function(e){this.tryComplete()},t.prototype._error=function(e){this.tryError(e)},t.prototype._complete=function(){this.tryComplete()},t.prototype.tryError=function(e){var t=this.group;t.isUnsubscribed||t.error(e),this.parent.removeGroup(this.key)},t.prototype.tryComplete=function(){var e=this.group;e.isUnsubscribed||e.complete(),this.parent.removeGroup(this.key)},t}(n.Subscriber),v=function(e){function t(t,r,s){e.call(this),this.key=t,this.groupSubject=r,this.refCountSubscription=s}return o(t,e),t.prototype._subscribe=function(e){var t=new a.Subscription,r=this,s=r.refCountSubscription,i=r.groupSubject;return s&&!s.isUnsubscribed&&t.add(new x(s)),t.add(i.subscribe(e)),t},t}(u.Observable);e.GroupedObservable=v;var x=function(e){function t(t){e.call(this),this.parent=t,t.count++}return o(t,e),t.prototype.unsubscribe=function(){var t=this.parent;t.isUnsubscribed||this.isUnsubscribed||(e.prototype.unsubscribe.call(this),t.count-=1,0===t.count&&t.attemptedToUnsubscribe&&t.unsubscribe())},t}(a.Subscription);return s.define=i,t.exports}),System.register("rxjs/add/operator/partition",["rxjs/Observable","rxjs/operator/partition"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/partition");return i.Observable.prototype.partition=o.partition,r.define=s,t.exports}),System.register("rxjs/add/operator/publishBehavior",["rxjs/Observable","rxjs/operator/publishBehavior"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/publishBehavior");return i.Observable.prototype.publishBehavior=o.publishBehavior,r.define=s,t.exports}),System.register("rxjs/add/operator/subscribeOn",["rxjs/Observable","rxjs/operator/subscribeOn"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/subscribeOn");return i.Observable.prototype.subscribeOn=o.subscribeOn,r.define=s,t.exports}),System.register("rxjs/add/operator/take",["rxjs/Observable","rxjs/operator/take"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/take");return i.Observable.prototype.take=o.take,r.define=s,t.exports}),System.register("rxjs/Subscriber",["rxjs/util/isFunction","rxjs/Subscription","rxjs/symbol/rxSubscriber","rxjs/Observer"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/util/isFunction"),n=require("rxjs/Subscription"),a=require("rxjs/symbol/rxSubscriber"),u=require("rxjs/Observer"),c=function(e){function t(r,s,i){switch(e.call(this),this.syncErrorValue=null,this.syncErrorThrown=!1,this.syncErrorThrowable=!1,this.isStopped=!1,arguments.length){case 0:this.destination=u.empty;break;case 1:if(!r){this.destination=u.empty;break}if("object"==typeof r){r instanceof t?this.destination=r:(this.syncErrorThrowable=!0,this.destination=new l(this,r));break}default:this.syncErrorThrowable=!0,this.destination=new l(this,r,s,i)}}return i(t,e),t.create=function(e,r,s){var i=new t(e,r,s);return i.syncErrorThrowable=!1,i},t.prototype.next=function(e){this.isStopped||this._next(e)},t.prototype.error=function(e){this.isStopped||(this.isStopped=!0,this._error(e))},t.prototype.complete=function(){this.isStopped||(this.isStopped=!0,this._complete())},t.prototype.unsubscribe=function(){this.isUnsubscribed||(this.isStopped=!0,e.prototype.unsubscribe.call(this))},t.prototype._next=function(e){this.destination.next(e)},t.prototype._error=function(e){this.destination.error(e),this.unsubscribe()},t.prototype._complete=function(){this.destination.complete(),this.unsubscribe()},t.prototype[a.rxSubscriber]=function(){return this},t}(n.Subscription);e.Subscriber=c;var l=function(e){function t(t,r,s,i){e.call(this),this._parent=t;var n,a=this;o.isFunction(r)?n=r:r&&(a=r,n=r.next,s=r.error,i=r.complete),this._context=a,this._next=n,this._error=s,this._complete=i}return i(t,e),t.prototype.next=function(e){if(!this.isStopped&&this._next){var t=this._parent;t.syncErrorThrowable?this.__tryOrSetError(t,this._next,e)&&this.unsubscribe():this.__tryOrUnsub(this._next,e)}},t.prototype.error=function(e){if(!this.isStopped){var t=this._parent;if(this._error)t.syncErrorThrowable?(this.__tryOrSetError(t,this._error,e),this.unsubscribe()):(this.__tryOrUnsub(this._error,e),this.unsubscribe());else{if(!t.syncErrorThrowable)throw this.unsubscribe(),e;t.syncErrorValue=e,t.syncErrorThrown=!0,this.unsubscribe()}}},t.prototype.complete=function(){if(!this.isStopped){var e=this._parent;this._complete?e.syncErrorThrowable?(this.__tryOrSetError(e,this._complete), +this.unsubscribe()):(this.__tryOrUnsub(this._complete),this.unsubscribe()):this.unsubscribe()}},t.prototype.__tryOrUnsub=function(e,t){try{e.call(this._context,t)}catch(r){throw this.unsubscribe(),r}},t.prototype.__tryOrSetError=function(e,t,r){try{t.call(this._context,r)}catch(s){return e.syncErrorValue=s,e.syncErrorThrown=!0,!0}return!1},t.prototype._unsubscribe=function(){var e=this._parent;this._context=null,this._parent=null,e.unsubscribe()},t}(c);return r.define=s,t.exports}),System.register("rxjs/add/observable/combineLatest",["rxjs/Observable","rxjs/operator/combineLatest"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/combineLatest");return i.Observable.combineLatest=o.combineLatestStatic,r.define=s,t.exports}),System.register("rxjs/add/observable/from",["rxjs/Observable","rxjs/observable/FromObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/FromObservable");return i.Observable.from=o.FromObservable.create,r.define=s,t.exports}),System.register("rxjs/scheduler/asap",["rxjs/scheduler/AsapScheduler"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/scheduler/AsapScheduler");return e.asap=new i.AsapScheduler,r.define=s,t.exports}),System.register("rxjs/operator/cache",["rxjs/operator/publishReplay"],!0,function(require,e,t){function r(e,t,r){return void 0===e&&(e=Number.POSITIVE_INFINITY),void 0===t&&(t=Number.POSITIVE_INFINITY),o.publishReplay.call(this,e,t,r).refCount()}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/operator/publishReplay");return e.cache=r,s.define=i,t.exports}),System.register("rxjs/add/operator/groupBy",["rxjs/Observable","rxjs/operator/groupBy"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/groupBy");return i.Observable.prototype.groupBy=o.groupBy,r.define=s,t.exports}),System.register("rxjs/util/toSubscriber",["rxjs/Subscriber","rxjs/symbol/rxSubscriber"],!0,function(require,e,t){function r(e,t,r){if(e&&"object"==typeof e){if(e instanceof o.Subscriber)return e;if("function"==typeof e[n.rxSubscriber])return e[n.rxSubscriber]()}return new o.Subscriber(e,t,r)}var s=System.global,i=s.define;s.define=void 0;var o=require("rxjs/Subscriber"),n=require("rxjs/symbol/rxSubscriber");return e.toSubscriber=r,s.define=i,t.exports}),System.register("rxjs/observable/IntervalObservable",["rxjs/util/isNumeric","rxjs/Observable","rxjs/scheduler/asap"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/util/isNumeric"),n=require("rxjs/Observable"),a=require("rxjs/scheduler/asap"),u=function(e){function t(t,r){void 0===t&&(t=0),void 0===r&&(r=a.asap),e.call(this),this.period=t,this.scheduler=r,(!o.isNumeric(t)||0>t)&&(this.period=0),r&&"function"==typeof r.schedule||(this.scheduler=a.asap)}return i(t,e),t.create=function(e,r){return void 0===e&&(e=0),void 0===r&&(r=a.asap),new t(e,r)},t.dispatch=function(e){var t=e.index,r=e.subscriber,s=e.period;r.next(t),r.isUnsubscribed||(e.index+=1,this.schedule(e,s))},t.prototype._subscribe=function(e){var r=0,s=this.period,i=this.scheduler;e.add(i.schedule(t.dispatch,s,{index:r,subscriber:e,period:s}))},t}(n.Observable);return e.IntervalObservable=u,r.define=s,t.exports}),System.register("rxjs/add/operator/cache",["rxjs/Observable","rxjs/operator/cache"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/operator/cache");return i.Observable.prototype.cache=o.cache,r.define=s,t.exports}),System.register("rxjs/Observable",["rxjs/util/root","rxjs/util/SymbolShim","rxjs/util/toSubscriber","rxjs/util/tryCatch","rxjs/util/errorObject"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/util/root"),o=require("rxjs/util/SymbolShim"),n=require("rxjs/util/toSubscriber"),a=require("rxjs/util/tryCatch"),u=require("rxjs/util/errorObject"),c=function(){function e(e){this._isScalar=!1,e&&(this._subscribe=e)}return e.prototype.lift=function(t){var r=new e;return r.source=this,r.operator=t,r},e.prototype.subscribe=function(e,t,r){var s=this.operator,i=n.toSubscriber(e,t,r);if(s?i.add(this._subscribe(s.call(i))):i.add(this._subscribe(i)),i.syncErrorThrowable&&(i.syncErrorThrowable=!1,i.syncErrorThrown))throw i.syncErrorValue;return i},e.prototype.forEach=function(e,t,r){if(r||(i.root.Rx&&i.root.Rx.config&&i.root.Rx.config.Promise?r=i.root.Rx.config.Promise:i.root.Promise&&(r=i.root.Promise)),!r)throw new Error("no Promise impl found");var s=this;return new r(function(r,i){s.subscribe(function(r){var s=a.tryCatch(e).call(t,r);s===u.errorObject&&i(u.errorObject.e)},i,r)})},e.prototype._subscribe=function(e){return this.source.subscribe(e)},e.prototype[o.SymbolShim.observable]=function(){return this},e.create=function(t){return new e(t)},e}();return e.Observable=c,r.define=s,t.exports}),System.register("rxjs/add/observable/interval",["rxjs/Observable","rxjs/observable/IntervalObservable"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=require("rxjs/Observable"),o=require("rxjs/observable/IntervalObservable");return i.Observable.interval=o.IntervalObservable.create,r.define=s,t.exports}),System.register("rxjs/Subject",["rxjs/Observable","rxjs/Subscriber","rxjs/Subscription","rxjs/subject/SubjectSubscription","rxjs/symbol/rxSubscriber","rxjs/util/throwError","rxjs/util/ObjectUnsubscribedError"],!0,function(require,e,t){var r=System.global,s=r.define;r.define=void 0;var i=this&&this.__extends||function(e,t){function r(){this.constructor=e}for(var s in t)t.hasOwnProperty(s)&&(e[s]=t[s]);e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)},o=require("rxjs/Observable"),n=require("rxjs/Subscriber"),a=require("rxjs/Subscription"),u=require("rxjs/subject/SubjectSubscription"),c=require("rxjs/symbol/rxSubscriber"),l=require("rxjs/util/throwError"),p=require("rxjs/util/ObjectUnsubscribedError"),b=function(e){function t(t,r){e.call(this),this.destination=t,this.source=r,this.observers=[],this.isUnsubscribed=!1,this.isStopped=!1,this.hasErrored=!1,this.dispatching=!1,this.hasCompleted=!1}return i(t,e),t.prototype.lift=function(e){var r=new t(this.destination||this,this);return r.operator=e,r},t.prototype.add=function(e){a.Subscription.prototype.add.call(this,e)},t.prototype.remove=function(e){a.Subscription.prototype.remove.call(this,e)},t.prototype.unsubscribe=function(){a.Subscription.prototype.unsubscribe.call(this)},t.prototype._subscribe=function(e){if(this.source)return this.source.subscribe(e);if(!e.isUnsubscribed){if(this.hasErrored)return e.error(this.errorValue);if(this.hasCompleted)return e.complete();this.throwIfUnsubscribed();var t=new u.SubjectSubscription(this,e);return this.observers.push(e),t}},t.prototype._unsubscribe=function(){this.source=null,this.isStopped=!0,this.observers=null,this.destination=null},t.prototype.next=function(e){this.throwIfUnsubscribed(),this.isStopped||(this.dispatching=!0,this._next(e),this.dispatching=!1,this.hasErrored?this._error(this.errorValue):this.hasCompleted&&this._complete())},t.prototype.error=function(e){this.throwIfUnsubscribed(),this.isStopped||(this.isStopped=!0,this.hasErrored=!0,this.errorValue=e,this.dispatching||this._error(e))},t.prototype.complete=function(){this.throwIfUnsubscribed(),this.isStopped||(this.isStopped=!0,this.hasCompleted=!0,this.dispatching||this._complete())},t.prototype.asObservable=function(){var e=new h(this);return e},t.prototype._next=function(e){this.destination?this.destination.next(e):this._finalNext(e)},t.prototype._finalNext=function(e){for(var t=-1,r=this.observers.slice(0),s=r.length;++t + */ +var Observable = (function () { + /** + * @constructor + * @param {Function} subscribe the function that is + * called when the Observable is initially subscribed to. This function is given a Subscriber, to which new values + * can be `next`ed, or an `error` method can be called to raise an error, or `complete` can be called to notify + * of a successful completion. + */ + function Observable(subscribe) { + this._isScalar = false; + if (subscribe) { + this._subscribe = subscribe; + } + } + /** + * @method lift + * @param {Operator} operator the operator defining the operation to take on the observable + * @returns {Observable} a new observable with the Operator applied + * @description creates a new Observable, with this Observable as the source, and the passed + * operator defined as the new observable's operator. + */ + Observable.prototype.lift = function (operator) { + var observable = new Observable(); + observable.source = this; + observable.operator = operator; + return observable; + }; + /** + * @method subscribe + * @param {PartialObserver|Function} observerOrNext (optional) either an observer defining all functions to be called, + * or the first of three possible handlers, which is the handler for each value emitted from the observable. + * @param {Function} error (optional) a handler for a terminal event resulting from an error. If no error handler is provided, + * the error will be thrown as unhandled + * @param {Function} complete (optional) a handler for a terminal event resulting from successful completion. + * @returns {Subscription} a subscription reference to the registered handlers + * @description registers handlers for handling emitted values, error and completions from the observable, and + * executes the observable's subscriber function, which will take action to set up the underlying data stream + */ + Observable.prototype.subscribe = function (observerOrNext, error, complete) { + var operator = this.operator; + var subscriber = toSubscriber_1.toSubscriber(observerOrNext, error, complete); + if (operator) { + subscriber.add(this._subscribe(operator.call(subscriber))); + } + else { + subscriber.add(this._subscribe(subscriber)); + } + if (subscriber.syncErrorThrowable) { + subscriber.syncErrorThrowable = false; + if (subscriber.syncErrorThrown) { + throw subscriber.syncErrorValue; + } + } + return subscriber; + }; + /** + * @method forEach + * @param {Function} next a handler for each value emitted by the observable + * @param {any} [thisArg] a `this` context for the `next` handler function + * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise + * @returns {Promise} a promise that either resolves on observable completion or + * rejects with the handled error + */ + Observable.prototype.forEach = function (next, thisArg, PromiseCtor) { + if (!PromiseCtor) { + if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) { + PromiseCtor = root_1.root.Rx.config.Promise; + } + else if (root_1.root.Promise) { + PromiseCtor = root_1.root.Promise; + } + } + if (!PromiseCtor) { + throw new Error('no Promise impl found'); + } + var source = this; + return new PromiseCtor(function (resolve, reject) { + source.subscribe(function (value) { + var result = tryCatch_1.tryCatch(next).call(thisArg, value); + if (result === errorObject_1.errorObject) { + reject(errorObject_1.errorObject.e); + } + }, reject, resolve); + }); + }; + Observable.prototype._subscribe = function (subscriber) { + return this.source.subscribe(subscriber); + }; + /** + * @method Symbol.observable + * @returns {Observable} this instance of the observable + * @description an interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable + */ + Observable.prototype[SymbolShim_1.SymbolShim.observable] = function () { + return this; + }; + // HACK: Since TypeScript inherits static properties too, we have to + // fight against TypeScript here so Subject can have a different static create signature + /** + * @static + * @method create + * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor + * @returns {Observable} a new cold observable + * @description creates a new cold Observable by calling the Observable constructor + */ + Observable.create = function (subscribe) { + return new Observable(subscribe); + }; + return Observable; +}()); +exports.Observable = Observable; + +},{"./util/SymbolShim":238,"./util/errorObject":239,"./util/root":249,"./util/toSubscriber":252,"./util/tryCatch":253}],4:[function(require,module,exports){ +"use strict"; +exports.empty = { + isUnsubscribed: true, + next: function (value) { }, + error: function (err) { throw err; }, + complete: function () { } +}; + +},{}],5:[function(require,module,exports){ +"use strict"; +var Subscriber_1 = require('./Subscriber'); +var Operator = (function () { + function Operator() { + } + Operator.prototype.call = function (subscriber) { + return new Subscriber_1.Subscriber(subscriber); + }; + return Operator; +}()); +exports.Operator = Operator; + +},{"./Subscriber":9}],6:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('./Subscriber'); +var OuterSubscriber = (function (_super) { + __extends(OuterSubscriber, _super); + function OuterSubscriber() { + _super.apply(this, arguments); + } + OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.destination.next(innerValue); + }; + OuterSubscriber.prototype.notifyError = function (error, innerSub) { + this.destination.error(error); + }; + OuterSubscriber.prototype.notifyComplete = function (innerSub) { + this.destination.complete(); + }; + return OuterSubscriber; +}(Subscriber_1.Subscriber)); +exports.OuterSubscriber = OuterSubscriber; + +},{"./Subscriber":9}],7:[function(require,module,exports){ +"use strict"; +/* tslint:disable:no-unused-variable */ +// Subject imported before Observable to bypass circular dependency issue since +// Subject extends Observable and Observable references Subject in it's +// definition +var Subject_1 = require('./Subject'); +exports.Subject = Subject_1.Subject; +/* tslint:enable:no-unused-variable */ +var Observable_1 = require('./Observable'); +exports.Observable = Observable_1.Observable; +// statics +/* tslint:disable:no-use-before-declare */ +require('./add/observable/combineLatest'); +require('./add/observable/concat'); +require('./add/observable/merge'); +require('./add/observable/race'); +require('./add/observable/bindCallback'); +require('./add/observable/bindNodeCallback'); +require('./add/observable/defer'); +require('./add/observable/empty'); +require('./add/observable/forkJoin'); +require('./add/observable/from'); +require('./add/observable/fromArray'); +require('./add/observable/fromEvent'); +require('./add/observable/fromEventPattern'); +require('./add/observable/fromPromise'); +require('./add/observable/interval'); +require('./add/observable/never'); +require('./add/observable/range'); +require('./add/observable/throw'); +require('./add/observable/timer'); +require('./add/observable/zip'); +//operators +require('./add/operator/buffer'); +require('./add/operator/bufferCount'); +require('./add/operator/bufferTime'); +require('./add/operator/bufferToggle'); +require('./add/operator/bufferWhen'); +require('./add/operator/cache'); +require('./add/operator/catch'); +require('./add/operator/combineAll'); +require('./add/operator/combineLatest'); +require('./add/operator/concat'); +require('./add/operator/concatAll'); +require('./add/operator/concatMap'); +require('./add/operator/concatMapTo'); +require('./add/operator/count'); +require('./add/operator/dematerialize'); +require('./add/operator/debounce'); +require('./add/operator/debounceTime'); +require('./add/operator/defaultIfEmpty'); +require('./add/operator/delay'); +require('./add/operator/delayWhen'); +require('./add/operator/distinctUntilChanged'); +require('./add/operator/do'); +require('./add/operator/expand'); +require('./add/operator/filter'); +require('./add/operator/finally'); +require('./add/operator/first'); +require('./add/operator/groupBy'); +require('./add/operator/ignoreElements'); +require('./add/operator/inspect'); +require('./add/operator/inspectTime'); +require('./add/operator/every'); +require('./add/operator/last'); +require('./add/operator/let'); +require('./add/operator/map'); +require('./add/operator/mapTo'); +require('./add/operator/materialize'); +require('./add/operator/merge'); +require('./add/operator/mergeAll'); +require('./add/operator/mergeMap'); +require('./add/operator/mergeMapTo'); +require('./add/operator/multicast'); +require('./add/operator/observeOn'); +require('./add/operator/partition'); +require('./add/operator/pluck'); +require('./add/operator/publish'); +require('./add/operator/publishBehavior'); +require('./add/operator/publishReplay'); +require('./add/operator/publishLast'); +require('./add/operator/race'); +require('./add/operator/reduce'); +require('./add/operator/repeat'); +require('./add/operator/retry'); +require('./add/operator/retryWhen'); +require('./add/operator/sample'); +require('./add/operator/sampleTime'); +require('./add/operator/scan'); +require('./add/operator/share'); +require('./add/operator/single'); +require('./add/operator/skip'); +require('./add/operator/skipUntil'); +require('./add/operator/skipWhile'); +require('./add/operator/startWith'); +require('./add/operator/subscribeOn'); +require('./add/operator/switch'); +require('./add/operator/switchMap'); +require('./add/operator/switchMapTo'); +require('./add/operator/take'); +require('./add/operator/takeLast'); +require('./add/operator/takeUntil'); +require('./add/operator/takeWhile'); +require('./add/operator/throttle'); +require('./add/operator/throttleTime'); +require('./add/operator/timeout'); +require('./add/operator/timeoutWith'); +require('./add/operator/toArray'); +require('./add/operator/toPromise'); +require('./add/operator/window'); +require('./add/operator/windowCount'); +require('./add/operator/windowTime'); +require('./add/operator/windowToggle'); +require('./add/operator/windowWhen'); +require('./add/operator/withLatestFrom'); +require('./add/operator/zip'); +require('./add/operator/zipAll'); +/* tslint:disable:no-unused-variable */ +var Operator_1 = require('./Operator'); +exports.Operator = Operator_1.Operator; +var Subscription_1 = require('./Subscription'); +exports.Subscription = Subscription_1.Subscription; +exports.UnsubscriptionError = Subscription_1.UnsubscriptionError; +var Subscriber_1 = require('./Subscriber'); +exports.Subscriber = Subscriber_1.Subscriber; +var AsyncSubject_1 = require('./subject/AsyncSubject'); +exports.AsyncSubject = AsyncSubject_1.AsyncSubject; +var ReplaySubject_1 = require('./subject/ReplaySubject'); +exports.ReplaySubject = ReplaySubject_1.ReplaySubject; +var BehaviorSubject_1 = require('./subject/BehaviorSubject'); +exports.BehaviorSubject = BehaviorSubject_1.BehaviorSubject; +var ConnectableObservable_1 = require('./observable/ConnectableObservable'); +exports.ConnectableObservable = ConnectableObservable_1.ConnectableObservable; +var Notification_1 = require('./Notification'); +exports.Notification = Notification_1.Notification; +var EmptyError_1 = require('./util/EmptyError'); +exports.EmptyError = EmptyError_1.EmptyError; +var ArgumentOutOfRangeError_1 = require('./util/ArgumentOutOfRangeError'); +exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError_1.ArgumentOutOfRangeError; +var ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError'); +exports.ObjectUnsubscribedError = ObjectUnsubscribedError_1.ObjectUnsubscribedError; +var asap_1 = require('./scheduler/asap'); +var queue_1 = require('./scheduler/queue'); +var rxSubscriber_1 = require('./symbol/rxSubscriber'); +/* tslint:enable:no-unused-variable */ +/* tslint:disable:no-var-keyword */ +var Scheduler = { + asap: asap_1.asap, + queue: queue_1.queue +}; +exports.Scheduler = Scheduler; +var Symbol = { + rxSubscriber: rxSubscriber_1.rxSubscriber +}; +exports.Symbol = Symbol; +/* tslint:enable:no-var-keyword */ + +},{"./Notification":2,"./Observable":3,"./Operator":5,"./Subject":8,"./Subscriber":9,"./Subscription":10,"./add/observable/bindCallback":11,"./add/observable/bindNodeCallback":12,"./add/observable/combineLatest":13,"./add/observable/concat":14,"./add/observable/defer":15,"./add/observable/empty":16,"./add/observable/forkJoin":17,"./add/observable/from":18,"./add/observable/fromArray":19,"./add/observable/fromEvent":20,"./add/observable/fromEventPattern":21,"./add/observable/fromPromise":22,"./add/observable/interval":23,"./add/observable/merge":24,"./add/observable/never":25,"./add/observable/race":26,"./add/observable/range":27,"./add/observable/throw":28,"./add/observable/timer":29,"./add/observable/zip":30,"./add/operator/buffer":31,"./add/operator/bufferCount":32,"./add/operator/bufferTime":33,"./add/operator/bufferToggle":34,"./add/operator/bufferWhen":35,"./add/operator/cache":36,"./add/operator/catch":37,"./add/operator/combineAll":38,"./add/operator/combineLatest":39,"./add/operator/concat":40,"./add/operator/concatAll":41,"./add/operator/concatMap":42,"./add/operator/concatMapTo":43,"./add/operator/count":44,"./add/operator/debounce":45,"./add/operator/debounceTime":46,"./add/operator/defaultIfEmpty":47,"./add/operator/delay":48,"./add/operator/delayWhen":49,"./add/operator/dematerialize":50,"./add/operator/distinctUntilChanged":51,"./add/operator/do":52,"./add/operator/every":53,"./add/operator/expand":54,"./add/operator/filter":55,"./add/operator/finally":56,"./add/operator/first":57,"./add/operator/groupBy":58,"./add/operator/ignoreElements":59,"./add/operator/inspect":60,"./add/operator/inspectTime":61,"./add/operator/last":62,"./add/operator/let":63,"./add/operator/map":64,"./add/operator/mapTo":65,"./add/operator/materialize":66,"./add/operator/merge":67,"./add/operator/mergeAll":68,"./add/operator/mergeMap":69,"./add/operator/mergeMapTo":70,"./add/operator/multicast":71,"./add/operator/observeOn":72,"./add/operator/partition":73,"./add/operator/pluck":74,"./add/operator/publish":75,"./add/operator/publishBehavior":76,"./add/operator/publishLast":77,"./add/operator/publishReplay":78,"./add/operator/race":79,"./add/operator/reduce":80,"./add/operator/repeat":81,"./add/operator/retry":82,"./add/operator/retryWhen":83,"./add/operator/sample":84,"./add/operator/sampleTime":85,"./add/operator/scan":86,"./add/operator/share":87,"./add/operator/single":88,"./add/operator/skip":89,"./add/operator/skipUntil":90,"./add/operator/skipWhile":91,"./add/operator/startWith":92,"./add/operator/subscribeOn":93,"./add/operator/switch":94,"./add/operator/switchMap":95,"./add/operator/switchMapTo":96,"./add/operator/take":97,"./add/operator/takeLast":98,"./add/operator/takeUntil":99,"./add/operator/takeWhile":100,"./add/operator/throttle":101,"./add/operator/throttleTime":102,"./add/operator/timeout":103,"./add/operator/timeoutWith":104,"./add/operator/toArray":105,"./add/operator/toPromise":106,"./add/operator/window":107,"./add/operator/windowCount":108,"./add/operator/windowTime":109,"./add/operator/windowToggle":110,"./add/operator/windowWhen":111,"./add/operator/withLatestFrom":112,"./add/operator/zip":113,"./add/operator/zipAll":114,"./observable/ConnectableObservable":119,"./scheduler/asap":224,"./scheduler/queue":225,"./subject/AsyncSubject":226,"./subject/BehaviorSubject":227,"./subject/ReplaySubject":228,"./symbol/rxSubscriber":230,"./util/ArgumentOutOfRangeError":231,"./util/EmptyError":232,"./util/ObjectUnsubscribedError":237}],8:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('./Observable'); +var Subscriber_1 = require('./Subscriber'); +var Subscription_1 = require('./Subscription'); +var SubjectSubscription_1 = require('./subject/SubjectSubscription'); +var rxSubscriber_1 = require('./symbol/rxSubscriber'); +var throwError_1 = require('./util/throwError'); +var ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError'); +var Subject = (function (_super) { + __extends(Subject, _super); + function Subject(destination, source) { + _super.call(this); + this.destination = destination; + this.source = source; + this.observers = []; + this.isUnsubscribed = false; + this.isStopped = false; + this.hasErrored = false; + this.dispatching = false; + this.hasCompleted = false; + } + Subject.prototype.lift = function (operator) { + var subject = new Subject(this.destination || this, this); + subject.operator = operator; + return subject; + }; + Subject.prototype.add = function (subscription) { + Subscription_1.Subscription.prototype.add.call(this, subscription); + }; + Subject.prototype.remove = function (subscription) { + Subscription_1.Subscription.prototype.remove.call(this, subscription); + }; + Subject.prototype.unsubscribe = function () { + Subscription_1.Subscription.prototype.unsubscribe.call(this); + }; + Subject.prototype._subscribe = function (subscriber) { + if (this.source) { + return this.source.subscribe(subscriber); + } + else { + if (subscriber.isUnsubscribed) { + return; + } + else if (this.hasErrored) { + return subscriber.error(this.errorValue); + } + else if (this.hasCompleted) { + return subscriber.complete(); + } + this.throwIfUnsubscribed(); + var subscription = new SubjectSubscription_1.SubjectSubscription(this, subscriber); + this.observers.push(subscriber); + return subscription; + } + }; + Subject.prototype._unsubscribe = function () { + this.source = null; + this.isStopped = true; + this.observers = null; + this.destination = null; + }; + Subject.prototype.next = function (value) { + this.throwIfUnsubscribed(); + if (this.isStopped) { + return; + } + this.dispatching = true; + this._next(value); + this.dispatching = false; + if (this.hasErrored) { + this._error(this.errorValue); + } + else if (this.hasCompleted) { + this._complete(); + } + }; + Subject.prototype.error = function (err) { + this.throwIfUnsubscribed(); + if (this.isStopped) { + return; + } + this.isStopped = true; + this.hasErrored = true; + this.errorValue = err; + if (this.dispatching) { + return; + } + this._error(err); + }; + Subject.prototype.complete = function () { + this.throwIfUnsubscribed(); + if (this.isStopped) { + return; + } + this.isStopped = true; + this.hasCompleted = true; + if (this.dispatching) { + return; + } + this._complete(); + }; + Subject.prototype.asObservable = function () { + var observable = new SubjectObservable(this); + return observable; + }; + Subject.prototype._next = function (value) { + if (this.destination) { + this.destination.next(value); + } + else { + this._finalNext(value); + } + }; + Subject.prototype._finalNext = function (value) { + var index = -1; + var observers = this.observers.slice(0); + var len = observers.length; + while (++index < len) { + observers[index].next(value); + } + }; + Subject.prototype._error = function (err) { + if (this.destination) { + this.destination.error(err); + } + else { + this._finalError(err); + } + }; + Subject.prototype._finalError = function (err) { + var index = -1; + var observers = this.observers; + // optimization to block our SubjectSubscriptions from + // splicing themselves out of the observers list one by one. + this.observers = null; + this.isUnsubscribed = true; + if (observers) { + var len = observers.length; + while (++index < len) { + observers[index].error(err); + } + } + this.isUnsubscribed = false; + this.unsubscribe(); + }; + Subject.prototype._complete = function () { + if (this.destination) { + this.destination.complete(); + } + else { + this._finalComplete(); + } + }; + Subject.prototype._finalComplete = function () { + var index = -1; + var observers = this.observers; + // optimization to block our SubjectSubscriptions from + // splicing themselves out of the observers list one by one. + this.observers = null; + this.isUnsubscribed = true; + if (observers) { + var len = observers.length; + while (++index < len) { + observers[index].complete(); + } + } + this.isUnsubscribed = false; + this.unsubscribe(); + }; + Subject.prototype.throwIfUnsubscribed = function () { + if (this.isUnsubscribed) { + throwError_1.throwError(new ObjectUnsubscribedError_1.ObjectUnsubscribedError()); + } + }; + Subject.prototype[rxSubscriber_1.rxSubscriber] = function () { + return new Subscriber_1.Subscriber(this); + }; + Subject.create = function (destination, source) { + return new Subject(destination, source); + }; + return Subject; +}(Observable_1.Observable)); +exports.Subject = Subject; +var SubjectObservable = (function (_super) { + __extends(SubjectObservable, _super); + function SubjectObservable(source) { + _super.call(this); + this.source = source; + } + return SubjectObservable; +}(Observable_1.Observable)); + +},{"./Observable":3,"./Subscriber":9,"./Subscription":10,"./subject/SubjectSubscription":229,"./symbol/rxSubscriber":230,"./util/ObjectUnsubscribedError":237,"./util/throwError":251}],9:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var isFunction_1 = require('./util/isFunction'); +var Subscription_1 = require('./Subscription'); +var rxSubscriber_1 = require('./symbol/rxSubscriber'); +var Observer_1 = require('./Observer'); +var Subscriber = (function (_super) { + __extends(Subscriber, _super); + function Subscriber(destinationOrNext, error, complete) { + _super.call(this); + this.syncErrorValue = null; + this.syncErrorThrown = false; + this.syncErrorThrowable = false; + this.isStopped = false; + switch (arguments.length) { + case 0: + this.destination = Observer_1.empty; + break; + case 1: + if (!destinationOrNext) { + this.destination = Observer_1.empty; + break; + } + if (typeof destinationOrNext === 'object') { + if (destinationOrNext instanceof Subscriber) { + this.destination = destinationOrNext; + } + else { + this.syncErrorThrowable = true; + this.destination = new SafeSubscriber(this, destinationOrNext); + } + break; + } + default: + this.syncErrorThrowable = true; + this.destination = new SafeSubscriber(this, destinationOrNext, error, complete); + break; + } + } + Subscriber.create = function (next, error, complete) { + var subscriber = new Subscriber(next, error, complete); + subscriber.syncErrorThrowable = false; + return subscriber; + }; + Subscriber.prototype.next = function (value) { + if (!this.isStopped) { + this._next(value); + } + }; + Subscriber.prototype.error = function (err) { + if (!this.isStopped) { + this.isStopped = true; + this._error(err); + } + }; + Subscriber.prototype.complete = function () { + if (!this.isStopped) { + this.isStopped = true; + this._complete(); + } + }; + Subscriber.prototype.unsubscribe = function () { + if (this.isUnsubscribed) { + return; + } + this.isStopped = true; + _super.prototype.unsubscribe.call(this); + }; + Subscriber.prototype._next = function (value) { + this.destination.next(value); + }; + Subscriber.prototype._error = function (err) { + this.destination.error(err); + this.unsubscribe(); + }; + Subscriber.prototype._complete = function () { + this.destination.complete(); + this.unsubscribe(); + }; + Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { + return this; + }; + return Subscriber; +}(Subscription_1.Subscription)); +exports.Subscriber = Subscriber; +var SafeSubscriber = (function (_super) { + __extends(SafeSubscriber, _super); + function SafeSubscriber(_parent, observerOrNext, error, complete) { + _super.call(this); + this._parent = _parent; + var next; + var context = this; + if (isFunction_1.isFunction(observerOrNext)) { + next = observerOrNext; + } + else if (observerOrNext) { + context = observerOrNext; + next = observerOrNext.next; + error = observerOrNext.error; + complete = observerOrNext.complete; + } + this._context = context; + this._next = next; + this._error = error; + this._complete = complete; + } + SafeSubscriber.prototype.next = function (value) { + if (!this.isStopped && this._next) { + var _parent = this._parent; + if (!_parent.syncErrorThrowable) { + this.__tryOrUnsub(this._next, value); + } + else if (this.__tryOrSetError(_parent, this._next, value)) { + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.error = function (err) { + if (!this.isStopped) { + var _parent = this._parent; + if (this._error) { + if (!_parent.syncErrorThrowable) { + this.__tryOrUnsub(this._error, err); + this.unsubscribe(); + } + else { + this.__tryOrSetError(_parent, this._error, err); + this.unsubscribe(); + } + } + else if (!_parent.syncErrorThrowable) { + this.unsubscribe(); + throw err; + } + else { + _parent.syncErrorValue = err; + _parent.syncErrorThrown = true; + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.complete = function () { + if (!this.isStopped) { + var _parent = this._parent; + if (this._complete) { + if (!_parent.syncErrorThrowable) { + this.__tryOrUnsub(this._complete); + this.unsubscribe(); + } + else { + this.__tryOrSetError(_parent, this._complete); + this.unsubscribe(); + } + } + else { + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) { + try { + fn.call(this._context, value); + } + catch (err) { + this.unsubscribe(); + throw err; + } + }; + SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) { + try { + fn.call(this._context, value); + } + catch (err) { + parent.syncErrorValue = err; + parent.syncErrorThrown = true; + return true; + } + return false; + }; + SafeSubscriber.prototype._unsubscribe = function () { + var _parent = this._parent; + this._context = null; + this._parent = null; + _parent.unsubscribe(); + }; + return SafeSubscriber; +}(Subscriber)); + +},{"./Observer":4,"./Subscription":10,"./symbol/rxSubscriber":230,"./util/isFunction":242}],10:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var isArray_1 = require('./util/isArray'); +var isObject_1 = require('./util/isObject'); +var isFunction_1 = require('./util/isFunction'); +var tryCatch_1 = require('./util/tryCatch'); +var errorObject_1 = require('./util/errorObject'); +var Subscription = (function () { + function Subscription(_unsubscribe) { + this.isUnsubscribed = false; + if (_unsubscribe) { + this._unsubscribe = _unsubscribe; + } + } + Subscription.prototype.unsubscribe = function () { + var hasErrors = false; + var errors; + if (this.isUnsubscribed) { + return; + } + this.isUnsubscribed = true; + var _a = this, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions; + this._subscriptions = null; + if (isFunction_1.isFunction(_unsubscribe)) { + var trial = tryCatch_1.tryCatch(_unsubscribe).call(this); + if (trial === errorObject_1.errorObject) { + hasErrors = true; + (errors = errors || []).push(errorObject_1.errorObject.e); + } + } + if (isArray_1.isArray(_subscriptions)) { + var index = -1; + var len = _subscriptions.length; + while (++index < len) { + var sub = _subscriptions[index]; + if (isObject_1.isObject(sub)) { + var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub); + if (trial === errorObject_1.errorObject) { + hasErrors = true; + errors = errors || []; + var err = errorObject_1.errorObject.e; + if (err instanceof UnsubscriptionError) { + errors = errors.concat(err.errors); + } + else { + errors.push(err); + } + } + } + } + } + if (hasErrors) { + throw new UnsubscriptionError(errors); + } + }; + Subscription.prototype.add = function (subscription) { + // return early if: + // 1. the subscription is null + // 2. we're attempting to add our this + // 3. we're attempting to add the static `empty` Subscription + if (!subscription || (subscription === this) || (subscription === Subscription.EMPTY)) { + return; + } + var sub = subscription; + switch (typeof subscription) { + case 'function': + sub = new Subscription(subscription); + case 'object': + if (sub.isUnsubscribed || typeof sub.unsubscribe !== 'function') { + break; + } + else if (this.isUnsubscribed) { + sub.unsubscribe(); + } + else { + (this._subscriptions || (this._subscriptions = [])).push(sub); + } + break; + default: + throw new Error('Unrecognized subscription ' + subscription + ' added to Subscription.'); + } + }; + Subscription.prototype.remove = function (subscription) { + // return early if: + // 1. the subscription is null + // 2. we're attempting to remove ourthis + // 3. we're attempting to remove the static `empty` Subscription + if (subscription == null || (subscription === this) || (subscription === Subscription.EMPTY)) { + return; + } + var subscriptions = this._subscriptions; + if (subscriptions) { + var subscriptionIndex = subscriptions.indexOf(subscription); + if (subscriptionIndex !== -1) { + subscriptions.splice(subscriptionIndex, 1); + } + } + }; + Subscription.EMPTY = (function (empty) { + empty.isUnsubscribed = true; + return empty; + }(new Subscription())); + return Subscription; +}()); +exports.Subscription = Subscription; +var UnsubscriptionError = (function (_super) { + __extends(UnsubscriptionError, _super); + function UnsubscriptionError(errors) { + _super.call(this, 'unsubscriptoin error(s)'); + this.errors = errors; + this.name = 'UnsubscriptionError'; + } + return UnsubscriptionError; +}(Error)); +exports.UnsubscriptionError = UnsubscriptionError; + +},{"./util/errorObject":239,"./util/isArray":240,"./util/isFunction":242,"./util/isObject":244,"./util/tryCatch":253}],11:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var BoundCallbackObservable_1 = require('../../observable/BoundCallbackObservable'); +Observable_1.Observable.bindCallback = BoundCallbackObservable_1.BoundCallbackObservable.create; + +},{"../../Observable":3,"../../observable/BoundCallbackObservable":117}],12:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var BoundNodeCallbackObservable_1 = require('../../observable/BoundNodeCallbackObservable'); +Observable_1.Observable.bindNodeCallback = BoundNodeCallbackObservable_1.BoundNodeCallbackObservable.create; + +},{"../../Observable":3,"../../observable/BoundNodeCallbackObservable":118}],13:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var combineLatest_1 = require('../../operator/combineLatest'); +Observable_1.Observable.combineLatest = combineLatest_1.combineLatestStatic; + +},{"../../Observable":3,"../../operator/combineLatest":143}],14:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var concat_1 = require('../../operator/concat'); +Observable_1.Observable.concat = concat_1.concatStatic; + +},{"../../Observable":3,"../../operator/concat":144}],15:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var DeferObservable_1 = require('../../observable/DeferObservable'); +Observable_1.Observable.defer = DeferObservable_1.DeferObservable.create; + +},{"../../Observable":3,"../../observable/DeferObservable":120}],16:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var EmptyObservable_1 = require('../../observable/EmptyObservable'); +Observable_1.Observable.empty = EmptyObservable_1.EmptyObservable.create; + +},{"../../Observable":3,"../../observable/EmptyObservable":121}],17:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var ForkJoinObservable_1 = require('../../observable/ForkJoinObservable'); +Observable_1.Observable.forkJoin = ForkJoinObservable_1.ForkJoinObservable.create; + +},{"../../Observable":3,"../../observable/ForkJoinObservable":123}],18:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var FromObservable_1 = require('../../observable/FromObservable'); +Observable_1.Observable.from = FromObservable_1.FromObservable.create; + +},{"../../Observable":3,"../../observable/FromObservable":126}],19:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var ArrayObservable_1 = require('../../observable/ArrayObservable'); +Observable_1.Observable.fromArray = ArrayObservable_1.ArrayObservable.create; +Observable_1.Observable.of = ArrayObservable_1.ArrayObservable.of; + +},{"../../Observable":3,"../../observable/ArrayObservable":116}],20:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var FromEventObservable_1 = require('../../observable/FromEventObservable'); +Observable_1.Observable.fromEvent = FromEventObservable_1.FromEventObservable.create; + +},{"../../Observable":3,"../../observable/FromEventObservable":124}],21:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var FromEventPatternObservable_1 = require('../../observable/FromEventPatternObservable'); +Observable_1.Observable.fromEventPattern = FromEventPatternObservable_1.FromEventPatternObservable.create; + +},{"../../Observable":3,"../../observable/FromEventPatternObservable":125}],22:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var PromiseObservable_1 = require('../../observable/PromiseObservable'); +Observable_1.Observable.fromPromise = PromiseObservable_1.PromiseObservable.create; + +},{"../../Observable":3,"../../observable/PromiseObservable":130}],23:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var IntervalObservable_1 = require('../../observable/IntervalObservable'); +Observable_1.Observable.interval = IntervalObservable_1.IntervalObservable.create; + +},{"../../Observable":3,"../../observable/IntervalObservable":127}],24:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var merge_1 = require('../../operator/merge'); +Observable_1.Observable.merge = merge_1.mergeStatic; + +},{"../../Observable":3,"../../operator/merge":171}],25:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var NeverObservable_1 = require('../../observable/NeverObservable'); +Observable_1.Observable.never = NeverObservable_1.NeverObservable.create; + +},{"../../Observable":3,"../../observable/NeverObservable":129}],26:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var race_1 = require('../../operator/race'); +Observable_1.Observable.race = race_1.raceStatic; + +},{"../../Observable":3,"../../operator/race":183}],27:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var RangeObservable_1 = require('../../observable/RangeObservable'); +Observable_1.Observable.range = RangeObservable_1.RangeObservable.create; + +},{"../../Observable":3,"../../observable/RangeObservable":131}],28:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var ErrorObservable_1 = require('../../observable/ErrorObservable'); +Observable_1.Observable.throw = ErrorObservable_1.ErrorObservable.create; + +},{"../../Observable":3,"../../observable/ErrorObservable":122}],29:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var TimerObservable_1 = require('../../observable/TimerObservable'); +Observable_1.Observable.timer = TimerObservable_1.TimerObservable.create; + +},{"../../Observable":3,"../../observable/TimerObservable":134}],30:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var zip_1 = require('../../operator/zip'); +Observable_1.Observable.zip = zip_1.zipStatic; + +},{"../../Observable":3,"../../operator/zip":217}],31:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var buffer_1 = require('../../operator/buffer'); +Observable_1.Observable.prototype.buffer = buffer_1.buffer; + +},{"../../Observable":3,"../../operator/buffer":135}],32:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var bufferCount_1 = require('../../operator/bufferCount'); +Observable_1.Observable.prototype.bufferCount = bufferCount_1.bufferCount; + +},{"../../Observable":3,"../../operator/bufferCount":136}],33:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var bufferTime_1 = require('../../operator/bufferTime'); +Observable_1.Observable.prototype.bufferTime = bufferTime_1.bufferTime; + +},{"../../Observable":3,"../../operator/bufferTime":137}],34:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var bufferToggle_1 = require('../../operator/bufferToggle'); +Observable_1.Observable.prototype.bufferToggle = bufferToggle_1.bufferToggle; + +},{"../../Observable":3,"../../operator/bufferToggle":138}],35:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var bufferWhen_1 = require('../../operator/bufferWhen'); +Observable_1.Observable.prototype.bufferWhen = bufferWhen_1.bufferWhen; + +},{"../../Observable":3,"../../operator/bufferWhen":139}],36:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var cache_1 = require('../../operator/cache'); +Observable_1.Observable.prototype.cache = cache_1.cache; + +},{"../../Observable":3,"../../operator/cache":140}],37:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var catch_1 = require('../../operator/catch'); +Observable_1.Observable.prototype.catch = catch_1._catch; + +},{"../../Observable":3,"../../operator/catch":141}],38:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var combineAll_1 = require('../../operator/combineAll'); +Observable_1.Observable.prototype.combineAll = combineAll_1.combineAll; + +},{"../../Observable":3,"../../operator/combineAll":142}],39:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var combineLatest_1 = require('../../operator/combineLatest'); +Observable_1.Observable.prototype.combineLatest = combineLatest_1.combineLatest; + +},{"../../Observable":3,"../../operator/combineLatest":143}],40:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var concat_1 = require('../../operator/concat'); +Observable_1.Observable.prototype.concat = concat_1.concat; + +},{"../../Observable":3,"../../operator/concat":144}],41:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var concatAll_1 = require('../../operator/concatAll'); +Observable_1.Observable.prototype.concatAll = concatAll_1.concatAll; + +},{"../../Observable":3,"../../operator/concatAll":145}],42:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var concatMap_1 = require('../../operator/concatMap'); +Observable_1.Observable.prototype.concatMap = concatMap_1.concatMap; + +},{"../../Observable":3,"../../operator/concatMap":146}],43:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var concatMapTo_1 = require('../../operator/concatMapTo'); +Observable_1.Observable.prototype.concatMapTo = concatMapTo_1.concatMapTo; + +},{"../../Observable":3,"../../operator/concatMapTo":147}],44:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var count_1 = require('../../operator/count'); +Observable_1.Observable.prototype.count = count_1.count; + +},{"../../Observable":3,"../../operator/count":148}],45:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var debounce_1 = require('../../operator/debounce'); +Observable_1.Observable.prototype.debounce = debounce_1.debounce; + +},{"../../Observable":3,"../../operator/debounce":149}],46:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var debounceTime_1 = require('../../operator/debounceTime'); +Observable_1.Observable.prototype.debounceTime = debounceTime_1.debounceTime; + +},{"../../Observable":3,"../../operator/debounceTime":150}],47:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var defaultIfEmpty_1 = require('../../operator/defaultIfEmpty'); +Observable_1.Observable.prototype.defaultIfEmpty = defaultIfEmpty_1.defaultIfEmpty; + +},{"../../Observable":3,"../../operator/defaultIfEmpty":151}],48:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var delay_1 = require('../../operator/delay'); +Observable_1.Observable.prototype.delay = delay_1.delay; + +},{"../../Observable":3,"../../operator/delay":152}],49:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var delayWhen_1 = require('../../operator/delayWhen'); +Observable_1.Observable.prototype.delayWhen = delayWhen_1.delayWhen; + +},{"../../Observable":3,"../../operator/delayWhen":153}],50:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var dematerialize_1 = require('../../operator/dematerialize'); +Observable_1.Observable.prototype.dematerialize = dematerialize_1.dematerialize; + +},{"../../Observable":3,"../../operator/dematerialize":154}],51:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var distinctUntilChanged_1 = require('../../operator/distinctUntilChanged'); +Observable_1.Observable.prototype.distinctUntilChanged = distinctUntilChanged_1.distinctUntilChanged; + +},{"../../Observable":3,"../../operator/distinctUntilChanged":155}],52:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var do_1 = require('../../operator/do'); +Observable_1.Observable.prototype.do = do_1._do; + +},{"../../Observable":3,"../../operator/do":156}],53:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var every_1 = require('../../operator/every'); +Observable_1.Observable.prototype.every = every_1.every; + +},{"../../Observable":3,"../../operator/every":157}],54:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var expand_1 = require('../../operator/expand'); +Observable_1.Observable.prototype.expand = expand_1.expand; + +},{"../../Observable":3,"../../operator/expand":158}],55:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var filter_1 = require('../../operator/filter'); +Observable_1.Observable.prototype.filter = filter_1.filter; + +},{"../../Observable":3,"../../operator/filter":159}],56:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var finally_1 = require('../../operator/finally'); +Observable_1.Observable.prototype.finally = finally_1._finally; + +},{"../../Observable":3,"../../operator/finally":160}],57:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var first_1 = require('../../operator/first'); +Observable_1.Observable.prototype.first = first_1.first; + +},{"../../Observable":3,"../../operator/first":161}],58:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var groupBy_1 = require('../../operator/groupBy'); +Observable_1.Observable.prototype.groupBy = groupBy_1.groupBy; + +},{"../../Observable":3,"../../operator/groupBy":162}],59:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var ignoreElements_1 = require('../../operator/ignoreElements'); +Observable_1.Observable.prototype.ignoreElements = ignoreElements_1.ignoreElements; + +},{"../../Observable":3,"../../operator/ignoreElements":163}],60:[function(require,module,exports){ +"use strict"; +/** + * Everything in this file is generated by the 'tools/generate-operator-patches.ts' script. + * Any manual edits to this file will be lost next time the script is run. + **/ +var Observable_1 = require('../../Observable'); +var inspect_1 = require('../../operator/inspect'); +Observable_1.Observable.prototype.inspect = inspect_1.inspect; + +},{"../../Observable":3,"../../operator/inspect":164}],61:[function(require,module,exports){ +"use strict"; +/** + * Everything in this file is generated by the 'tools/generate-operator-patches.ts' script. + * Any manual edits to this file will be lost next time the script is run. + **/ +var Observable_1 = require('../../Observable'); +var inspectTime_1 = require('../../operator/inspectTime'); +Observable_1.Observable.prototype.inspectTime = inspectTime_1.inspectTime; + +},{"../../Observable":3,"../../operator/inspectTime":165}],62:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var last_1 = require('../../operator/last'); +Observable_1.Observable.prototype.last = last_1.last; + +},{"../../Observable":3,"../../operator/last":166}],63:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var let_1 = require('../../operator/let'); +Observable_1.Observable.prototype.let = let_1.letProto; +Observable_1.Observable.prototype.letBind = let_1.letProto; + +},{"../../Observable":3,"../../operator/let":167}],64:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var map_1 = require('../../operator/map'); +Observable_1.Observable.prototype.map = map_1.map; + +},{"../../Observable":3,"../../operator/map":168}],65:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var mapTo_1 = require('../../operator/mapTo'); +Observable_1.Observable.prototype.mapTo = mapTo_1.mapTo; + +},{"../../Observable":3,"../../operator/mapTo":169}],66:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var materialize_1 = require('../../operator/materialize'); +Observable_1.Observable.prototype.materialize = materialize_1.materialize; + +},{"../../Observable":3,"../../operator/materialize":170}],67:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var merge_1 = require('../../operator/merge'); +Observable_1.Observable.prototype.merge = merge_1.merge; + +},{"../../Observable":3,"../../operator/merge":171}],68:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var mergeAll_1 = require('../../operator/mergeAll'); +Observable_1.Observable.prototype.mergeAll = mergeAll_1.mergeAll; + +},{"../../Observable":3,"../../operator/mergeAll":172}],69:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var mergeMap_1 = require('../../operator/mergeMap'); +Observable_1.Observable.prototype.mergeMap = mergeMap_1.mergeMap; +Observable_1.Observable.prototype.flatMap = mergeMap_1.mergeMap; + +},{"../../Observable":3,"../../operator/mergeMap":173}],70:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var mergeMapTo_1 = require('../../operator/mergeMapTo'); +Observable_1.Observable.prototype.mergeMapTo = mergeMapTo_1.mergeMapTo; + +},{"../../Observable":3,"../../operator/mergeMapTo":174}],71:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var multicast_1 = require('../../operator/multicast'); +Observable_1.Observable.prototype.multicast = multicast_1.multicast; + +},{"../../Observable":3,"../../operator/multicast":175}],72:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var observeOn_1 = require('../../operator/observeOn'); +Observable_1.Observable.prototype.observeOn = observeOn_1.observeOn; + +},{"../../Observable":3,"../../operator/observeOn":176}],73:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var partition_1 = require('../../operator/partition'); +Observable_1.Observable.prototype.partition = partition_1.partition; + +},{"../../Observable":3,"../../operator/partition":177}],74:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var pluck_1 = require('../../operator/pluck'); +Observable_1.Observable.prototype.pluck = pluck_1.pluck; + +},{"../../Observable":3,"../../operator/pluck":178}],75:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var publish_1 = require('../../operator/publish'); +Observable_1.Observable.prototype.publish = publish_1.publish; + +},{"../../Observable":3,"../../operator/publish":179}],76:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var publishBehavior_1 = require('../../operator/publishBehavior'); +Observable_1.Observable.prototype.publishBehavior = publishBehavior_1.publishBehavior; + +},{"../../Observable":3,"../../operator/publishBehavior":180}],77:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var publishLast_1 = require('../../operator/publishLast'); +Observable_1.Observable.prototype.publishLast = publishLast_1.publishLast; + +},{"../../Observable":3,"../../operator/publishLast":181}],78:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var publishReplay_1 = require('../../operator/publishReplay'); +Observable_1.Observable.prototype.publishReplay = publishReplay_1.publishReplay; + +},{"../../Observable":3,"../../operator/publishReplay":182}],79:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var race_1 = require('../../operator/race'); +Observable_1.Observable.prototype.race = race_1.race; + +},{"../../Observable":3,"../../operator/race":183}],80:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var reduce_1 = require('../../operator/reduce'); +Observable_1.Observable.prototype.reduce = reduce_1.reduce; + +},{"../../Observable":3,"../../operator/reduce":184}],81:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var repeat_1 = require('../../operator/repeat'); +Observable_1.Observable.prototype.repeat = repeat_1.repeat; + +},{"../../Observable":3,"../../operator/repeat":185}],82:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var retry_1 = require('../../operator/retry'); +Observable_1.Observable.prototype.retry = retry_1.retry; + +},{"../../Observable":3,"../../operator/retry":186}],83:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var retryWhen_1 = require('../../operator/retryWhen'); +Observable_1.Observable.prototype.retryWhen = retryWhen_1.retryWhen; + +},{"../../Observable":3,"../../operator/retryWhen":187}],84:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var sample_1 = require('../../operator/sample'); +Observable_1.Observable.prototype.sample = sample_1.sample; + +},{"../../Observable":3,"../../operator/sample":188}],85:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var sampleTime_1 = require('../../operator/sampleTime'); +Observable_1.Observable.prototype.sampleTime = sampleTime_1.sampleTime; + +},{"../../Observable":3,"../../operator/sampleTime":189}],86:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var scan_1 = require('../../operator/scan'); +Observable_1.Observable.prototype.scan = scan_1.scan; + +},{"../../Observable":3,"../../operator/scan":190}],87:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var share_1 = require('../../operator/share'); +Observable_1.Observable.prototype.share = share_1.share; + +},{"../../Observable":3,"../../operator/share":191}],88:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var single_1 = require('../../operator/single'); +Observable_1.Observable.prototype.single = single_1.single; + +},{"../../Observable":3,"../../operator/single":192}],89:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var skip_1 = require('../../operator/skip'); +Observable_1.Observable.prototype.skip = skip_1.skip; + +},{"../../Observable":3,"../../operator/skip":193}],90:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var skipUntil_1 = require('../../operator/skipUntil'); +Observable_1.Observable.prototype.skipUntil = skipUntil_1.skipUntil; + +},{"../../Observable":3,"../../operator/skipUntil":194}],91:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var skipWhile_1 = require('../../operator/skipWhile'); +Observable_1.Observable.prototype.skipWhile = skipWhile_1.skipWhile; + +},{"../../Observable":3,"../../operator/skipWhile":195}],92:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var startWith_1 = require('../../operator/startWith'); +Observable_1.Observable.prototype.startWith = startWith_1.startWith; + +},{"../../Observable":3,"../../operator/startWith":196}],93:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var subscribeOn_1 = require('../../operator/subscribeOn'); +Observable_1.Observable.prototype.subscribeOn = subscribeOn_1.subscribeOn; + +},{"../../Observable":3,"../../operator/subscribeOn":197}],94:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var switch_1 = require('../../operator/switch'); +Observable_1.Observable.prototype.switch = switch_1._switch; + +},{"../../Observable":3,"../../operator/switch":198}],95:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var switchMap_1 = require('../../operator/switchMap'); +Observable_1.Observable.prototype.switchMap = switchMap_1.switchMap; + +},{"../../Observable":3,"../../operator/switchMap":199}],96:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var switchMapTo_1 = require('../../operator/switchMapTo'); +Observable_1.Observable.prototype.switchMapTo = switchMapTo_1.switchMapTo; + +},{"../../Observable":3,"../../operator/switchMapTo":200}],97:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var take_1 = require('../../operator/take'); +Observable_1.Observable.prototype.take = take_1.take; + +},{"../../Observable":3,"../../operator/take":201}],98:[function(require,module,exports){ +"use strict"; +/** + * Everything in this file is generated by the 'tools/generate-operator-patches.ts' script. + * Any manual edits to this file will be lost next time the script is run. + **/ +var Observable_1 = require('../../Observable'); +var takeLast_1 = require('../../operator/takeLast'); +Observable_1.Observable.prototype.takeLast = takeLast_1.takeLast; + +},{"../../Observable":3,"../../operator/takeLast":202}],99:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var takeUntil_1 = require('../../operator/takeUntil'); +Observable_1.Observable.prototype.takeUntil = takeUntil_1.takeUntil; + +},{"../../Observable":3,"../../operator/takeUntil":203}],100:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var takeWhile_1 = require('../../operator/takeWhile'); +Observable_1.Observable.prototype.takeWhile = takeWhile_1.takeWhile; + +},{"../../Observable":3,"../../operator/takeWhile":204}],101:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var throttle_1 = require('../../operator/throttle'); +Observable_1.Observable.prototype.throttle = throttle_1.throttle; + +},{"../../Observable":3,"../../operator/throttle":205}],102:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var throttleTime_1 = require('../../operator/throttleTime'); +Observable_1.Observable.prototype.throttleTime = throttleTime_1.throttleTime; + +},{"../../Observable":3,"../../operator/throttleTime":206}],103:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var timeout_1 = require('../../operator/timeout'); +Observable_1.Observable.prototype.timeout = timeout_1.timeout; + +},{"../../Observable":3,"../../operator/timeout":207}],104:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var timeoutWith_1 = require('../../operator/timeoutWith'); +Observable_1.Observable.prototype.timeoutWith = timeoutWith_1.timeoutWith; + +},{"../../Observable":3,"../../operator/timeoutWith":208}],105:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var toArray_1 = require('../../operator/toArray'); +Observable_1.Observable.prototype.toArray = toArray_1.toArray; + +},{"../../Observable":3,"../../operator/toArray":209}],106:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var toPromise_1 = require('../../operator/toPromise'); +Observable_1.Observable.prototype.toPromise = toPromise_1.toPromise; + +},{"../../Observable":3,"../../operator/toPromise":210}],107:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var window_1 = require('../../operator/window'); +Observable_1.Observable.prototype.window = window_1.window; + +},{"../../Observable":3,"../../operator/window":211}],108:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var windowCount_1 = require('../../operator/windowCount'); +Observable_1.Observable.prototype.windowCount = windowCount_1.windowCount; + +},{"../../Observable":3,"../../operator/windowCount":212}],109:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var windowTime_1 = require('../../operator/windowTime'); +Observable_1.Observable.prototype.windowTime = windowTime_1.windowTime; + +},{"../../Observable":3,"../../operator/windowTime":213}],110:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var windowToggle_1 = require('../../operator/windowToggle'); +Observable_1.Observable.prototype.windowToggle = windowToggle_1.windowToggle; + +},{"../../Observable":3,"../../operator/windowToggle":214}],111:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var windowWhen_1 = require('../../operator/windowWhen'); +Observable_1.Observable.prototype.windowWhen = windowWhen_1.windowWhen; + +},{"../../Observable":3,"../../operator/windowWhen":215}],112:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var withLatestFrom_1 = require('../../operator/withLatestFrom'); +Observable_1.Observable.prototype.withLatestFrom = withLatestFrom_1.withLatestFrom; + +},{"../../Observable":3,"../../operator/withLatestFrom":216}],113:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var zip_1 = require('../../operator/zip'); +Observable_1.Observable.prototype.zip = zip_1.zipProto; + +},{"../../Observable":3,"../../operator/zip":217}],114:[function(require,module,exports){ +"use strict"; +var Observable_1 = require('../../Observable'); +var zipAll_1 = require('../../operator/zipAll'); +Observable_1.Observable.prototype.zipAll = zipAll_1.zipAll; + +},{"../../Observable":3,"../../operator/zipAll":218}],115:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var ScalarObservable_1 = require('./ScalarObservable'); +var EmptyObservable_1 = require('./EmptyObservable'); +var ArrayLikeObservable = (function (_super) { + __extends(ArrayLikeObservable, _super); + function ArrayLikeObservable(arrayLike, mapFn, thisArg, scheduler) { + _super.call(this); + this.arrayLike = arrayLike; + this.scheduler = scheduler; + if (!mapFn && !scheduler && arrayLike.length === 1) { + this._isScalar = true; + this.value = arrayLike[0]; + } + if (mapFn) { + this.mapFn = mapFn.bind(thisArg); + } + } + ArrayLikeObservable.create = function (arrayLike, mapFn, thisArg, scheduler) { + var length = arrayLike.length; + if (length === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + else if (length === 1 && !mapFn) { + return new ScalarObservable_1.ScalarObservable(arrayLike[0], scheduler); + } + else { + return new ArrayLikeObservable(arrayLike, mapFn, thisArg, scheduler); + } + }; + ArrayLikeObservable.dispatch = function (state) { + var arrayLike = state.arrayLike, index = state.index, length = state.length, mapFn = state.mapFn, subscriber = state.subscriber; + if (subscriber.isUnsubscribed) { + return; + } + if (index >= length) { + subscriber.complete(); + return; + } + var result = mapFn ? mapFn(arrayLike[index], index) : arrayLike[index]; + subscriber.next(result); + state.index = index + 1; + this.schedule(state); + }; + ArrayLikeObservable.prototype._subscribe = function (subscriber) { + var index = 0; + var _a = this, arrayLike = _a.arrayLike, mapFn = _a.mapFn, scheduler = _a.scheduler; + var length = arrayLike.length; + if (scheduler) { + return scheduler.schedule(ArrayLikeObservable.dispatch, 0, { + arrayLike: arrayLike, index: index, length: length, mapFn: mapFn, subscriber: subscriber + }); + } + else { + for (var i = 0; i < length && !subscriber.isUnsubscribed; i++) { + var result = mapFn ? mapFn(arrayLike[i], i) : arrayLike[i]; + subscriber.next(result); + } + subscriber.complete(); + } + }; + return ArrayLikeObservable; +}(Observable_1.Observable)); +exports.ArrayLikeObservable = ArrayLikeObservable; + +},{"../Observable":3,"./EmptyObservable":121,"./ScalarObservable":132}],116:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var ScalarObservable_1 = require('./ScalarObservable'); +var EmptyObservable_1 = require('./EmptyObservable'); +var isScheduler_1 = require('../util/isScheduler'); +var ArrayObservable = (function (_super) { + __extends(ArrayObservable, _super); + function ArrayObservable(array, scheduler) { + _super.call(this); + this.array = array; + this.scheduler = scheduler; + if (!scheduler && array.length === 1) { + this._isScalar = true; + this.value = array[0]; + } + } + ArrayObservable.create = function (array, scheduler) { + return new ArrayObservable(array, scheduler); + }; + ArrayObservable.of = function () { + var array = []; + for (var _i = 0; _i < arguments.length; _i++) { + array[_i - 0] = arguments[_i]; + } + var scheduler = array[array.length - 1]; + if (isScheduler_1.isScheduler(scheduler)) { + array.pop(); + } + else { + scheduler = null; + } + var len = array.length; + if (len > 1) { + return new ArrayObservable(array, scheduler); + } + else if (len === 1) { + return new ScalarObservable_1.ScalarObservable(array[0], scheduler); + } + else { + return new EmptyObservable_1.EmptyObservable(scheduler); + } + }; + ArrayObservable.dispatch = function (state) { + var array = state.array, index = state.index, count = state.count, subscriber = state.subscriber; + if (index >= count) { + subscriber.complete(); + return; + } + subscriber.next(array[index]); + if (subscriber.isUnsubscribed) { + return; + } + state.index = index + 1; + this.schedule(state); + }; + ArrayObservable.prototype._subscribe = function (subscriber) { + var index = 0; + var array = this.array; + var count = array.length; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(ArrayObservable.dispatch, 0, { + array: array, index: index, count: count, subscriber: subscriber + }); + } + else { + for (var i = 0; i < count && !subscriber.isUnsubscribed; i++) { + subscriber.next(array[i]); + } + subscriber.complete(); + } + }; + return ArrayObservable; +}(Observable_1.Observable)); +exports.ArrayObservable = ArrayObservable; + +},{"../Observable":3,"../util/isScheduler":246,"./EmptyObservable":121,"./ScalarObservable":132}],117:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var AsyncSubject_1 = require('../subject/AsyncSubject'); +var BoundCallbackObservable = (function (_super) { + __extends(BoundCallbackObservable, _super); + function BoundCallbackObservable(callbackFunc, selector, args, scheduler) { + _super.call(this); + this.callbackFunc = callbackFunc; + this.selector = selector; + this.args = args; + this.scheduler = scheduler; + } + /* tslint:enable:max-line-length */ + BoundCallbackObservable.create = function (callbackFunc, selector, scheduler) { + if (selector === void 0) { selector = undefined; } + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + return new BoundCallbackObservable(callbackFunc, selector, args, scheduler); + }; + }; + BoundCallbackObservable.prototype._subscribe = function (subscriber) { + var callbackFunc = this.callbackFunc; + var args = this.args; + var scheduler = this.scheduler; + var subject = this.subject; + if (!scheduler) { + if (!subject) { + subject = this.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, subject = source.subject; + if (selector) { + var result_1 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_1 === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + else { + subject.next(result_1); + subject.complete(); + } + } + else { + subject.next(innerArgs.length === 1 ? innerArgs[0] : innerArgs); + subject.complete(); + } + }; + // use named function instance to avoid closure. + handler.source = this; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + return subject.subscribe(subscriber); + } + else { + return scheduler.schedule(dispatch, 0, { source: this, subscriber: subscriber }); + } + }; + return BoundCallbackObservable; +}(Observable_1.Observable)); +exports.BoundCallbackObservable = BoundCallbackObservable; +function dispatch(state) { + var self = this; + var source = state.source, subscriber = state.subscriber; + var callbackFunc = source.callbackFunc, args = source.args, scheduler = source.scheduler; + var subject = source.subject; + if (!subject) { + subject = source.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, subject = source.subject; + if (selector) { + var result_2 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_2 === errorObject_1.errorObject) { + self.add(scheduler.schedule(dispatchError, 0, { err: errorObject_1.errorObject.e, subject: subject })); + } + else { + self.add(scheduler.schedule(dispatchNext, 0, { value: result_2, subject: subject })); + } + } + else { + var value = innerArgs.length === 1 ? innerArgs[0] : innerArgs; + self.add(scheduler.schedule(dispatchNext, 0, { value: value, subject: subject })); + } + }; + // use named function to pass values in without closure + handler.source = source; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + self.add(subject.subscribe(subscriber)); +} +function dispatchNext(_a) { + var value = _a.value, subject = _a.subject; + subject.next(value); + subject.complete(); +} +function dispatchError(_a) { + var err = _a.err, subject = _a.subject; + subject.error(err); +} + +},{"../Observable":3,"../subject/AsyncSubject":226,"../util/errorObject":239,"../util/tryCatch":253}],118:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var AsyncSubject_1 = require('../subject/AsyncSubject'); +var BoundNodeCallbackObservable = (function (_super) { + __extends(BoundNodeCallbackObservable, _super); + function BoundNodeCallbackObservable(callbackFunc, selector, args, scheduler) { + _super.call(this); + this.callbackFunc = callbackFunc; + this.selector = selector; + this.args = args; + this.scheduler = scheduler; + } + /* tslint:enable:max-line-length */ + BoundNodeCallbackObservable.create = function (callbackFunc, selector, scheduler) { + if (selector === void 0) { selector = undefined; } + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + return new BoundNodeCallbackObservable(callbackFunc, selector, args, scheduler); + }; + }; + BoundNodeCallbackObservable.prototype._subscribe = function (subscriber) { + var callbackFunc = this.callbackFunc; + var args = this.args; + var scheduler = this.scheduler; + var subject = this.subject; + if (!scheduler) { + if (!subject) { + subject = this.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, subject = source.subject; + var err = innerArgs.shift(); + if (err) { + subject.error(err); + } + else if (selector) { + var result_1 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_1 === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + else { + subject.next(result_1); + subject.complete(); + } + } + else { + subject.next(innerArgs.length === 1 ? innerArgs[0] : innerArgs); + subject.complete(); + } + }; + // use named function instance to avoid closure. + handler.source = this; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + return subject.subscribe(subscriber); + } + else { + return scheduler.schedule(dispatch, 0, { source: this, subscriber: subscriber }); + } + }; + return BoundNodeCallbackObservable; +}(Observable_1.Observable)); +exports.BoundNodeCallbackObservable = BoundNodeCallbackObservable; +function dispatch(state) { + var self = this; + var source = state.source, subscriber = state.subscriber; + var callbackFunc = source.callbackFunc, args = source.args, scheduler = source.scheduler; + var subject = source.subject; + if (!subject) { + subject = source.subject = new AsyncSubject_1.AsyncSubject(); + var handler = function handlerFn() { + var innerArgs = []; + for (var _i = 0; _i < arguments.length; _i++) { + innerArgs[_i - 0] = arguments[_i]; + } + var source = handlerFn.source; + var selector = source.selector, subject = source.subject; + var err = innerArgs.shift(); + if (err) { + subject.error(err); + } + else if (selector) { + var result_2 = tryCatch_1.tryCatch(selector).apply(this, innerArgs); + if (result_2 === errorObject_1.errorObject) { + self.add(scheduler.schedule(dispatchError, 0, { err: errorObject_1.errorObject.e, subject: subject })); + } + else { + self.add(scheduler.schedule(dispatchNext, 0, { value: result_2, subject: subject })); + } + } + else { + var value = innerArgs.length === 1 ? innerArgs[0] : innerArgs; + self.add(scheduler.schedule(dispatchNext, 0, { value: value, subject: subject })); + } + }; + // use named function to pass values in without closure + handler.source = source; + var result = tryCatch_1.tryCatch(callbackFunc).apply(this, args.concat(handler)); + if (result === errorObject_1.errorObject) { + subject.error(errorObject_1.errorObject.e); + } + } + self.add(subject.subscribe(subscriber)); +} +function dispatchNext(_a) { + var value = _a.value, subject = _a.subject; + subject.next(value); + subject.complete(); +} +function dispatchError(_a) { + var err = _a.err, subject = _a.subject; + subject.error(err); +} + +},{"../Observable":3,"../subject/AsyncSubject":226,"../util/errorObject":239,"../util/tryCatch":253}],119:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var Subscriber_1 = require('../Subscriber'); +var Subscription_1 = require('../Subscription'); +var ConnectableObservable = (function (_super) { + __extends(ConnectableObservable, _super); + function ConnectableObservable(source, subjectFactory) { + _super.call(this); + this.source = source; + this.subjectFactory = subjectFactory; + } + ConnectableObservable.prototype._subscribe = function (subscriber) { + return this.getSubject().subscribe(subscriber); + }; + ConnectableObservable.prototype.getSubject = function () { + var subject = this.subject; + if (subject && !subject.isUnsubscribed) { + return subject; + } + return (this.subject = this.subjectFactory()); + }; + ConnectableObservable.prototype.connect = function () { + var source = this.source; + var subscription = this.subscription; + if (subscription && !subscription.isUnsubscribed) { + return subscription; + } + subscription = source.subscribe(this.getSubject()); + subscription.add(new ConnectableSubscription(this)); + return (this.subscription = subscription); + }; + ConnectableObservable.prototype.refCount = function () { + return new RefCountObservable(this); + }; + /** + * This method is opened for `ConnectableSubscription`. + * Not to call from others. + */ + ConnectableObservable.prototype._closeSubscription = function () { + this.subject = null; + this.subscription = null; + }; + return ConnectableObservable; +}(Observable_1.Observable)); +exports.ConnectableObservable = ConnectableObservable; +var ConnectableSubscription = (function (_super) { + __extends(ConnectableSubscription, _super); + function ConnectableSubscription(connectable) { + _super.call(this); + this.connectable = connectable; + } + ConnectableSubscription.prototype._unsubscribe = function () { + var connectable = this.connectable; + connectable._closeSubscription(); + this.connectable = null; + }; + return ConnectableSubscription; +}(Subscription_1.Subscription)); +var RefCountObservable = (function (_super) { + __extends(RefCountObservable, _super); + function RefCountObservable(connectable, refCount) { + if (refCount === void 0) { refCount = 0; } + _super.call(this); + this.connectable = connectable; + this.refCount = refCount; + } + RefCountObservable.prototype._subscribe = function (subscriber) { + var connectable = this.connectable; + var refCountSubscriber = new RefCountSubscriber(subscriber, this); + var subscription = connectable.subscribe(refCountSubscriber); + if (!subscription.isUnsubscribed && ++this.refCount === 1) { + refCountSubscriber.connection = this.connection = connectable.connect(); + } + return subscription; + }; + return RefCountObservable; +}(Observable_1.Observable)); +var RefCountSubscriber = (function (_super) { + __extends(RefCountSubscriber, _super); + function RefCountSubscriber(destination, refCountObservable) { + _super.call(this, null); + this.destination = destination; + this.refCountObservable = refCountObservable; + this.connection = refCountObservable.connection; + destination.add(this); + } + RefCountSubscriber.prototype._next = function (value) { + this.destination.next(value); + }; + RefCountSubscriber.prototype._error = function (err) { + this._resetConnectable(); + this.destination.error(err); + }; + RefCountSubscriber.prototype._complete = function () { + this._resetConnectable(); + this.destination.complete(); + }; + RefCountSubscriber.prototype._resetConnectable = function () { + var observable = this.refCountObservable; + var obsConnection = observable.connection; + var subConnection = this.connection; + if (subConnection && subConnection === obsConnection) { + observable.refCount = 0; + obsConnection.unsubscribe(); + observable.connection = null; + this.unsubscribe(); + } + }; + RefCountSubscriber.prototype._unsubscribe = function () { + var observable = this.refCountObservable; + if (observable.refCount === 0) { + return; + } + if (--observable.refCount === 0) { + var obsConnection = observable.connection; + var subConnection = this.connection; + if (subConnection && subConnection === obsConnection) { + obsConnection.unsubscribe(); + observable.connection = null; + } + } + }; + return RefCountSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Observable":3,"../Subscriber":9,"../Subscription":10}],120:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var DeferObservable = (function (_super) { + __extends(DeferObservable, _super); + function DeferObservable(observableFactory) { + _super.call(this); + this.observableFactory = observableFactory; + } + DeferObservable.create = function (observableFactory) { + return new DeferObservable(observableFactory); + }; + DeferObservable.prototype._subscribe = function (subscriber) { + var result = tryCatch_1.tryCatch(this.observableFactory)(); + if (result === errorObject_1.errorObject) { + subscriber.error(errorObject_1.errorObject.e); + } + else { + result.subscribe(subscriber); + } + }; + return DeferObservable; +}(Observable_1.Observable)); +exports.DeferObservable = DeferObservable; + +},{"../Observable":3,"../util/errorObject":239,"../util/tryCatch":253}],121:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var EmptyObservable = (function (_super) { + __extends(EmptyObservable, _super); + function EmptyObservable(scheduler) { + _super.call(this); + this.scheduler = scheduler; + } + EmptyObservable.create = function (scheduler) { + return new EmptyObservable(scheduler); + }; + EmptyObservable.dispatch = function (_a) { + var subscriber = _a.subscriber; + subscriber.complete(); + }; + EmptyObservable.prototype._subscribe = function (subscriber) { + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(EmptyObservable.dispatch, 0, { subscriber: subscriber }); + } + else { + subscriber.complete(); + } + }; + return EmptyObservable; +}(Observable_1.Observable)); +exports.EmptyObservable = EmptyObservable; + +},{"../Observable":3}],122:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var ErrorObservable = (function (_super) { + __extends(ErrorObservable, _super); + function ErrorObservable(error, scheduler) { + _super.call(this); + this.error = error; + this.scheduler = scheduler; + } + ErrorObservable.create = function (error, scheduler) { + return new ErrorObservable(error, scheduler); + }; + ErrorObservable.dispatch = function (_a) { + var error = _a.error, subscriber = _a.subscriber; + subscriber.error(error); + }; + ErrorObservable.prototype._subscribe = function (subscriber) { + var error = this.error; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(ErrorObservable.dispatch, 0, { + error: error, subscriber: subscriber + }); + } + else { + subscriber.error(error); + } + }; + return ErrorObservable; +}(Observable_1.Observable)); +exports.ErrorObservable = ErrorObservable; + +},{"../Observable":3}],123:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var Subscriber_1 = require('../Subscriber'); +var PromiseObservable_1 = require('./PromiseObservable'); +var EmptyObservable_1 = require('./EmptyObservable'); +var isPromise_1 = require('../util/isPromise'); +var isArray_1 = require('../util/isArray'); +var ForkJoinObservable = (function (_super) { + __extends(ForkJoinObservable, _super); + function ForkJoinObservable(sources, resultSelector) { + _super.call(this); + this.sources = sources; + this.resultSelector = resultSelector; + } + ForkJoinObservable.create = function () { + var sources = []; + for (var _i = 0; _i < arguments.length; _i++) { + sources[_i - 0] = arguments[_i]; + } + if (sources === null || arguments.length === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + var resultSelector = null; + if (typeof sources[sources.length - 1] === 'function') { + resultSelector = sources.pop(); + } + // if the first and only other argument besides the resultSelector is an array + // assume it's been called with `forkJoin([obs1, obs2, obs3], resultSelector)` + if (sources.length === 1 && isArray_1.isArray(sources[0])) { + sources = sources[0]; + } + if (sources.length === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + return new ForkJoinObservable(sources, resultSelector); + }; + ForkJoinObservable.prototype._subscribe = function (subscriber) { + var sources = this.sources; + var len = sources.length; + var context = { completed: 0, total: len, values: emptyArray(len), selector: this.resultSelector }; + for (var i = 0; i < len; i++) { + var source = sources[i]; + if (isPromise_1.isPromise(source)) { + source = new PromiseObservable_1.PromiseObservable(source); + } + source.subscribe(new AllSubscriber(subscriber, i, context)); + } + }; + return ForkJoinObservable; +}(Observable_1.Observable)); +exports.ForkJoinObservable = ForkJoinObservable; +var AllSubscriber = (function (_super) { + __extends(AllSubscriber, _super); + function AllSubscriber(destination, index, context) { + _super.call(this, destination); + this.index = index; + this.context = context; + this._value = null; + } + AllSubscriber.prototype._next = function (value) { + this._value = value; + }; + AllSubscriber.prototype._complete = function () { + var destination = this.destination; + if (this._value == null) { + destination.complete(); + } + var context = this.context; + context.completed++; + context.values[this.index] = this._value; + var values = context.values; + if (context.completed !== values.length) { + return; + } + if (values.every(hasValue)) { + var value = context.selector ? context.selector.apply(this, values) : + values; + destination.next(value); + } + destination.complete(); + }; + return AllSubscriber; +}(Subscriber_1.Subscriber)); +function hasValue(x) { + return x !== null; +} +function emptyArray(len) { + var arr = []; + for (var i = 0; i < len; i++) { + arr.push(null); + } + return arr; +} + +},{"../Observable":3,"../Subscriber":9,"../util/isArray":240,"../util/isPromise":245,"./EmptyObservable":121,"./PromiseObservable":130}],124:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var Subscription_1 = require('../Subscription'); +function isNodeStyleEventEmmitter(sourceObj) { + return !!sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function'; +} +function isJQueryStyleEventEmitter(sourceObj) { + return !!sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function'; +} +function isNodeList(sourceObj) { + return !!sourceObj && sourceObj.toString() === '[object NodeList]'; +} +function isHTMLCollection(sourceObj) { + return !!sourceObj && sourceObj.toString() === '[object HTMLCollection]'; +} +function isEventTarget(sourceObj) { + return !!sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function'; +} +var FromEventObservable = (function (_super) { + __extends(FromEventObservable, _super); + function FromEventObservable(sourceObj, eventName, selector) { + _super.call(this); + this.sourceObj = sourceObj; + this.eventName = eventName; + this.selector = selector; + } + FromEventObservable.create = function (sourceObj, eventName, selector) { + return new FromEventObservable(sourceObj, eventName, selector); + }; + FromEventObservable.setupSubscription = function (sourceObj, eventName, handler, subscriber) { + var unsubscribe; + if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) { + for (var i = 0, len = sourceObj.length; i < len; i++) { + FromEventObservable.setupSubscription(sourceObj[i], eventName, handler, subscriber); + } + } + else if (isEventTarget(sourceObj)) { + sourceObj.addEventListener(eventName, handler); + unsubscribe = function () { return sourceObj.removeEventListener(eventName, handler); }; + } + else if (isJQueryStyleEventEmitter(sourceObj)) { + sourceObj.on(eventName, handler); + unsubscribe = function () { return sourceObj.off(eventName, handler); }; + } + else if (isNodeStyleEventEmmitter(sourceObj)) { + sourceObj.addListener(eventName, handler); + unsubscribe = function () { return sourceObj.removeListener(eventName, handler); }; + } + subscriber.add(new Subscription_1.Subscription(unsubscribe)); + }; + FromEventObservable.prototype._subscribe = function (subscriber) { + var sourceObj = this.sourceObj; + var eventName = this.eventName; + var selector = this.selector; + var handler = selector ? function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + var result = tryCatch_1.tryCatch(selector).apply(void 0, args); + if (result === errorObject_1.errorObject) { + subscriber.error(errorObject_1.errorObject.e); + } + else { + subscriber.next(result); + } + } : function (e) { return subscriber.next(e); }; + FromEventObservable.setupSubscription(sourceObj, eventName, handler, subscriber); + }; + return FromEventObservable; +}(Observable_1.Observable)); +exports.FromEventObservable = FromEventObservable; + +},{"../Observable":3,"../Subscription":10,"../util/errorObject":239,"../util/tryCatch":253}],125:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var Subscription_1 = require('../Subscription'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var FromEventPatternObservable = (function (_super) { + __extends(FromEventPatternObservable, _super); + function FromEventPatternObservable(addHandler, removeHandler, selector) { + _super.call(this); + this.addHandler = addHandler; + this.removeHandler = removeHandler; + this.selector = selector; + } + FromEventPatternObservable.create = function (addHandler, removeHandler, selector) { + return new FromEventPatternObservable(addHandler, removeHandler, selector); + }; + FromEventPatternObservable.prototype._subscribe = function (subscriber) { + var addHandler = this.addHandler; + var removeHandler = this.removeHandler; + var selector = this.selector; + var handler = selector ? function (e) { + var result = tryCatch_1.tryCatch(selector).apply(null, arguments); + if (result === errorObject_1.errorObject) { + subscriber.error(result.e); + } + else { + subscriber.next(result); + } + } : function (e) { subscriber.next(e); }; + var result = tryCatch_1.tryCatch(addHandler)(handler); + if (result === errorObject_1.errorObject) { + subscriber.error(result.e); + } + subscriber.add(new Subscription_1.Subscription(function () { + //TODO: determine whether or not to forward to error handler + removeHandler(handler); + })); + }; + return FromEventPatternObservable; +}(Observable_1.Observable)); +exports.FromEventPatternObservable = FromEventPatternObservable; + +},{"../Observable":3,"../Subscription":10,"../util/errorObject":239,"../util/tryCatch":253}],126:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var isArray_1 = require('../util/isArray'); +var isFunction_1 = require('../util/isFunction'); +var isPromise_1 = require('../util/isPromise'); +var isScheduler_1 = require('../util/isScheduler'); +var PromiseObservable_1 = require('./PromiseObservable'); +var IteratorObservable_1 = require('./IteratorObservable'); +var ArrayObservable_1 = require('./ArrayObservable'); +var ArrayLikeObservable_1 = require('./ArrayLikeObservable'); +var SymbolShim_1 = require('../util/SymbolShim'); +var Observable_1 = require('../Observable'); +var observeOn_1 = require('../operator/observeOn'); +var isArrayLike = (function (x) { return x && typeof x.length === 'number'; }); +var FromObservable = (function (_super) { + __extends(FromObservable, _super); + function FromObservable(ish, scheduler) { + _super.call(this, null); + this.ish = ish; + this.scheduler = scheduler; + } + FromObservable.create = function (ish, mapFnOrScheduler, thisArg, lastScheduler) { + var scheduler = null; + var mapFn = null; + if (isFunction_1.isFunction(mapFnOrScheduler)) { + scheduler = lastScheduler || null; + mapFn = mapFnOrScheduler; + } + else if (isScheduler_1.isScheduler(scheduler)) { + scheduler = mapFnOrScheduler; + } + if (ish != null) { + if (typeof ish[SymbolShim_1.SymbolShim.observable] === 'function') { + if (ish instanceof Observable_1.Observable && !scheduler) { + return ish; + } + return new FromObservable(ish, scheduler); + } + else if (isArray_1.isArray(ish)) { + return new ArrayObservable_1.ArrayObservable(ish, scheduler); + } + else if (isPromise_1.isPromise(ish)) { + return new PromiseObservable_1.PromiseObservable(ish, scheduler); + } + else if (typeof ish[SymbolShim_1.SymbolShim.iterator] === 'function' || typeof ish === 'string') { + return new IteratorObservable_1.IteratorObservable(ish, null, null, scheduler); + } + else if (isArrayLike(ish)) { + return new ArrayLikeObservable_1.ArrayLikeObservable(ish, mapFn, thisArg, scheduler); + } + } + throw new TypeError((ish !== null && typeof ish || ish) + ' is not observable'); + }; + FromObservable.prototype._subscribe = function (subscriber) { + var ish = this.ish; + var scheduler = this.scheduler; + if (scheduler == null) { + return ish[SymbolShim_1.SymbolShim.observable]().subscribe(subscriber); + } + else { + return ish[SymbolShim_1.SymbolShim.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber, scheduler, 0)); + } + }; + return FromObservable; +}(Observable_1.Observable)); +exports.FromObservable = FromObservable; + +},{"../Observable":3,"../operator/observeOn":176,"../util/SymbolShim":238,"../util/isArray":240,"../util/isFunction":242,"../util/isPromise":245,"../util/isScheduler":246,"./ArrayLikeObservable":115,"./ArrayObservable":116,"./IteratorObservable":128,"./PromiseObservable":130}],127:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var isNumeric_1 = require('../util/isNumeric'); +var Observable_1 = require('../Observable'); +var asap_1 = require('../scheduler/asap'); +var IntervalObservable = (function (_super) { + __extends(IntervalObservable, _super); + function IntervalObservable(period, scheduler) { + if (period === void 0) { period = 0; } + if (scheduler === void 0) { scheduler = asap_1.asap; } + _super.call(this); + this.period = period; + this.scheduler = scheduler; + if (!isNumeric_1.isNumeric(period) || period < 0) { + this.period = 0; + } + if (!scheduler || typeof scheduler.schedule !== 'function') { + this.scheduler = asap_1.asap; + } + } + IntervalObservable.create = function (period, scheduler) { + if (period === void 0) { period = 0; } + if (scheduler === void 0) { scheduler = asap_1.asap; } + return new IntervalObservable(period, scheduler); + }; + IntervalObservable.dispatch = function (state) { + var index = state.index, subscriber = state.subscriber, period = state.period; + subscriber.next(index); + if (subscriber.isUnsubscribed) { + return; + } + state.index += 1; + this.schedule(state, period); + }; + IntervalObservable.prototype._subscribe = function (subscriber) { + var index = 0; + var period = this.period; + var scheduler = this.scheduler; + subscriber.add(scheduler.schedule(IntervalObservable.dispatch, period, { + index: index, subscriber: subscriber, period: period + })); + }; + return IntervalObservable; +}(Observable_1.Observable)); +exports.IntervalObservable = IntervalObservable; + +},{"../Observable":3,"../scheduler/asap":224,"../util/isNumeric":243}],128:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var root_1 = require('../util/root'); +var isObject_1 = require('../util/isObject'); +var tryCatch_1 = require('../util/tryCatch'); +var Observable_1 = require('../Observable'); +var isFunction_1 = require('../util/isFunction'); +var SymbolShim_1 = require('../util/SymbolShim'); +var errorObject_1 = require('../util/errorObject'); +var IteratorObservable = (function (_super) { + __extends(IteratorObservable, _super); + function IteratorObservable(iterator, project, thisArg, scheduler) { + _super.call(this); + if (iterator == null) { + throw new Error('iterator cannot be null.'); + } + if (isObject_1.isObject(project)) { + this.thisArg = project; + this.scheduler = thisArg; + } + else if (isFunction_1.isFunction(project)) { + this.project = project; + this.thisArg = thisArg; + this.scheduler = scheduler; + } + else if (project != null) { + throw new Error('When provided, `project` must be a function.'); + } + this.iterator = getIterator(iterator); + } + IteratorObservable.create = function (iterator, project, thisArg, scheduler) { + return new IteratorObservable(iterator, project, thisArg, scheduler); + }; + IteratorObservable.dispatch = function (state) { + var index = state.index, hasError = state.hasError, thisArg = state.thisArg, project = state.project, iterator = state.iterator, subscriber = state.subscriber; + if (hasError) { + subscriber.error(state.error); + return; + } + var result = iterator.next(); + if (result.done) { + subscriber.complete(); + return; + } + if (project) { + result = tryCatch_1.tryCatch(project).call(thisArg, result.value, index); + if (result === errorObject_1.errorObject) { + state.error = errorObject_1.errorObject.e; + state.hasError = true; + } + else { + subscriber.next(result); + state.index = index + 1; + } + } + else { + subscriber.next(result.value); + state.index = index + 1; + } + if (subscriber.isUnsubscribed) { + return; + } + this.schedule(state); + }; + IteratorObservable.prototype._subscribe = function (subscriber) { + var index = 0; + var _a = this, iterator = _a.iterator, project = _a.project, thisArg = _a.thisArg, scheduler = _a.scheduler; + if (scheduler) { + return scheduler.schedule(IteratorObservable.dispatch, 0, { + index: index, thisArg: thisArg, project: project, iterator: iterator, subscriber: subscriber + }); + } + else { + do { + var result = iterator.next(); + if (result.done) { + subscriber.complete(); + break; + } + else if (project) { + result = tryCatch_1.tryCatch(project).call(thisArg, result.value, index++); + if (result === errorObject_1.errorObject) { + subscriber.error(errorObject_1.errorObject.e); + break; + } + subscriber.next(result); + } + else { + subscriber.next(result.value); + } + if (subscriber.isUnsubscribed) { + break; + } + } while (true); + } + }; + return IteratorObservable; +}(Observable_1.Observable)); +exports.IteratorObservable = IteratorObservable; +var StringIterator = (function () { + function StringIterator(str, idx, len) { + if (idx === void 0) { idx = 0; } + if (len === void 0) { len = str.length; } + this.str = str; + this.idx = idx; + this.len = len; + } + StringIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function () { return (this); }; + StringIterator.prototype.next = function () { + return this.idx < this.len ? { + done: false, + value: this.str.charAt(this.idx++) + } : { + done: true, + value: undefined + }; + }; + return StringIterator; +}()); +var ArrayIterator = (function () { + function ArrayIterator(arr, idx, len) { + if (idx === void 0) { idx = 0; } + if (len === void 0) { len = toLength(arr); } + this.arr = arr; + this.idx = idx; + this.len = len; + } + ArrayIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function () { return this; }; + ArrayIterator.prototype.next = function () { + return this.idx < this.len ? { + done: false, + value: this.arr[this.idx++] + } : { + done: true, + value: undefined + }; + }; + return ArrayIterator; +}()); +function getIterator(obj) { + var i = obj[SymbolShim_1.SymbolShim.iterator]; + if (!i && typeof obj === 'string') { + return new StringIterator(obj); + } + if (!i && obj.length !== undefined) { + return new ArrayIterator(obj); + } + if (!i) { + throw new TypeError('Object is not iterable'); + } + return obj[SymbolShim_1.SymbolShim.iterator](); +} +var maxSafeInteger = Math.pow(2, 53) - 1; +function toLength(o) { + var len = +o.length; + if (isNaN(len)) { + return 0; + } + if (len === 0 || !numberIsFinite(len)) { + return len; + } + len = sign(len) * Math.floor(Math.abs(len)); + if (len <= 0) { + return 0; + } + if (len > maxSafeInteger) { + return maxSafeInteger; + } + return len; +} +function numberIsFinite(value) { + return typeof value === 'number' && root_1.root.isFinite(value); +} +function sign(value) { + var valueAsNumber = +value; + if (valueAsNumber === 0) { + return valueAsNumber; + } + if (isNaN(valueAsNumber)) { + return valueAsNumber; + } + return valueAsNumber < 0 ? -1 : 1; +} + +},{"../Observable":3,"../util/SymbolShim":238,"../util/errorObject":239,"../util/isFunction":242,"../util/isObject":244,"../util/root":249,"../util/tryCatch":253}],129:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var noop_1 = require('../util/noop'); +var NeverObservable = (function (_super) { + __extends(NeverObservable, _super); + function NeverObservable() { + _super.call(this); + } + NeverObservable.create = function () { + return new NeverObservable(); + }; + NeverObservable.prototype._subscribe = function (subscriber) { + noop_1.noop(); + }; + return NeverObservable; +}(Observable_1.Observable)); +exports.NeverObservable = NeverObservable; + +},{"../Observable":3,"../util/noop":247}],130:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var root_1 = require('../util/root'); +var Observable_1 = require('../Observable'); +var PromiseObservable = (function (_super) { + __extends(PromiseObservable, _super); + function PromiseObservable(promise, scheduler) { + if (scheduler === void 0) { scheduler = null; } + _super.call(this); + this.promise = promise; + this.scheduler = scheduler; + } + PromiseObservable.create = function (promise, scheduler) { + if (scheduler === void 0) { scheduler = null; } + return new PromiseObservable(promise, scheduler); + }; + PromiseObservable.prototype._subscribe = function (subscriber) { + var _this = this; + var promise = this.promise; + var scheduler = this.scheduler; + if (scheduler == null) { + if (this._isScalar) { + if (!subscriber.isUnsubscribed) { + subscriber.next(this.value); + subscriber.complete(); + } + } + else { + promise.then(function (value) { + _this.value = value; + _this._isScalar = true; + if (!subscriber.isUnsubscribed) { + subscriber.next(value); + subscriber.complete(); + } + }, function (err) { + if (!subscriber.isUnsubscribed) { + subscriber.error(err); + } + }) + .then(null, function (err) { + // escape the promise trap, throw unhandled errors + root_1.root.setTimeout(function () { throw err; }); + }); + } + } + else { + if (this._isScalar) { + if (!subscriber.isUnsubscribed) { + return scheduler.schedule(dispatchNext, 0, { value: this.value, subscriber: subscriber }); + } + } + else { + promise.then(function (value) { + _this.value = value; + _this._isScalar = true; + if (!subscriber.isUnsubscribed) { + subscriber.add(scheduler.schedule(dispatchNext, 0, { value: value, subscriber: subscriber })); + } + }, function (err) { + if (!subscriber.isUnsubscribed) { + subscriber.add(scheduler.schedule(dispatchError, 0, { err: err, subscriber: subscriber })); + } + }) + .then(null, function (err) { + // escape the promise trap, throw unhandled errors + root_1.root.setTimeout(function () { throw err; }); + }); + } + } + }; + return PromiseObservable; +}(Observable_1.Observable)); +exports.PromiseObservable = PromiseObservable; +function dispatchNext(_a) { + var value = _a.value, subscriber = _a.subscriber; + if (!subscriber.isUnsubscribed) { + subscriber.next(value); + subscriber.complete(); + } +} +function dispatchError(_a) { + var err = _a.err, subscriber = _a.subscriber; + if (!subscriber.isUnsubscribed) { + subscriber.error(err); + } +} + +},{"../Observable":3,"../util/root":249}],131:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var RangeObservable = (function (_super) { + __extends(RangeObservable, _super); + function RangeObservable(start, end, scheduler) { + _super.call(this); + this.start = start; + this.end = end; + this.scheduler = scheduler; + } + RangeObservable.create = function (start, end, scheduler) { + if (start === void 0) { start = 0; } + if (end === void 0) { end = 0; } + return new RangeObservable(start, end, scheduler); + }; + RangeObservable.dispatch = function (state) { + var start = state.start, index = state.index, end = state.end, subscriber = state.subscriber; + if (index >= end) { + subscriber.complete(); + return; + } + subscriber.next(start); + if (subscriber.isUnsubscribed) { + return; + } + state.index = index + 1; + state.start = start + 1; + this.schedule(state); + }; + RangeObservable.prototype._subscribe = function (subscriber) { + var index = 0; + var start = this.start; + var end = this.end; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(RangeObservable.dispatch, 0, { + index: index, end: end, start: start, subscriber: subscriber + }); + } + else { + do { + if (index++ >= end) { + subscriber.complete(); + break; + } + subscriber.next(start++); + if (subscriber.isUnsubscribed) { + break; + } + } while (true); + } + }; + return RangeObservable; +}(Observable_1.Observable)); +exports.RangeObservable = RangeObservable; + +},{"../Observable":3}],132:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var ScalarObservable = (function (_super) { + __extends(ScalarObservable, _super); + function ScalarObservable(value, scheduler) { + _super.call(this); + this.value = value; + this.scheduler = scheduler; + this._isScalar = true; + } + ScalarObservable.create = function (value, scheduler) { + return new ScalarObservable(value, scheduler); + }; + ScalarObservable.dispatch = function (state) { + var done = state.done, value = state.value, subscriber = state.subscriber; + if (done) { + subscriber.complete(); + return; + } + subscriber.next(value); + if (subscriber.isUnsubscribed) { + return; + } + state.done = true; + this.schedule(state); + }; + ScalarObservable.prototype._subscribe = function (subscriber) { + var value = this.value; + var scheduler = this.scheduler; + if (scheduler) { + return scheduler.schedule(ScalarObservable.dispatch, 0, { + done: false, value: value, subscriber: subscriber + }); + } + else { + subscriber.next(value); + if (!subscriber.isUnsubscribed) { + subscriber.complete(); + } + } + }; + return ScalarObservable; +}(Observable_1.Observable)); +exports.ScalarObservable = ScalarObservable; + +},{"../Observable":3}],133:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Observable_1 = require('../Observable'); +var asap_1 = require('../scheduler/asap'); +var isNumeric_1 = require('../util/isNumeric'); +var SubscribeOnObservable = (function (_super) { + __extends(SubscribeOnObservable, _super); + function SubscribeOnObservable(source, delayTime, scheduler) { + if (delayTime === void 0) { delayTime = 0; } + if (scheduler === void 0) { scheduler = asap_1.asap; } + _super.call(this); + this.source = source; + this.delayTime = delayTime; + this.scheduler = scheduler; + if (!isNumeric_1.isNumeric(delayTime) || delayTime < 0) { + this.delayTime = 0; + } + if (!scheduler || typeof scheduler.schedule !== 'function') { + this.scheduler = asap_1.asap; + } + } + SubscribeOnObservable.create = function (source, delay, scheduler) { + if (delay === void 0) { delay = 0; } + if (scheduler === void 0) { scheduler = asap_1.asap; } + return new SubscribeOnObservable(source, delay, scheduler); + }; + SubscribeOnObservable.dispatch = function (_a) { + var source = _a.source, subscriber = _a.subscriber; + return source.subscribe(subscriber); + }; + SubscribeOnObservable.prototype._subscribe = function (subscriber) { + var delay = this.delayTime; + var source = this.source; + var scheduler = this.scheduler; + return scheduler.schedule(SubscribeOnObservable.dispatch, delay, { + source: source, subscriber: subscriber + }); + }; + return SubscribeOnObservable; +}(Observable_1.Observable)); +exports.SubscribeOnObservable = SubscribeOnObservable; + +},{"../Observable":3,"../scheduler/asap":224,"../util/isNumeric":243}],134:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var isNumeric_1 = require('../util/isNumeric'); +var Observable_1 = require('../Observable'); +var asap_1 = require('../scheduler/asap'); +var isScheduler_1 = require('../util/isScheduler'); +var isDate_1 = require('../util/isDate'); +var TimerObservable = (function (_super) { + __extends(TimerObservable, _super); + function TimerObservable(dueTime, period, scheduler) { + if (dueTime === void 0) { dueTime = 0; } + _super.call(this); + this.period = -1; + this.dueTime = 0; + if (isNumeric_1.isNumeric(period)) { + this.period = Number(period) < 1 && 1 || Number(period); + } + else if (isScheduler_1.isScheduler(period)) { + scheduler = period; + } + if (!isScheduler_1.isScheduler(scheduler)) { + scheduler = asap_1.asap; + } + this.scheduler = scheduler; + this.dueTime = isDate_1.isDate(dueTime) ? + (+dueTime - this.scheduler.now()) : + dueTime; + } + TimerObservable.create = function (dueTime, period, scheduler) { + if (dueTime === void 0) { dueTime = 0; } + return new TimerObservable(dueTime, period, scheduler); + }; + TimerObservable.dispatch = function (state) { + var index = state.index, period = state.period, subscriber = state.subscriber; + var action = this; + subscriber.next(index); + if (subscriber.isUnsubscribed) { + return; + } + else if (period === -1) { + return subscriber.complete(); + } + state.index = index + 1; + action.schedule(state, period); + }; + TimerObservable.prototype._subscribe = function (subscriber) { + var index = 0; + var _a = this, period = _a.period, dueTime = _a.dueTime, scheduler = _a.scheduler; + return scheduler.schedule(TimerObservable.dispatch, dueTime, { + index: index, period: period, subscriber: subscriber + }); + }; + return TimerObservable; +}(Observable_1.Observable)); +exports.TimerObservable = TimerObservable; + +},{"../Observable":3,"../scheduler/asap":224,"../util/isDate":241,"../util/isNumeric":243,"../util/isScheduler":246}],135:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Buffers the incoming observable values until the passed `closingNotifier` + * emits a value, at which point it emits the buffer on the returned observable + * and starts a new buffer internally, awaiting the next time `closingNotifier` + * emits. + * + * + * + * @param {Observable} closingNotifier an Observable that signals the + * buffer to be emitted} from the returned observable. + * @returns {Observable} an Observable of buffers, which are arrays of + * values. + */ +function buffer(closingNotifier) { + return this.lift(new BufferOperator(closingNotifier)); +} +exports.buffer = buffer; +var BufferOperator = (function () { + function BufferOperator(closingNotifier) { + this.closingNotifier = closingNotifier; + } + BufferOperator.prototype.call = function (subscriber) { + return new BufferSubscriber(subscriber, this.closingNotifier); + }; + return BufferOperator; +}()); +var BufferSubscriber = (function (_super) { + __extends(BufferSubscriber, _super); + function BufferSubscriber(destination, closingNotifier) { + _super.call(this, destination); + this.buffer = []; + this.add(subscribeToResult_1.subscribeToResult(this, closingNotifier)); + } + BufferSubscriber.prototype._next = function (value) { + this.buffer.push(value); + }; + BufferSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var buffer = this.buffer; + this.buffer = []; + this.destination.next(buffer); + }; + return BufferSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],136:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Buffers a number of values from the source observable by `bufferSize` then + * emits the buffer and clears it, and starts a new buffer each + * `startBufferEvery` values. If `startBufferEvery` is not provided or is + * `null`, then new buffers are started immediately at the start of the source + * and when each buffer closes and is emitted. + * + * + * + * @param {number} bufferSize the maximum size of the buffer emitted. + * @param {number} [startBufferEvery] optional interval at which to start a new + * buffer. (e.g. if `startBufferEvery` is `2`, then a new buffer will be started + * on every other value from the source.) A new buffer is started at the + * beginning of the source by default. + * @returns {Observable} an Observable of arrays of buffered values. + */ +function bufferCount(bufferSize, startBufferEvery) { + if (startBufferEvery === void 0) { startBufferEvery = null; } + return this.lift(new BufferCountOperator(bufferSize, startBufferEvery)); +} +exports.bufferCount = bufferCount; +var BufferCountOperator = (function () { + function BufferCountOperator(bufferSize, startBufferEvery) { + this.bufferSize = bufferSize; + this.startBufferEvery = startBufferEvery; + } + BufferCountOperator.prototype.call = function (subscriber) { + return new BufferCountSubscriber(subscriber, this.bufferSize, this.startBufferEvery); + }; + return BufferCountOperator; +}()); +var BufferCountSubscriber = (function (_super) { + __extends(BufferCountSubscriber, _super); + function BufferCountSubscriber(destination, bufferSize, startBufferEvery) { + _super.call(this, destination); + this.bufferSize = bufferSize; + this.startBufferEvery = startBufferEvery; + this.buffers = [[]]; + this.count = 0; + } + BufferCountSubscriber.prototype._next = function (value) { + var count = (this.count += 1); + var destination = this.destination; + var bufferSize = this.bufferSize; + var startBufferEvery = (this.startBufferEvery == null) ? bufferSize : this.startBufferEvery; + var buffers = this.buffers; + var len = buffers.length; + var remove = -1; + if (count % startBufferEvery === 0) { + buffers.push([]); + } + for (var i = 0; i < len; i++) { + var buffer = buffers[i]; + buffer.push(value); + if (buffer.length === bufferSize) { + remove = i; + destination.next(buffer); + } + } + if (remove !== -1) { + buffers.splice(remove, 1); + } + }; + BufferCountSubscriber.prototype._complete = function () { + var destination = this.destination; + var buffers = this.buffers; + while (buffers.length > 0) { + var buffer = buffers.shift(); + if (buffer.length > 0) { + destination.next(buffer); + } + } + _super.prototype._complete.call(this); + }; + return BufferCountSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],137:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var asap_1 = require('../scheduler/asap'); +/** + * Buffers values from the source for a specific time period. Optionally allows + * new buffers to be set up at an interval. + * + * + * + * @param {number} bufferTimeSpan the amount of time to fill each buffer for + * before emitting them and clearing them. + * @param {number} [bufferCreationInterval] the interval at which to start new + * buffers. + * @param {Scheduler} [scheduler] (optional, defaults to `asap` scheduler) The + * scheduler on which to schedule the intervals that determine buffer + * boundaries. + * @returns {Observable} an observable of arrays of buffered values. + */ +function bufferTime(bufferTimeSpan, bufferCreationInterval, scheduler) { + if (bufferCreationInterval === void 0) { bufferCreationInterval = null; } + if (scheduler === void 0) { scheduler = asap_1.asap; } + return this.lift(new BufferTimeOperator(bufferTimeSpan, bufferCreationInterval, scheduler)); +} +exports.bufferTime = bufferTime; +var BufferTimeOperator = (function () { + function BufferTimeOperator(bufferTimeSpan, bufferCreationInterval, scheduler) { + this.bufferTimeSpan = bufferTimeSpan; + this.bufferCreationInterval = bufferCreationInterval; + this.scheduler = scheduler; + } + BufferTimeOperator.prototype.call = function (subscriber) { + return new BufferTimeSubscriber(subscriber, this.bufferTimeSpan, this.bufferCreationInterval, this.scheduler); + }; + return BufferTimeOperator; +}()); +var BufferTimeSubscriber = (function (_super) { + __extends(BufferTimeSubscriber, _super); + function BufferTimeSubscriber(destination, bufferTimeSpan, bufferCreationInterval, scheduler) { + _super.call(this, destination); + this.bufferTimeSpan = bufferTimeSpan; + this.bufferCreationInterval = bufferCreationInterval; + this.scheduler = scheduler; + this.buffers = []; + var buffer = this.openBuffer(); + if (bufferCreationInterval !== null && bufferCreationInterval >= 0) { + var closeState = { subscriber: this, buffer: buffer }; + var creationState = { bufferTimeSpan: bufferTimeSpan, bufferCreationInterval: bufferCreationInterval, subscriber: this, scheduler: scheduler }; + this.add(scheduler.schedule(dispatchBufferClose, bufferTimeSpan, closeState)); + this.add(scheduler.schedule(dispatchBufferCreation, bufferCreationInterval, creationState)); + } + else { + var timeSpanOnlyState = { subscriber: this, buffer: buffer, bufferTimeSpan: bufferTimeSpan }; + this.add(scheduler.schedule(dispatchBufferTimeSpanOnly, bufferTimeSpan, timeSpanOnlyState)); + } + } + BufferTimeSubscriber.prototype._next = function (value) { + var buffers = this.buffers; + var len = buffers.length; + for (var i = 0; i < len; i++) { + buffers[i].push(value); + } + }; + BufferTimeSubscriber.prototype._error = function (err) { + this.buffers.length = 0; + _super.prototype._error.call(this, err); + }; + BufferTimeSubscriber.prototype._complete = function () { + var _a = this, buffers = _a.buffers, destination = _a.destination; + while (buffers.length > 0) { + destination.next(buffers.shift()); + } + _super.prototype._complete.call(this); + }; + BufferTimeSubscriber.prototype._unsubscribe = function () { + this.buffers = null; + }; + BufferTimeSubscriber.prototype.openBuffer = function () { + var buffer = []; + this.buffers.push(buffer); + return buffer; + }; + BufferTimeSubscriber.prototype.closeBuffer = function (buffer) { + this.destination.next(buffer); + var buffers = this.buffers; + buffers.splice(buffers.indexOf(buffer), 1); + }; + return BufferTimeSubscriber; +}(Subscriber_1.Subscriber)); +function dispatchBufferTimeSpanOnly(state) { + var subscriber = state.subscriber; + var prevBuffer = state.buffer; + if (prevBuffer) { + subscriber.closeBuffer(prevBuffer); + } + state.buffer = subscriber.openBuffer(); + if (!subscriber.isUnsubscribed) { + this.schedule(state, state.bufferTimeSpan); + } +} +function dispatchBufferCreation(state) { + var bufferCreationInterval = state.bufferCreationInterval, bufferTimeSpan = state.bufferTimeSpan, subscriber = state.subscriber, scheduler = state.scheduler; + var buffer = subscriber.openBuffer(); + var action = this; + if (!subscriber.isUnsubscribed) { + action.add(scheduler.schedule(dispatchBufferClose, bufferTimeSpan, { subscriber: subscriber, buffer: buffer })); + action.schedule(state, bufferCreationInterval); + } +} +function dispatchBufferClose(_a) { + var subscriber = _a.subscriber, buffer = _a.buffer; + subscriber.closeBuffer(buffer); +} + +},{"../Subscriber":9,"../scheduler/asap":224}],138:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Subscription_1 = require('../Subscription'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +/** + * Buffers values from the source by opening the buffer via signals from an + * Observable provided to `openings`, and closing and sending the buffers when + * an Observable returned by the `closingSelector` emits. + * + * + * + * @param {Observable} openings An observable of notifications to start new + * buffers. + * @param {Function} closingSelector a function that takes the value emitted by + * the `openings` observable and returns an Observable, which, when it emits, + * signals that the associated buffer should be emitted and cleared. + * @returns {Observable} an observable of arrays of buffered values. + */ +function bufferToggle(openings, closingSelector) { + return this.lift(new BufferToggleOperator(openings, closingSelector)); +} +exports.bufferToggle = bufferToggle; +var BufferToggleOperator = (function () { + function BufferToggleOperator(openings, closingSelector) { + this.openings = openings; + this.closingSelector = closingSelector; + } + BufferToggleOperator.prototype.call = function (subscriber) { + return new BufferToggleSubscriber(subscriber, this.openings, this.closingSelector); + }; + return BufferToggleOperator; +}()); +var BufferToggleSubscriber = (function (_super) { + __extends(BufferToggleSubscriber, _super); + function BufferToggleSubscriber(destination, openings, closingSelector) { + _super.call(this, destination); + this.openings = openings; + this.closingSelector = closingSelector; + this.contexts = []; + this.add(this.openings.subscribe(new BufferToggleOpeningsSubscriber(this))); + } + BufferToggleSubscriber.prototype._next = function (value) { + var contexts = this.contexts; + var len = contexts.length; + for (var i = 0; i < len; i++) { + contexts[i].buffer.push(value); + } + }; + BufferToggleSubscriber.prototype._error = function (err) { + var contexts = this.contexts; + while (contexts.length > 0) { + var context = contexts.shift(); + context.subscription.unsubscribe(); + context.buffer = null; + context.subscription = null; + } + this.contexts = null; + _super.prototype._error.call(this, err); + }; + BufferToggleSubscriber.prototype._complete = function () { + var contexts = this.contexts; + while (contexts.length > 0) { + var context = contexts.shift(); + this.destination.next(context.buffer); + context.subscription.unsubscribe(); + context.buffer = null; + context.subscription = null; + } + this.contexts = null; + _super.prototype._complete.call(this); + }; + BufferToggleSubscriber.prototype.openBuffer = function (value) { + var closingSelector = this.closingSelector; + var contexts = this.contexts; + var closingNotifier = tryCatch_1.tryCatch(closingSelector)(value); + if (closingNotifier === errorObject_1.errorObject) { + this._error(errorObject_1.errorObject.e); + } + else { + var context = { + buffer: [], + subscription: new Subscription_1.Subscription() + }; + contexts.push(context); + var subscriber = new BufferToggleClosingsSubscriber(this, context); + var subscription = closingNotifier.subscribe(subscriber); + context.subscription.add(subscription); + this.add(subscription); + } + }; + BufferToggleSubscriber.prototype.closeBuffer = function (context) { + var contexts = this.contexts; + if (contexts === null) { + return; + } + var buffer = context.buffer, subscription = context.subscription; + this.destination.next(buffer); + contexts.splice(contexts.indexOf(context), 1); + this.remove(subscription); + subscription.unsubscribe(); + }; + return BufferToggleSubscriber; +}(Subscriber_1.Subscriber)); +var BufferToggleOpeningsSubscriber = (function (_super) { + __extends(BufferToggleOpeningsSubscriber, _super); + function BufferToggleOpeningsSubscriber(parent) { + _super.call(this, null); + this.parent = parent; + } + BufferToggleOpeningsSubscriber.prototype._next = function (value) { + this.parent.openBuffer(value); + }; + BufferToggleOpeningsSubscriber.prototype._error = function (err) { + this.parent.error(err); + }; + BufferToggleOpeningsSubscriber.prototype._complete = function () { + // noop + }; + return BufferToggleOpeningsSubscriber; +}(Subscriber_1.Subscriber)); +var BufferToggleClosingsSubscriber = (function (_super) { + __extends(BufferToggleClosingsSubscriber, _super); + function BufferToggleClosingsSubscriber(parent, context) { + _super.call(this, null); + this.parent = parent; + this.context = context; + } + BufferToggleClosingsSubscriber.prototype._next = function () { + this.parent.closeBuffer(this.context); + }; + BufferToggleClosingsSubscriber.prototype._error = function (err) { + this.parent.error(err); + }; + BufferToggleClosingsSubscriber.prototype._complete = function () { + this.parent.closeBuffer(this.context); + }; + return BufferToggleClosingsSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../Subscription":10,"../util/errorObject":239,"../util/tryCatch":253}],139:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscription_1 = require('../Subscription'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Opens a buffer immediately, then closes the buffer when the observable + * returned by calling `closingSelector` emits a value. It that immediately + * opens a new buffer and repeats the process. + * + * + * + * @param {function} closingSelector a function that takes no arguments and + * returns an Observable that signals buffer closure. + * @returns {Observable} an observable of arrays of buffered values. + */ +function bufferWhen(closingSelector) { + return this.lift(new BufferWhenOperator(closingSelector)); +} +exports.bufferWhen = bufferWhen; +var BufferWhenOperator = (function () { + function BufferWhenOperator(closingSelector) { + this.closingSelector = closingSelector; + } + BufferWhenOperator.prototype.call = function (subscriber) { + return new BufferWhenSubscriber(subscriber, this.closingSelector); + }; + return BufferWhenOperator; +}()); +var BufferWhenSubscriber = (function (_super) { + __extends(BufferWhenSubscriber, _super); + function BufferWhenSubscriber(destination, closingSelector) { + _super.call(this, destination); + this.closingSelector = closingSelector; + this.subscribing = false; + this.openBuffer(); + } + BufferWhenSubscriber.prototype._next = function (value) { + this.buffer.push(value); + }; + BufferWhenSubscriber.prototype._complete = function () { + var buffer = this.buffer; + if (buffer) { + this.destination.next(buffer); + } + _super.prototype._complete.call(this); + }; + BufferWhenSubscriber.prototype._unsubscribe = function () { + this.buffer = null; + this.subscribing = false; + }; + BufferWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.openBuffer(); + }; + BufferWhenSubscriber.prototype.notifyComplete = function () { + if (this.subscribing) { + this.complete(); + } + else { + this.openBuffer(); + } + }; + BufferWhenSubscriber.prototype.openBuffer = function () { + var closingSubscription = this.closingSubscription; + if (closingSubscription) { + this.remove(closingSubscription); + closingSubscription.unsubscribe(); + } + var buffer = this.buffer; + if (this.buffer) { + this.destination.next(buffer); + } + this.buffer = []; + var closingNotifier = tryCatch_1.tryCatch(this.closingSelector)(); + if (closingNotifier === errorObject_1.errorObject) { + this.error(errorObject_1.errorObject.e); + } + else { + closingSubscription = new Subscription_1.Subscription(); + this.closingSubscription = closingSubscription; + this.add(closingSubscription); + this.subscribing = true; + closingSubscription.add(subscribeToResult_1.subscribeToResult(this, closingNotifier)); + this.subscribing = false; + } + }; + return BufferWhenSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../Subscription":10,"../util/errorObject":239,"../util/subscribeToResult":250,"../util/tryCatch":253}],140:[function(require,module,exports){ +"use strict"; +var publishReplay_1 = require('./publishReplay'); +function cache(bufferSize, windowTime, scheduler) { + if (bufferSize === void 0) { bufferSize = Number.POSITIVE_INFINITY; } + if (windowTime === void 0) { windowTime = Number.POSITIVE_INFINITY; } + return publishReplay_1.publishReplay.call(this, bufferSize, windowTime, scheduler).refCount(); +} +exports.cache = cache; + +},{"./publishReplay":182}],141:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Catches errors on the observable to be handled by returning a new observable or throwing an error. + * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which + * is the source observable, in case you'd like to "retry" that observable by returning it again. Whatever observable + * is returned by the `selector` will be used to continue the observable chain. + * @return {Observable} an observable that originates from either the source or the observable returned by the + * catch `selector` function. + */ +function _catch(selector) { + var operator = new CatchOperator(selector); + var caught = this.lift(operator); + return (operator.caught = caught); +} +exports._catch = _catch; +var CatchOperator = (function () { + function CatchOperator(selector) { + this.selector = selector; + } + CatchOperator.prototype.call = function (subscriber) { + return new CatchSubscriber(subscriber, this.selector, this.caught); + }; + return CatchOperator; +}()); +var CatchSubscriber = (function (_super) { + __extends(CatchSubscriber, _super); + function CatchSubscriber(destination, selector, caught) { + _super.call(this, destination); + this.selector = selector; + this.caught = caught; + } + // NOTE: overriding `error` instead of `_error` because we don't want + // to have this flag this subscriber as `isStopped`. + CatchSubscriber.prototype.error = function (err) { + if (!this.isStopped) { + var result = void 0; + try { + result = this.selector(err, this.caught); + } + catch (err) { + this.destination.error(err); + return; + } + this._innerSub(result); + } + }; + CatchSubscriber.prototype._innerSub = function (result) { + this.unsubscribe(); + this.destination.remove(this); + result.subscribe(this.destination); + }; + return CatchSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],142:[function(require,module,exports){ +"use strict"; +var combineLatest_1 = require('./combineLatest'); +/** + * Takes an Observable of Observables, and collects all observables from it. Once the outer observable + * completes, it subscribes to all collected observables and "combines" their values, such that: + * - every time an observable emits, the returned observable emits + * - when the returned observable emits, it emits all of the most recent values by: + * - if a `project` function is provided, it is called with each recent value from each observable in whatever order they arrived, + * and the result of the `project` function is what is emitted by the returned observable + * - if there is no `project` function, an array of all of the most recent values is emitted by the returned observable. + * @param {function} [project] an optional function to map the most recent values from each observable into a new result. Takes each of the + * most recent values from each collected observable as arguments, in order. + * @returns {Observable} an observable of projected results or arrays of recent values. + */ +function combineAll(project) { + return this.lift(new combineLatest_1.CombineLatestOperator(project)); +} +exports.combineAll = combineAll; + +},{"./combineLatest":143}],143:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var ArrayObservable_1 = require('../observable/ArrayObservable'); +var isArray_1 = require('../util/isArray'); +var isScheduler_1 = require('../util/isScheduler'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Combines the values from this observable with values from observables passed as arguments. This is done by subscribing + * to each observable, in order, and collecting an array of each of the most recent values any time any of the observables + * emits, then either taking that array and passing it as arguments to an option `project` function and emitting the return + * value of that, or just emitting the array of recent values directly if there is no `project` function. + * @param {...Observable} observables the observables to combine the source with + * @param {function} [project] an optional function to project the values from the combined recent values into a new value for emission. + * @returns {Observable} an observable of other projected values from the most recent values from each observable, or an array of each of + * the most recent values from each observable. + */ +function combineLatest() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var project = null; + if (typeof observables[observables.length - 1] === 'function') { + project = observables.pop(); + } + // if the first and only other argument besides the resultSelector is an array + // assume it's been called with `combineLatest([obs1, obs2, obs3], project)` + if (observables.length === 1 && isArray_1.isArray(observables[0])) { + observables = observables[0]; + } + observables.unshift(this); + return new ArrayObservable_1.ArrayObservable(observables).lift(new CombineLatestOperator(project)); +} +exports.combineLatest = combineLatest; +/* tslint:enable:max-line-length */ +function combineLatestStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var project = null; + var scheduler = null; + if (isScheduler_1.isScheduler(observables[observables.length - 1])) { + scheduler = observables.pop(); + } + if (typeof observables[observables.length - 1] === 'function') { + project = observables.pop(); + } + // if the first and only other argument besides the resultSelector is an array + // assume it's been called with `combineLatest([obs1, obs2, obs3], project)` + if (observables.length === 1 && isArray_1.isArray(observables[0])) { + observables = observables[0]; + } + return new ArrayObservable_1.ArrayObservable(observables, scheduler).lift(new CombineLatestOperator(project)); +} +exports.combineLatestStatic = combineLatestStatic; +var CombineLatestOperator = (function () { + function CombineLatestOperator(project) { + this.project = project; + } + CombineLatestOperator.prototype.call = function (subscriber) { + return new CombineLatestSubscriber(subscriber, this.project); + }; + return CombineLatestOperator; +}()); +exports.CombineLatestOperator = CombineLatestOperator; +var CombineLatestSubscriber = (function (_super) { + __extends(CombineLatestSubscriber, _super); + function CombineLatestSubscriber(destination, project) { + _super.call(this, destination); + this.project = project; + this.active = 0; + this.values = []; + this.observables = []; + this.toRespond = []; + } + CombineLatestSubscriber.prototype._next = function (observable) { + var toRespond = this.toRespond; + toRespond.push(toRespond.length); + this.observables.push(observable); + }; + CombineLatestSubscriber.prototype._complete = function () { + var observables = this.observables; + var len = observables.length; + if (len === 0) { + this.destination.complete(); + } + else { + this.active = len; + for (var i = 0; i < len; i++) { + var observable = observables[i]; + this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i)); + } + } + }; + CombineLatestSubscriber.prototype.notifyComplete = function (unused) { + if ((this.active -= 1) === 0) { + this.destination.complete(); + } + }; + CombineLatestSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var values = this.values; + values[outerIndex] = innerValue; + var toRespond = this.toRespond; + if (toRespond.length > 0) { + var found = toRespond.indexOf(outerIndex); + if (found !== -1) { + toRespond.splice(found, 1); + } + } + if (toRespond.length === 0) { + if (this.project) { + this._tryProject(values); + } + else { + this.destination.next(values); + } + } + }; + CombineLatestSubscriber.prototype._tryProject = function (values) { + var result; + try { + result = this.project.apply(this, values); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.next(result); + }; + return CombineLatestSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); +exports.CombineLatestSubscriber = CombineLatestSubscriber; + +},{"../OuterSubscriber":6,"../observable/ArrayObservable":116,"../util/isArray":240,"../util/isScheduler":246,"../util/subscribeToResult":250}],144:[function(require,module,exports){ +"use strict"; +var isScheduler_1 = require('../util/isScheduler'); +var ArrayObservable_1 = require('../observable/ArrayObservable'); +var mergeAll_1 = require('./mergeAll'); +/** + * Joins this observable with multiple other observables by subscribing to them one at a time, starting with the source, + * and merging their results into the returned observable. Will wait for each observable to complete before moving + * on to the next. + * @params {...Observable} the observables to concatenate + * @params {Scheduler} [scheduler] an optional scheduler to schedule each observable subscription on. + * @returns {Observable} All values of each passed observable merged into a single observable, in order, in serial fashion. + */ +function concat() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + return concatStatic.apply(void 0, [this].concat(observables)); +} +exports.concat = concat; +/** + * Joins multiple observables together by subscribing to them one at a time and merging their results + * into the returned observable. Will wait for each observable to complete before moving on to the next. + * @params {...Observable} the observables to concatenate + * @params {Scheduler} [scheduler] an optional scheduler to schedule each observable subscription on. + * @returns {Observable} All values of each passed observable merged into a single observable, in order, in serial fashion. + */ +function concatStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var scheduler = null; + var args = observables; + if (isScheduler_1.isScheduler(args[observables.length - 1])) { + scheduler = args.pop(); + } + return new ArrayObservable_1.ArrayObservable(observables, scheduler).lift(new mergeAll_1.MergeAllOperator(1)); +} +exports.concatStatic = concatStatic; + +},{"../observable/ArrayObservable":116,"../util/isScheduler":246,"./mergeAll":172}],145:[function(require,module,exports){ +"use strict"; +var mergeAll_1 = require('./mergeAll'); +/** + * Joins every Observable emitted by the source (an Observable of Observables), in a serial + * fashion. Subscribing to each one only when the previous one has completed, and merging + * all of their values into the returned observable. + * + * __Warning:__ If the source Observable emits Observables quickly and endlessly, and the + * Observables it emits generally complete slower than the source emits, you can run into + * memory issues as the incoming observables collect in an unbounded buffer. + * + * @returns {Observable} an observable of values merged from the incoming observables. + */ +function concatAll() { + return this.lift(new mergeAll_1.MergeAllOperator(1)); +} +exports.concatAll = concatAll; + +},{"./mergeAll":172}],146:[function(require,module,exports){ +"use strict"; +var mergeMap_1 = require('./mergeMap'); +/** + * Maps values from the source observable into new Observables, then merges them in a serialized fashion, + * waiting for each one to complete before merging the next. + * + * __Warning:__ if incoming values arrive endlessly and faster than the observables they're being mapped + * to can complete, it will result in memory issues as created observables amass in an unbounded buffer + * waiting for their turn to be subscribed to. + * + * @param {function} project a function to map incoming values into Observables to be concatenated. accepts + * the `value` and the `index` as arguments. + * @param {function} [resultSelector] an optional result selector that is applied to values before they're + * merged into the returned observable. The arguments passed to this function are: + * - `outerValue`: the value that came from the source + * - `innerValue`: the value that came from the projected Observable + * - `outerIndex`: the "index" of the value that came from the source + * - `innerIndex`: the "index" of the value from the projected Observable + * @returns {Observable} an observable of values merged from the projected Observables as they were subscribed to, + * one at a time. Optionally, these values may have been projected from a passed `projectResult` argument. + */ +function concatMap(project, resultSelector) { + return this.lift(new mergeMap_1.MergeMapOperator(project, resultSelector, 1)); +} +exports.concatMap = concatMap; + +},{"./mergeMap":173}],147:[function(require,module,exports){ +"use strict"; +var mergeMapTo_1 = require('./mergeMapTo'); +/** + * Maps values from the source to a specific observable, and merges them together in a serialized fashion. + * + * @param {Observable} observable the observable to map each source value to + * @param {function} [resultSelector] an optional result selector that is applied to values before they're + * merged into the returned observable. The arguments passed to this function are: + * - `outerValue`: the value that came from the source + * - `innerValue`: the value that came from the projected Observable + * - `outerIndex`: the "index" of the value that came from the source + * - `innerIndex`: the "index" of the value from the projected Observable + * @returns {Observable} an observable of values merged together by joining the passed observable + * with itself, one after the other, for each value emitted from the source. + */ +function concatMapTo(observable, resultSelector) { + return this.lift(new mergeMapTo_1.MergeMapToOperator(observable, resultSelector, 1)); +} +exports.concatMapTo = concatMapTo; + +},{"./mergeMapTo":174}],148:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an observable of a single number that represents the number of items that either: + * Match a provided predicate function, _or_ if a predicate is not provided, the number + * represents the total count of all items in the source observable. The count is emitted + * by the returned observable when the source observable completes. + * @param {function} [predicate] a boolean function to select what values are to be counted. + * it is provided with arguments of: + * - `value`: the value from the source observable + * - `index`: the "index" of the value from the source observable + * - `source`: the source observable instance itself. + * @returns {Observable} an observable of one number that represents the count as described + * above + */ +function count(predicate) { + return this.lift(new CountOperator(predicate, this)); +} +exports.count = count; +var CountOperator = (function () { + function CountOperator(predicate, source) { + this.predicate = predicate; + this.source = source; + } + CountOperator.prototype.call = function (subscriber) { + return new CountSubscriber(subscriber, this.predicate, this.source); + }; + return CountOperator; +}()); +var CountSubscriber = (function (_super) { + __extends(CountSubscriber, _super); + function CountSubscriber(destination, predicate, source) { + _super.call(this, destination); + this.predicate = predicate; + this.source = source; + this.count = 0; + this.index = 0; + } + CountSubscriber.prototype._next = function (value) { + if (this.predicate) { + this._tryPredicate(value); + } + else { + this.count++; + } + }; + CountSubscriber.prototype._tryPredicate = function (value) { + var result; + try { + result = this.predicate(value, this.index++, this.source); + } + catch (err) { + this.destination.error(err); + return; + } + if (result) { + this.count++; + } + }; + CountSubscriber.prototype._complete = function () { + this.destination.next(this.count); + this.destination.complete(); + }; + return CountSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],149:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Returns the source Observable delayed by the computed debounce duration, + * with the duration lengthened if a new source item arrives before the delay + * duration ends. + * In practice, for each item emitted on the source, this operator holds the + * latest item, waits for a silence as long as the `durationSelector` specifies, + * and only then emits the latest source item on the result Observable. + * @param {function} durationSelector function for computing the timeout duration for each item. + * @returns {Observable} an Observable the same as source Observable, but drops items. + */ +function debounce(durationSelector) { + return this.lift(new DebounceOperator(durationSelector)); +} +exports.debounce = debounce; +var DebounceOperator = (function () { + function DebounceOperator(durationSelector) { + this.durationSelector = durationSelector; + } + DebounceOperator.prototype.call = function (subscriber) { + return new DebounceSubscriber(subscriber, this.durationSelector); + }; + return DebounceOperator; +}()); +var DebounceSubscriber = (function (_super) { + __extends(DebounceSubscriber, _super); + function DebounceSubscriber(destination, durationSelector) { + _super.call(this, destination); + this.durationSelector = durationSelector; + this.hasValue = false; + this.durationSubscription = null; + } + DebounceSubscriber.prototype._next = function (value) { + try { + var result = this.durationSelector.call(this, value); + if (result) { + this._tryNext(value, result); + } + } + catch (err) { + this.destination.error(err); + } + }; + DebounceSubscriber.prototype._complete = function () { + this.emitValue(); + this.destination.complete(); + }; + DebounceSubscriber.prototype._tryNext = function (value, duration) { + var subscription = this.durationSubscription; + this.value = value; + this.hasValue = true; + if (subscription) { + subscription.unsubscribe(); + this.remove(subscription); + } + subscription = subscribeToResult_1.subscribeToResult(this, duration); + if (!subscription.isUnsubscribed) { + this.add(this.durationSubscription = subscription); + } + }; + DebounceSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.emitValue(); + }; + DebounceSubscriber.prototype.notifyComplete = function () { + this.emitValue(); + }; + DebounceSubscriber.prototype.emitValue = function () { + if (this.hasValue) { + var value = this.value; + var subscription = this.durationSubscription; + if (subscription) { + this.durationSubscription = null; + subscription.unsubscribe(); + this.remove(subscription); + } + this.value = null; + this.hasValue = false; + _super.prototype._next.call(this, value); + } + }; + return DebounceSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],150:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var asap_1 = require('../scheduler/asap'); +/** + * Returns the source Observable delayed by the computed debounce duration, + * with the duration lengthened if a new source item arrives before the delay + * duration ends. + * In practice, for each item emitted on the source, this operator holds the + * latest item, waits for a silence for the `dueTime` length, and only then + * emits the latest source item on the result Observable. + * Optionally takes a scheduler for manging timers. + * @param {number} dueTime the timeout value for the window of time required to not drop the item. + * @param {Scheduler} [scheduler] the Scheduler to use for managing the timers that handle the timeout for each item. + * @returns {Observable} an Observable the same as source Observable, but drops items. + */ +function debounceTime(dueTime, scheduler) { + if (scheduler === void 0) { scheduler = asap_1.asap; } + return this.lift(new DebounceTimeOperator(dueTime, scheduler)); +} +exports.debounceTime = debounceTime; +var DebounceTimeOperator = (function () { + function DebounceTimeOperator(dueTime, scheduler) { + this.dueTime = dueTime; + this.scheduler = scheduler; + } + DebounceTimeOperator.prototype.call = function (subscriber) { + return new DebounceTimeSubscriber(subscriber, this.dueTime, this.scheduler); + }; + return DebounceTimeOperator; +}()); +var DebounceTimeSubscriber = (function (_super) { + __extends(DebounceTimeSubscriber, _super); + function DebounceTimeSubscriber(destination, dueTime, scheduler) { + _super.call(this, destination); + this.dueTime = dueTime; + this.scheduler = scheduler; + this.debouncedSubscription = null; + this.lastValue = null; + this.hasValue = false; + } + DebounceTimeSubscriber.prototype._next = function (value) { + this.clearDebounce(); + this.lastValue = value; + this.hasValue = true; + this.add(this.debouncedSubscription = this.scheduler.schedule(dispatchNext, this.dueTime, this)); + }; + DebounceTimeSubscriber.prototype._complete = function () { + this.debouncedNext(); + this.destination.complete(); + }; + DebounceTimeSubscriber.prototype.debouncedNext = function () { + this.clearDebounce(); + if (this.hasValue) { + this.destination.next(this.lastValue); + this.lastValue = null; + this.hasValue = false; + } + }; + DebounceTimeSubscriber.prototype.clearDebounce = function () { + var debouncedSubscription = this.debouncedSubscription; + if (debouncedSubscription !== null) { + this.remove(debouncedSubscription); + debouncedSubscription.unsubscribe(); + this.debouncedSubscription = null; + } + }; + return DebounceTimeSubscriber; +}(Subscriber_1.Subscriber)); +function dispatchNext(subscriber) { + subscriber.debouncedNext(); +} + +},{"../Subscriber":9,"../scheduler/asap":224}],151:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that emits the elements of the source or a specified default value if empty. + * @param {any} defaultValue the default value used if source is empty; defaults to null. + * @returns {Observable} an Observable of the items emitted by the where empty values are replaced by the specified default value or null. + */ +function defaultIfEmpty(defaultValue) { + if (defaultValue === void 0) { defaultValue = null; } + return this.lift(new DefaultIfEmptyOperator(defaultValue)); +} +exports.defaultIfEmpty = defaultIfEmpty; +var DefaultIfEmptyOperator = (function () { + function DefaultIfEmptyOperator(defaultValue) { + this.defaultValue = defaultValue; + } + DefaultIfEmptyOperator.prototype.call = function (subscriber) { + return new DefaultIfEmptySubscriber(subscriber, this.defaultValue); + }; + return DefaultIfEmptyOperator; +}()); +var DefaultIfEmptySubscriber = (function (_super) { + __extends(DefaultIfEmptySubscriber, _super); + function DefaultIfEmptySubscriber(destination, defaultValue) { + _super.call(this, destination); + this.defaultValue = defaultValue; + this.isEmpty = true; + } + DefaultIfEmptySubscriber.prototype._next = function (value) { + this.isEmpty = false; + this.destination.next(value); + }; + DefaultIfEmptySubscriber.prototype._complete = function () { + if (this.isEmpty) { + this.destination.next(this.defaultValue); + } + this.destination.complete(); + }; + return DefaultIfEmptySubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],152:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var asap_1 = require('../scheduler/asap'); +var isDate_1 = require('../util/isDate'); +var Subscriber_1 = require('../Subscriber'); +var Notification_1 = require('../Notification'); +/** + * Returns an Observable that delays the emission of items from the source Observable + * by a given timeout or until a given Date. + * @param {number|Date} delay the timeout value or date until which the emission of the source items is delayed. + * @param {Scheduler} [scheduler] the Scheduler to use for managing the timers that handle the timeout for each item. + * @returns {Observable} an Observable that delays the emissions of the source Observable by the specified timeout or Date. + */ +function delay(delay, scheduler) { + if (scheduler === void 0) { scheduler = asap_1.asap; } + var absoluteDelay = isDate_1.isDate(delay); + var delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay); + return this.lift(new DelayOperator(delayFor, scheduler)); +} +exports.delay = delay; +var DelayOperator = (function () { + function DelayOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + DelayOperator.prototype.call = function (subscriber) { + return new DelaySubscriber(subscriber, this.delay, this.scheduler); + }; + return DelayOperator; +}()); +var DelaySubscriber = (function (_super) { + __extends(DelaySubscriber, _super); + function DelaySubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + this.queue = []; + this.active = false; + this.errored = false; + } + DelaySubscriber.dispatch = function (state) { + var source = state.source; + var queue = source.queue; + var scheduler = state.scheduler; + var destination = state.destination; + while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) { + queue.shift().notification.observe(destination); + } + if (queue.length > 0) { + var delay_1 = Math.max(0, queue[0].time - scheduler.now()); + this.schedule(state, delay_1); + } + else { + source.active = false; + } + }; + DelaySubscriber.prototype._schedule = function (scheduler) { + this.active = true; + this.add(scheduler.schedule(DelaySubscriber.dispatch, this.delay, { + source: this, destination: this.destination, scheduler: scheduler + })); + }; + DelaySubscriber.prototype.scheduleNotification = function (notification) { + if (this.errored === true) { + return; + } + var scheduler = this.scheduler; + var message = new DelayMessage(scheduler.now() + this.delay, notification); + this.queue.push(message); + if (this.active === false) { + this._schedule(scheduler); + } + }; + DelaySubscriber.prototype._next = function (value) { + this.scheduleNotification(Notification_1.Notification.createNext(value)); + }; + DelaySubscriber.prototype._error = function (err) { + this.errored = true; + this.queue = []; + this.destination.error(err); + }; + DelaySubscriber.prototype._complete = function () { + this.scheduleNotification(Notification_1.Notification.createComplete()); + }; + return DelaySubscriber; +}(Subscriber_1.Subscriber)); +var DelayMessage = (function () { + function DelayMessage(time, notification) { + this.time = time; + this.notification = notification; + } + return DelayMessage; +}()); + +},{"../Notification":2,"../Subscriber":9,"../scheduler/asap":224,"../util/isDate":241}],153:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Observable_1 = require('../Observable'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Returns an Observable that delays the emission of items from the source Observable + * by a subscription delay and a delay selector function for each element. + * @param {Function} selector function to retrieve a sequence indicating the delay for each given element. + * @param {Observable} sequence indicating the delay for the subscription to the source. + * @returns {Observable} an Observable that delays the emissions of the source Observable by the specified timeout or Date. + */ +function delayWhen(delayDurationSelector, subscriptionDelay) { + if (subscriptionDelay) { + return new SubscriptionDelayObservable(this, subscriptionDelay) + .lift(new DelayWhenOperator(delayDurationSelector)); + } + return this.lift(new DelayWhenOperator(delayDurationSelector)); +} +exports.delayWhen = delayWhen; +var DelayWhenOperator = (function () { + function DelayWhenOperator(delayDurationSelector) { + this.delayDurationSelector = delayDurationSelector; + } + DelayWhenOperator.prototype.call = function (subscriber) { + return new DelayWhenSubscriber(subscriber, this.delayDurationSelector); + }; + return DelayWhenOperator; +}()); +var DelayWhenSubscriber = (function (_super) { + __extends(DelayWhenSubscriber, _super); + function DelayWhenSubscriber(destination, delayDurationSelector) { + _super.call(this, destination); + this.delayDurationSelector = delayDurationSelector; + this.completed = false; + this.delayNotifierSubscriptions = []; + this.values = []; + } + DelayWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.destination.next(outerValue); + this.removeSubscription(innerSub); + this.tryComplete(); + }; + DelayWhenSubscriber.prototype.notifyError = function (error, innerSub) { + this._error(error); + }; + DelayWhenSubscriber.prototype.notifyComplete = function (innerSub) { + var value = this.removeSubscription(innerSub); + if (value) { + this.destination.next(value); + } + this.tryComplete(); + }; + DelayWhenSubscriber.prototype._next = function (value) { + try { + var delayNotifier = this.delayDurationSelector(value); + if (delayNotifier) { + this.tryDelay(delayNotifier, value); + } + } + catch (err) { + this.destination.error(err); + } + }; + DelayWhenSubscriber.prototype._complete = function () { + this.completed = true; + this.tryComplete(); + }; + DelayWhenSubscriber.prototype.removeSubscription = function (subscription) { + subscription.unsubscribe(); + var subscriptionIdx = this.delayNotifierSubscriptions.indexOf(subscription); + var value = null; + if (subscriptionIdx !== -1) { + value = this.values[subscriptionIdx]; + this.delayNotifierSubscriptions.splice(subscriptionIdx, 1); + this.values.splice(subscriptionIdx, 1); + } + return value; + }; + DelayWhenSubscriber.prototype.tryDelay = function (delayNotifier, value) { + var notifierSubscription = subscribeToResult_1.subscribeToResult(this, delayNotifier, value); + this.add(notifierSubscription); + this.delayNotifierSubscriptions.push(notifierSubscription); + this.values.push(value); + }; + DelayWhenSubscriber.prototype.tryComplete = function () { + if (this.completed && this.delayNotifierSubscriptions.length === 0) { + this.destination.complete(); + } + }; + return DelayWhenSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); +var SubscriptionDelayObservable = (function (_super) { + __extends(SubscriptionDelayObservable, _super); + function SubscriptionDelayObservable(source, subscriptionDelay) { + _super.call(this); + this.source = source; + this.subscriptionDelay = subscriptionDelay; + } + SubscriptionDelayObservable.prototype._subscribe = function (subscriber) { + this.subscriptionDelay.subscribe(new SubscriptionDelaySubscriber(subscriber, this.source)); + }; + return SubscriptionDelayObservable; +}(Observable_1.Observable)); +var SubscriptionDelaySubscriber = (function (_super) { + __extends(SubscriptionDelaySubscriber, _super); + function SubscriptionDelaySubscriber(parent, source) { + _super.call(this); + this.parent = parent; + this.source = source; + this.sourceSubscribed = false; + } + SubscriptionDelaySubscriber.prototype._next = function (unused) { + this.subscribeToSource(); + }; + SubscriptionDelaySubscriber.prototype._error = function (err) { + this.unsubscribe(); + this.parent.error(err); + }; + SubscriptionDelaySubscriber.prototype._complete = function () { + this.subscribeToSource(); + }; + SubscriptionDelaySubscriber.prototype.subscribeToSource = function () { + if (!this.sourceSubscribed) { + this.sourceSubscribed = true; + this.unsubscribe(); + this.source.subscribe(this.parent); + } + }; + return SubscriptionDelaySubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Observable":3,"../OuterSubscriber":6,"../Subscriber":9,"../util/subscribeToResult":250}],154:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that transforms Notification objects into the items or notifications they represent. + * @returns {Observable} an Observable that emits items and notifications embedded in Notification objects emitted by the source Observable. + */ +function dematerialize() { + return this.lift(new DeMaterializeOperator()); +} +exports.dematerialize = dematerialize; +var DeMaterializeOperator = (function () { + function DeMaterializeOperator() { + } + DeMaterializeOperator.prototype.call = function (subscriber) { + return new DeMaterializeSubscriber(subscriber); + }; + return DeMaterializeOperator; +}()); +var DeMaterializeSubscriber = (function (_super) { + __extends(DeMaterializeSubscriber, _super); + function DeMaterializeSubscriber(destination) { + _super.call(this, destination); + } + DeMaterializeSubscriber.prototype._next = function (value) { + value.observe(this.destination); + }; + return DeMaterializeSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],155:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +function distinctUntilChanged(compare, keySelector) { + return this.lift(new DistinctUntilChangedOperator(compare, keySelector)); +} +exports.distinctUntilChanged = distinctUntilChanged; +var DistinctUntilChangedOperator = (function () { + function DistinctUntilChangedOperator(compare, keySelector) { + this.compare = compare; + this.keySelector = keySelector; + } + DistinctUntilChangedOperator.prototype.call = function (subscriber) { + return new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector); + }; + return DistinctUntilChangedOperator; +}()); +var DistinctUntilChangedSubscriber = (function (_super) { + __extends(DistinctUntilChangedSubscriber, _super); + function DistinctUntilChangedSubscriber(destination, compare, keySelector) { + _super.call(this, destination); + this.keySelector = keySelector; + this.hasKey = false; + if (typeof compare === 'function') { + this.compare = compare; + } + } + DistinctUntilChangedSubscriber.prototype.compare = function (x, y) { + return x === y; + }; + DistinctUntilChangedSubscriber.prototype._next = function (value) { + var keySelector = this.keySelector; + var key = value; + if (keySelector) { + key = tryCatch_1.tryCatch(this.keySelector)(value); + if (key === errorObject_1.errorObject) { + return this.destination.error(errorObject_1.errorObject.e); + } + } + var result = false; + if (this.hasKey) { + result = tryCatch_1.tryCatch(this.compare)(this.key, key); + if (result === errorObject_1.errorObject) { + return this.destination.error(errorObject_1.errorObject.e); + } + } + else { + this.hasKey = true; + } + if (Boolean(result) === false) { + this.key = key; + this.destination.next(value); + } + }; + return DistinctUntilChangedSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../util/errorObject":239,"../util/tryCatch":253}],156:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var noop_1 = require('../util/noop'); +/** + * Returns a mirrored Observable of the source Observable, but modified so that the provided Observer is called + * for every item emitted by the source. + * This operator is useful for debugging your observables for the correct values or performing other side effects. + * @param {Observer|function} [nextOrObserver] a normal observer callback or callback for onNext. + * @param {function} [error] callback for errors in the source. + * @param {function} [complete] callback for the completion of the source. + * @reurns {Observable} a mirrored Observable with the specified Observer or callback attached for each item. + */ +function _do(nextOrObserver, error, complete) { + var next; + if (nextOrObserver && typeof nextOrObserver === 'object') { + next = nextOrObserver.next; + error = nextOrObserver.error; + complete = nextOrObserver.complete; + } + else { + next = nextOrObserver; + } + return this.lift(new DoOperator(next || noop_1.noop, error || noop_1.noop, complete || noop_1.noop)); +} +exports._do = _do; +var DoOperator = (function () { + function DoOperator(next, error, complete) { + this.next = next; + this.error = error; + this.complete = complete; + } + DoOperator.prototype.call = function (subscriber) { + return new DoSubscriber(subscriber, this.next, this.error, this.complete); + }; + return DoOperator; +}()); +var DoSubscriber = (function (_super) { + __extends(DoSubscriber, _super); + function DoSubscriber(destination, next, error, complete) { + _super.call(this, destination); + this.__next = next; + this.__error = error; + this.__complete = complete; + } + // NOTE: important, all try catch blocks below are there for performance + // reasons. tryCatcher approach does not benefit this operator. + DoSubscriber.prototype._next = function (value) { + try { + this.__next(value); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.next(value); + }; + DoSubscriber.prototype._error = function (err) { + try { + this.__error(err); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.error(err); + }; + DoSubscriber.prototype._complete = function () { + try { + this.__complete(); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.complete(); + }; + return DoSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../util/noop":247}],157:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that emits whether or not every item of the source satisfies the condition specified. + * @param {function} predicate a function for determining if an item meets a specified condition. + * @param {any} [thisArg] optional object to use for `this` in the callback + * @returns {Observable} an Observable of booleans that determines if all items of the source Observable meet the condition specified. + */ +function every(predicate, thisArg) { + var source = this; + return source.lift(new EveryOperator(predicate, thisArg, source)); +} +exports.every = every; +var EveryOperator = (function () { + function EveryOperator(predicate, thisArg, source) { + this.predicate = predicate; + this.thisArg = thisArg; + this.source = source; + } + EveryOperator.prototype.call = function (observer) { + return new EverySubscriber(observer, this.predicate, this.thisArg, this.source); + }; + return EveryOperator; +}()); +var EverySubscriber = (function (_super) { + __extends(EverySubscriber, _super); + function EverySubscriber(destination, predicate, thisArg, source) { + _super.call(this, destination); + this.predicate = predicate; + this.thisArg = thisArg; + this.source = source; + this.index = 0; + this.thisArg = thisArg || this; + } + EverySubscriber.prototype.notifyComplete = function (everyValueMatch) { + this.destination.next(everyValueMatch); + this.destination.complete(); + }; + EverySubscriber.prototype._next = function (value) { + var result = false; + try { + result = this.predicate.call(this.thisArg, value, this.index++, this.source); + } + catch (err) { + this.destination.error(err); + return; + } + if (!result) { + this.notifyComplete(false); + } + }; + EverySubscriber.prototype._complete = function () { + this.notifyComplete(true); + }; + return EverySubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],158:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Returns an Observable where for each item in the source Observable, the supplied function is applied to each item, + * resulting in a new value to then be applied again with the function. + * @param {function} project the function for projecting the next emitted item of the Observable. + * @param {number} [concurrent] the max number of observables that can be created concurrently. defaults to infinity. + * @param {Scheduler} [scheduler] The Scheduler to use for managing the expansions. + * @returns {Observable} an Observable containing the expansions of the source Observable. + */ +function expand(project, concurrent, scheduler) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + if (scheduler === void 0) { scheduler = undefined; } + concurrent = (concurrent || 0) < 1 ? Number.POSITIVE_INFINITY : concurrent; + return this.lift(new ExpandOperator(project, concurrent, scheduler)); +} +exports.expand = expand; +var ExpandOperator = (function () { + function ExpandOperator(project, concurrent, scheduler) { + this.project = project; + this.concurrent = concurrent; + this.scheduler = scheduler; + } + ExpandOperator.prototype.call = function (subscriber) { + return new ExpandSubscriber(subscriber, this.project, this.concurrent, this.scheduler); + }; + return ExpandOperator; +}()); +exports.ExpandOperator = ExpandOperator; +var ExpandSubscriber = (function (_super) { + __extends(ExpandSubscriber, _super); + function ExpandSubscriber(destination, project, concurrent, scheduler) { + _super.call(this, destination); + this.project = project; + this.concurrent = concurrent; + this.scheduler = scheduler; + this.index = 0; + this.active = 0; + this.hasCompleted = false; + if (concurrent < Number.POSITIVE_INFINITY) { + this.buffer = []; + } + } + ExpandSubscriber.dispatch = function (_a) { + var subscriber = _a.subscriber, result = _a.result, value = _a.value, index = _a.index; + subscriber.subscribeToProjection(result, value, index); + }; + ExpandSubscriber.prototype._next = function (value) { + var destination = this.destination; + if (destination.isUnsubscribed) { + this._complete(); + return; + } + var index = this.index++; + if (this.active < this.concurrent) { + destination.next(value); + var result = tryCatch_1.tryCatch(this.project)(value, index); + if (result === errorObject_1.errorObject) { + destination.error(errorObject_1.errorObject.e); + } + else if (!this.scheduler) { + this.subscribeToProjection(result, value, index); + } + else { + var state = { subscriber: this, result: result, value: value, index: index }; + this.add(this.scheduler.schedule(ExpandSubscriber.dispatch, 0, state)); + } + } + else { + this.buffer.push(value); + } + }; + ExpandSubscriber.prototype.subscribeToProjection = function (result, value, index) { + this.active++; + this.add(subscribeToResult_1.subscribeToResult(this, result, value, index)); + }; + ExpandSubscriber.prototype._complete = function () { + this.hasCompleted = true; + if (this.hasCompleted && this.active === 0) { + this.destination.complete(); + } + }; + ExpandSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this._next(innerValue); + }; + ExpandSubscriber.prototype.notifyComplete = function (innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer && buffer.length > 0) { + this._next(buffer.shift()); + } + if (this.hasCompleted && this.active === 0) { + this.destination.complete(); + } + }; + return ExpandSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); +exports.ExpandSubscriber = ExpandSubscriber; + +},{"../OuterSubscriber":6,"../util/errorObject":239,"../util/subscribeToResult":250,"../util/tryCatch":253}],159:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Similar to the well-known `Array.prototype.filter` method, this operator filters values down to a set + * allowed by a `select` function + * + * @param {Function} select a function that is used to select the resulting values + * if it returns `true`, the value is emitted, if `false` the value is not passed to the resulting observable + * @param {any} [thisArg] an optional argument to determine the value of `this` in the `select` function + * @returns {Observable} an observable of values allowed by the select function + */ +function filter(select, thisArg) { + return this.lift(new FilterOperator(select, thisArg)); +} +exports.filter = filter; +var FilterOperator = (function () { + function FilterOperator(select, thisArg) { + this.select = select; + this.thisArg = thisArg; + } + FilterOperator.prototype.call = function (subscriber) { + return new FilterSubscriber(subscriber, this.select, this.thisArg); + }; + return FilterOperator; +}()); +var FilterSubscriber = (function (_super) { + __extends(FilterSubscriber, _super); + function FilterSubscriber(destination, select, thisArg) { + _super.call(this, destination); + this.select = select; + this.thisArg = thisArg; + this.count = 0; + this.select = select; + } + // the try catch block below is left specifically for + // optimization and perf reasons. a tryCatcher is not necessary here. + FilterSubscriber.prototype._next = function (value) { + var result; + try { + result = this.select.call(this.thisArg, value, this.count++); + } + catch (err) { + this.destination.error(err); + return; + } + if (result) { + this.destination.next(value); + } + }; + return FilterSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],160:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Subscription_1 = require('../Subscription'); +/** + * Returns an Observable that mirrors the source Observable, but will call a specified function when + * the source terminates on complete or error. + * @param {function} finallySelector function to be called when source terminates. + * @returns {Observable} an Observable that mirrors the source, but will call the specified function on termination. + */ +function _finally(finallySelector) { + return this.lift(new FinallyOperator(finallySelector)); +} +exports._finally = _finally; +var FinallyOperator = (function () { + function FinallyOperator(finallySelector) { + this.finallySelector = finallySelector; + } + FinallyOperator.prototype.call = function (subscriber) { + return new FinallySubscriber(subscriber, this.finallySelector); + }; + return FinallyOperator; +}()); +var FinallySubscriber = (function (_super) { + __extends(FinallySubscriber, _super); + function FinallySubscriber(destination, finallySelector) { + _super.call(this, destination); + this.add(new Subscription_1.Subscription(finallySelector)); + } + return FinallySubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../Subscription":10}],161:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var EmptyError_1 = require('../util/EmptyError'); +/** + * Returns an Observable that emits the first item of the source Observable that matches the specified condition. + * Throws an error if matching element is not found. + * @param {function} predicate function called with each item to test for condition matching. + * @returns {Observable} an Observable of the first item that matches the condition. + */ +function first(predicate, resultSelector, defaultValue) { + return this.lift(new FirstOperator(predicate, resultSelector, defaultValue, this)); +} +exports.first = first; +var FirstOperator = (function () { + function FirstOperator(predicate, resultSelector, defaultValue, source) { + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + } + FirstOperator.prototype.call = function (observer) { + return new FirstSubscriber(observer, this.predicate, this.resultSelector, this.defaultValue, this.source); + }; + return FirstOperator; +}()); +var FirstSubscriber = (function (_super) { + __extends(FirstSubscriber, _super); + function FirstSubscriber(destination, predicate, resultSelector, defaultValue, source) { + _super.call(this, destination); + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + this.index = 0; + this.hasCompleted = false; + } + FirstSubscriber.prototype._next = function (value) { + var index = this.index++; + if (this.predicate) { + this._tryPredicate(value, index); + } + else { + this._emit(value, index); + } + }; + FirstSubscriber.prototype._tryPredicate = function (value, index) { + var result; + try { + result = this.predicate(value, index, this.source); + } + catch (err) { + this.destination.error(err); + return; + } + if (result) { + this._emit(value, index); + } + }; + FirstSubscriber.prototype._emit = function (value, index) { + if (this.resultSelector) { + this._tryResultSelector(value, index); + return; + } + this._emitFinal(value); + }; + FirstSubscriber.prototype._tryResultSelector = function (value, index) { + var result; + try { + result = this.resultSelector(value, index); + } + catch (err) { + this.destination.error(err); + return; + } + this._emitFinal(result); + }; + FirstSubscriber.prototype._emitFinal = function (value) { + var destination = this.destination; + destination.next(value); + destination.complete(); + this.hasCompleted = true; + }; + FirstSubscriber.prototype._complete = function () { + var destination = this.destination; + if (!this.hasCompleted && typeof this.defaultValue !== 'undefined') { + destination.next(this.defaultValue); + destination.complete(); + } + else if (!this.hasCompleted) { + destination.error(new EmptyError_1.EmptyError); + } + }; + return FirstSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../util/EmptyError":232}],162:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Subscription_1 = require('../Subscription'); +var Observable_1 = require('../Observable'); +var Operator_1 = require('../Operator'); +var Subject_1 = require('../Subject'); +var Map_1 = require('../util/Map'); +var FastMap_1 = require('../util/FastMap'); +/** + * Groups the items emitted by an Observable according to a specified criterion, + * and emits these grouped items as `GroupedObservables`, one `GroupedObservable` per group. + * + * + * + * @param {Function} keySelector - a function that extracts the key for each item + * @param {Function} elementSelector - a function that extracts the return element for each item + * @returns {Observable} an Observable that emits GroupedObservables, each of which corresponds + * to a unique key value and each of which emits those items from the source Observable that share + * that key value. + */ +function groupBy(keySelector, elementSelector, durationSelector) { + return this.lift(new GroupByOperator(this, keySelector, elementSelector, durationSelector)); +} +exports.groupBy = groupBy; +var GroupByOperator = (function (_super) { + __extends(GroupByOperator, _super); + function GroupByOperator(source, keySelector, elementSelector, durationSelector) { + _super.call(this); + this.source = source; + this.keySelector = keySelector; + this.elementSelector = elementSelector; + this.durationSelector = durationSelector; + } + GroupByOperator.prototype.call = function (subscriber) { + return new GroupBySubscriber(subscriber, this.keySelector, this.elementSelector, this.durationSelector); + }; + return GroupByOperator; +}(Operator_1.Operator)); +var GroupBySubscriber = (function (_super) { + __extends(GroupBySubscriber, _super); + function GroupBySubscriber(destination, keySelector, elementSelector, durationSelector) { + _super.call(this); + this.keySelector = keySelector; + this.elementSelector = elementSelector; + this.durationSelector = durationSelector; + this.groups = null; + this.attemptedToUnsubscribe = false; + this.count = 0; + this.destination = destination; + this.add(destination); + } + GroupBySubscriber.prototype._next = function (value) { + var key; + try { + key = this.keySelector(value); + } + catch (err) { + this.error(err); + return; + } + this._group(value, key); + }; + GroupBySubscriber.prototype._group = function (value, key) { + var groups = this.groups; + if (!groups) { + groups = this.groups = typeof key === 'string' ? new FastMap_1.FastMap() : new Map_1.Map(); + } + var group = groups.get(key); + if (!group) { + groups.set(key, group = new Subject_1.Subject()); + var groupedObservable = new GroupedObservable(key, group, this); + if (this.durationSelector) { + this._selectDuration(key, group); + } + this.destination.next(groupedObservable); + } + if (this.elementSelector) { + this._selectElement(value, group); + } + else { + this.tryGroupNext(value, group); + } + }; + GroupBySubscriber.prototype._selectElement = function (value, group) { + var result; + try { + result = this.elementSelector(value); + } + catch (err) { + this.error(err); + return; + } + this.tryGroupNext(result, group); + }; + GroupBySubscriber.prototype._selectDuration = function (key, group) { + var duration; + try { + duration = this.durationSelector(new GroupedObservable(key, group)); + } + catch (err) { + this.error(err); + return; + } + this.add(duration.subscribe(new GroupDurationSubscriber(key, group, this))); + }; + GroupBySubscriber.prototype.tryGroupNext = function (value, group) { + if (!group.isUnsubscribed) { + group.next(value); + } + }; + GroupBySubscriber.prototype._error = function (err) { + var groups = this.groups; + if (groups) { + groups.forEach(function (group, key) { + group.error(err); + }); + groups.clear(); + } + this.destination.error(err); + }; + GroupBySubscriber.prototype._complete = function () { + var groups = this.groups; + if (groups) { + groups.forEach(function (group, key) { + group.complete(); + }); + groups.clear(); + } + this.destination.complete(); + }; + GroupBySubscriber.prototype.removeGroup = function (key) { + this.groups.delete(key); + }; + GroupBySubscriber.prototype.unsubscribe = function () { + if (!this.isUnsubscribed && !this.attemptedToUnsubscribe) { + this.attemptedToUnsubscribe = true; + if (this.count === 0) { + _super.prototype.unsubscribe.call(this); + } + } + }; + return GroupBySubscriber; +}(Subscriber_1.Subscriber)); +var GroupDurationSubscriber = (function (_super) { + __extends(GroupDurationSubscriber, _super); + function GroupDurationSubscriber(key, group, parent) { + _super.call(this); + this.key = key; + this.group = group; + this.parent = parent; + } + GroupDurationSubscriber.prototype._next = function (value) { + this.tryComplete(); + }; + GroupDurationSubscriber.prototype._error = function (err) { + this.tryError(err); + }; + GroupDurationSubscriber.prototype._complete = function () { + this.tryComplete(); + }; + GroupDurationSubscriber.prototype.tryError = function (err) { + var group = this.group; + if (!group.isUnsubscribed) { + group.error(err); + } + this.parent.removeGroup(this.key); + }; + GroupDurationSubscriber.prototype.tryComplete = function () { + var group = this.group; + if (!group.isUnsubscribed) { + group.complete(); + } + this.parent.removeGroup(this.key); + }; + return GroupDurationSubscriber; +}(Subscriber_1.Subscriber)); +var GroupedObservable = (function (_super) { + __extends(GroupedObservable, _super); + function GroupedObservable(key, groupSubject, refCountSubscription) { + _super.call(this); + this.key = key; + this.groupSubject = groupSubject; + this.refCountSubscription = refCountSubscription; + } + GroupedObservable.prototype._subscribe = function (subscriber) { + var subscription = new Subscription_1.Subscription(); + var _a = this, refCountSubscription = _a.refCountSubscription, groupSubject = _a.groupSubject; + if (refCountSubscription && !refCountSubscription.isUnsubscribed) { + subscription.add(new InnerRefCountSubscription(refCountSubscription)); + } + subscription.add(groupSubject.subscribe(subscriber)); + return subscription; + }; + return GroupedObservable; +}(Observable_1.Observable)); +exports.GroupedObservable = GroupedObservable; +var InnerRefCountSubscription = (function (_super) { + __extends(InnerRefCountSubscription, _super); + function InnerRefCountSubscription(parent) { + _super.call(this); + this.parent = parent; + parent.count++; + } + InnerRefCountSubscription.prototype.unsubscribe = function () { + var parent = this.parent; + if (!parent.isUnsubscribed && !this.isUnsubscribed) { + _super.prototype.unsubscribe.call(this); + parent.count -= 1; + if (parent.count === 0 && parent.attemptedToUnsubscribe) { + parent.unsubscribe(); + } + } + }; + return InnerRefCountSubscription; +}(Subscription_1.Subscription)); + +},{"../Observable":3,"../Operator":5,"../Subject":8,"../Subscriber":9,"../Subscription":10,"../util/FastMap":233,"../util/Map":235}],163:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var noop_1 = require('../util/noop'); +/** + * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`. + * + * + * + * @returns {Observable} an empty Observable that only calls `complete` + * or `error`, based on which one is called by the source Observable. + */ +function ignoreElements() { + return this.lift(new IgnoreElementsOperator()); +} +exports.ignoreElements = ignoreElements; +; +var IgnoreElementsOperator = (function () { + function IgnoreElementsOperator() { + } + IgnoreElementsOperator.prototype.call = function (subscriber) { + return new IgnoreElementsSubscriber(subscriber); + }; + return IgnoreElementsOperator; +}()); +var IgnoreElementsSubscriber = (function (_super) { + __extends(IgnoreElementsSubscriber, _super); + function IgnoreElementsSubscriber() { + _super.apply(this, arguments); + } + IgnoreElementsSubscriber.prototype._next = function (unused) { + noop_1.noop(); + }; + return IgnoreElementsSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../util/noop":247}],164:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function inspect(durationSelector) { + return this.lift(new InspectOperator(durationSelector)); +} +exports.inspect = inspect; +var InspectOperator = (function () { + function InspectOperator(durationSelector) { + this.durationSelector = durationSelector; + } + InspectOperator.prototype.call = function (subscriber) { + return new InspectSubscriber(subscriber, this.durationSelector); + }; + return InspectOperator; +}()); +var InspectSubscriber = (function (_super) { + __extends(InspectSubscriber, _super); + function InspectSubscriber(destination, durationSelector) { + _super.call(this, destination); + this.durationSelector = durationSelector; + this.hasValue = false; + } + InspectSubscriber.prototype._next = function (value) { + this.value = value; + this.hasValue = true; + if (!this.throttled) { + var duration = tryCatch_1.tryCatch(this.durationSelector)(value); + if (duration === errorObject_1.errorObject) { + this.destination.error(errorObject_1.errorObject.e); + } + else { + this.add(this.throttled = subscribeToResult_1.subscribeToResult(this, duration)); + } + } + }; + InspectSubscriber.prototype.clearThrottle = function () { + var _a = this, value = _a.value, hasValue = _a.hasValue, throttled = _a.throttled; + if (throttled) { + this.remove(throttled); + this.throttled = null; + throttled.unsubscribe(); + } + if (hasValue) { + this.value = null; + this.hasValue = false; + this.destination.next(value); + } + }; + InspectSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex) { + this.clearThrottle(); + }; + InspectSubscriber.prototype.notifyComplete = function () { + this.clearThrottle(); + }; + return InspectSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/errorObject":239,"../util/subscribeToResult":250,"../util/tryCatch":253}],165:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var asap_1 = require('../scheduler/asap'); +var Subscriber_1 = require('../Subscriber'); +function inspectTime(delay, scheduler) { + if (scheduler === void 0) { scheduler = asap_1.asap; } + return this.lift(new InspectTimeOperator(delay, scheduler)); +} +exports.inspectTime = inspectTime; +var InspectTimeOperator = (function () { + function InspectTimeOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + InspectTimeOperator.prototype.call = function (subscriber) { + return new InspectTimeSubscriber(subscriber, this.delay, this.scheduler); + }; + return InspectTimeOperator; +}()); +var InspectTimeSubscriber = (function (_super) { + __extends(InspectTimeSubscriber, _super); + function InspectTimeSubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + this.hasValue = false; + } + InspectTimeSubscriber.prototype._next = function (value) { + this.value = value; + this.hasValue = true; + if (!this.throttled) { + this.add(this.throttled = this.scheduler.schedule(dispatchNext, this.delay, this)); + } + }; + InspectTimeSubscriber.prototype.clearThrottle = function () { + var _a = this, value = _a.value, hasValue = _a.hasValue, throttled = _a.throttled; + if (throttled) { + this.remove(throttled); + this.throttled = null; + throttled.unsubscribe(); + } + if (hasValue) { + this.value = null; + this.hasValue = false; + this.destination.next(value); + } + }; + return InspectTimeSubscriber; +}(Subscriber_1.Subscriber)); +function dispatchNext(subscriber) { + subscriber.clearThrottle(); +} + +},{"../Subscriber":9,"../scheduler/asap":224}],166:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var EmptyError_1 = require('../util/EmptyError'); +/** + * Returns an Observable that emits only the last item emitted by the source Observable. + * It optionally takes a predicate function as a parameter, in which case, rather than emitting + * the last item from the source Observable, the resulting Observable will emit the last item + * from the source Observable that satisfies the predicate. + * + * + * + * @param {function} predicate - the condition any source emitted item has to satisfy. + * @returns {Observable} an Observable that emits only the last item satisfying the given condition + * from the source, or an NoSuchElementException if no such items are emitted. + * @throws - Throws if no items that match the predicate are emitted by the source Observable. + */ +function last(predicate, resultSelector, defaultValue) { + return this.lift(new LastOperator(predicate, resultSelector, defaultValue, this)); +} +exports.last = last; +var LastOperator = (function () { + function LastOperator(predicate, resultSelector, defaultValue, source) { + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + } + LastOperator.prototype.call = function (observer) { + return new LastSubscriber(observer, this.predicate, this.resultSelector, this.defaultValue, this.source); + }; + return LastOperator; +}()); +var LastSubscriber = (function (_super) { + __extends(LastSubscriber, _super); + function LastSubscriber(destination, predicate, resultSelector, defaultValue, source) { + _super.call(this, destination); + this.predicate = predicate; + this.resultSelector = resultSelector; + this.defaultValue = defaultValue; + this.source = source; + this.hasValue = false; + this.index = 0; + if (typeof defaultValue !== 'undefined') { + this.lastValue = defaultValue; + this.hasValue = true; + } + } + LastSubscriber.prototype._next = function (value) { + var index = this.index++; + if (this.predicate) { + this._tryPredicate(value, index); + } + else { + if (this.resultSelector) { + this._tryResultSelector(value, index); + return; + } + this.lastValue = value; + this.hasValue = true; + } + }; + LastSubscriber.prototype._tryPredicate = function (value, index) { + var result; + try { + result = this.predicate(value, index, this.source); + } + catch (err) { + this.destination.error(err); + return; + } + if (result) { + if (this.resultSelector) { + this._tryResultSelector(value, index); + return; + } + this.lastValue = value; + this.hasValue = true; + } + }; + LastSubscriber.prototype._tryResultSelector = function (value, index) { + var result; + try { + result = this.resultSelector(value, index); + } + catch (err) { + this.destination.error(err); + return; + } + this.lastValue = result; + this.hasValue = true; + }; + LastSubscriber.prototype._complete = function () { + var destination = this.destination; + if (this.hasValue) { + destination.next(this.lastValue); + destination.complete(); + } + else { + destination.error(new EmptyError_1.EmptyError); + } + }; + return LastSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../util/EmptyError":232}],167:[function(require,module,exports){ +"use strict"; +function letProto(func) { + return func(this); +} +exports.letProto = letProto; + +},{}],168:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Similar to the well known `Array.prototype.map` function, this operator + * applies a projection to each value and emits that projection in the returned observable + * + * + * + * @param {Function} project the function to create projection + * @param {any} [thisArg] an optional argument to define what `this` is in the project function + * @returns {Observable} a observable of projected values + */ +function map(project, thisArg) { + if (typeof project !== 'function') { + throw new TypeError('argument is not a function. Are you looking for `mapTo()`?'); + } + return this.lift(new MapOperator(project, thisArg)); +} +exports.map = map; +var MapOperator = (function () { + function MapOperator(project, thisArg) { + this.project = project; + this.thisArg = thisArg; + } + MapOperator.prototype.call = function (subscriber) { + return new MapSubscriber(subscriber, this.project, this.thisArg); + }; + return MapOperator; +}()); +var MapSubscriber = (function (_super) { + __extends(MapSubscriber, _super); + function MapSubscriber(destination, project, thisArg) { + _super.call(this, destination); + this.project = project; + this.count = 0; + this.thisArg = thisArg || this; + } + // NOTE: This looks unoptimized, but it's actually purposefully NOT + // using try/catch optimizations. + MapSubscriber.prototype._next = function (value) { + var result; + try { + result = this.project.call(this.thisArg, value, this.count++); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.next(result); + }; + return MapSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],169:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Maps every value to the same value every time. + * + * + * + * @param {any} value the value to map each incoming value to + * @returns {Observable} an observable of the passed value that emits everytime the source does + */ +function mapTo(value) { + return this.lift(new MapToOperator(value)); +} +exports.mapTo = mapTo; +var MapToOperator = (function () { + function MapToOperator(value) { + this.value = value; + } + MapToOperator.prototype.call = function (subscriber) { + return new MapToSubscriber(subscriber, this.value); + }; + return MapToOperator; +}()); +var MapToSubscriber = (function (_super) { + __extends(MapToSubscriber, _super); + function MapToSubscriber(destination, value) { + _super.call(this, destination); + this.value = value; + } + MapToSubscriber.prototype._next = function (x) { + this.destination.next(this.value); + }; + return MapToSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],170:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Notification_1 = require('../Notification'); +/** + * Returns an Observable that represents all of the emissions and notifications + * from the source Observable into emissions marked with their original types + * within a `Notification` objects. + * + * + * + * @scheduler materialize does not operate by default on a particular Scheduler. + * @returns {Observable} an Observable that emits items that are the result of + * materializing the items and notifications of the source Observable. + */ +function materialize() { + return this.lift(new MaterializeOperator()); +} +exports.materialize = materialize; +var MaterializeOperator = (function () { + function MaterializeOperator() { + } + MaterializeOperator.prototype.call = function (subscriber) { + return new MaterializeSubscriber(subscriber); + }; + return MaterializeOperator; +}()); +var MaterializeSubscriber = (function (_super) { + __extends(MaterializeSubscriber, _super); + function MaterializeSubscriber(destination) { + _super.call(this, destination); + } + MaterializeSubscriber.prototype._next = function (value) { + this.destination.next(Notification_1.Notification.createNext(value)); + }; + MaterializeSubscriber.prototype._error = function (err) { + var destination = this.destination; + destination.next(Notification_1.Notification.createError(err)); + destination.complete(); + }; + MaterializeSubscriber.prototype._complete = function () { + var destination = this.destination; + destination.next(Notification_1.Notification.createComplete()); + destination.complete(); + }; + return MaterializeSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Notification":2,"../Subscriber":9}],171:[function(require,module,exports){ +"use strict"; +var ArrayObservable_1 = require('../observable/ArrayObservable'); +var mergeAll_1 = require('./mergeAll'); +var isScheduler_1 = require('../util/isScheduler'); +/** + * Creates a result Observable which emits values from every given input Observable. + * + * + * + * @param {Observable} input Observables + * @returns {Observable} an Observable that emits items that are the result of every input Observable. + */ +function merge() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + observables.unshift(this); + return mergeStatic.apply(this, observables); +} +exports.merge = merge; +function mergeStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var concurrent = Number.POSITIVE_INFINITY; + var scheduler = null; + var last = observables[observables.length - 1]; + if (isScheduler_1.isScheduler(last)) { + scheduler = observables.pop(); + if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') { + concurrent = observables.pop(); + } + } + else if (typeof last === 'number') { + concurrent = observables.pop(); + } + if (observables.length === 1) { + return observables[0]; + } + return new ArrayObservable_1.ArrayObservable(observables, scheduler).lift(new mergeAll_1.MergeAllOperator(concurrent)); +} +exports.mergeStatic = mergeStatic; + +},{"../observable/ArrayObservable":116,"../util/isScheduler":246,"./mergeAll":172}],172:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function mergeAll(concurrent) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + return this.lift(new MergeAllOperator(concurrent)); +} +exports.mergeAll = mergeAll; +var MergeAllOperator = (function () { + function MergeAllOperator(concurrent) { + this.concurrent = concurrent; + } + MergeAllOperator.prototype.call = function (observer) { + return new MergeAllSubscriber(observer, this.concurrent); + }; + return MergeAllOperator; +}()); +exports.MergeAllOperator = MergeAllOperator; +var MergeAllSubscriber = (function (_super) { + __extends(MergeAllSubscriber, _super); + function MergeAllSubscriber(destination, concurrent) { + _super.call(this, destination); + this.concurrent = concurrent; + this.hasCompleted = false; + this.buffer = []; + this.active = 0; + } + MergeAllSubscriber.prototype._next = function (observable) { + if (this.active < this.concurrent) { + this.active++; + this.add(subscribeToResult_1.subscribeToResult(this, observable)); + } + else { + this.buffer.push(observable); + } + }; + MergeAllSubscriber.prototype._complete = function () { + this.hasCompleted = true; + if (this.active === 0 && this.buffer.length === 0) { + this.destination.complete(); + } + }; + MergeAllSubscriber.prototype.notifyComplete = function (innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer.length > 0) { + this._next(buffer.shift()); + } + else if (this.active === 0 && this.hasCompleted) { + this.destination.complete(); + } + }; + return MergeAllSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); +exports.MergeAllSubscriber = MergeAllSubscriber; + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],173:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var subscribeToResult_1 = require('../util/subscribeToResult'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +/** + * Returns an Observable that emits items based on applying a function that you supply to each item emitted by the + * source Observable, where that function returns an Observable, and then merging those resulting Observables and + * emitting the results of this merger. + * + * + * + * @param {Function} a function that, when applied to an item emitted by the source Observable, returns an Observable. + * @returns {Observable} an Observable that emits the result of applying the transformation function to each item + * emitted by the source Observable and merging the results of the Observables obtained from this transformation + */ +function mergeMap(project, resultSelector, concurrent) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + return this.lift(new MergeMapOperator(project, resultSelector, concurrent)); +} +exports.mergeMap = mergeMap; +var MergeMapOperator = (function () { + function MergeMapOperator(project, resultSelector, concurrent) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + this.project = project; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + } + MergeMapOperator.prototype.call = function (observer) { + return new MergeMapSubscriber(observer, this.project, this.resultSelector, this.concurrent); + }; + return MergeMapOperator; +}()); +exports.MergeMapOperator = MergeMapOperator; +var MergeMapSubscriber = (function (_super) { + __extends(MergeMapSubscriber, _super); + function MergeMapSubscriber(destination, project, resultSelector, concurrent) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + _super.call(this, destination); + this.project = project; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + this.hasCompleted = false; + this.buffer = []; + this.active = 0; + this.index = 0; + } + MergeMapSubscriber.prototype._next = function (value) { + if (this.active < this.concurrent) { + this._tryNext(value); + } + else { + this.buffer.push(value); + } + }; + MergeMapSubscriber.prototype._tryNext = function (value) { + var result; + var index = this.index++; + try { + result = this.project(value, index); + } + catch (err) { + this.destination.error(err); + return; + } + this.active++; + this._innerSub(result, value, index); + }; + MergeMapSubscriber.prototype._innerSub = function (ish, value, index) { + this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index)); + }; + MergeMapSubscriber.prototype._complete = function () { + this.hasCompleted = true; + if (this.active === 0 && this.buffer.length === 0) { + this.destination.complete(); + } + }; + MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (this.resultSelector) { + this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex); + } + else { + this.destination.next(innerValue); + } + }; + MergeMapSubscriber.prototype._notifyResultSelector = function (outerValue, innerValue, outerIndex, innerIndex) { + var result; + try { + result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.next(result); + }; + MergeMapSubscriber.prototype.notifyComplete = function (innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer.length > 0) { + this._next(buffer.shift()); + } + else if (this.active === 0 && this.hasCompleted) { + this.destination.complete(); + } + }; + return MergeMapSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); +exports.MergeMapSubscriber = MergeMapSubscriber; + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],174:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function mergeMapTo(observable, resultSelector, concurrent) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + return this.lift(new MergeMapToOperator(observable, resultSelector, concurrent)); +} +exports.mergeMapTo = mergeMapTo; +// TODO: Figure out correct signature here: an Operator, R2> +// needs to implement call(observer: Subscriber): Subscriber> +var MergeMapToOperator = (function () { + function MergeMapToOperator(ish, resultSelector, concurrent) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + this.ish = ish; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + } + MergeMapToOperator.prototype.call = function (observer) { + return new MergeMapToSubscriber(observer, this.ish, this.resultSelector, this.concurrent); + }; + return MergeMapToOperator; +}()); +exports.MergeMapToOperator = MergeMapToOperator; +var MergeMapToSubscriber = (function (_super) { + __extends(MergeMapToSubscriber, _super); + function MergeMapToSubscriber(destination, ish, resultSelector, concurrent) { + if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; } + _super.call(this, destination); + this.ish = ish; + this.resultSelector = resultSelector; + this.concurrent = concurrent; + this.hasCompleted = false; + this.buffer = []; + this.active = 0; + this.index = 0; + } + MergeMapToSubscriber.prototype._next = function (value) { + if (this.active < this.concurrent) { + var resultSelector = this.resultSelector; + var index = this.index++; + var ish = this.ish; + var destination = this.destination; + this.active++; + this._innerSub(ish, destination, resultSelector, value, index); + } + else { + this.buffer.push(value); + } + }; + MergeMapToSubscriber.prototype._innerSub = function (ish, destination, resultSelector, value, index) { + this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index)); + }; + MergeMapToSubscriber.prototype._complete = function () { + this.hasCompleted = true; + if (this.active === 0 && this.buffer.length === 0) { + this.destination.complete(); + } + }; + MergeMapToSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var _a = this, resultSelector = _a.resultSelector, destination = _a.destination; + if (resultSelector) { + this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex); + } + else { + destination.next(innerValue); + } + }; + MergeMapToSubscriber.prototype.trySelectResult = function (outerValue, innerValue, outerIndex, innerIndex) { + var _a = this, resultSelector = _a.resultSelector, destination = _a.destination; + var result; + try { + result = resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } + catch (err) { + destination.error(err); + return; + } + destination.next(result); + }; + MergeMapToSubscriber.prototype.notifyError = function (err) { + this.destination.error(err); + }; + MergeMapToSubscriber.prototype.notifyComplete = function (innerSub) { + var buffer = this.buffer; + this.remove(innerSub); + this.active--; + if (buffer.length > 0) { + this._next(buffer.shift()); + } + else if (this.active === 0 && this.hasCompleted) { + this.destination.complete(); + } + }; + return MergeMapToSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); +exports.MergeMapToSubscriber = MergeMapToSubscriber; + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],175:[function(require,module,exports){ +"use strict"; +var ConnectableObservable_1 = require('../observable/ConnectableObservable'); +/** + * Returns an Observable that emits the results of invoking a specified selector on items + * emitted by a ConnectableObservable that shares a single subscription to the underlying stream. + * + * + * + * @param {Function} selector - a function that can use the multicasted source stream + * as many times as needed, without causing multiple subscriptions to the source stream. + * Subscribers to the given source will receive all notifications of the source from the + * time of the subscription forward. + * @returns {Observable} an Observable that emits the results of invoking the selector + * on the items emitted by a `ConnectableObservable` that shares a single subscription to + * the underlying stream. + */ +function multicast(subjectOrSubjectFactory) { + var subjectFactory; + if (typeof subjectOrSubjectFactory === 'function') { + subjectFactory = subjectOrSubjectFactory; + } + else { + subjectFactory = function subjectFactory() { + return subjectOrSubjectFactory; + }; + } + return new ConnectableObservable_1.ConnectableObservable(this, subjectFactory); +} +exports.multicast = multicast; + +},{"../observable/ConnectableObservable":119}],176:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Notification_1 = require('../Notification'); +function observeOn(scheduler, delay) { + if (delay === void 0) { delay = 0; } + return this.lift(new ObserveOnOperator(scheduler, delay)); +} +exports.observeOn = observeOn; +var ObserveOnOperator = (function () { + function ObserveOnOperator(scheduler, delay) { + if (delay === void 0) { delay = 0; } + this.scheduler = scheduler; + this.delay = delay; + } + ObserveOnOperator.prototype.call = function (subscriber) { + return new ObserveOnSubscriber(subscriber, this.scheduler, this.delay); + }; + return ObserveOnOperator; +}()); +exports.ObserveOnOperator = ObserveOnOperator; +var ObserveOnSubscriber = (function (_super) { + __extends(ObserveOnSubscriber, _super); + function ObserveOnSubscriber(destination, scheduler, delay) { + if (delay === void 0) { delay = 0; } + _super.call(this, destination); + this.scheduler = scheduler; + this.delay = delay; + } + ObserveOnSubscriber.dispatch = function (_a) { + var notification = _a.notification, destination = _a.destination; + notification.observe(destination); + }; + ObserveOnSubscriber.prototype.scheduleMessage = function (notification) { + this.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination))); + }; + ObserveOnSubscriber.prototype._next = function (value) { + this.scheduleMessage(Notification_1.Notification.createNext(value)); + }; + ObserveOnSubscriber.prototype._error = function (err) { + this.scheduleMessage(Notification_1.Notification.createError(err)); + }; + ObserveOnSubscriber.prototype._complete = function () { + this.scheduleMessage(Notification_1.Notification.createComplete()); + }; + return ObserveOnSubscriber; +}(Subscriber_1.Subscriber)); +exports.ObserveOnSubscriber = ObserveOnSubscriber; +var ObserveOnMessage = (function () { + function ObserveOnMessage(notification, destination) { + this.notification = notification; + this.destination = destination; + } + return ObserveOnMessage; +}()); + +},{"../Notification":2,"../Subscriber":9}],177:[function(require,module,exports){ +"use strict"; +var not_1 = require('../util/not'); +var filter_1 = require('./filter'); +function partition(predicate, thisArg) { + return [ + filter_1.filter.call(this, predicate), + filter_1.filter.call(this, not_1.not(predicate, thisArg)) + ]; +} +exports.partition = partition; + +},{"../util/not":248,"./filter":159}],178:[function(require,module,exports){ +"use strict"; +var map_1 = require('./map'); +/** + * Retrieves the value of a specified nested property from all elements in + * the Observable sequence. If a property can't be resolved, it will return + * `undefined` for that value. + * + * @param {...args} properties the nested properties to pluck + * @returns {Observable} Returns a new Observable sequence of property values + */ +function pluck() { + var properties = []; + for (var _i = 0; _i < arguments.length; _i++) { + properties[_i - 0] = arguments[_i]; + } + var length = properties.length; + if (length === 0) { + throw new Error('List of properties cannot be empty.'); + } + return map_1.map.call(this, plucker(properties, length)); +} +exports.pluck = pluck; +function plucker(props, length) { + var mapper = function (x) { + var currentProp = x; + for (var i = 0; i < length; i++) { + var p = currentProp[props[i]]; + if (typeof p !== 'undefined') { + currentProp = p; + } + else { + return undefined; + } + } + return currentProp; + }; + return mapper; +} + +},{"./map":168}],179:[function(require,module,exports){ +"use strict"; +var Subject_1 = require('../Subject'); +var multicast_1 = require('./multicast'); +/** + * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called + * before it begins emitting items to those Observers that have subscribed to it. + * + * + * + * @returns a ConnectableObservable that upon connection causes the source Observable to emit items to its Observers. + */ +function publish() { + return multicast_1.multicast.call(this, new Subject_1.Subject()); +} +exports.publish = publish; + +},{"../Subject":8,"./multicast":175}],180:[function(require,module,exports){ +"use strict"; +var BehaviorSubject_1 = require('../subject/BehaviorSubject'); +var multicast_1 = require('./multicast'); +function publishBehavior(value) { + return multicast_1.multicast.call(this, new BehaviorSubject_1.BehaviorSubject(value)); +} +exports.publishBehavior = publishBehavior; + +},{"../subject/BehaviorSubject":227,"./multicast":175}],181:[function(require,module,exports){ +"use strict"; +var AsyncSubject_1 = require('../subject/AsyncSubject'); +var multicast_1 = require('./multicast'); +function publishLast() { + return multicast_1.multicast.call(this, new AsyncSubject_1.AsyncSubject()); +} +exports.publishLast = publishLast; + +},{"../subject/AsyncSubject":226,"./multicast":175}],182:[function(require,module,exports){ +"use strict"; +var ReplaySubject_1 = require('../subject/ReplaySubject'); +var multicast_1 = require('./multicast'); +function publishReplay(bufferSize, windowTime, scheduler) { + if (bufferSize === void 0) { bufferSize = Number.POSITIVE_INFINITY; } + if (windowTime === void 0) { windowTime = Number.POSITIVE_INFINITY; } + return multicast_1.multicast.call(this, new ReplaySubject_1.ReplaySubject(bufferSize, windowTime, scheduler)); +} +exports.publishReplay = publishReplay; + +},{"../subject/ReplaySubject":228,"./multicast":175}],183:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var isArray_1 = require('../util/isArray'); +var ArrayObservable_1 = require('../observable/ArrayObservable'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Returns an Observable that mirrors the first source Observable to emit an item + * from the combination of this Observable and supplied Observables + * @param {...Observables} ...observables sources used to race for which Observable emits first. + * @returns {Observable} an Observable that mirrors the output of the first Observable to emit an item. + */ +function race() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + // if the only argument is an array, it was most likely called with + // `pair([obs1, obs2, ...])` + if (observables.length === 1 && isArray_1.isArray(observables[0])) { + observables = observables[0]; + } + observables.unshift(this); + return raceStatic.apply(this, observables); +} +exports.race = race; +/** + * Returns an Observable that mirrors the first source Observable to emit an item. + * @param {...Observables} ...observables sources used to race for which Observable emits first. + * @returns {Observable} an Observable that mirrors the output of the first Observable to emit an item. + */ +function raceStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + // if the only argument is an array, it was most likely called with + // `pair([obs1, obs2, ...])` + if (observables.length === 1) { + if (isArray_1.isArray(observables[0])) { + observables = observables[0]; + } + else { + return observables[0]; + } + } + return new ArrayObservable_1.ArrayObservable(observables).lift(new RaceOperator()); +} +exports.raceStatic = raceStatic; +var RaceOperator = (function () { + function RaceOperator() { + } + RaceOperator.prototype.call = function (subscriber) { + return new RaceSubscriber(subscriber); + }; + return RaceOperator; +}()); +exports.RaceOperator = RaceOperator; +var RaceSubscriber = (function (_super) { + __extends(RaceSubscriber, _super); + function RaceSubscriber(destination) { + _super.call(this, destination); + this.hasFirst = false; + this.observables = []; + this.subscriptions = []; + } + RaceSubscriber.prototype._next = function (observable) { + this.observables.push(observable); + }; + RaceSubscriber.prototype._complete = function () { + var observables = this.observables; + var len = observables.length; + if (len === 0) { + this.destination.complete(); + } + else { + for (var i = 0; i < len; i++) { + var observable = observables[i]; + var subscription = subscribeToResult_1.subscribeToResult(this, observable, observable, i); + this.subscriptions.push(subscription); + this.add(subscription); + } + this.observables = null; + } + }; + RaceSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (!this.hasFirst) { + this.hasFirst = true; + for (var i = 0; i < this.subscriptions.length; i++) { + if (i !== outerIndex) { + var subscription = this.subscriptions[i]; + subscription.unsubscribe(); + this.remove(subscription); + } + } + this.subscriptions = null; + } + this.destination.next(innerValue); + }; + return RaceSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); +exports.RaceSubscriber = RaceSubscriber; + +},{"../OuterSubscriber":6,"../observable/ArrayObservable":116,"../util/isArray":240,"../util/subscribeToResult":250}],184:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable, + * then feeds the result of that function along with the second item emitted by the source Observable into the same + * function, and so on until all items have been emitted by the source Observable, and emits the final result from + * the final call to your function as its sole item. + * This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or + * "inject" in other programming contexts. + * + * + * + * @param {initialValue} the initial (seed) accumulator value + * @param {accumulator} an accumulator function to be invoked on each item emitted by the source Observable, the + * result of which will be used in the next accumulator call. + * @returns {Observable} an Observable that emits a single item that is the result of accumulating the output from the + * items emitted by the source Observable. + */ +function reduce(project, seed) { + return this.lift(new ReduceOperator(project, seed)); +} +exports.reduce = reduce; +var ReduceOperator = (function () { + function ReduceOperator(project, seed) { + this.project = project; + this.seed = seed; + } + ReduceOperator.prototype.call = function (subscriber) { + return new ReduceSubscriber(subscriber, this.project, this.seed); + }; + return ReduceOperator; +}()); +exports.ReduceOperator = ReduceOperator; +var ReduceSubscriber = (function (_super) { + __extends(ReduceSubscriber, _super); + function ReduceSubscriber(destination, project, seed) { + _super.call(this, destination); + this.hasValue = false; + this.acc = seed; + this.project = project; + this.hasSeed = typeof seed !== 'undefined'; + } + ReduceSubscriber.prototype._next = function (value) { + if (this.hasValue || (this.hasValue = this.hasSeed)) { + this._tryReduce(value); + } + else { + this.acc = value; + this.hasValue = true; + } + }; + ReduceSubscriber.prototype._tryReduce = function (value) { + var result; + try { + result = this.project(this.acc, value); + } + catch (err) { + this.destination.error(err); + return; + } + this.acc = result; + }; + ReduceSubscriber.prototype._complete = function () { + if (this.hasValue || this.hasSeed) { + this.destination.next(this.acc); + } + this.destination.complete(); + }; + return ReduceSubscriber; +}(Subscriber_1.Subscriber)); +exports.ReduceSubscriber = ReduceSubscriber; + +},{"../Subscriber":9}],185:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var EmptyObservable_1 = require('../observable/EmptyObservable'); +/** + * Returns an Observable that repeats the stream of items emitted by the source Observable at most count times, + * on a particular Scheduler. + * + * + * + * @param {Scheduler} [scheduler] the Scheduler to emit the items on. + * @param {number} [count] the number of times the source Observable items are repeated, a count of 0 will yield + * an empty Observable. + * @returns {Observable} an Observable that repeats the stream of items emitted by the source Observable at most + * count times. + */ +function repeat(count) { + if (count === void 0) { count = -1; } + if (count === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + else if (count < 0) { + return this.lift(new RepeatOperator(-1, this)); + } + else { + return this.lift(new RepeatOperator(count - 1, this)); + } +} +exports.repeat = repeat; +var RepeatOperator = (function () { + function RepeatOperator(count, source) { + this.count = count; + this.source = source; + } + RepeatOperator.prototype.call = function (subscriber) { + return new RepeatSubscriber(subscriber, this.count, this.source); + }; + return RepeatOperator; +}()); +var RepeatSubscriber = (function (_super) { + __extends(RepeatSubscriber, _super); + function RepeatSubscriber(destination, count, source) { + _super.call(this, destination); + this.count = count; + this.source = source; + } + RepeatSubscriber.prototype.complete = function () { + if (!this.isStopped) { + var _a = this, source = _a.source, count = _a.count; + if (count === 0) { + return _super.prototype.complete.call(this); + } + else if (count > -1) { + this.count = count - 1; + } + this.unsubscribe(); + this.isStopped = false; + this.isUnsubscribed = false; + source.subscribe(this); + } + }; + return RepeatSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../observable/EmptyObservable":121}],186:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that mirrors the source Observable, resubscribing to it if it calls `error` and the + * predicate returns true for that specific exception and retry count. + * If the source Observable calls `error`, this method will resubscribe to the source Observable for a maximum of + * count resubscriptions (given as a number parameter) rather than propagating the `error` call. + * + * + * + * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted + * during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second + * time and emits: [1, 2, 3, 4, 5] then the complete stream of emissions and notifications + * would be: [1, 2, 1, 2, 3, 4, 5, `complete`]. + * @param {number} number of retry attempts before failing. + * @returns {Observable} the source Observable modified with the retry logic. + */ +function retry(count) { + if (count === void 0) { count = -1; } + return this.lift(new RetryOperator(count, this)); +} +exports.retry = retry; +var RetryOperator = (function () { + function RetryOperator(count, source) { + this.count = count; + this.source = source; + } + RetryOperator.prototype.call = function (subscriber) { + return new RetrySubscriber(subscriber, this.count, this.source); + }; + return RetryOperator; +}()); +var RetrySubscriber = (function (_super) { + __extends(RetrySubscriber, _super); + function RetrySubscriber(destination, count, source) { + _super.call(this, destination); + this.count = count; + this.source = source; + } + RetrySubscriber.prototype.error = function (err) { + if (!this.isStopped) { + var _a = this, source = _a.source, count = _a.count; + if (count === 0) { + return _super.prototype.error.call(this, err); + } + else if (count > -1) { + this.count = count - 1; + } + this.unsubscribe(); + this.isStopped = false; + this.isUnsubscribed = false; + source.subscribe(this); + } + }; + return RetrySubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],187:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subject_1 = require('../Subject'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Returns an Observable that emits the same values as the source observable with the exception of an `error`. + * An `error` will cause the emission of the Throwable that cause the error to the Observable returned from + * notificationHandler. If that Observable calls onComplete or `error` then retry will call `complete` or `error` + * on the child subscription. Otherwise, this Observable will resubscribe to the source observable, on a particular + * Scheduler. + * + * + * + * @param {notificationHandler} receives an Observable of notifications with which a user can `complete` or `error`, + * aborting the retry. + * @param {scheduler} the Scheduler on which to subscribe to the source Observable. + * @returns {Observable} the source Observable modified with retry logic. + */ +function retryWhen(notifier) { + return this.lift(new RetryWhenOperator(notifier, this)); +} +exports.retryWhen = retryWhen; +var RetryWhenOperator = (function () { + function RetryWhenOperator(notifier, source) { + this.notifier = notifier; + this.source = source; + } + RetryWhenOperator.prototype.call = function (subscriber) { + return new RetryWhenSubscriber(subscriber, this.notifier, this.source); + }; + return RetryWhenOperator; +}()); +var RetryWhenSubscriber = (function (_super) { + __extends(RetryWhenSubscriber, _super); + function RetryWhenSubscriber(destination, notifier, source) { + _super.call(this, destination); + this.notifier = notifier; + this.source = source; + } + RetryWhenSubscriber.prototype.error = function (err) { + if (!this.isStopped) { + var errors = this.errors; + var retries = this.retries; + var retriesSubscription = this.retriesSubscription; + if (!retries) { + errors = new Subject_1.Subject(); + retries = tryCatch_1.tryCatch(this.notifier)(errors); + if (retries === errorObject_1.errorObject) { + return _super.prototype.error.call(this, errorObject_1.errorObject.e); + } + retriesSubscription = subscribeToResult_1.subscribeToResult(this, retries); + } + else { + this.errors = null; + this.retriesSubscription = null; + } + this.unsubscribe(); + this.isUnsubscribed = false; + this.errors = errors; + this.retries = retries; + this.retriesSubscription = retriesSubscription; + errors.next(err); + } + }; + RetryWhenSubscriber.prototype._unsubscribe = function () { + var _a = this, errors = _a.errors, retriesSubscription = _a.retriesSubscription; + if (errors) { + errors.unsubscribe(); + this.errors = null; + } + if (retriesSubscription) { + retriesSubscription.unsubscribe(); + this.retriesSubscription = null; + } + this.retries = null; + }; + RetryWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var _a = this, errors = _a.errors, retries = _a.retries, retriesSubscription = _a.retriesSubscription; + this.errors = null; + this.retries = null; + this.retriesSubscription = null; + this.unsubscribe(); + this.isStopped = false; + this.isUnsubscribed = false; + this.errors = errors; + this.retries = retries; + this.retriesSubscription = retriesSubscription; + this.source.subscribe(this); + }; + return RetryWhenSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../Subject":8,"../util/errorObject":239,"../util/subscribeToResult":250,"../util/tryCatch":253}],188:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Returns an Observable that, when the specified sampler Observable emits an item or completes, it then emits the most + * recently emitted item (if any) emitted by the source Observable since the previous emission from the sampler + * Observable. + * + * + * + * @param {Observable} sampler - the Observable to use for sampling the source Observable. + * @returns {Observable} an Observable that emits the results of sampling the items emitted by this Observable + * whenever the sampler Observable emits an item or completes. + */ +function sample(notifier) { + return this.lift(new SampleOperator(notifier)); +} +exports.sample = sample; +var SampleOperator = (function () { + function SampleOperator(notifier) { + this.notifier = notifier; + } + SampleOperator.prototype.call = function (subscriber) { + return new SampleSubscriber(subscriber, this.notifier); + }; + return SampleOperator; +}()); +var SampleSubscriber = (function (_super) { + __extends(SampleSubscriber, _super); + function SampleSubscriber(destination, notifier) { + _super.call(this, destination); + this.hasValue = false; + this.add(subscribeToResult_1.subscribeToResult(this, notifier)); + } + SampleSubscriber.prototype._next = function (value) { + this.value = value; + this.hasValue = true; + }; + SampleSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.emitValue(); + }; + SampleSubscriber.prototype.notifyComplete = function () { + this.emitValue(); + }; + SampleSubscriber.prototype.emitValue = function () { + if (this.hasValue) { + this.hasValue = false; + this.destination.next(this.value); + } + }; + return SampleSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],189:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var asap_1 = require('../scheduler/asap'); +function sampleTime(delay, scheduler) { + if (scheduler === void 0) { scheduler = asap_1.asap; } + return this.lift(new SampleTimeOperator(delay, scheduler)); +} +exports.sampleTime = sampleTime; +var SampleTimeOperator = (function () { + function SampleTimeOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + SampleTimeOperator.prototype.call = function (subscriber) { + return new SampleTimeSubscriber(subscriber, this.delay, this.scheduler); + }; + return SampleTimeOperator; +}()); +var SampleTimeSubscriber = (function (_super) { + __extends(SampleTimeSubscriber, _super); + function SampleTimeSubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + this.hasValue = false; + this.add(scheduler.schedule(dispatchNotification, delay, { subscriber: this, delay: delay })); + } + SampleTimeSubscriber.prototype._next = function (value) { + this.lastValue = value; + this.hasValue = true; + }; + SampleTimeSubscriber.prototype.notifyNext = function () { + if (this.hasValue) { + this.hasValue = false; + this.destination.next(this.lastValue); + } + }; + return SampleTimeSubscriber; +}(Subscriber_1.Subscriber)); +function dispatchNotification(state) { + var subscriber = state.subscriber, delay = state.delay; + subscriber.notifyNext(); + this.schedule(state, delay); +} + +},{"../Subscriber":9,"../scheduler/asap":224}],190:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that applies a specified accumulator function to each item emitted by the source Observable. + * If a seed value is specified, then that value will be used as the initial value for the accumulator. + * If no seed value is specified, the first item of the source is used as the seed. + * @param {function} accumulator The accumulator function called on each item. + * + * + * + * @param {any} [seed] The initial accumulator value. + * @returns {Obervable} An observable of the accumulated values. + */ +function scan(accumulator, seed) { + return this.lift(new ScanOperator(accumulator, seed)); +} +exports.scan = scan; +var ScanOperator = (function () { + function ScanOperator(accumulator, seed) { + this.accumulator = accumulator; + this.seed = seed; + } + ScanOperator.prototype.call = function (subscriber) { + return new ScanSubscriber(subscriber, this.accumulator, this.seed); + }; + return ScanOperator; +}()); +var ScanSubscriber = (function (_super) { + __extends(ScanSubscriber, _super); + function ScanSubscriber(destination, accumulator, seed) { + _super.call(this, destination); + this.accumulator = accumulator; + this.accumulatorSet = false; + this.seed = seed; + this.accumulator = accumulator; + this.accumulatorSet = typeof seed !== 'undefined'; + } + Object.defineProperty(ScanSubscriber.prototype, "seed", { + get: function () { + return this._seed; + }, + set: function (value) { + this.accumulatorSet = true; + this._seed = value; + }, + enumerable: true, + configurable: true + }); + ScanSubscriber.prototype._next = function (value) { + if (!this.accumulatorSet) { + this.seed = value; + this.destination.next(value); + } + else { + return this._tryNext(value); + } + }; + ScanSubscriber.prototype._tryNext = function (value) { + var result; + try { + result = this.accumulator(this.seed, value); + } + catch (err) { + this.destination.error(err); + } + this.seed = result; + this.destination.next(result); + }; + return ScanSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],191:[function(require,module,exports){ +"use strict"; +var multicast_1 = require('./multicast'); +var Subject_1 = require('../Subject'); +function shareSubjectFactory() { + return new Subject_1.Subject(); +} +/** + * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one + * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will + * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`. + * This is an alias for .publish().refCount(). + * + * + * + * @returns {Observable} an Observable that upon connection causes the source Observable to emit items to its Observers + */ +function share() { + return multicast_1.multicast.call(this, shareSubjectFactory).refCount(); +} +exports.share = share; +; + +},{"../Subject":8,"./multicast":175}],192:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var EmptyError_1 = require('../util/EmptyError'); +/** + * Returns an Observable that emits the single item emitted by the source Observable that matches a specified + * predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no + * such items, notify of an IllegalArgumentException or NoSuchElementException respectively. + * + * + * + * @param {Function} a predicate function to evaluate items emitted by the source Observable. + * @returns {Observable} an Observable that emits the single item emitted by the source Observable that matches + * the predicate. + . + */ +function single(predicate) { + return this.lift(new SingleOperator(predicate, this)); +} +exports.single = single; +var SingleOperator = (function () { + function SingleOperator(predicate, source) { + this.predicate = predicate; + this.source = source; + } + SingleOperator.prototype.call = function (subscriber) { + return new SingleSubscriber(subscriber, this.predicate, this.source); + }; + return SingleOperator; +}()); +var SingleSubscriber = (function (_super) { + __extends(SingleSubscriber, _super); + function SingleSubscriber(destination, predicate, source) { + _super.call(this, destination); + this.predicate = predicate; + this.source = source; + this.seenValue = false; + this.index = 0; + } + SingleSubscriber.prototype.applySingleValue = function (value) { + if (this.seenValue) { + this.destination.error('Sequence contains more than one element'); + } + else { + this.seenValue = true; + this.singleValue = value; + } + }; + SingleSubscriber.prototype._next = function (value) { + var predicate = this.predicate; + this.index++; + if (predicate) { + this.tryNext(value); + } + else { + this.applySingleValue(value); + } + }; + SingleSubscriber.prototype.tryNext = function (value) { + try { + var result = this.predicate(value, this.index, this.source); + if (result) { + this.applySingleValue(value); + } + } + catch (err) { + this.destination.error(err); + } + }; + SingleSubscriber.prototype._complete = function () { + var destination = this.destination; + if (this.index > 0) { + destination.next(this.seenValue ? this.singleValue : undefined); + destination.complete(); + } + else { + destination.error(new EmptyError_1.EmptyError); + } + }; + return SingleSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../util/EmptyError":232}],193:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that skips `n` items emitted by an Observable. + * + * + * + * @param {Number} the `n` of times, items emitted by source Observable should be skipped. + * @returns {Observable} an Observable that skips values emitted by the source Observable. + * + */ +function skip(total) { + return this.lift(new SkipOperator(total)); +} +exports.skip = skip; +var SkipOperator = (function () { + function SkipOperator(total) { + this.total = total; + } + SkipOperator.prototype.call = function (subscriber) { + return new SkipSubscriber(subscriber, this.total); + }; + return SkipOperator; +}()); +var SkipSubscriber = (function (_super) { + __extends(SkipSubscriber, _super); + function SkipSubscriber(destination, total) { + _super.call(this, destination); + this.total = total; + this.count = 0; + } + SkipSubscriber.prototype._next = function (x) { + if (++this.count > this.total) { + this.destination.next(x); + } + }; + return SkipSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],194:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** +* Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item. +* +* +* +* @param {Observable} the second Observable that has to emit an item before the source Observable's elements begin to +* be mirrored by the resulting Observable. +* @returns {Observable} an Observable that skips items from the source Observable until the second Observable emits +* an item, then emits the remaining items. +*/ +function skipUntil(notifier) { + return this.lift(new SkipUntilOperator(notifier)); +} +exports.skipUntil = skipUntil; +var SkipUntilOperator = (function () { + function SkipUntilOperator(notifier) { + this.notifier = notifier; + } + SkipUntilOperator.prototype.call = function (subscriber) { + return new SkipUntilSubscriber(subscriber, this.notifier); + }; + return SkipUntilOperator; +}()); +var SkipUntilSubscriber = (function (_super) { + __extends(SkipUntilSubscriber, _super); + function SkipUntilSubscriber(destination, notifier) { + _super.call(this, destination); + this.hasValue = false; + this.isInnerStopped = false; + this.add(subscribeToResult_1.subscribeToResult(this, notifier)); + } + SkipUntilSubscriber.prototype._next = function (value) { + if (this.hasValue) { + _super.prototype._next.call(this, value); + } + }; + SkipUntilSubscriber.prototype._complete = function () { + if (this.isInnerStopped) { + _super.prototype._complete.call(this); + } + else { + this.unsubscribe(); + } + }; + SkipUntilSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.hasValue = true; + }; + SkipUntilSubscriber.prototype.notifyComplete = function () { + this.isInnerStopped = true; + if (this.isStopped) { + _super.prototype._complete.call(this); + } + }; + return SkipUntilSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],195:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +/** + * Returns an Observable that skips all items emitted by the source Observable as long as a specified condition holds + * true, but emits all further source items as soon as the condition becomes false. + * + * + * + * @param {Function} predicate - a function to test each item emitted from the source Observable. + * @returns {Observable} an Observable that begins emitting items emitted by the source Observable when the + * specified predicate becomes false. + */ +function skipWhile(predicate) { + return this.lift(new SkipWhileOperator(predicate)); +} +exports.skipWhile = skipWhile; +var SkipWhileOperator = (function () { + function SkipWhileOperator(predicate) { + this.predicate = predicate; + } + SkipWhileOperator.prototype.call = function (subscriber) { + return new SkipWhileSubscriber(subscriber, this.predicate); + }; + return SkipWhileOperator; +}()); +var SkipWhileSubscriber = (function (_super) { + __extends(SkipWhileSubscriber, _super); + function SkipWhileSubscriber(destination, predicate) { + _super.call(this, destination); + this.predicate = predicate; + this.skipping = true; + this.index = 0; + } + SkipWhileSubscriber.prototype._next = function (value) { + var destination = this.destination; + if (this.skipping) { + this.tryCallPredicate(value); + } + if (!this.skipping) { + destination.next(value); + } + }; + SkipWhileSubscriber.prototype.tryCallPredicate = function (value) { + try { + var result = this.predicate(value, this.index++); + this.skipping = Boolean(result); + } + catch (err) { + this.destination.error(err); + } + }; + return SkipWhileSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],196:[function(require,module,exports){ +"use strict"; +var ArrayObservable_1 = require('../observable/ArrayObservable'); +var ScalarObservable_1 = require('../observable/ScalarObservable'); +var EmptyObservable_1 = require('../observable/EmptyObservable'); +var concat_1 = require('./concat'); +var isScheduler_1 = require('../util/isScheduler'); +/** + * Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the + * source Observable. + * + * + * + * @param {Values} an Iterable that contains the items you want the modified Observable to emit first. + * @returns {Observable} an Observable that emits the items in the specified Iterable and then emits the items + * emitted by the source Observable. + */ +function startWith() { + var array = []; + for (var _i = 0; _i < arguments.length; _i++) { + array[_i - 0] = arguments[_i]; + } + var scheduler = array[array.length - 1]; + if (isScheduler_1.isScheduler(scheduler)) { + array.pop(); + } + else { + scheduler = null; + } + var len = array.length; + if (len === 1) { + return concat_1.concatStatic(new ScalarObservable_1.ScalarObservable(array[0], scheduler), this); + } + else if (len > 1) { + return concat_1.concatStatic(new ArrayObservable_1.ArrayObservable(array, scheduler), this); + } + else { + return concat_1.concatStatic(new EmptyObservable_1.EmptyObservable(scheduler), this); + } +} +exports.startWith = startWith; + +},{"../observable/ArrayObservable":116,"../observable/EmptyObservable":121,"../observable/ScalarObservable":132,"../util/isScheduler":246,"./concat":144}],197:[function(require,module,exports){ +"use strict"; +var SubscribeOnObservable_1 = require('../observable/SubscribeOnObservable'); +/** + * Asynchronously subscribes Observers to this Observable on the specified Scheduler. + * + * + * + * @param {Scheduler} the Scheduler to perform subscription actions on. + * @returns {Observable} the source Observable modified so that its subscriptions happen on the specified Scheduler + . + */ +function subscribeOn(scheduler, delay) { + if (delay === void 0) { delay = 0; } + return new SubscribeOnObservable_1.SubscribeOnObservable(this, delay, scheduler); +} +exports.subscribeOn = subscribeOn; + +},{"../observable/SubscribeOnObservable":133}],198:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Converts an Observable that emits Observables into an Observable that emits the items emitted by the most recently + * emitted of those Observables. + * + * + * + * Switch subscribes to an Observable that emits Observables. Each time it observes one of these emitted Observables, + * the Observable returned by switchOnNext begins emitting the items emitted by that Observable. When a new Observable + * is emitted, switchOnNext stops emitting items from the earlier-emitted Observable and begins emitting items from the + * new one. + * + * @param {Function} a predicate function to evaluate items emitted by the source Observable. + * @returns {Observable} an Observable that emits the items emitted by the Observable most recently emitted by the + * source Observable. + */ +function _switch() { + return this.lift(new SwitchOperator()); +} +exports._switch = _switch; +var SwitchOperator = (function () { + function SwitchOperator() { + } + SwitchOperator.prototype.call = function (subscriber) { + return new SwitchSubscriber(subscriber); + }; + return SwitchOperator; +}()); +var SwitchSubscriber = (function (_super) { + __extends(SwitchSubscriber, _super); + function SwitchSubscriber(destination) { + _super.call(this, destination); + this.active = 0; + this.hasCompleted = false; + } + SwitchSubscriber.prototype._next = function (value) { + this.unsubscribeInner(); + this.active++; + this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, value)); + }; + SwitchSubscriber.prototype._complete = function () { + this.hasCompleted = true; + if (this.active === 0) { + this.destination.complete(); + } + }; + SwitchSubscriber.prototype.unsubscribeInner = function () { + this.active = this.active > 0 ? this.active - 1 : 0; + var innerSubscription = this.innerSubscription; + if (innerSubscription) { + innerSubscription.unsubscribe(); + this.remove(innerSubscription); + } + }; + SwitchSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.destination.next(innerValue); + }; + SwitchSubscriber.prototype.notifyError = function (err) { + this.destination.error(err); + }; + SwitchSubscriber.prototype.notifyComplete = function () { + this.unsubscribeInner(); + if (this.hasCompleted && this.active === 0) { + this.destination.complete(); + } + }; + return SwitchSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],199:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * Returns a new Observable by applying a function that you supply to each item emitted by the source Observable that + * returns an Observable, and then emitting the items emitted by the most recently emitted of these Observables. + * + * + * + * @param {Observable} a function that, when applied to an item emitted by the source Observable, returns an Observable. + * @returns {Observable} an Observable that emits the items emitted by the Observable returned from applying func to + * the most recently emitted item emitted by the source Observable. + */ +function switchMap(project, resultSelector) { + return this.lift(new SwitchMapOperator(project, resultSelector)); +} +exports.switchMap = switchMap; +var SwitchMapOperator = (function () { + function SwitchMapOperator(project, resultSelector) { + this.project = project; + this.resultSelector = resultSelector; + } + SwitchMapOperator.prototype.call = function (subscriber) { + return new SwitchMapSubscriber(subscriber, this.project, this.resultSelector); + }; + return SwitchMapOperator; +}()); +var SwitchMapSubscriber = (function (_super) { + __extends(SwitchMapSubscriber, _super); + function SwitchMapSubscriber(destination, project, resultSelector) { + _super.call(this, destination); + this.project = project; + this.resultSelector = resultSelector; + this.index = 0; + } + SwitchMapSubscriber.prototype._next = function (value) { + var result; + var index = this.index++; + try { + result = this.project(value, index); + } + catch (error) { + this.destination.error(error); + return; + } + this._innerSub(result, value, index); + }; + SwitchMapSubscriber.prototype._innerSub = function (result, value, index) { + var innerSubscription = this.innerSubscription; + if (innerSubscription) { + innerSubscription.unsubscribe(); + } + this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, result, value, index)); + }; + SwitchMapSubscriber.prototype._complete = function () { + var innerSubscription = this.innerSubscription; + if (!innerSubscription || innerSubscription.isUnsubscribed) { + _super.prototype._complete.call(this); + } + }; + SwitchMapSubscriber.prototype._unsubscribe = function () { + this.innerSubscription = null; + }; + SwitchMapSubscriber.prototype.notifyComplete = function (innerSub) { + this.remove(innerSub); + this.innerSubscription = null; + if (this.isStopped) { + _super.prototype._complete.call(this); + } + }; + SwitchMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (this.resultSelector) { + this._tryNotifyNext(outerValue, innerValue, outerIndex, innerIndex); + } + else { + this.destination.next(innerValue); + } + }; + SwitchMapSubscriber.prototype._tryNotifyNext = function (outerValue, innerValue, outerIndex, innerIndex) { + var result; + try { + result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.next(result); + }; + return SwitchMapSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],200:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function switchMapTo(observable, resultSelector) { + return this.lift(new SwitchMapToOperator(observable, resultSelector)); +} +exports.switchMapTo = switchMapTo; +var SwitchMapToOperator = (function () { + function SwitchMapToOperator(observable, resultSelector) { + this.observable = observable; + this.resultSelector = resultSelector; + } + SwitchMapToOperator.prototype.call = function (subscriber) { + return new SwitchMapToSubscriber(subscriber, this.observable, this.resultSelector); + }; + return SwitchMapToOperator; +}()); +var SwitchMapToSubscriber = (function (_super) { + __extends(SwitchMapToSubscriber, _super); + function SwitchMapToSubscriber(destination, inner, resultSelector) { + _super.call(this, destination); + this.inner = inner; + this.resultSelector = resultSelector; + this.index = 0; + } + SwitchMapToSubscriber.prototype._next = function (value) { + var innerSubscription = this.innerSubscription; + if (innerSubscription) { + innerSubscription.unsubscribe(); + } + this.add(this.innerSubscription = subscribeToResult_1.subscribeToResult(this, this.inner, value, this.index++)); + }; + SwitchMapToSubscriber.prototype._complete = function () { + var innerSubscription = this.innerSubscription; + if (!innerSubscription || innerSubscription.isUnsubscribed) { + _super.prototype._complete.call(this); + } + }; + SwitchMapToSubscriber.prototype._unsubscribe = function () { + this.innerSubscription = null; + }; + SwitchMapToSubscriber.prototype.notifyComplete = function (innerSub) { + this.remove(innerSub); + this.innerSubscription = null; + if (this.isStopped) { + _super.prototype._complete.call(this); + } + }; + SwitchMapToSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + var _a = this, resultSelector = _a.resultSelector, destination = _a.destination; + if (resultSelector) { + this.tryResultSelector(outerValue, innerValue, outerIndex, innerIndex); + } + else { + destination.next(innerValue); + } + }; + SwitchMapToSubscriber.prototype.tryResultSelector = function (outerValue, innerValue, outerIndex, innerIndex) { + var _a = this, resultSelector = _a.resultSelector, destination = _a.destination; + var result; + try { + result = resultSelector(outerValue, innerValue, outerIndex, innerIndex); + } + catch (err) { + destination.error(err); + return; + } + destination.next(result); + }; + return SwitchMapToSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],201:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var ArgumentOutOfRangeError_1 = require('../util/ArgumentOutOfRangeError'); +var EmptyObservable_1 = require('../observable/EmptyObservable'); +function take(total) { + if (total === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + else { + return this.lift(new TakeOperator(total)); + } +} +exports.take = take; +var TakeOperator = (function () { + function TakeOperator(total) { + this.total = total; + if (this.total < 0) { + throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError; + } + } + TakeOperator.prototype.call = function (subscriber) { + return new TakeSubscriber(subscriber, this.total); + }; + return TakeOperator; +}()); +var TakeSubscriber = (function (_super) { + __extends(TakeSubscriber, _super); + function TakeSubscriber(destination, total) { + _super.call(this, destination); + this.total = total; + this.count = 0; + } + TakeSubscriber.prototype._next = function (value) { + var total = this.total; + if (++this.count <= total) { + this.destination.next(value); + if (this.count === total) { + this.destination.complete(); + } + } + }; + return TakeSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../observable/EmptyObservable":121,"../util/ArgumentOutOfRangeError":231}],202:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var ArgumentOutOfRangeError_1 = require('../util/ArgumentOutOfRangeError'); +var EmptyObservable_1 = require('../observable/EmptyObservable'); +function takeLast(total) { + if (total === 0) { + return new EmptyObservable_1.EmptyObservable(); + } + else { + return this.lift(new TakeLastOperator(total)); + } +} +exports.takeLast = takeLast; +var TakeLastOperator = (function () { + function TakeLastOperator(total) { + this.total = total; + if (this.total < 0) { + throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError; + } + } + TakeLastOperator.prototype.call = function (subscriber) { + return new TakeLastSubscriber(subscriber, this.total); + }; + return TakeLastOperator; +}()); +var TakeLastSubscriber = (function (_super) { + __extends(TakeLastSubscriber, _super); + function TakeLastSubscriber(destination, total) { + _super.call(this, destination); + this.total = total; + this.count = 0; + this.index = 0; + this.ring = new Array(total); + } + TakeLastSubscriber.prototype._next = function (value) { + var index = this.index; + var ring = this.ring; + var total = this.total; + var count = this.count; + if (total > 1) { + if (count < total) { + this.count = count + 1; + this.index = index + 1; + } + else if (index === 0) { + this.index = ++index; + } + else if (index < total) { + this.index = index + 1; + } + else { + this.index = index = 0; + } + } + else if (count < total) { + this.count = total; + } + ring[index] = value; + }; + TakeLastSubscriber.prototype._complete = function () { + var iter = -1; + var _a = this, ring = _a.ring, count = _a.count, total = _a.total, destination = _a.destination; + var index = (total === 1 || count < total) ? 0 : this.index - 1; + while (++iter < count) { + if (iter + index === total) { + index = total - iter; + } + destination.next(ring[iter + index]); + } + destination.complete(); + }; + return TakeLastSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../observable/EmptyObservable":121,"../util/ArgumentOutOfRangeError":231}],203:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function takeUntil(notifier) { + return this.lift(new TakeUntilOperator(notifier)); +} +exports.takeUntil = takeUntil; +var TakeUntilOperator = (function () { + function TakeUntilOperator(notifier) { + this.notifier = notifier; + } + TakeUntilOperator.prototype.call = function (subscriber) { + return new TakeUntilSubscriber(subscriber, this.notifier); + }; + return TakeUntilOperator; +}()); +var TakeUntilSubscriber = (function (_super) { + __extends(TakeUntilSubscriber, _super); + function TakeUntilSubscriber(destination, notifier) { + _super.call(this, destination); + this.notifier = notifier; + this.add(subscribeToResult_1.subscribeToResult(this, notifier)); + } + TakeUntilSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.complete(); + }; + TakeUntilSubscriber.prototype.notifyComplete = function () { + // noop + }; + return TakeUntilSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],204:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +function takeWhile(predicate) { + return this.lift(new TakeWhileOperator(predicate)); +} +exports.takeWhile = takeWhile; +var TakeWhileOperator = (function () { + function TakeWhileOperator(predicate) { + this.predicate = predicate; + } + TakeWhileOperator.prototype.call = function (subscriber) { + return new TakeWhileSubscriber(subscriber, this.predicate); + }; + return TakeWhileOperator; +}()); +var TakeWhileSubscriber = (function (_super) { + __extends(TakeWhileSubscriber, _super); + function TakeWhileSubscriber(destination, predicate) { + _super.call(this, destination); + this.predicate = predicate; + this.index = 0; + } + TakeWhileSubscriber.prototype._next = function (value) { + var destination = this.destination; + var result; + try { + result = this.predicate(value, this.index++); + } + catch (err) { + destination.error(err); + return; + } + this.nextOrComplete(value, result); + }; + TakeWhileSubscriber.prototype.nextOrComplete = function (value, predicateResult) { + var destination = this.destination; + if (Boolean(predicateResult)) { + destination.next(value); + } + else { + destination.complete(); + } + }; + return TakeWhileSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],205:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function throttle(durationSelector) { + return this.lift(new ThrottleOperator(durationSelector)); +} +exports.throttle = throttle; +var ThrottleOperator = (function () { + function ThrottleOperator(durationSelector) { + this.durationSelector = durationSelector; + } + ThrottleOperator.prototype.call = function (subscriber) { + return new ThrottleSubscriber(subscriber, this.durationSelector); + }; + return ThrottleOperator; +}()); +var ThrottleSubscriber = (function (_super) { + __extends(ThrottleSubscriber, _super); + function ThrottleSubscriber(destination, durationSelector) { + _super.call(this, destination); + this.destination = destination; + this.durationSelector = durationSelector; + } + ThrottleSubscriber.prototype._next = function (value) { + if (!this.throttled) { + this.tryDurationSelector(value); + } + }; + ThrottleSubscriber.prototype.tryDurationSelector = function (value) { + var duration = null; + try { + duration = this.durationSelector(value); + } + catch (err) { + this.destination.error(err); + return; + } + this.emitAndThrottle(value, duration); + }; + ThrottleSubscriber.prototype.emitAndThrottle = function (value, duration) { + this.add(this.throttled = subscribeToResult_1.subscribeToResult(this, duration)); + this.destination.next(value); + }; + ThrottleSubscriber.prototype._unsubscribe = function () { + var throttled = this.throttled; + if (throttled) { + this.remove(throttled); + this.throttled = null; + throttled.unsubscribe(); + } + }; + ThrottleSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this._unsubscribe(); + }; + ThrottleSubscriber.prototype.notifyComplete = function () { + this._unsubscribe(); + }; + return ThrottleSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],206:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var asap_1 = require('../scheduler/asap'); +function throttleTime(delay, scheduler) { + if (scheduler === void 0) { scheduler = asap_1.asap; } + return this.lift(new ThrottleTimeOperator(delay, scheduler)); +} +exports.throttleTime = throttleTime; +var ThrottleTimeOperator = (function () { + function ThrottleTimeOperator(delay, scheduler) { + this.delay = delay; + this.scheduler = scheduler; + } + ThrottleTimeOperator.prototype.call = function (subscriber) { + return new ThrottleTimeSubscriber(subscriber, this.delay, this.scheduler); + }; + return ThrottleTimeOperator; +}()); +var ThrottleTimeSubscriber = (function (_super) { + __extends(ThrottleTimeSubscriber, _super); + function ThrottleTimeSubscriber(destination, delay, scheduler) { + _super.call(this, destination); + this.delay = delay; + this.scheduler = scheduler; + } + ThrottleTimeSubscriber.prototype._next = function (value) { + if (!this.throttled) { + this.add(this.throttled = this.scheduler.schedule(dispatchNext, this.delay, { subscriber: this })); + this.destination.next(value); + } + }; + ThrottleTimeSubscriber.prototype.clearThrottle = function () { + var throttled = this.throttled; + if (throttled) { + throttled.unsubscribe(); + this.remove(throttled); + this.throttled = null; + } + }; + return ThrottleTimeSubscriber; +}(Subscriber_1.Subscriber)); +function dispatchNext(_a) { + var subscriber = _a.subscriber; + subscriber.clearThrottle(); +} + +},{"../Subscriber":9,"../scheduler/asap":224}],207:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var asap_1 = require('../scheduler/asap'); +var isDate_1 = require('../util/isDate'); +var Subscriber_1 = require('../Subscriber'); +function timeout(due, errorToSend, scheduler) { + if (errorToSend === void 0) { errorToSend = null; } + if (scheduler === void 0) { scheduler = asap_1.asap; } + var absoluteTimeout = isDate_1.isDate(due); + var waitFor = absoluteTimeout ? (+due - scheduler.now()) : Math.abs(due); + return this.lift(new TimeoutOperator(waitFor, absoluteTimeout, errorToSend, scheduler)); +} +exports.timeout = timeout; +var TimeoutOperator = (function () { + function TimeoutOperator(waitFor, absoluteTimeout, errorToSend, scheduler) { + this.waitFor = waitFor; + this.absoluteTimeout = absoluteTimeout; + this.errorToSend = errorToSend; + this.scheduler = scheduler; + } + TimeoutOperator.prototype.call = function (subscriber) { + return new TimeoutSubscriber(subscriber, this.absoluteTimeout, this.waitFor, this.errorToSend, this.scheduler); + }; + return TimeoutOperator; +}()); +var TimeoutSubscriber = (function (_super) { + __extends(TimeoutSubscriber, _super); + function TimeoutSubscriber(destination, absoluteTimeout, waitFor, errorToSend, scheduler) { + _super.call(this, destination); + this.absoluteTimeout = absoluteTimeout; + this.waitFor = waitFor; + this.errorToSend = errorToSend; + this.scheduler = scheduler; + this.index = 0; + this._previousIndex = 0; + this._hasCompleted = false; + this.scheduleTimeout(); + } + Object.defineProperty(TimeoutSubscriber.prototype, "previousIndex", { + get: function () { + return this._previousIndex; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TimeoutSubscriber.prototype, "hasCompleted", { + get: function () { + return this._hasCompleted; + }, + enumerable: true, + configurable: true + }); + TimeoutSubscriber.dispatchTimeout = function (state) { + var source = state.subscriber; + var currentIndex = state.index; + if (!source.hasCompleted && source.previousIndex === currentIndex) { + source.notifyTimeout(); + } + }; + TimeoutSubscriber.prototype.scheduleTimeout = function () { + var currentIndex = this.index; + this.scheduler.schedule(TimeoutSubscriber.dispatchTimeout, this.waitFor, { subscriber: this, index: currentIndex }); + this.index++; + this._previousIndex = currentIndex; + }; + TimeoutSubscriber.prototype._next = function (value) { + this.destination.next(value); + if (!this.absoluteTimeout) { + this.scheduleTimeout(); + } + }; + TimeoutSubscriber.prototype._error = function (err) { + this.destination.error(err); + this._hasCompleted = true; + }; + TimeoutSubscriber.prototype._complete = function () { + this.destination.complete(); + this._hasCompleted = true; + }; + TimeoutSubscriber.prototype.notifyTimeout = function () { + this.error(this.errorToSend || new Error('timeout')); + }; + return TimeoutSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9,"../scheduler/asap":224,"../util/isDate":241}],208:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var asap_1 = require('../scheduler/asap'); +var isDate_1 = require('../util/isDate'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function timeoutWith(due, withObservable, scheduler) { + if (scheduler === void 0) { scheduler = asap_1.asap; } + var absoluteTimeout = isDate_1.isDate(due); + var waitFor = absoluteTimeout ? (+due - scheduler.now()) : Math.abs(due); + return this.lift(new TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler)); +} +exports.timeoutWith = timeoutWith; +var TimeoutWithOperator = (function () { + function TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler) { + this.waitFor = waitFor; + this.absoluteTimeout = absoluteTimeout; + this.withObservable = withObservable; + this.scheduler = scheduler; + } + TimeoutWithOperator.prototype.call = function (subscriber) { + return new TimeoutWithSubscriber(subscriber, this.absoluteTimeout, this.waitFor, this.withObservable, this.scheduler); + }; + return TimeoutWithOperator; +}()); +var TimeoutWithSubscriber = (function (_super) { + __extends(TimeoutWithSubscriber, _super); + function TimeoutWithSubscriber(destination, absoluteTimeout, waitFor, withObservable, scheduler) { + _super.call(this); + this.destination = destination; + this.absoluteTimeout = absoluteTimeout; + this.waitFor = waitFor; + this.withObservable = withObservable; + this.scheduler = scheduler; + this.timeoutSubscription = undefined; + this.index = 0; + this._previousIndex = 0; + this._hasCompleted = false; + destination.add(this); + this.scheduleTimeout(); + } + Object.defineProperty(TimeoutWithSubscriber.prototype, "previousIndex", { + get: function () { + return this._previousIndex; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TimeoutWithSubscriber.prototype, "hasCompleted", { + get: function () { + return this._hasCompleted; + }, + enumerable: true, + configurable: true + }); + TimeoutWithSubscriber.dispatchTimeout = function (state) { + var source = state.subscriber; + var currentIndex = state.index; + if (!source.hasCompleted && source.previousIndex === currentIndex) { + source.handleTimeout(); + } + }; + TimeoutWithSubscriber.prototype.scheduleTimeout = function () { + var currentIndex = this.index; + var timeoutState = { subscriber: this, index: currentIndex }; + this.scheduler.schedule(TimeoutWithSubscriber.dispatchTimeout, this.waitFor, timeoutState); + this.index++; + this._previousIndex = currentIndex; + }; + TimeoutWithSubscriber.prototype._next = function (value) { + this.destination.next(value); + if (!this.absoluteTimeout) { + this.scheduleTimeout(); + } + }; + TimeoutWithSubscriber.prototype._error = function (err) { + this.destination.error(err); + this._hasCompleted = true; + }; + TimeoutWithSubscriber.prototype._complete = function () { + this.destination.complete(); + this._hasCompleted = true; + }; + TimeoutWithSubscriber.prototype.handleTimeout = function () { + if (!this.isUnsubscribed) { + var withObservable = this.withObservable; + this.unsubscribe(); + this.destination.add(this.timeoutSubscription = subscribeToResult_1.subscribeToResult(this, withObservable)); + } + }; + return TimeoutWithSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../scheduler/asap":224,"../util/isDate":241,"../util/subscribeToResult":250}],209:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +function toArray() { + return this.lift(new ToArrayOperator()); +} +exports.toArray = toArray; +var ToArrayOperator = (function () { + function ToArrayOperator() { + } + ToArrayOperator.prototype.call = function (subscriber) { + return new ToArraySubscriber(subscriber); + }; + return ToArrayOperator; +}()); +var ToArraySubscriber = (function (_super) { + __extends(ToArraySubscriber, _super); + function ToArraySubscriber(destination) { + _super.call(this, destination); + this.array = []; + } + ToArraySubscriber.prototype._next = function (x) { + this.array.push(x); + }; + ToArraySubscriber.prototype._complete = function () { + this.destination.next(this.array); + this.destination.complete(); + }; + return ToArraySubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subscriber":9}],210:[function(require,module,exports){ +"use strict"; +var root_1 = require('../util/root'); +function toPromise(PromiseCtor) { + var _this = this; + if (!PromiseCtor) { + if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) { + PromiseCtor = root_1.root.Rx.config.Promise; + } + else if (root_1.root.Promise) { + PromiseCtor = root_1.root.Promise; + } + } + if (!PromiseCtor) { + throw new Error('no Promise impl found'); + } + return new PromiseCtor(function (resolve, reject) { + var value; + _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); }); + }); +} +exports.toPromise = toPromise; + +},{"../util/root":249}],211:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subject_1 = require('../Subject'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function window(closingNotifier) { + return this.lift(new WindowOperator(closingNotifier)); +} +exports.window = window; +var WindowOperator = (function () { + function WindowOperator(closingNotifier) { + this.closingNotifier = closingNotifier; + } + WindowOperator.prototype.call = function (subscriber) { + return new WindowSubscriber(subscriber, this.closingNotifier); + }; + return WindowOperator; +}()); +var WindowSubscriber = (function (_super) { + __extends(WindowSubscriber, _super); + function WindowSubscriber(destination, closingNotifier) { + _super.call(this, destination); + this.destination = destination; + this.closingNotifier = closingNotifier; + this.add(subscribeToResult_1.subscribeToResult(this, closingNotifier)); + this.openWindow(); + } + WindowSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.openWindow(); + }; + WindowSubscriber.prototype.notifyError = function (error, innerSub) { + this._error(error); + }; + WindowSubscriber.prototype.notifyComplete = function (innerSub) { + this._complete(); + }; + WindowSubscriber.prototype._next = function (value) { + this.window.next(value); + }; + WindowSubscriber.prototype._error = function (err) { + this.window.error(err); + this.destination.error(err); + }; + WindowSubscriber.prototype._complete = function () { + this.window.complete(); + this.destination.complete(); + }; + WindowSubscriber.prototype.openWindow = function () { + var prevWindow = this.window; + if (prevWindow) { + prevWindow.complete(); + } + var destination = this.destination; + var newWindow = this.window = new Subject_1.Subject(); + destination.add(newWindow); + destination.next(newWindow); + }; + return WindowSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../Subject":8,"../util/subscribeToResult":250}],212:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Subject_1 = require('../Subject'); +function windowCount(windowSize, startWindowEvery) { + if (startWindowEvery === void 0) { startWindowEvery = 0; } + return this.lift(new WindowCountOperator(windowSize, startWindowEvery)); +} +exports.windowCount = windowCount; +var WindowCountOperator = (function () { + function WindowCountOperator(windowSize, startWindowEvery) { + this.windowSize = windowSize; + this.startWindowEvery = startWindowEvery; + } + WindowCountOperator.prototype.call = function (subscriber) { + return new WindowCountSubscriber(subscriber, this.windowSize, this.startWindowEvery); + }; + return WindowCountOperator; +}()); +var WindowCountSubscriber = (function (_super) { + __extends(WindowCountSubscriber, _super); + function WindowCountSubscriber(destination, windowSize, startWindowEvery) { + _super.call(this, destination); + this.destination = destination; + this.windowSize = windowSize; + this.startWindowEvery = startWindowEvery; + this.windows = [new Subject_1.Subject()]; + this.count = 0; + var firstWindow = this.windows[0]; + destination.add(firstWindow); + destination.next(firstWindow); + } + WindowCountSubscriber.prototype._next = function (value) { + var startWindowEvery = (this.startWindowEvery > 0) ? this.startWindowEvery : this.windowSize; + var destination = this.destination; + var windowSize = this.windowSize; + var windows = this.windows; + var len = windows.length; + for (var i = 0; i < len; i++) { + windows[i].next(value); + } + var c = this.count - windowSize + 1; + if (c >= 0 && c % startWindowEvery === 0) { + windows.shift().complete(); + } + if (++this.count % startWindowEvery === 0) { + var window_1 = new Subject_1.Subject(); + windows.push(window_1); + destination.add(window_1); + destination.next(window_1); + } + }; + WindowCountSubscriber.prototype._error = function (err) { + var windows = this.windows; + while (windows.length > 0) { + windows.shift().error(err); + } + this.destination.error(err); + }; + WindowCountSubscriber.prototype._complete = function () { + var windows = this.windows; + while (windows.length > 0) { + windows.shift().complete(); + } + this.destination.complete(); + }; + return WindowCountSubscriber; +}(Subscriber_1.Subscriber)); + +},{"../Subject":8,"../Subscriber":9}],213:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscriber_1 = require('../Subscriber'); +var Subject_1 = require('../Subject'); +var asap_1 = require('../scheduler/asap'); +function windowTime(windowTimeSpan, windowCreationInterval, scheduler) { + if (windowCreationInterval === void 0) { windowCreationInterval = null; } + if (scheduler === void 0) { scheduler = asap_1.asap; } + return this.lift(new WindowTimeOperator(windowTimeSpan, windowCreationInterval, scheduler)); +} +exports.windowTime = windowTime; +var WindowTimeOperator = (function () { + function WindowTimeOperator(windowTimeSpan, windowCreationInterval, scheduler) { + this.windowTimeSpan = windowTimeSpan; + this.windowCreationInterval = windowCreationInterval; + this.scheduler = scheduler; + } + WindowTimeOperator.prototype.call = function (subscriber) { + return new WindowTimeSubscriber(subscriber, this.windowTimeSpan, this.windowCreationInterval, this.scheduler); + }; + return WindowTimeOperator; +}()); +var WindowTimeSubscriber = (function (_super) { + __extends(WindowTimeSubscriber, _super); + function WindowTimeSubscriber(destination, windowTimeSpan, windowCreationInterval, scheduler) { + _super.call(this, destination); + this.destination = destination; + this.windowTimeSpan = windowTimeSpan; + this.windowCreationInterval = windowCreationInterval; + this.scheduler = scheduler; + this.windows = []; + if (windowCreationInterval !== null && windowCreationInterval >= 0) { + var window_1 = this.openWindow(); + var closeState = { subscriber: this, window: window_1, context: null }; + var creationState = { windowTimeSpan: windowTimeSpan, windowCreationInterval: windowCreationInterval, subscriber: this, scheduler: scheduler }; + this.add(scheduler.schedule(dispatchWindowClose, windowTimeSpan, closeState)); + this.add(scheduler.schedule(dispatchWindowCreation, windowCreationInterval, creationState)); + } + else { + var window_2 = this.openWindow(); + var timeSpanOnlyState = { subscriber: this, window: window_2, windowTimeSpan: windowTimeSpan }; + this.add(scheduler.schedule(dispatchWindowTimeSpanOnly, windowTimeSpan, timeSpanOnlyState)); + } + } + WindowTimeSubscriber.prototype._next = function (value) { + var windows = this.windows; + var len = windows.length; + for (var i = 0; i < len; i++) { + var window_3 = windows[i]; + if (!window_3.isUnsubscribed) { + window_3.next(value); + } + } + }; + WindowTimeSubscriber.prototype._error = function (err) { + var windows = this.windows; + while (windows.length > 0) { + windows.shift().error(err); + } + this.destination.error(err); + }; + WindowTimeSubscriber.prototype._complete = function () { + var windows = this.windows; + while (windows.length > 0) { + var window_4 = windows.shift(); + if (!window_4.isUnsubscribed) { + window_4.complete(); + } + } + this.destination.complete(); + }; + WindowTimeSubscriber.prototype.openWindow = function () { + var window = new Subject_1.Subject(); + this.windows.push(window); + var destination = this.destination; + destination.add(window); + destination.next(window); + return window; + }; + WindowTimeSubscriber.prototype.closeWindow = function (window) { + window.complete(); + var windows = this.windows; + windows.splice(windows.indexOf(window), 1); + }; + return WindowTimeSubscriber; +}(Subscriber_1.Subscriber)); +function dispatchWindowTimeSpanOnly(state) { + var subscriber = state.subscriber, windowTimeSpan = state.windowTimeSpan, window = state.window; + if (window) { + window.complete(); + } + state.window = subscriber.openWindow(); + this.schedule(state, windowTimeSpan); +} +function dispatchWindowCreation(state) { + var windowTimeSpan = state.windowTimeSpan, subscriber = state.subscriber, scheduler = state.scheduler, windowCreationInterval = state.windowCreationInterval; + var window = subscriber.openWindow(); + var action = this; + var context = { action: action, subscription: null }; + var timeSpanState = { subscriber: subscriber, window: window, context: context }; + context.subscription = scheduler.schedule(dispatchWindowClose, windowTimeSpan, timeSpanState); + action.add(context.subscription); + action.schedule(state, windowCreationInterval); +} +function dispatchWindowClose(_a) { + var subscriber = _a.subscriber, window = _a.window, context = _a.context; + if (context && context.action && context.subscription) { + context.action.remove(context.subscription); + } + subscriber.closeWindow(window); +} + +},{"../Subject":8,"../Subscriber":9,"../scheduler/asap":224}],214:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subject_1 = require('../Subject'); +var Subscription_1 = require('../Subscription'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function windowToggle(openings, closingSelector) { + return this.lift(new WindowToggleOperator(openings, closingSelector)); +} +exports.windowToggle = windowToggle; +var WindowToggleOperator = (function () { + function WindowToggleOperator(openings, closingSelector) { + this.openings = openings; + this.closingSelector = closingSelector; + } + WindowToggleOperator.prototype.call = function (subscriber) { + return new WindowToggleSubscriber(subscriber, this.openings, this.closingSelector); + }; + return WindowToggleOperator; +}()); +var WindowToggleSubscriber = (function (_super) { + __extends(WindowToggleSubscriber, _super); + function WindowToggleSubscriber(destination, openings, closingSelector) { + _super.call(this, destination); + this.openings = openings; + this.closingSelector = closingSelector; + this.contexts = []; + this.add(this.openSubscription = subscribeToResult_1.subscribeToResult(this, openings, openings)); + } + WindowToggleSubscriber.prototype._next = function (value) { + var contexts = this.contexts; + if (contexts) { + var len = contexts.length; + for (var i = 0; i < len; i++) { + contexts[i].window.next(value); + } + } + }; + WindowToggleSubscriber.prototype._error = function (err) { + var contexts = this.contexts; + this.contexts = null; + if (contexts) { + var len = contexts.length; + var index = -1; + while (++index < len) { + var context = contexts[index]; + context.window.error(err); + context.subscription.unsubscribe(); + } + } + _super.prototype._error.call(this, err); + }; + WindowToggleSubscriber.prototype._complete = function () { + var contexts = this.contexts; + this.contexts = null; + if (contexts) { + var len = contexts.length; + var index = -1; + while (++index < len) { + var context = contexts[index]; + context.window.complete(); + context.subscription.unsubscribe(); + } + } + _super.prototype._complete.call(this); + }; + WindowToggleSubscriber.prototype._unsubscribe = function () { + var contexts = this.contexts; + this.contexts = null; + if (contexts) { + var len = contexts.length; + var index = -1; + while (++index < len) { + var context = contexts[index]; + context.window.unsubscribe(); + context.subscription.unsubscribe(); + } + } + }; + WindowToggleSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + if (outerValue === this.openings) { + var closingSelector = this.closingSelector; + var closingNotifier = tryCatch_1.tryCatch(closingSelector)(innerValue); + if (closingNotifier === errorObject_1.errorObject) { + return this.error(errorObject_1.errorObject.e); + } + else { + var window_1 = new Subject_1.Subject(); + var subscription = new Subscription_1.Subscription(); + var context = { window: window_1, subscription: subscription }; + this.contexts.push(context); + var innerSubscription = subscribeToResult_1.subscribeToResult(this, closingNotifier, context); + innerSubscription.context = context; + subscription.add(innerSubscription); + this.destination.next(window_1); + } + } + else { + this.closeWindow(this.contexts.indexOf(outerValue)); + } + }; + WindowToggleSubscriber.prototype.notifyError = function (err) { + this.error(err); + }; + WindowToggleSubscriber.prototype.notifyComplete = function (inner) { + if (inner !== this.openSubscription) { + this.closeWindow(this.contexts.indexOf(inner.context)); + } + }; + WindowToggleSubscriber.prototype.closeWindow = function (index) { + var contexts = this.contexts; + var context = contexts[index]; + var window = context.window, subscription = context.subscription; + contexts.splice(index, 1); + window.complete(); + subscription.unsubscribe(); + }; + return WindowToggleSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../Subject":8,"../Subscription":10,"../util/errorObject":239,"../util/subscribeToResult":250,"../util/tryCatch":253}],215:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subject_1 = require('../Subject'); +var tryCatch_1 = require('../util/tryCatch'); +var errorObject_1 = require('../util/errorObject'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +function windowWhen(closingSelector) { + return this.lift(new WindowOperator(closingSelector)); +} +exports.windowWhen = windowWhen; +var WindowOperator = (function () { + function WindowOperator(closingSelector) { + this.closingSelector = closingSelector; + } + WindowOperator.prototype.call = function (subscriber) { + return new WindowSubscriber(subscriber, this.closingSelector); + }; + return WindowOperator; +}()); +var WindowSubscriber = (function (_super) { + __extends(WindowSubscriber, _super); + function WindowSubscriber(destination, closingSelector) { + _super.call(this, destination); + this.destination = destination; + this.closingSelector = closingSelector; + this.openWindow(); + } + WindowSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.openWindow(innerSub); + }; + WindowSubscriber.prototype.notifyError = function (error, innerSub) { + this._error(error); + }; + WindowSubscriber.prototype.notifyComplete = function (innerSub) { + this.openWindow(innerSub); + }; + WindowSubscriber.prototype._next = function (value) { + this.window.next(value); + }; + WindowSubscriber.prototype._error = function (err) { + this.window.error(err); + this.destination.error(err); + this.unsubscribeClosingNotification(); + }; + WindowSubscriber.prototype._complete = function () { + this.window.complete(); + this.destination.complete(); + this.unsubscribeClosingNotification(); + }; + WindowSubscriber.prototype.unsubscribeClosingNotification = function () { + if (this.closingNotification) { + this.closingNotification.unsubscribe(); + } + }; + WindowSubscriber.prototype.openWindow = function (innerSub) { + if (innerSub === void 0) { innerSub = null; } + if (innerSub) { + this.remove(innerSub); + innerSub.unsubscribe(); + } + var prevWindow = this.window; + if (prevWindow) { + prevWindow.complete(); + } + var window = this.window = new Subject_1.Subject(); + this.destination.next(window); + var closingNotifier = tryCatch_1.tryCatch(this.closingSelector)(); + if (closingNotifier === errorObject_1.errorObject) { + var err = errorObject_1.errorObject.e; + this.destination.error(err); + this.window.error(err); + } + else { + this.add(this.closingNotification = subscribeToResult_1.subscribeToResult(this, closingNotifier)); + this.add(window); + } + }; + return WindowSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../Subject":8,"../util/errorObject":239,"../util/subscribeToResult":250,"../util/tryCatch":253}],216:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +/** + * @param {Observable} observables the observables to get the latest values from. + * @param {Function} [project] optional projection function for merging values together. Receives all values in order + * of observables passed. (e.g. `a.withLatestFrom(b, c, (a1, b1, c1) => a1 + b1 + c1)`). If this is not passed, arrays + * will be returned. + * @description merges each value from an observable with the latest values from the other passed observables. + * All observables must emit at least one value before the resulting observable will emit + * + * #### example + * ``` + * A.withLatestFrom(B, C) + * + * A: ----a-----------------b---------------c-----------| + * B: ---d----------------e--------------f---------| + * C: --x----------------y-------------z-------------| + * result: ---([a,d,x])---------([b,e,y])--------([c,f,z])---| + * ``` + */ +function withLatestFrom() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + var project; + if (typeof args[args.length - 1] === 'function') { + project = args.pop(); + } + var observables = args; + return this.lift(new WithLatestFromOperator(observables, project)); +} +exports.withLatestFrom = withLatestFrom; +/* tslint:enable:max-line-length */ +var WithLatestFromOperator = (function () { + function WithLatestFromOperator(observables, project) { + this.observables = observables; + this.project = project; + } + WithLatestFromOperator.prototype.call = function (subscriber) { + return new WithLatestFromSubscriber(subscriber, this.observables, this.project); + }; + return WithLatestFromOperator; +}()); +var WithLatestFromSubscriber = (function (_super) { + __extends(WithLatestFromSubscriber, _super); + function WithLatestFromSubscriber(destination, observables, project) { + _super.call(this, destination); + this.observables = observables; + this.project = project; + this.toRespond = []; + var len = observables.length; + this.values = new Array(len); + for (var i = 0; i < len; i++) { + this.toRespond.push(i); + } + for (var i = 0; i < len; i++) { + var observable = observables[i]; + this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i)); + } + } + WithLatestFromSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.values[outerIndex] = innerValue; + var toRespond = this.toRespond; + if (toRespond.length > 0) { + var found = toRespond.indexOf(outerIndex); + if (found !== -1) { + toRespond.splice(found, 1); + } + } + }; + WithLatestFromSubscriber.prototype.notifyComplete = function () { + // noop + }; + WithLatestFromSubscriber.prototype._next = function (value) { + if (this.toRespond.length === 0) { + var args = [value].concat(this.values); + if (this.project) { + this._tryProject(args); + } + else { + this.destination.next(args); + } + } + }; + WithLatestFromSubscriber.prototype._tryProject = function (args) { + var result; + try { + result = this.project.apply(this, args); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.next(result); + }; + return WithLatestFromSubscriber; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../util/subscribeToResult":250}],217:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var ArrayObservable_1 = require('../observable/ArrayObservable'); +var isArray_1 = require('../util/isArray'); +var Subscriber_1 = require('../Subscriber'); +var OuterSubscriber_1 = require('../OuterSubscriber'); +var subscribeToResult_1 = require('../util/subscribeToResult'); +var SymbolShim_1 = require('../util/SymbolShim'); +function zipProto() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + observables.unshift(this); + return zipStatic.apply(this, observables); +} +exports.zipProto = zipProto; +/* tslint:enable:max-line-length */ +function zipStatic() { + var observables = []; + for (var _i = 0; _i < arguments.length; _i++) { + observables[_i - 0] = arguments[_i]; + } + var project = observables[observables.length - 1]; + if (typeof project === 'function') { + observables.pop(); + } + return new ArrayObservable_1.ArrayObservable(observables).lift(new ZipOperator(project)); +} +exports.zipStatic = zipStatic; +var ZipOperator = (function () { + function ZipOperator(project) { + this.project = project; + } + ZipOperator.prototype.call = function (subscriber) { + return new ZipSubscriber(subscriber, this.project); + }; + return ZipOperator; +}()); +exports.ZipOperator = ZipOperator; +var ZipSubscriber = (function (_super) { + __extends(ZipSubscriber, _super); + function ZipSubscriber(destination, project, values) { + if (values === void 0) { values = Object.create(null); } + _super.call(this, destination); + this.index = 0; + this.iterators = []; + this.active = 0; + this.project = (typeof project === 'function') ? project : null; + this.values = values; + } + ZipSubscriber.prototype._next = function (value) { + var iterators = this.iterators; + var index = this.index++; + if (isArray_1.isArray(value)) { + iterators.push(new StaticArrayIterator(value)); + } + else if (typeof value[SymbolShim_1.SymbolShim.iterator] === 'function') { + iterators.push(new StaticIterator(value[SymbolShim_1.SymbolShim.iterator]())); + } + else { + iterators.push(new ZipBufferIterator(this.destination, this, value, index)); + } + }; + ZipSubscriber.prototype._complete = function () { + var iterators = this.iterators; + var len = iterators.length; + this.active = len; + for (var i = 0; i < len; i++) { + var iterator = iterators[i]; + if (iterator.stillUnsubscribed) { + this.add(iterator.subscribe(iterator, i)); + } + else { + this.active--; // not an observable + } + } + }; + ZipSubscriber.prototype.notifyInactive = function () { + this.active--; + if (this.active === 0) { + this.destination.complete(); + } + }; + ZipSubscriber.prototype.checkIterators = function () { + var iterators = this.iterators; + var len = iterators.length; + var destination = this.destination; + // abort if not all of them have values + for (var i = 0; i < len; i++) { + var iterator = iterators[i]; + if (typeof iterator.hasValue === 'function' && !iterator.hasValue()) { + return; + } + } + var shouldComplete = false; + var args = []; + for (var i = 0; i < len; i++) { + var iterator = iterators[i]; + var result = iterator.next(); + // check to see if it's completed now that you've gotten + // the next value. + if (iterator.hasCompleted()) { + shouldComplete = true; + } + if (result.done) { + destination.complete(); + return; + } + args.push(result.value); + } + if (this.project) { + this._tryProject(args); + } + else { + destination.next(args); + } + if (shouldComplete) { + destination.complete(); + } + }; + ZipSubscriber.prototype._tryProject = function (args) { + var result; + try { + result = this.project.apply(this, args); + } + catch (err) { + this.destination.error(err); + return; + } + this.destination.next(result); + }; + return ZipSubscriber; +}(Subscriber_1.Subscriber)); +exports.ZipSubscriber = ZipSubscriber; +var StaticIterator = (function () { + function StaticIterator(iterator) { + this.iterator = iterator; + this.nextResult = iterator.next(); + } + StaticIterator.prototype.hasValue = function () { + return true; + }; + StaticIterator.prototype.next = function () { + var result = this.nextResult; + this.nextResult = this.iterator.next(); + return result; + }; + StaticIterator.prototype.hasCompleted = function () { + var nextResult = this.nextResult; + return nextResult && nextResult.done; + }; + return StaticIterator; +}()); +var StaticArrayIterator = (function () { + function StaticArrayIterator(array) { + this.array = array; + this.index = 0; + this.length = 0; + this.length = array.length; + } + StaticArrayIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function () { + return this; + }; + StaticArrayIterator.prototype.next = function (value) { + var i = this.index++; + var array = this.array; + return i < this.length ? { value: array[i], done: false } : { done: true }; + }; + StaticArrayIterator.prototype.hasValue = function () { + return this.array.length > this.index; + }; + StaticArrayIterator.prototype.hasCompleted = function () { + return this.array.length === this.index; + }; + return StaticArrayIterator; +}()); +var ZipBufferIterator = (function (_super) { + __extends(ZipBufferIterator, _super); + function ZipBufferIterator(destination, parent, observable, index) { + _super.call(this, destination); + this.parent = parent; + this.observable = observable; + this.index = index; + this.stillUnsubscribed = true; + this.buffer = []; + this.isComplete = false; + } + ZipBufferIterator.prototype[SymbolShim_1.SymbolShim.iterator] = function () { + return this; + }; + // NOTE: there is actually a name collision here with Subscriber.next and Iterator.next + // this is legit because `next()` will never be called by a subscription in this case. + ZipBufferIterator.prototype.next = function () { + var buffer = this.buffer; + if (buffer.length === 0 && this.isComplete) { + return { done: true }; + } + else { + return { value: buffer.shift(), done: false }; + } + }; + ZipBufferIterator.prototype.hasValue = function () { + return this.buffer.length > 0; + }; + ZipBufferIterator.prototype.hasCompleted = function () { + return this.buffer.length === 0 && this.isComplete; + }; + ZipBufferIterator.prototype.notifyComplete = function () { + if (this.buffer.length > 0) { + this.isComplete = true; + this.parent.notifyInactive(); + } + else { + this.destination.complete(); + } + }; + ZipBufferIterator.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) { + this.buffer.push(innerValue); + this.parent.checkIterators(); + }; + ZipBufferIterator.prototype.subscribe = function (value, index) { + return subscribeToResult_1.subscribeToResult(this, this.observable, this, index); + }; + return ZipBufferIterator; +}(OuterSubscriber_1.OuterSubscriber)); + +},{"../OuterSubscriber":6,"../Subscriber":9,"../observable/ArrayObservable":116,"../util/SymbolShim":238,"../util/isArray":240,"../util/subscribeToResult":250}],218:[function(require,module,exports){ +"use strict"; +var zip_1 = require('./zip'); +function zipAll(project) { + return this.lift(new zip_1.ZipOperator(project)); +} +exports.zipAll = zipAll; + +},{"./zip":217}],219:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Immediate_1 = require('../util/Immediate'); +var FutureAction_1 = require('./FutureAction'); +var AsapAction = (function (_super) { + __extends(AsapAction, _super); + function AsapAction() { + _super.apply(this, arguments); + } + AsapAction.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; + var scheduler = this.scheduler; + scheduler.actions.push(this); + if (!scheduler.scheduledId) { + scheduler.scheduledId = Immediate_1.Immediate.setImmediate(function () { + scheduler.scheduledId = null; + scheduler.flush(); + }); + } + return this; + }; + AsapAction.prototype._unsubscribe = function () { + var scheduler = this.scheduler; + var scheduledId = scheduler.scheduledId, actions = scheduler.actions; + _super.prototype._unsubscribe.call(this); + if (actions.length === 0) { + scheduler.active = false; + if (scheduledId != null) { + scheduler.scheduledId = null; + Immediate_1.Immediate.clearImmediate(scheduledId); + } + } + }; + return AsapAction; +}(FutureAction_1.FutureAction)); +exports.AsapAction = AsapAction; + +},{"../util/Immediate":234,"./FutureAction":221}],220:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var AsapAction_1 = require('./AsapAction'); +var QueueScheduler_1 = require('./QueueScheduler'); +var AsapScheduler = (function (_super) { + __extends(AsapScheduler, _super); + function AsapScheduler() { + _super.apply(this, arguments); + } + AsapScheduler.prototype.scheduleNow = function (work, state) { + return new AsapAction_1.AsapAction(this, work).schedule(state); + }; + return AsapScheduler; +}(QueueScheduler_1.QueueScheduler)); +exports.AsapScheduler = AsapScheduler; + +},{"./AsapAction":219,"./QueueScheduler":223}],221:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var root_1 = require('../util/root'); +var Subscription_1 = require('../Subscription'); +var FutureAction = (function (_super) { + __extends(FutureAction, _super); + function FutureAction(scheduler, work) { + _super.call(this); + this.scheduler = scheduler; + this.work = work; + } + FutureAction.prototype.execute = function () { + if (this.isUnsubscribed) { + throw new Error('How did did we execute a canceled Action?'); + } + this.work(this.state); + }; + FutureAction.prototype.schedule = function (state, delay) { + if (delay === void 0) { delay = 0; } + if (this.isUnsubscribed) { + return this; + } + return this._schedule(state, delay); + }; + FutureAction.prototype._schedule = function (state, delay) { + var _this = this; + if (delay === void 0) { delay = 0; } + this.delay = delay; + this.state = state; + var id = this.id; + if (id != null) { + this.id = undefined; + root_1.root.clearTimeout(id); + } + this.id = root_1.root.setTimeout(function () { + _this.id = null; + var scheduler = _this.scheduler; + scheduler.actions.push(_this); + scheduler.flush(); + }, delay); + return this; + }; + FutureAction.prototype._unsubscribe = function () { + var _a = this, id = _a.id, scheduler = _a.scheduler; + var actions = scheduler.actions; + var index = actions.indexOf(this); + if (id != null) { + this.id = null; + root_1.root.clearTimeout(id); + } + if (index !== -1) { + actions.splice(index, 1); + } + this.work = null; + this.state = null; + this.scheduler = null; + }; + return FutureAction; +}(Subscription_1.Subscription)); +exports.FutureAction = FutureAction; + +},{"../Subscription":10,"../util/root":249}],222:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var FutureAction_1 = require('./FutureAction'); +var QueueAction = (function (_super) { + __extends(QueueAction, _super); + function QueueAction() { + _super.apply(this, arguments); + } + 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; + var scheduler = this.scheduler; + scheduler.actions.push(this); + scheduler.flush(); + return this; + }; + return QueueAction; +}(FutureAction_1.FutureAction)); +exports.QueueAction = QueueAction; + +},{"./FutureAction":221}],223:[function(require,module,exports){ +"use strict"; +var QueueAction_1 = require('./QueueAction'); +var FutureAction_1 = require('./FutureAction'); +var QueueScheduler = (function () { + function QueueScheduler() { + this.active = false; + this.actions = []; + this.scheduledId = null; + } + QueueScheduler.prototype.now = function () { + return Date.now(); + }; + QueueScheduler.prototype.flush = function () { + if (this.active || this.scheduledId) { + return; + } + this.active = true; + var actions = this.actions; + for (var action = void 0; action = actions.shift();) { + action.execute(); + } + this.active = false; + }; + QueueScheduler.prototype.schedule = function (work, delay, state) { + if (delay === void 0) { delay = 0; } + return (delay <= 0) ? + this.scheduleNow(work, state) : + this.scheduleLater(work, delay, state); + }; + QueueScheduler.prototype.scheduleNow = function (work, state) { + return new QueueAction_1.QueueAction(this, work).schedule(state); + }; + QueueScheduler.prototype.scheduleLater = function (work, delay, state) { + return new FutureAction_1.FutureAction(this, work).schedule(state, delay); + }; + return QueueScheduler; +}()); +exports.QueueScheduler = QueueScheduler; + +},{"./FutureAction":221,"./QueueAction":222}],224:[function(require,module,exports){ +"use strict"; +var AsapScheduler_1 = require('./AsapScheduler'); +exports.asap = new AsapScheduler_1.AsapScheduler(); + +},{"./AsapScheduler":220}],225:[function(require,module,exports){ +"use strict"; +var QueueScheduler_1 = require('./QueueScheduler'); +exports.queue = new QueueScheduler_1.QueueScheduler(); + +},{"./QueueScheduler":223}],226:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subject_1 = require('../Subject'); +var AsyncSubject = (function (_super) { + __extends(AsyncSubject, _super); + function AsyncSubject() { + _super.apply(this, arguments); + this.value = null; + this.hasNext = false; + } + AsyncSubject.prototype._subscribe = function (subscriber) { + if (this.hasCompleted && this.hasNext) { + subscriber.next(this.value); + } + return _super.prototype._subscribe.call(this, subscriber); + }; + AsyncSubject.prototype._next = function (value) { + this.value = value; + this.hasNext = true; + }; + AsyncSubject.prototype._complete = function () { + var index = -1; + var observers = this.observers; + var len = observers.length; + // optimization to block our SubjectSubscriptions from + // splicing themselves out of the observers list one by one. + this.isUnsubscribed = true; + if (this.hasNext) { + while (++index < len) { + var o = observers[index]; + o.next(this.value); + o.complete(); + } + } + else { + while (++index < len) { + observers[index].complete(); + } + } + this.isUnsubscribed = false; + this.unsubscribe(); + }; + return AsyncSubject; +}(Subject_1.Subject)); +exports.AsyncSubject = AsyncSubject; + +},{"../Subject":8}],227:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subject_1 = require('../Subject'); +var throwError_1 = require('../util/throwError'); +var ObjectUnsubscribedError_1 = require('../util/ObjectUnsubscribedError'); +var BehaviorSubject = (function (_super) { + __extends(BehaviorSubject, _super); + function BehaviorSubject(_value) { + _super.call(this); + this._value = _value; + } + BehaviorSubject.prototype.getValue = function () { + if (this.hasErrored) { + throwError_1.throwError(this.errorValue); + } + else if (this.isUnsubscribed) { + throwError_1.throwError(new ObjectUnsubscribedError_1.ObjectUnsubscribedError()); + } + else { + return this._value; + } + }; + Object.defineProperty(BehaviorSubject.prototype, "value", { + get: function () { + return this.getValue(); + }, + enumerable: true, + configurable: true + }); + BehaviorSubject.prototype._subscribe = function (subscriber) { + var subscription = _super.prototype._subscribe.call(this, subscriber); + if (subscription && !subscription.isUnsubscribed) { + subscriber.next(this._value); + } + return subscription; + }; + BehaviorSubject.prototype._next = function (value) { + _super.prototype._next.call(this, this._value = value); + }; + BehaviorSubject.prototype._error = function (err) { + this.hasErrored = true; + _super.prototype._error.call(this, this.errorValue = err); + }; + return BehaviorSubject; +}(Subject_1.Subject)); +exports.BehaviorSubject = BehaviorSubject; + +},{"../Subject":8,"../util/ObjectUnsubscribedError":237,"../util/throwError":251}],228:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subject_1 = require('../Subject'); +var queue_1 = require('../scheduler/queue'); +var observeOn_1 = require('../operator/observeOn'); +var ReplaySubject = (function (_super) { + __extends(ReplaySubject, _super); + function ReplaySubject(bufferSize, windowTime, scheduler) { + if (bufferSize === void 0) { bufferSize = Number.POSITIVE_INFINITY; } + if (windowTime === void 0) { windowTime = Number.POSITIVE_INFINITY; } + _super.call(this); + this.events = []; + this.scheduler = scheduler; + this.bufferSize = bufferSize < 1 ? 1 : bufferSize; + this._windowTime = windowTime < 1 ? 1 : windowTime; + } + ReplaySubject.prototype._next = function (value) { + var now = this._getNow(); + this.events.push(new ReplayEvent(now, value)); + this._trimBufferThenGetEvents(now); + _super.prototype._next.call(this, value); + }; + ReplaySubject.prototype._subscribe = function (subscriber) { + var events = this._trimBufferThenGetEvents(this._getNow()); + var scheduler = this.scheduler; + if (scheduler) { + subscriber.add(subscriber = new observeOn_1.ObserveOnSubscriber(subscriber, scheduler)); + } + var index = -1; + var len = events.length; + while (++index < len && !subscriber.isUnsubscribed) { + subscriber.next(events[index].value); + } + return _super.prototype._subscribe.call(this, subscriber); + }; + ReplaySubject.prototype._getNow = function () { + return (this.scheduler || queue_1.queue).now(); + }; + ReplaySubject.prototype._trimBufferThenGetEvents = function (now) { + var bufferSize = this.bufferSize; + var _windowTime = this._windowTime; + var events = this.events; + var eventsCount = events.length; + var spliceCount = 0; + // Trim events that fall out of the time window. + // Start at the front of the list. Break early once + // we encounter an event that falls within the window. + while (spliceCount < eventsCount) { + if ((now - events[spliceCount].time) < _windowTime) { + break; + } + spliceCount += 1; + } + if (eventsCount > bufferSize) { + spliceCount = Math.max(spliceCount, eventsCount - bufferSize); + } + if (spliceCount > 0) { + events.splice(0, spliceCount); + } + return events; + }; + return ReplaySubject; +}(Subject_1.Subject)); +exports.ReplaySubject = ReplaySubject; +var ReplayEvent = (function () { + function ReplayEvent(time, value) { + this.time = time; + this.value = value; + } + return ReplayEvent; +}()); + +},{"../Subject":8,"../operator/observeOn":176,"../scheduler/queue":225}],229:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var Subscription_1 = require('../Subscription'); +var SubjectSubscription = (function (_super) { + __extends(SubjectSubscription, _super); + function SubjectSubscription(subject, observer) { + _super.call(this); + this.subject = subject; + this.observer = observer; + this.isUnsubscribed = false; + } + SubjectSubscription.prototype.unsubscribe = function () { + if (this.isUnsubscribed) { + return; + } + this.isUnsubscribed = true; + var subject = this.subject; + var observers = subject.observers; + this.subject = null; + if (!observers || observers.length === 0 || subject.isUnsubscribed) { + return; + } + var subscriberIndex = observers.indexOf(this.observer); + if (subscriberIndex !== -1) { + observers.splice(subscriberIndex, 1); + } + }; + return SubjectSubscription; +}(Subscription_1.Subscription)); +exports.SubjectSubscription = SubjectSubscription; + +},{"../Subscription":10}],230:[function(require,module,exports){ +"use strict"; +var SymbolShim_1 = require('../util/SymbolShim'); +/** + * rxSubscriber symbol is a symbol for retreiving an "Rx safe" Observer from an object + * "Rx safety" can be defined as an object that has all of the traits of an Rx Subscriber, + * including the ability to add and remove subscriptions to the subscription chain and + * guarantees involving event triggering (can't "next" after unsubscription, etc). + */ +exports.rxSubscriber = SymbolShim_1.SymbolShim.for('rxSubscriber'); + +},{"../util/SymbolShim":238}],231:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var ArgumentOutOfRangeError = (function (_super) { + __extends(ArgumentOutOfRangeError, _super); + function ArgumentOutOfRangeError() { + _super.call(this, 'argument out of range'); + this.name = 'ArgumentOutOfRangeError'; + } + return ArgumentOutOfRangeError; +}(Error)); +exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError; + +},{}],232:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var EmptyError = (function (_super) { + __extends(EmptyError, _super); + function EmptyError() { + _super.call(this, 'no elements in sequence'); + this.name = 'EmptyError'; + } + return EmptyError; +}(Error)); +exports.EmptyError = EmptyError; + +},{}],233:[function(require,module,exports){ +"use strict"; +var FastMap = (function () { + function FastMap() { + this.values = {}; + } + FastMap.prototype.delete = function (key) { + this.values[key] = null; + return true; + }; + FastMap.prototype.set = function (key, value) { + this.values[key] = value; + return this; + }; + FastMap.prototype.get = function (key) { + return this.values[key]; + }; + FastMap.prototype.forEach = function (cb, thisArg) { + var values = this.values; + for (var key in values) { + if (values.hasOwnProperty(key) && values[key] !== null) { + cb.call(thisArg, values[key], key); + } + } + }; + FastMap.prototype.clear = function () { + this.values = {}; + }; + return FastMap; +}()); +exports.FastMap = FastMap; + +},{}],234:[function(require,module,exports){ +/** +Some credit for this helper goes to http://github.com/YuzuJS/setImmediate +*/ +"use strict"; +var root_1 = require('./root'); +var ImmediateDefinition = (function () { + function ImmediateDefinition(root) { + this.root = root; + if (root.setImmediate && typeof root.setImmediate === 'function') { + this.setImmediate = root.setImmediate.bind(root); + this.clearImmediate = root.clearImmediate.bind(root); + } + else { + this.nextHandle = 1; + this.tasksByHandle = {}; + this.currentlyRunningATask = false; + // Don't get fooled by e.g. browserify environments. + if (this.canUseProcessNextTick()) { + // For Node.js before 0.9 + this.setImmediate = this.createProcessNextTickSetImmediate(); + } + else if (this.canUsePostMessage()) { + // For non-IE10 modern browsers + this.setImmediate = this.createPostMessageSetImmediate(); + } + else if (this.canUseMessageChannel()) { + // For web workers, where supported + this.setImmediate = this.createMessageChannelSetImmediate(); + } + else if (this.canUseReadyStateChange()) { + // For IE 6–8 + this.setImmediate = this.createReadyStateChangeSetImmediate(); + } + else { + // For older browsers + this.setImmediate = this.createSetTimeoutSetImmediate(); + } + var ci = function clearImmediate(handle) { + delete clearImmediate.instance.tasksByHandle[handle]; + }; + ci.instance = this; + this.clearImmediate = ci; + } + } + ImmediateDefinition.prototype.identify = function (o) { + return this.root.Object.prototype.toString.call(o); + }; + ImmediateDefinition.prototype.canUseProcessNextTick = function () { + return this.identify(this.root.process) === '[object process]'; + }; + ImmediateDefinition.prototype.canUseMessageChannel = function () { + return Boolean(this.root.MessageChannel); + }; + ImmediateDefinition.prototype.canUseReadyStateChange = function () { + var document = this.root.document; + return Boolean(document && 'onreadystatechange' in document.createElement('script')); + }; + ImmediateDefinition.prototype.canUsePostMessage = function () { + var root = this.root; + // The test against `importScripts` prevents this implementation from being installed inside a web worker, + // where `root.postMessage` means something completely different and can't be used for this purpose. + if (root.postMessage && !root.importScripts) { + var postMessageIsAsynchronous_1 = true; + var oldOnMessage = root.onmessage; + root.onmessage = function () { + postMessageIsAsynchronous_1 = false; + }; + root.postMessage('', '*'); + root.onmessage = oldOnMessage; + return postMessageIsAsynchronous_1; + } + return false; + }; + // This function accepts the same arguments as setImmediate, but + // returns a function that requires no arguments. + ImmediateDefinition.prototype.partiallyApplied = function (handler) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + var fn = function result() { + var _a = result, handler = _a.handler, args = _a.args; + if (typeof handler === 'function') { + handler.apply(undefined, args); + } + else { + (new Function('' + handler))(); + } + }; + fn.handler = handler; + fn.args = args; + return fn; + }; + ImmediateDefinition.prototype.addFromSetImmediateArguments = function (args) { + this.tasksByHandle[this.nextHandle] = this.partiallyApplied.apply(undefined, args); + return this.nextHandle++; + }; + ImmediateDefinition.prototype.createProcessNextTickSetImmediate = function () { + var fn = function setImmediate() { + var instance = setImmediate.instance; + var handle = instance.addFromSetImmediateArguments(arguments); + instance.root.process.nextTick(instance.partiallyApplied(instance.runIfPresent, handle)); + return handle; + }; + fn.instance = this; + return fn; + }; + ImmediateDefinition.prototype.createPostMessageSetImmediate = function () { + // Installs an event handler on `global` for the `message` event: see + // * https://developer.mozilla.org/en/DOM/window.postMessage + // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages + var root = this.root; + var messagePrefix = 'setImmediate$' + root.Math.random() + '$'; + var onGlobalMessage = function globalMessageHandler(event) { + var instance = globalMessageHandler.instance; + if (event.source === root && + typeof event.data === 'string' && + event.data.indexOf(messagePrefix) === 0) { + instance.runIfPresent(+event.data.slice(messagePrefix.length)); + } + }; + onGlobalMessage.instance = this; + root.addEventListener('message', onGlobalMessage, false); + var fn = function setImmediate() { + var _a = setImmediate, messagePrefix = _a.messagePrefix, instance = _a.instance; + var handle = instance.addFromSetImmediateArguments(arguments); + instance.root.postMessage(messagePrefix + handle, '*'); + return handle; + }; + fn.instance = this; + fn.messagePrefix = messagePrefix; + return fn; + }; + ImmediateDefinition.prototype.runIfPresent = function (handle) { + // From the spec: 'Wait until any invocations of this algorithm started before this one have completed.' + // So if we're currently running a task, we'll need to delay this invocation. + if (this.currentlyRunningATask) { + // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a + // 'too much recursion' error. + this.root.setTimeout(this.partiallyApplied(this.runIfPresent, handle), 0); + } + else { + var task = this.tasksByHandle[handle]; + if (task) { + this.currentlyRunningATask = true; + try { + task(); + } + finally { + this.clearImmediate(handle); + this.currentlyRunningATask = false; + } + } + } + }; + ImmediateDefinition.prototype.createMessageChannelSetImmediate = function () { + var _this = this; + var channel = new this.root.MessageChannel(); + channel.port1.onmessage = function (event) { + var handle = event.data; + _this.runIfPresent(handle); + }; + var fn = function setImmediate() { + var _a = setImmediate, channel = _a.channel, instance = _a.instance; + var handle = instance.addFromSetImmediateArguments(arguments); + channel.port2.postMessage(handle); + return handle; + }; + fn.channel = channel; + fn.instance = this; + return fn; + }; + ImmediateDefinition.prototype.createReadyStateChangeSetImmediate = function () { + var fn = function setImmediate() { + var instance = setImmediate.instance; + var root = instance.root; + var doc = root.document; + var html = doc.documentElement; + var handle = instance.addFromSetImmediateArguments(arguments); + // Create a