text: webpackJsonp([10],{
  
  /***/ 300:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CardsPageModule", function() { return CardsPageModule; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngx_translate_core__ = __webpack_require__(332);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_ionic_angular__ = __webpack_require__(11);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__cards__ = __webpack_require__(369);
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  
  
  
  
  var CardsPageModule = /** @class */ (function () {
      function CardsPageModule() {
      }
      CardsPageModule = __decorate([
          Object(__WEBPACK_IMPORTED_MODULE_0__angular_core__["I" /* NgModule */])({
              declarations: [
                  __WEBPACK_IMPORTED_MODULE_3__cards__["a" /* CardsPage */],
              ],
              imports: [
                  __WEBPACK_IMPORTED_MODULE_2_ionic_angular__["f" /* IonicPageModule */].forChild(__WEBPACK_IMPORTED_MODULE_3__cards__["a" /* CardsPage */]),
                  __WEBPACK_IMPORTED_MODULE_1__ngx_translate_core__["a" /* TranslateModule */].forChild()
              ],
              exports: [
                  __WEBPACK_IMPORTED_MODULE_3__cards__["a" /* CardsPage */]
              ]
          })
      ], CardsPageModule);
      return CardsPageModule;
  }());
  
  //# sourceMappingURL=cards.module.js.map
  
  /***/ }),
  
  /***/ 321:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return USE_STORE; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return USE_DEFAULT_LANG; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslateService; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__ = __webpack_require__(7);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_add_observable_of__ = __webpack_require__(333);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_add_observable_of___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_add_observable_of__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_add_operator_concat__ = __webpack_require__(334);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_add_operator_concat___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_rxjs_add_operator_concat__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_add_operator_share__ = __webpack_require__(344);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_add_operator_share___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_rxjs_add_operator_share__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_add_operator_map__ = __webpack_require__(227);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_add_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_rxjs_add_operator_map__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_add_operator_merge__ = __webpack_require__(345);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_add_operator_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_rxjs_add_operator_merge__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_add_operator_switchMap__ = __webpack_require__(348);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_add_operator_switchMap___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_rxjs_add_operator_switchMap__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rxjs_add_operator_toArray__ = __webpack_require__(351);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rxjs_add_operator_toArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_rxjs_add_operator_toArray__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rxjs_add_operator_take__ = __webpack_require__(358);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rxjs_add_operator_take___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_rxjs_add_operator_take__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__translate_store__ = __webpack_require__(329);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__translate_loader__ = __webpack_require__(323);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__translate_compiler__ = __webpack_require__(325);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__missing_translation_handler__ = __webpack_require__(326);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__translate_parser__ = __webpack_require__(327);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_15__util__ = __webpack_require__(322);
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  var USE_STORE = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["B" /* InjectionToken */]('USE_STORE');
  var USE_DEFAULT_LANG = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["B" /* InjectionToken */]('USE_DEFAULT_LANG');
  var TranslateService = (function () {
      /**
       *
       * @param store an instance of the store (that is supposed to be unique)
       * @param currentLoader An instance of the loader currently used
       * @param compiler An instance of the compiler currently used
       * @param parser An instance of the parser currently used
       * @param missingTranslationHandler A handler for missing translations.
       * @param isolate whether this service should use the store or not
       * @param useDefaultLang whether we should use default language translation when current language translation is missing.
       */
      function TranslateService(store, currentLoader, compiler, parser, missingTranslationHandler, useDefaultLang, isolate) {
          if (useDefaultLang === void 0) { useDefaultLang = true; }
          if (isolate === void 0) { isolate = false; }
          this.store = store;
          this.currentLoader = currentLoader;
          this.compiler = compiler;
          this.parser = parser;
          this.missingTranslationHandler = missingTranslationHandler;
          this.useDefaultLang = useDefaultLang;
          this.isolate = isolate;
          this.pending = false;
          this._onTranslationChange = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["v" /* EventEmitter */]();
          this._onLangChange = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["v" /* EventEmitter */]();
          this._onDefaultLangChange = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["v" /* EventEmitter */]();
          this._langs = [];
          this._translations = {};
          this._translationRequests = {};
      }
      Object.defineProperty(TranslateService.prototype, "onTranslationChange", {
          /**
           * An EventEmitter to listen to translation change events
           * onTranslationChange.subscribe((params: TranslationChangeEvent) => {
           *     // do something
           * });
           * @type {EventEmitter<TranslationChangeEvent>}
           */
          get: function () {
              return this.isolate ? this._onTranslationChange : this.store.onTranslationChange;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(TranslateService.prototype, "onLangChange", {
          /**
           * An EventEmitter to listen to lang change events
           * onLangChange.subscribe((params: LangChangeEvent) => {
           *     // do something
           * });
           * @type {EventEmitter<LangChangeEvent>}
           */
          get: function () {
              return this.isolate ? this._onLangChange : this.store.onLangChange;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(TranslateService.prototype, "onDefaultLangChange", {
          /**
           * An EventEmitter to listen to default lang change events
           * onDefaultLangChange.subscribe((params: DefaultLangChangeEvent) => {
           *     // do something
           * });
           * @type {EventEmitter<DefaultLangChangeEvent>}
           */
          get: function () {
              return this.isolate ? this._onDefaultLangChange : this.store.onDefaultLangChange;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(TranslateService.prototype, "defaultLang", {
          /**
           * The default lang to fallback when translations are missing on the current lang
           */
          get: function () {
              return this.isolate ? this._defaultLang : this.store.defaultLang;
          },
          set: function (defaultLang) {
              if (this.isolate) {
                  this._defaultLang = defaultLang;
              }
              else {
                  this.store.defaultLang = defaultLang;
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(TranslateService.prototype, "currentLang", {
          /**
           * The lang currently used
           * @type {string}
           */
          get: function () {
              return this.isolate ? this._currentLang : this.store.currentLang;
          },
          set: function (currentLang) {
              if (this.isolate) {
                  this._currentLang = currentLang;
              }
              else {
                  this.store.currentLang = currentLang;
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(TranslateService.prototype, "langs", {
          /**
           * an array of langs
           * @type {Array}
           */
          get: function () {
              return this.isolate ? this._langs : this.store.langs;
          },
          set: function (langs) {
              if (this.isolate) {
                  this._langs = langs;
              }
              else {
                  this.store.langs = langs;
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(TranslateService.prototype, "translations", {
          /**
           * a list of translations per lang
           * @type {{}}
           */
          get: function () {
              return this.isolate ? this._translations : this.store.translations;
          },
          set: function (translations) {
              if (this.isolate) {
                  this._currentLang = translations;
              }
              else {
                  this.store.translations = translations;
              }
          },
          enumerable: true,
          configurable: true
      });
      /**
       * Sets the default language to use as a fallback
       * @param lang
       */
      TranslateService.prototype.setDefaultLang = function (lang) {
          var _this = this;
          if (lang === this.defaultLang) {
              return;
          }
          var pending = this.retrieveTranslations(lang);
          if (typeof pending !== "undefined") {
              // on init set the defaultLang immediately
              if (!this.defaultLang) {
                  this.defaultLang = lang;
              }
              pending.take(1)
                  .subscribe(function (res) {
                  _this.changeDefaultLang(lang);
              });
          }
          else {
              this.changeDefaultLang(lang);
          }
      };
      /**
       * Gets the default language used
       * @returns string
       */
      TranslateService.prototype.getDefaultLang = function () {
          return this.defaultLang;
      };
      /**
       * Changes the lang currently used
       * @param lang
       * @returns {Observable<*>}
       */
      TranslateService.prototype.use = function (lang) {
          var _this = this;
          // don't change the language if the language given is already selected
          if (lang === this.currentLang) {
              return __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__["Observable"].of(this.translations[lang]);
          }
          var pending = this.retrieveTranslations(lang);
          if (typeof pending !== "undefined") {
              // on init set the currentLang immediately
              if (!this.currentLang) {
                  this.currentLang = lang;
              }
              pending.take(1)
                  .subscribe(function (res) {
                  _this.changeLang(lang);
              });
              return pending;
          }
          else {
              this.changeLang(lang);
              return __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__["Observable"].of(this.translations[lang]);
          }
      };
      /**
       * Retrieves the given translations
       * @param lang
       * @returns {Observable<*>}
       */
      TranslateService.prototype.retrieveTranslations = function (lang) {
          var pending;
          // if this language is unavailable, ask for it
          if (typeof this.translations[lang] === "undefined") {
              this._translationRequests[lang] = this._translationRequests[lang] || this.getTranslation(lang);
              pending = this._translationRequests[lang];
          }
          return pending;
      };
      /**
       * Gets an object of translations for a given language with the current loader
       * and passes it through the compiler
       * @param lang
       * @returns {Observable<*>}
       */
      TranslateService.prototype.getTranslation = function (lang) {
          var _this = this;
          this.pending = true;
          this.loadingTranslations = this.currentLoader.getTranslation(lang).share();
          this.loadingTranslations.take(1)
              .subscribe(function (res) {
              _this.translations[lang] = _this.compiler.compileTranslations(res, lang);
              _this.updateLangs();
              _this.pending = false;
          }, function (err) {
              _this.pending = false;
          });
          return this.loadingTranslations;
      };
      /**
       * Manually sets an object of translations for a given language
       * after passing it through the compiler
       * @param lang
       * @param translations
       * @param shouldMerge
       */
      TranslateService.prototype.setTranslation = function (lang, translations, shouldMerge) {
          if (shouldMerge === void 0) { shouldMerge = false; }
          translations = this.compiler.compileTranslations(translations, lang);
          if (shouldMerge && this.translations[lang]) {
              this.translations[lang] = Object(__WEBPACK_IMPORTED_MODULE_15__util__["c" /* mergeDeep */])(this.translations[lang], translations);
          }
          else {
              this.translations[lang] = translations;
          }
          this.updateLangs();
          this.onTranslationChange.emit({ lang: lang, translations: this.translations[lang] });
      };
      /**
       * Returns an array of currently available langs
       * @returns {any}
       */
      TranslateService.prototype.getLangs = function () {
          return this.langs;
      };
      /**
       * @param langs
       * Add available langs
       */
      TranslateService.prototype.addLangs = function (langs) {
          var _this = this;
          langs.forEach(function (lang) {
              if (_this.langs.indexOf(lang) === -1) {
                  _this.langs.push(lang);
              }
          });
      };
      /**
       * Update the list of available langs
       */
      TranslateService.prototype.updateLangs = function () {
          this.addLangs(Object.keys(this.translations));
      };
      /**
       * Returns the parsed result of the translations
       * @param translations
       * @param key
       * @param interpolateParams
       * @returns {any}
       */
      TranslateService.prototype.getParsedResult = function (translations, key, interpolateParams) {
          var res;
          if (key instanceof Array) {
              var result = {}, observables = false;
              for (var _i = 0, key_1 = key; _i < key_1.length; _i++) {
                  var k = key_1[_i];
                  result[k] = this.getParsedResult(translations, k, interpolateParams);
                  if (typeof result[k].subscribe === "function") {
                      observables = true;
                  }
              }
              if (observables) {
                  var mergedObs = void 0;
                  for (var _a = 0, key_2 = key; _a < key_2.length; _a++) {
                      var k = key_2[_a];
                      var obs = typeof result[k].subscribe === "function" ? result[k] : __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__["Observable"].of(result[k]);
                      if (typeof mergedObs === "undefined") {
                          mergedObs = obs;
                      }
                      else {
                          mergedObs = mergedObs.merge(obs);
                      }
                  }
                  return mergedObs.toArray().map(function (arr) {
                      var obj = {};
                      arr.forEach(function (value, index) {
                          obj[key[index]] = value;
                      });
                      return obj;
                  });
              }
              return result;
          }
          if (translations) {
              res = this.parser.interpolate(this.parser.getValue(translations, key), interpolateParams);
          }
          if (typeof res === "undefined" && this.defaultLang && this.defaultLang !== this.currentLang && this.useDefaultLang) {
              res = this.parser.interpolate(this.parser.getValue(this.translations[this.defaultLang], key), interpolateParams);
          }
          if (typeof res === "undefined") {
              var params = { key: key, translateService: this };
              if (typeof interpolateParams !== 'undefined') {
                  params.interpolateParams = interpolateParams;
              }
              res = this.missingTranslationHandler.handle(params);
          }
          return typeof res !== "undefined" ? res : key;
      };
      /**
       * Gets the translated value of a key (or an array of keys)
       * @param key
       * @param interpolateParams
       * @returns {any} the translated key, or an object of translated keys
       */
      TranslateService.prototype.get = function (key, interpolateParams) {
          var _this = this;
          if (!Object(__WEBPACK_IMPORTED_MODULE_15__util__["b" /* isDefined */])(key) || !key.length) {
              throw new Error("Parameter \"key\" required");
          }
          // check if we are loading a new translation to use
          if (this.pending) {
              return __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__["Observable"].create(function (observer) {
                  var onComplete = function (res) {
                      observer.next(res);
                      observer.complete();
                  };
                  var onError = function (err) {
                      observer.error(err);
                  };
                  _this.loadingTranslations.subscribe(function (res) {
                      res = _this.getParsedResult(res, key, interpolateParams);
                      if (typeof res.subscribe === "function") {
                          res.subscribe(onComplete, onError);
                      }
                      else {
                          onComplete(res);
                      }
                  }, onError);
              });
          }
          else {
              var res = this.getParsedResult(this.translations[this.currentLang], key, interpolateParams);
              if (typeof res.subscribe === "function") {
                  return res;
              }
              else {
                  return __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__["Observable"].of(res);
              }
          }
      };
      /**
       * Returns a stream of translated values of a key (or an array of keys) which updates
       * whenever the language changes.
       * @param key
       * @param interpolateParams
       * @returns {any} A stream of the translated key, or an object of translated keys
       */
      TranslateService.prototype.stream = function (key, interpolateParams) {
          var _this = this;
          if (!Object(__WEBPACK_IMPORTED_MODULE_15__util__["b" /* isDefined */])(key) || !key.length) {
              throw new Error("Parameter \"key\" required");
          }
          return this
              .get(key, interpolateParams)
              .concat(this.onLangChange.switchMap(function (event) {
              var res = _this.getParsedResult(event.translations, key, interpolateParams);
              if (typeof res.subscribe === "function") {
                  return res;
              }
              else {
                  return __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__["Observable"].of(res);
              }
          }));
      };
      /**
       * Returns a translation instantly from the internal state of loaded translation.
       * All rules regarding the current language, the preferred language of even fallback languages will be used except any promise handling.
       * @param key
       * @param interpolateParams
       * @returns {string}
       */
      TranslateService.prototype.instant = function (key, interpolateParams) {
          if (!Object(__WEBPACK_IMPORTED_MODULE_15__util__["b" /* isDefined */])(key) || !key.length) {
              throw new Error("Parameter \"key\" required");
          }
          var res = this.getParsedResult(this.translations[this.currentLang], key, interpolateParams);
          if (typeof res.subscribe !== "undefined") {
              if (key instanceof Array) {
                  var obj_1 = {};
                  key.forEach(function (value, index) {
                      obj_1[key[index]] = key[index];
                  });
                  return obj_1;
              }
              return key;
          }
          else {
              return res;
          }
      };
      /**
       * Sets the translated value of a key, after compiling it
       * @param key
       * @param value
       * @param lang
       */
      TranslateService.prototype.set = function (key, value, lang) {
          if (lang === void 0) { lang = this.currentLang; }
          this.translations[lang][key] = this.compiler.compile(value, lang);
          this.updateLangs();
          this.onTranslationChange.emit({ lang: lang, translations: this.translations[lang] });
      };
      /**
       * Changes the current lang
       * @param lang
       */
      TranslateService.prototype.changeLang = function (lang) {
          this.currentLang = lang;
          this.onLangChange.emit({ lang: lang, translations: this.translations[lang] });
          // if there is no default lang, use the one that we just set
          if (!this.defaultLang) {
              this.changeDefaultLang(lang);
          }
      };
      /**
       * Changes the default lang
       * @param lang
       */
      TranslateService.prototype.changeDefaultLang = function (lang) {
          this.defaultLang = lang;
          this.onDefaultLangChange.emit({ lang: lang, translations: this.translations[lang] });
      };
      /**
       * Allows to reload the lang file from the file
       * @param lang
       * @returns {Observable<any>}
       */
      TranslateService.prototype.reloadLang = function (lang) {
          this.resetLang(lang);
          return this.getTranslation(lang);
      };
      /**
       * Deletes inner translation
       * @param lang
       */
      TranslateService.prototype.resetLang = function (lang) {
          this._translationRequests[lang] = undefined;
          this.translations[lang] = undefined;
      };
      /**
       * Returns the language code name from the browser, e.g. "de"
       *
       * @returns string
       */
      TranslateService.prototype.getBrowserLang = function () {
          if (typeof window === 'undefined' || typeof window.navigator === 'undefined') {
              return undefined;
          }
          var browserLang = window.navigator.languages ? window.navigator.languages[0] : null;
          browserLang = browserLang || window.navigator.language || window.navigator.browserLanguage || window.navigator.userLanguage;
          if (browserLang.indexOf('-') !== -1) {
              browserLang = browserLang.split('-')[0];
          }
          if (browserLang.indexOf('_') !== -1) {
              browserLang = browserLang.split('_')[0];
          }
          return browserLang;
      };
      /**
       * Returns the culture language code name from the browser, e.g. "de-DE"
       *
       * @returns string
       */
      TranslateService.prototype.getBrowserCultureLang = function () {
          if (typeof window === 'undefined' || typeof window.navigator === 'undefined') {
              return undefined;
          }
          var browserCultureLang = window.navigator.languages ? window.navigator.languages[0] : null;
          browserCultureLang = browserCultureLang || window.navigator.language || window.navigator.browserLanguage || window.navigator.userLanguage;
          return browserCultureLang;
      };
      return TranslateService;
  }());
  
  TranslateService.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["A" /* Injectable */] },
  ];
  /** @nocollapse */
  TranslateService.ctorParameters = function () { return [
      { type: __WEBPACK_IMPORTED_MODULE_10__translate_store__["a" /* TranslateStore */], },
      { type: __WEBPACK_IMPORTED_MODULE_11__translate_loader__["b" /* TranslateLoader */], },
      { type: __WEBPACK_IMPORTED_MODULE_12__translate_compiler__["a" /* TranslateCompiler */], },
      { type: __WEBPACK_IMPORTED_MODULE_14__translate_parser__["b" /* TranslateParser */], },
      { type: __WEBPACK_IMPORTED_MODULE_13__missing_translation_handler__["b" /* MissingTranslationHandler */], },
      { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["z" /* Inject */], args: [USE_DEFAULT_LANG,] },] },
      { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["z" /* Inject */], args: [USE_STORE,] },] },
  ]; };
  
  
  /***/ }),
  
  /***/ 322:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (immutable) */ __webpack_exports__["a"] = equals;
  /* harmony export (immutable) */ __webpack_exports__["b"] = isDefined;
  /* unused harmony export isObject */
  /* harmony export (immutable) */ __webpack_exports__["c"] = mergeDeep;
  /* tslint:disable */
  /**
   * @name equals
   *
   * @description
   * Determines if two objects or two values are equivalent.
   *
   * Two objects or values are considered equivalent if at least one of the following is true:
   *
   * * Both objects or values pass `===` comparison.
   * * Both objects or values are of the same type and all of their properties are equal by
   *   comparing them with `equals`.
   *
   * @param {*} o1 Object or value to compare.
   * @param {*} o2 Object or value to compare.
   * @returns {boolean} True if arguments are equal.
   */
  /* tslint:disable */ function equals(o1, o2) {
      if (o1 === o2)
          return true;
      if (o1 === null || o2 === null)
          return false;
      if (o1 !== o1 && o2 !== o2)
          return true; // NaN === NaN
      var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
      if (t1 == t2 && t1 == 'object') {
          if (Array.isArray(o1)) {
              if (!Array.isArray(o2))
                  return false;
              if ((length = o1.length) == o2.length) {
                  for (key = 0; key < length; key++) {
                      if (!equals(o1[key], o2[key]))
                          return false;
                  }
                  return true;
              }
          }
          else {
              if (Array.isArray(o2)) {
                  return false;
              }
              keySet = Object.create(null);
              for (key in o1) {
                  if (!equals(o1[key], o2[key])) {
                      return false;
                  }
                  keySet[key] = true;
              }
              for (key in o2) {
                  if (!(key in keySet) && typeof o2[key] !== 'undefined') {
                      return false;
                  }
              }
              return true;
          }
      }
      return false;
  }
  /* tslint:enable */
  function isDefined(value) {
      return typeof value !== 'undefined' && value !== null;
  }
  function isObject(item) {
      return (item && typeof item === 'object' && !Array.isArray(item));
  }
  function mergeDeep(target, source) {
      target = JSON.parse(JSON.stringify(target));
      source = JSON.parse(JSON.stringify(source));
      var output = Object.assign({}, target);
      if (isObject(target) && isObject(source)) {
          Object.keys(source).forEach(function (key) {
              if (isObject(source[key])) {
                  if (!(key in target)) {
                      Object.assign(output, (_a = {}, _a[key] = source[key], _a));
                  }
                  else {
                      output[key] = mergeDeep(target[key], source[key]);
                  }
              }
              else {
                  Object.assign(output, (_b = {}, _b[key] = source[key], _b));
              }
              var _a, _b;
          });
      }
      return output;
  }
  
  
  /***/ }),
  
  /***/ 323:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return TranslateLoader; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslateFakeLoader; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_rxjs_Observable__ = __webpack_require__(7);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_rxjs_Observable___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_rxjs_Observable__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_core__ = __webpack_require__(0);
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  var TranslateLoader = (function () {
      function TranslateLoader() {
      }
      return TranslateLoader;
  }());
  
  /**
   * This loader is just a placeholder that does nothing, in case you don't need a loader at all
   */
  var TranslateFakeLoader = (function (_super) {
      __extends(TranslateFakeLoader, _super);
      function TranslateFakeLoader() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      TranslateFakeLoader.prototype.getTranslation = function (lang) {
          return __WEBPACK_IMPORTED_MODULE_0_rxjs_Observable__["Observable"].of({});
      };
      return TranslateFakeLoader;
  }(TranslateLoader));
  
  TranslateFakeLoader.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["A" /* Injectable */] },
  ];
  /** @nocollapse */
  TranslateFakeLoader.ctorParameters = function () { return []; };
  
  
  /***/ }),
  
  /***/ 324:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var isScheduler_1 = __webpack_require__(118);
  var of_1 = __webpack_require__(219);
  var from_1 = __webpack_require__(337);
  var concatAll_1 = __webpack_require__(343);
  /* tslint:enable:max-line-length */
  /**
   * Creates an output Observable which sequentially emits all values from given
   * Observable and then moves on to the next.
   *
   * <span class="informal">Concatenates multiple Observables together by
   * sequentially emitting their values, one Observable after the other.</span>
   *
   * <img src="./img/concat.png" width="100%">
   *
   * `concat` joins multiple Observables together, by subscribing to them one at a time and
   * merging their results into the output Observable. You can pass either an array of
   * Observables, or put them directly as arguments. Passing an empty array will result
   * in Observable that completes immediately.
   *
   * `concat` will subscribe to first input Observable and emit all its values, without
   * changing or affecting them in any way. When that Observable completes, it will
   * subscribe to then next Observable passed and, again, emit its values. This will be
   * repeated, until the operator runs out of Observables. When last input Observable completes,
   * `concat` will complete as well. At any given moment only one Observable passed to operator
   * emits values. If you would like to emit values from passed Observables concurrently, check out
   * {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact,
   * `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`.
   *
   * Note that if some input Observable never completes, `concat` will also never complete
   * and Observables following the one that did not complete will never be subscribed. On the other
   * hand, if some Observable simply completes immediately after it is subscribed, it will be
   * invisible for `concat`, which will just move on to the next Observable.
   *
   * If any Observable in chain errors, instead of passing control to the next Observable,
   * `concat` will error immediately as well. Observables that would be subscribed after
   * the one that emitted error, never will.
   *
   * If you pass to `concat` the same Observable many times, its stream of values
   * will be "replayed" on every subscription, which means you can repeat given Observable
   * as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious,
   * you can always use {@link repeat}.
   *
   * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>
   * var timer = Rx.Observable.interval(1000).take(4);
   * var sequence = Rx.Observable.range(1, 10);
   * var result = Rx.Observable.concat(timer, sequence);
   * result.subscribe(x => console.log(x));
   *
   * // results in:
   * // 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10
   *
   *
   * @example <caption>Concatenate an array of 3 Observables</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var result = Rx.Observable.concat([timer1, timer2, timer3]); // note that array is passed
   * result.subscribe(x => console.log(x));
   *
   * // results in the following:
   * // (Prints to console sequentially)
   * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9
   * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5
   * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9
   *
   *
   * @example <caption>Concatenate the same Observable to repeat it</caption>
   * const timer = Rx.Observable.interval(1000).take(2);
   *
   * Rx.Observable.concat(timer, timer) // concating the same Observable!
   * .subscribe(
   *   value => console.log(value),
   *   err => {},
   *   () => console.log('...and it is done!')
   * );
   *
   * // Logs:
   * // 0 after 1s
   * // 1 after 2s
   * // 0 after 3s
   * // 1 after 4s
   * // "...and it is done!" also after 4s
   *
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   *
   * @param {ObservableInput} input1 An input Observable to concatenate with others.
   * @param {ObservableInput} input2 An input Observable to concatenate with others.
   * More than one input Observables may be given as argument.
   * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each
   * Observable subscription on.
   * @return {Observable} All values of each passed Observable merged into a
   * single Observable, in order, in serial fashion.
   * @static true
   * @name concat
   * @owner Observable
   */
  function concat() {
      var observables = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          observables[_i - 0] = arguments[_i];
      }
      if (observables.length === 1 || (observables.length === 2 && isScheduler_1.isScheduler(observables[1]))) {
          return from_1.from(observables[0]);
      }
      return concatAll_1.concatAll()(of_1.of.apply(void 0, observables));
  }
  exports.concat = concat;
  //# sourceMappingURL=concat.js.map
  
  /***/ }),
  
  /***/ 325:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslateCompiler; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return TranslateFakeCompiler; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  var TranslateCompiler = (function () {
      function TranslateCompiler() {
      }
      return TranslateCompiler;
  }());
  
  /**
   * This compiler is just a placeholder that does nothing, in case you don't need a compiler at all
   */
  var TranslateFakeCompiler = (function (_super) {
      __extends(TranslateFakeCompiler, _super);
      function TranslateFakeCompiler() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      TranslateFakeCompiler.prototype.compile = function (value, lang) {
          return value;
      };
      TranslateFakeCompiler.prototype.compileTranslations = function (translations, lang) {
          return translations;
      };
      return TranslateFakeCompiler;
  }(TranslateCompiler));
  
  TranslateFakeCompiler.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["A" /* Injectable */] },
  ];
  /** @nocollapse */
  TranslateFakeCompiler.ctorParameters = function () { return []; };
  
  
  /***/ }),
  
  /***/ 326:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return MissingTranslationHandler; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return FakeMissingTranslationHandler; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  
  var MissingTranslationHandler = (function () {
      function MissingTranslationHandler() {
      }
      return MissingTranslationHandler;
  }());
  
  /**
   * This handler is just a placeholder that does nothing, in case you don't need a missing translation handler at all
   */
  var FakeMissingTranslationHandler = (function () {
      function FakeMissingTranslationHandler() {
      }
      FakeMissingTranslationHandler.prototype.handle = function (params) {
          return params.key;
      };
      return FakeMissingTranslationHandler;
  }());
  
  FakeMissingTranslationHandler.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["A" /* Injectable */] },
  ];
  /** @nocollapse */
  FakeMissingTranslationHandler.ctorParameters = function () { return []; };
  
  
  /***/ }),
  
  /***/ 327:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return TranslateParser; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslateDefaultParser; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util__ = __webpack_require__(322);
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  
  
  var TranslateParser = (function () {
      function TranslateParser() {
      }
      return TranslateParser;
  }());
  
  var TranslateDefaultParser = (function (_super) {
      __extends(TranslateDefaultParser, _super);
      function TranslateDefaultParser() {
          var _this = _super !== null && _super.apply(this, arguments) || this;
          _this.templateMatcher = /{{\s?([^{}\s]*)\s?}}/g;
          return _this;
      }
      TranslateDefaultParser.prototype.interpolate = function (expr, params) {
          var result;
          if (typeof expr === 'string') {
              result = this.interpolateString(expr, params);
          }
          else if (typeof expr === 'function') {
              result = this.interpolateFunction(expr, params);
          }
          else {
              // this should not happen, but an unrelated TranslateService test depends on it
              result = expr;
          }
          return result;
      };
      TranslateDefaultParser.prototype.getValue = function (target, key) {
          var keys = key.split('.');
          key = '';
          do {
              key += keys.shift();
              if (Object(__WEBPACK_IMPORTED_MODULE_1__util__["b" /* isDefined */])(target) && Object(__WEBPACK_IMPORTED_MODULE_1__util__["b" /* isDefined */])(target[key]) && (typeof target[key] === 'object' || !keys.length)) {
                  target = target[key];
                  key = '';
              }
              else if (!keys.length) {
                  target = undefined;
              }
              else {
                  key += '.';
              }
          } while (keys.length);
          return target;
      };
      TranslateDefaultParser.prototype.interpolateFunction = function (fn, params) {
          return fn(params);
      };
      TranslateDefaultParser.prototype.interpolateString = function (expr, params) {
          var _this = this;
          if (!params) {
              return expr;
          }
          return expr.replace(this.templateMatcher, function (substring, b) {
              var r = _this.getValue(params, b);
              return Object(__WEBPACK_IMPORTED_MODULE_1__util__["b" /* isDefined */])(r) ? r : substring;
          });
      };
      return TranslateDefaultParser;
  }(TranslateParser));
  
  TranslateDefaultParser.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["A" /* Injectable */] },
  ];
  /** @nocollapse */
  TranslateDefaultParser.ctorParameters = function () { return []; };
  
  
  /***/ }),
  
  /***/ 328:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 __());
  };
  /**
   * An error thrown when an element was queried at a certain index of an
   * Observable, but no such index or position exists in that sequence.
   *
   * @see {@link elementAt}
   * @see {@link take}
   * @see {@link takeLast}
   *
   * @class ArgumentOutOfRangeError
   */
  var ArgumentOutOfRangeError = (function (_super) {
      __extends(ArgumentOutOfRangeError, _super);
      function ArgumentOutOfRangeError() {
          var err = _super.call(this, 'argument out of range');
          this.name = err.name = 'ArgumentOutOfRangeError';
          this.stack = err.stack;
          this.message = err.message;
      }
      return ArgumentOutOfRangeError;
  }(Error));
  exports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;
  //# sourceMappingURL=ArgumentOutOfRangeError.js.map
  
  /***/ }),
  
  /***/ 329:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslateStore; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  
  var TranslateStore = (function () {
      function TranslateStore() {
          /**
           * The lang currently used
           * @type {string}
           */
          this.currentLang = this.defaultLang;
          /**
           * a list of translations per lang
           * @type {{}}
           */
          this.translations = {};
          /**
           * an array of langs
           * @type {Array}
           */
          this.langs = [];
          /**
           * An EventEmitter to listen to translation change events
           * onTranslationChange.subscribe((params: TranslationChangeEvent) => {
           *     // do something
           * });
           * @type {EventEmitter<TranslationChangeEvent>}
           */
          this.onTranslationChange = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["v" /* EventEmitter */]();
          /**
           * An EventEmitter to listen to lang change events
           * onLangChange.subscribe((params: LangChangeEvent) => {
           *     // do something
           * });
           * @type {EventEmitter<LangChangeEvent>}
           */
          this.onLangChange = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["v" /* EventEmitter */]();
          /**
           * An EventEmitter to listen to default lang change events
           * onDefaultLangChange.subscribe((params: DefaultLangChangeEvent) => {
           *     // do something
           * });
           * @type {EventEmitter<DefaultLangChangeEvent>}
           */
          this.onDefaultLangChange = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["v" /* EventEmitter */]();
      }
      return TranslateStore;
  }());
  
  
  
  /***/ }),
  
  /***/ 330:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslateDirective; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util__ = __webpack_require__(322);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__translate_service__ = __webpack_require__(321);
  
  
  
  var TranslateDirective = (function () {
      function TranslateDirective(translateService, element, _ref) {
          var _this = this;
          this.translateService = translateService;
          this.element = element;
          this._ref = _ref;
          // subscribe to onTranslationChange event, in case the translations of the current lang change
          if (!this.onTranslationChangeSub) {
              this.onTranslationChangeSub = this.translateService.onTranslationChange.subscribe(function (event) {
                  if (event.lang === _this.translateService.currentLang) {
                      _this.checkNodes(true, event.translations);
                  }
              });
          }
          // subscribe to onLangChange event, in case the language changes
          if (!this.onLangChangeSub) {
              this.onLangChangeSub = this.translateService.onLangChange.subscribe(function (event) {
                  _this.checkNodes(true, event.translations);
              });
          }
          // subscribe to onDefaultLangChange event, in case the default language changes
          if (!this.onDefaultLangChangeSub) {
              this.onDefaultLangChangeSub = this.translateService.onDefaultLangChange.subscribe(function (event) {
                  _this.checkNodes(true);
              });
          }
      }
      Object.defineProperty(TranslateDirective.prototype, "translate", {
          set: function (key) {
              if (key) {
                  this.key = key;
                  this.checkNodes();
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(TranslateDirective.prototype, "translateParams", {
          set: function (params) {
              if (!Object(__WEBPACK_IMPORTED_MODULE_1__util__["a" /* equals */])(this.currentParams, params)) {
                  this.currentParams = params;
                  this.checkNodes(true);
              }
          },
          enumerable: true,
          configurable: true
      });
      TranslateDirective.prototype.ngAfterViewChecked = function () {
          this.checkNodes();
      };
      TranslateDirective.prototype.checkNodes = function (forceUpdate, translations) {
          if (forceUpdate === void 0) { forceUpdate = false; }
          var nodes = this.element.nativeElement.childNodes;
          // if the element is empty
          if (!nodes.length) {
              // we add the key as content
              this.setContent(this.element.nativeElement, this.key);
              nodes = this.element.nativeElement.childNodes;
          }
          for (var i = 0; i < nodes.length; ++i) {
              var node = nodes[i];
              if (node.nodeType === 3) {
                  var key = void 0;
                  if (this.key) {
                      key = this.key;
                      if (forceUpdate) {
                          node.lastKey = null;
                      }
                  }
                  else {
                      var content = this.getContent(node).trim();
                      if (content.length) {
                          // we want to use the content as a key, not the translation value
                          if (content !== node.currentValue) {
                              key = content;
                              // the content was changed from the user, we'll use it as a reference if needed
                              node.originalContent = this.getContent(node);
                          }
                          else if (node.originalContent && forceUpdate) {
                              node.lastKey = null;
                              // the current content is the translation, not the key, use the last real content as key
                              key = node.originalContent.trim();
                          }
                      }
                  }
                  this.updateValue(key, node, translations);
              }
          }
      };
      TranslateDirective.prototype.updateValue = function (key, node, translations) {
          var _this = this;
          if (key) {
              if (node.lastKey === key && this.lastParams === this.currentParams) {
                  return;
              }
              this.lastParams = this.currentParams;
              var onTranslation = function (res) {
                  if (res !== key) {
                      node.lastKey = key;
                  }
                  if (!node.originalContent) {
                      node.originalContent = _this.getContent(node);
                  }
                  node.currentValue = Object(__WEBPACK_IMPORTED_MODULE_1__util__["b" /* isDefined */])(res) ? res : (node.originalContent || key);
                  // we replace in the original content to preserve spaces that we might have trimmed
                  _this.setContent(node, _this.key ? node.currentValue : node.originalContent.replace(key, node.currentValue));
                  _this._ref.markForCheck();
              };
              if (Object(__WEBPACK_IMPORTED_MODULE_1__util__["b" /* isDefined */])(translations)) {
                  var res = this.translateService.getParsedResult(translations, key, this.currentParams);
                  if (typeof res.subscribe === "function") {
                      res.subscribe(onTranslation);
                  }
                  else {
                      onTranslation(res);
                  }
              }
              else {
                  this.translateService.get(key, this.currentParams).subscribe(onTranslation);
              }
          }
      };
      TranslateDirective.prototype.getContent = function (node) {
          return Object(__WEBPACK_IMPORTED_MODULE_1__util__["b" /* isDefined */])(node.textContent) ? node.textContent : node.data;
      };
      TranslateDirective.prototype.setContent = function (node, content) {
          if (Object(__WEBPACK_IMPORTED_MODULE_1__util__["b" /* isDefined */])(node.textContent)) {
              node.textContent = content;
          }
          else {
              node.data = content;
          }
      };
      TranslateDirective.prototype.ngOnDestroy = function () {
          if (this.onLangChangeSub) {
              this.onLangChangeSub.unsubscribe();
          }
          if (this.onDefaultLangChangeSub) {
              this.onDefaultLangChangeSub.unsubscribe();
          }
          if (this.onTranslationChangeSub) {
              this.onTranslationChangeSub.unsubscribe();
          }
      };
      return TranslateDirective;
  }());
  
  TranslateDirective.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["s" /* Directive */], args: [{
                  selector: '[translate],[ngx-translate]'
              },] },
  ];
  /** @nocollapse */
  TranslateDirective.ctorParameters = function () { return [
      { type: __WEBPACK_IMPORTED_MODULE_2__translate_service__["a" /* TranslateService */], },
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["t" /* ElementRef */], },
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["j" /* ChangeDetectorRef */], },
  ]; };
  TranslateDirective.propDecorators = {
      'translate': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["D" /* Input */] },],
      'translateParams': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["D" /* Input */] },],
  };
  
  
  /***/ }),
  
  /***/ 331:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslatePipe; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__translate_service__ = __webpack_require__(321);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__util__ = __webpack_require__(322);
  
  
  
  var TranslatePipe = (function () {
      function TranslatePipe(translate, _ref) {
          this.translate = translate;
          this._ref = _ref;
          this.value = '';
      }
      TranslatePipe.prototype.updateValue = function (key, interpolateParams, translations) {
          var _this = this;
          var onTranslation = function (res) {
              _this.value = res !== undefined ? res : key;
              _this.lastKey = key;
              _this._ref.markForCheck();
          };
          if (translations) {
              var res = this.translate.getParsedResult(translations, key, interpolateParams);
              if (typeof res.subscribe === 'function') {
                  res.subscribe(onTranslation);
              }
              else {
                  onTranslation(res);
              }
          }
          this.translate.get(key, interpolateParams).subscribe(onTranslation);
      };
      TranslatePipe.prototype.transform = function (query) {
          var _this = this;
          var args = [];
          for (var _i = 1; _i < arguments.length; _i++) {
              args[_i - 1] = arguments[_i];
          }
          if (!query || query.length === 0) {
              return query;
          }
          // if we ask another time for the same key, return the last value
          if (Object(__WEBPACK_IMPORTED_MODULE_2__util__["a" /* equals */])(query, this.lastKey) && Object(__WEBPACK_IMPORTED_MODULE_2__util__["a" /* equals */])(args, this.lastParams)) {
              return this.value;
          }
          var interpolateParams;
          if (Object(__WEBPACK_IMPORTED_MODULE_2__util__["b" /* isDefined */])(args[0]) && args.length) {
              if (typeof args[0] === 'string' && args[0].length) {
                  // we accept objects written in the template such as {n:1}, {'n':1}, {n:'v'}
                  // which is why we might need to change it to real JSON objects such as {"n":1} or {"n":"v"}
                  var validArgs = args[0]
                      .replace(/(\')?([a-zA-Z0-9_]+)(\')?(\s)?:/g, '"$2":')
                      .replace(/:(\s)?(\')(.*?)(\')/g, ':"$3"');
                  try {
                      interpolateParams = JSON.parse(validArgs);
                  }
                  catch (e) {
                      throw new SyntaxError("Wrong parameter in TranslatePipe. Expected a valid Object, received: " + args[0]);
                  }
              }
              else if (typeof args[0] === 'object' && !Array.isArray(args[0])) {
                  interpolateParams = args[0];
              }
          }
          // store the query, in case it changes
          this.lastKey = query;
          // store the params, in case they change
          this.lastParams = args;
          // set the value
          this.updateValue(query, interpolateParams);
          // if there is a subscription to onLangChange, clean it
          this._dispose();
          // subscribe to onTranslationChange event, in case the translations change
          if (!this.onTranslationChange) {
              this.onTranslationChange = this.translate.onTranslationChange.subscribe(function (event) {
                  if (_this.lastKey && event.lang === _this.translate.currentLang) {
                      _this.lastKey = null;
                      _this.updateValue(query, interpolateParams, event.translations);
                  }
              });
          }
          // subscribe to onLangChange event, in case the language changes
          if (!this.onLangChange) {
              this.onLangChange = this.translate.onLangChange.subscribe(function (event) {
                  if (_this.lastKey) {
                      _this.lastKey = null; // we want to make sure it doesn't return the same value until it's been updated
                      _this.updateValue(query, interpolateParams, event.translations);
                  }
              });
          }
          // subscribe to onDefaultLangChange event, in case the default language changes
          if (!this.onDefaultLangChange) {
              this.onDefaultLangChange = this.translate.onDefaultLangChange.subscribe(function () {
                  if (_this.lastKey) {
                      _this.lastKey = null; // we want to make sure it doesn't return the same value until it's been updated
                      _this.updateValue(query, interpolateParams);
                  }
              });
          }
          return this.value;
      };
      /**
       * Clean any existing subscription to change events
       * @private
       */
      TranslatePipe.prototype._dispose = function () {
          if (typeof this.onTranslationChange !== 'undefined') {
              this.onTranslationChange.unsubscribe();
              this.onTranslationChange = undefined;
          }
          if (typeof this.onLangChange !== 'undefined') {
              this.onLangChange.unsubscribe();
              this.onLangChange = undefined;
          }
          if (typeof this.onDefaultLangChange !== 'undefined') {
              this.onDefaultLangChange.unsubscribe();
              this.onDefaultLangChange = undefined;
          }
      };
      TranslatePipe.prototype.ngOnDestroy = function () {
          this._dispose();
      };
      return TranslatePipe;
  }());
  
  TranslatePipe.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["A" /* Injectable */] },
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["S" /* Pipe */], args: [{
                  name: 'translate',
                  pure: false // required to update the value when the promise is resolved
              },] },
  ];
  /** @nocollapse */
  TranslatePipe.ctorParameters = function () { return [
      { type: __WEBPACK_IMPORTED_MODULE_1__translate_service__["a" /* TranslateService */], },
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["j" /* ChangeDetectorRef */], },
  ]; };
  
  
  /***/ }),
  
  /***/ 332:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TranslateModule; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__src_translate_loader__ = __webpack_require__(323);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__src_translate_service__ = __webpack_require__(321);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__src_missing_translation_handler__ = __webpack_require__(326);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__src_translate_parser__ = __webpack_require__(327);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__src_translate_compiler__ = __webpack_require__(325);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__src_translate_directive__ = __webpack_require__(330);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__src_translate_pipe__ = __webpack_require__(331);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__src_translate_store__ = __webpack_require__(329);
  /* unused harmony namespace reexport */
  /* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __WEBPACK_IMPORTED_MODULE_2__src_translate_service__["a"]; });
  /* unused harmony namespace reexport */
  /* unused harmony namespace reexport */
  /* unused harmony namespace reexport */
  /* unused harmony namespace reexport */
  /* unused harmony namespace reexport */
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  var TranslateModule = (function () {
      function TranslateModule() {
      }
      /**
       * Use this method in your root module to provide the TranslateService
       * @param {TranslateModuleConfig} config
       * @returns {ModuleWithProviders}
       */
      TranslateModule.forRoot = function (config) {
          if (config === void 0) { config = {}; }
          return {
              ngModule: TranslateModule,
              providers: [
                  config.loader || { provide: __WEBPACK_IMPORTED_MODULE_1__src_translate_loader__["b" /* TranslateLoader */], useClass: __WEBPACK_IMPORTED_MODULE_1__src_translate_loader__["a" /* TranslateFakeLoader */] },
                  config.compiler || { provide: __WEBPACK_IMPORTED_MODULE_5__src_translate_compiler__["a" /* TranslateCompiler */], useClass: __WEBPACK_IMPORTED_MODULE_5__src_translate_compiler__["b" /* TranslateFakeCompiler */] },
                  config.parser || { provide: __WEBPACK_IMPORTED_MODULE_4__src_translate_parser__["b" /* TranslateParser */], useClass: __WEBPACK_IMPORTED_MODULE_4__src_translate_parser__["a" /* TranslateDefaultParser */] },
                  config.missingTranslationHandler || { provide: __WEBPACK_IMPORTED_MODULE_3__src_missing_translation_handler__["b" /* MissingTranslationHandler */], useClass: __WEBPACK_IMPORTED_MODULE_3__src_missing_translation_handler__["a" /* FakeMissingTranslationHandler */] },
                  __WEBPACK_IMPORTED_MODULE_8__src_translate_store__["a" /* TranslateStore */],
                  { provide: __WEBPACK_IMPORTED_MODULE_2__src_translate_service__["c" /* USE_STORE */], useValue: config.isolate },
                  { provide: __WEBPACK_IMPORTED_MODULE_2__src_translate_service__["b" /* USE_DEFAULT_LANG */], useValue: config.useDefaultLang },
                  __WEBPACK_IMPORTED_MODULE_2__src_translate_service__["a" /* TranslateService */]
              ]
          };
      };
      /**
       * Use this method in your other (non root) modules to import the directive/pipe
       * @param {TranslateModuleConfig} config
       * @returns {ModuleWithProviders}
       */
      TranslateModule.forChild = function (config) {
          if (config === void 0) { config = {}; }
          return {
              ngModule: TranslateModule,
              providers: [
                  config.loader || { provide: __WEBPACK_IMPORTED_MODULE_1__src_translate_loader__["b" /* TranslateLoader */], useClass: __WEBPACK_IMPORTED_MODULE_1__src_translate_loader__["a" /* TranslateFakeLoader */] },
                  config.compiler || { provide: __WEBPACK_IMPORTED_MODULE_5__src_translate_compiler__["a" /* TranslateCompiler */], useClass: __WEBPACK_IMPORTED_MODULE_5__src_translate_compiler__["b" /* TranslateFakeCompiler */] },
                  config.parser || { provide: __WEBPACK_IMPORTED_MODULE_4__src_translate_parser__["b" /* TranslateParser */], useClass: __WEBPACK_IMPORTED_MODULE_4__src_translate_parser__["a" /* TranslateDefaultParser */] },
                  config.missingTranslationHandler || { provide: __WEBPACK_IMPORTED_MODULE_3__src_missing_translation_handler__["b" /* MissingTranslationHandler */], useClass: __WEBPACK_IMPORTED_MODULE_3__src_missing_translation_handler__["a" /* FakeMissingTranslationHandler */] },
                  { provide: __WEBPACK_IMPORTED_MODULE_2__src_translate_service__["c" /* USE_STORE */], useValue: config.isolate },
                  { provide: __WEBPACK_IMPORTED_MODULE_2__src_translate_service__["b" /* USE_DEFAULT_LANG */], useValue: config.useDefaultLang },
                  __WEBPACK_IMPORTED_MODULE_2__src_translate_service__["a" /* TranslateService */]
              ]
          };
      };
      return TranslateModule;
  }());
  
  TranslateModule.decorators = [
      { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["I" /* NgModule */], args: [{
                  declarations: [
                      __WEBPACK_IMPORTED_MODULE_7__src_translate_pipe__["a" /* TranslatePipe */],
                      __WEBPACK_IMPORTED_MODULE_6__src_translate_directive__["a" /* TranslateDirective */]
                  ],
                  exports: [
                      __WEBPACK_IMPORTED_MODULE_7__src_translate_pipe__["a" /* TranslatePipe */],
                      __WEBPACK_IMPORTED_MODULE_6__src_translate_directive__["a" /* TranslateDirective */]
                  ]
              },] },
  ];
  /** @nocollapse */
  TranslateModule.ctorParameters = function () { return []; };
  
  
  /***/ }),
  
  /***/ 333:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  var of_1 = __webpack_require__(219);
  Observable_1.Observable.of = of_1.of;
  //# sourceMappingURL=of.js.map
  
  /***/ }),
  
  /***/ 334:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  var concat_1 = __webpack_require__(335);
  Observable_1.Observable.prototype.concat = concat_1.concat;
  //# sourceMappingURL=concat.js.map
  
  /***/ }),
  
  /***/ 335:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concat_1 = __webpack_require__(336);
  var concat_2 = __webpack_require__(324);
  exports.concatStatic = concat_2.concat;
  /* tslint:enable:max-line-length */
  /**
   * Creates an output Observable which sequentially emits all values from every
   * given input Observable after the current Observable.
   *
   * <span class="informal">Concatenates multiple Observables together by
   * sequentially emitting their values, one Observable after the other.</span>
   *
   * <img src="./img/concat.png" width="100%">
   *
   * 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
   * output Observable. Will wait for each Observable to complete before moving
   * on to the next.
   *
   * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>
   * var timer = Rx.Observable.interval(1000).take(4);
   * var sequence = Rx.Observable.range(1, 10);
   * var result = timer.concat(sequence);
   * result.subscribe(x => console.log(x));
   *
   * // results in:
   * // 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10
   *
   * @example <caption>Concatenate 3 Observables</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var result = timer1.concat(timer2, timer3);
   * result.subscribe(x => console.log(x));
   *
   * // results in the following:
   * // (Prints to console sequentially)
   * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9
   * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5
   * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9
   *
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   *
   * @param {ObservableInput} other An input Observable to concatenate after the source
   * Observable. More than one input Observables may be given as argument.
   * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each
   * Observable subscription on.
   * @return {Observable} All values of each passed Observable merged into a
   * single Observable, in order, in serial fashion.
   * @method concat
   * @owner Observable
   */
  function concat() {
      var observables = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          observables[_i - 0] = arguments[_i];
      }
      return concat_1.concat.apply(void 0, observables)(this);
  }
  exports.concat = concat;
  //# sourceMappingURL=concat.js.map
  
  /***/ }),
  
  /***/ 336:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var concat_1 = __webpack_require__(324);
  var concat_2 = __webpack_require__(324);
  exports.concatStatic = concat_2.concat;
  /* tslint:enable:max-line-length */
  /**
   * Creates an output Observable which sequentially emits all values from every
   * given input Observable after the current Observable.
   *
   * <span class="informal">Concatenates multiple Observables together by
   * sequentially emitting their values, one Observable after the other.</span>
   *
   * <img src="./img/concat.png" width="100%">
   *
   * 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
   * output Observable. Will wait for each Observable to complete before moving
   * on to the next.
   *
   * @example <caption>Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10</caption>
   * var timer = Rx.Observable.interval(1000).take(4);
   * var sequence = Rx.Observable.range(1, 10);
   * var result = timer.concat(sequence);
   * result.subscribe(x => console.log(x));
   *
   * // results in:
   * // 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10
   *
   * @example <caption>Concatenate 3 Observables</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var result = timer1.concat(timer2, timer3);
   * result.subscribe(x => console.log(x));
   *
   * // results in the following:
   * // (Prints to console sequentially)
   * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9
   * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5
   * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9
   *
   * @see {@link concatAll}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   *
   * @param {ObservableInput} other An input Observable to concatenate after the source
   * Observable. More than one input Observables may be given as argument.
   * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each
   * Observable subscription on.
   * @return {Observable} All values of each passed Observable merged into a
   * single Observable, in order, in serial fashion.
   * @method concat
   * @owner Observable
   */
  function concat() {
      var observables = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          observables[_i - 0] = arguments[_i];
      }
      return function (source) { return source.lift.call(concat_1.concat.apply(void 0, [source].concat(observables))); };
  }
  exports.concat = concat;
  //# sourceMappingURL=concat.js.map
  
  /***/ }),
  
  /***/ 337:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var FromObservable_1 = __webpack_require__(338);
  exports.from = FromObservable_1.FromObservable.create;
  //# sourceMappingURL=from.js.map
  
  /***/ }),
  
  /***/ 338:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(115);
  var isArrayLike_1 = __webpack_require__(223);
  var isPromise_1 = __webpack_require__(224);
  var PromiseObservable_1 = __webpack_require__(226);
  var IteratorObservable_1 = __webpack_require__(339);
  var ArrayObservable_1 = __webpack_require__(117);
  var ArrayLikeObservable_1 = __webpack_require__(340);
  var iterator_1 = __webpack_require__(218);
  var Observable_1 = __webpack_require__(7);
  var observeOn_1 = __webpack_require__(341);
  var observable_1 = __webpack_require__(116);
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */
  var FromObservable = (function (_super) {
      __extends(FromObservable, _super);
      function FromObservable(ish, scheduler) {
          _super.call(this, null);
          this.ish = ish;
          this.scheduler = scheduler;
      }
      /**
       * Creates an Observable from an Array, an array-like object, a Promise, an
       * iterable object, or an Observable-like object.
       *
       * <span class="informal">Converts almost anything to an Observable.</span>
       *
       * <img src="./img/from.png" width="100%">
       *
       * Convert various other objects and data types into Observables. `from`
       * converts a Promise or an array-like or an
       * [iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)
       * object into an Observable that emits the items in that promise or array or
       * iterable. A String, in this context, is treated as an array of characters.
       * Observable-like objects (contains a function named with the ES2015 Symbol
       * for Observable) can also be converted through this operator.
       *
       * @example <caption>Converts an array to an Observable</caption>
       * var array = [10, 20, 30];
       * var result = Rx.Observable.from(array);
       * result.subscribe(x => console.log(x));
       *
       * // Results in the following:
       * // 10 20 30
       *
       * @example <caption>Convert an infinite iterable (from a generator) to an Observable</caption>
       * function* generateDoubles(seed) {
       *   var i = seed;
       *   while (true) {
       *     yield i;
       *     i = 2 * i; // double it
       *   }
       * }
       *
       * var iterator = generateDoubles(3);
       * var result = Rx.Observable.from(iterator).take(10);
       * result.subscribe(x => console.log(x));
       *
       * // Results in the following:
       * // 3 6 12 24 48 96 192 384 768 1536
       *
       * @see {@link create}
       * @see {@link fromEvent}
       * @see {@link fromEventPattern}
       * @see {@link fromPromise}
       *
       * @param {ObservableInput<T>} ish A subscribable object, a Promise, an
       * Observable-like, an Array, an iterable or an array-like object to be
       * converted.
       * @param {Scheduler} [scheduler] The scheduler on which to schedule the
       * emissions of values.
       * @return {Observable<T>} The Observable whose values are originally from the
       * input object that was converted.
       * @static true
       * @name from
       * @owner Observable
       */
      FromObservable.create = function (ish, scheduler) {
          if (ish != null) {
              if (typeof ish[observable_1.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[iterator_1.iterator] === 'function' || typeof ish === 'string') {
                  return new IteratorObservable_1.IteratorObservable(ish, scheduler);
              }
              else if (isArrayLike_1.isArrayLike(ish)) {
                  return new ArrayLikeObservable_1.ArrayLikeObservable(ish, scheduler);
              }
          }
          throw new TypeError((ish !== null && typeof ish || ish) + ' is not observable');
      };
      /** @deprecated internal use only */ FromObservable.prototype._subscribe = function (subscriber) {
          var ish = this.ish;
          var scheduler = this.scheduler;
          if (scheduler == null) {
              return ish[observable_1.observable]().subscribe(subscriber);
          }
          else {
              return ish[observable_1.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber, scheduler, 0));
          }
      };
      return FromObservable;
  }(Observable_1.Observable));
  exports.FromObservable = FromObservable;
  //# sourceMappingURL=FromObservable.js.map
  
  /***/ }),
  
  /***/ 339:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(32);
  var Observable_1 = __webpack_require__(7);
  var iterator_1 = __webpack_require__(218);
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */
  var IteratorObservable = (function (_super) {
      __extends(IteratorObservable, _super);
      function IteratorObservable(iterator, scheduler) {
          _super.call(this);
          this.scheduler = scheduler;
          if (iterator == null) {
              throw new Error('iterator cannot be null.');
          }
          this.iterator = getIterator(iterator);
      }
      IteratorObservable.create = function (iterator, scheduler) {
          return new IteratorObservable(iterator, scheduler);
      };
      IteratorObservable.dispatch = function (state) {
          var index = state.index, hasError = state.hasError, iterator = state.iterator, subscriber = state.subscriber;
          if (hasError) {
              subscriber.error(state.error);
              return;
          }
          var result = iterator.next();
          if (result.done) {
              subscriber.complete();
              return;
          }
          subscriber.next(result.value);
          state.index = index + 1;
          if (subscriber.closed) {
              if (typeof iterator.return === 'function') {
                  iterator.return();
              }
              return;
          }
          this.schedule(state);
      };
      /** @deprecated internal use only */ IteratorObservable.prototype._subscribe = function (subscriber) {
          var index = 0;
          var _a = this, iterator = _a.iterator, scheduler = _a.scheduler;
          if (scheduler) {
              return scheduler.schedule(IteratorObservable.dispatch, 0, {
                  index: index, iterator: iterator, subscriber: subscriber
              });
          }
          else {
              do {
                  var result = iterator.next();
                  if (result.done) {
                      subscriber.complete();
                      break;
                  }
                  else {
                      subscriber.next(result.value);
                  }
                  if (subscriber.closed) {
                      if (typeof iterator.return === 'function') {
                          iterator.return();
                      }
                      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[iterator_1.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[iterator_1.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[iterator_1.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[iterator_1.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;
  }
  //# sourceMappingURL=IteratorObservable.js.map
  
  /***/ }),
  
  /***/ 340:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(7);
  var ScalarObservable_1 = __webpack_require__(221);
  var EmptyObservable_1 = __webpack_require__(114);
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */
  var ArrayLikeObservable = (function (_super) {
      __extends(ArrayLikeObservable, _super);
      function ArrayLikeObservable(arrayLike, scheduler) {
          _super.call(this);
          this.arrayLike = arrayLike;
          this.scheduler = scheduler;
          if (!scheduler && arrayLike.length === 1) {
              this._isScalar = true;
              this.value = arrayLike[0];
          }
      }
      ArrayLikeObservable.create = function (arrayLike, scheduler) {
          var length = arrayLike.length;
          if (length === 0) {
              return new EmptyObservable_1.EmptyObservable();
          }
          else if (length === 1) {
              return new ScalarObservable_1.ScalarObservable(arrayLike[0], scheduler);
          }
          else {
              return new ArrayLikeObservable(arrayLike, scheduler);
          }
      };
      ArrayLikeObservable.dispatch = function (state) {
          var arrayLike = state.arrayLike, index = state.index, length = state.length, subscriber = state.subscriber;
          if (subscriber.closed) {
              return;
          }
          if (index >= length) {
              subscriber.complete();
              return;
          }
          subscriber.next(arrayLike[index]);
          state.index = index + 1;
          this.schedule(state);
      };
      /** @deprecated internal use only */ ArrayLikeObservable.prototype._subscribe = function (subscriber) {
          var index = 0;
          var _a = this, arrayLike = _a.arrayLike, scheduler = _a.scheduler;
          var length = arrayLike.length;
          if (scheduler) {
              return scheduler.schedule(ArrayLikeObservable.dispatch, 0, {
                  arrayLike: arrayLike, index: index, length: length, subscriber: subscriber
              });
          }
          else {
              for (var i = 0; i < length && !subscriber.closed; i++) {
                  subscriber.next(arrayLike[i]);
              }
              subscriber.complete();
          }
      };
      return ArrayLikeObservable;
  }(Observable_1.Observable));
  exports.ArrayLikeObservable = ArrayLikeObservable;
  //# sourceMappingURL=ArrayLikeObservable.js.map
  
  /***/ }),
  
  /***/ 341:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(20);
  var Notification_1 = __webpack_require__(342);
  /**
   *
   * Re-emits all notifications from source Observable with specified scheduler.
   *
   * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span>
   *
   * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule
   * notifications emitted by the source Observable. It might be useful, if you do not have control over
   * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.
   *
   * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,
   * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal
   * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits
   * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.
   * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split
   * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source
   * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a
   * little bit more, to ensure that they are emitted at expected moments.
   *
   * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications
   * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`
   * will delay all notifications - including error notifications - while `delay` will pass through error
   * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator
   * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used
   * for notification emissions in general.
   *
   * @example <caption>Ensure values in subscribe are called just before browser repaint.</caption>
   * const intervals = Rx.Observable.interval(10); // Intervals are scheduled
   *                                               // with async scheduler by default...
   *
   * intervals
   * .observeOn(Rx.Scheduler.animationFrame)       // ...but we will observe on animationFrame
   * .subscribe(val => {                           // scheduler to ensure smooth animation.
   *   someDiv.style.height = val + 'px';
   * });
   *
   * @see {@link delay}
   *
   * @param {IScheduler} scheduler Scheduler that will be used to reschedule notifications from source Observable.
   * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.
   * @return {Observable<T>} Observable that emits the same notifications as the source Observable,
   * but with provided scheduler.
   *
   * @method observeOn
   * @owner Observable
   */
  function observeOn(scheduler, delay) {
      if (delay === void 0) { delay = 0; }
      return function observeOnOperatorFunction(source) {
          return source.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, source) {
          return source.subscribe(new ObserveOnSubscriber(subscriber, this.scheduler, this.delay));
      };
      return ObserveOnOperator;
  }());
  exports.ObserveOnOperator = ObserveOnOperator;
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  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 (arg) {
          var notification = arg.notification, destination = arg.destination;
          notification.observe(destination);
          this.unsubscribe();
      };
      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;
  }());
  exports.ObserveOnMessage = ObserveOnMessage;
  //# sourceMappingURL=observeOn.js.map
  
  /***/ }),
  
  /***/ 342:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  /**
   * Represents a push-based event or value that an {@link Observable} can emit.
   * This class is particularly useful for operators that manage notifications,
   * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and
   * others. Besides wrapping the actual delivered value, it also annotates it
   * with metadata of, for instance, what type of push message it is (`next`,
   * `error`, or `complete`).
   *
   * @see {@link materialize}
   * @see {@link dematerialize}
   * @see {@link observeOn}
   *
   * @class Notification<T>
   */
  var Notification = (function () {
      function Notification(kind, value, error) {
          this.kind = kind;
          this.value = value;
          this.error = error;
          this.hasValue = kind === 'N';
      }
      /**
       * Delivers to the given `observer` the value wrapped by this Notification.
       * @param {Observer} observer
       * @return
       */
      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.error);
              case 'C':
                  return observer.complete && observer.complete();
          }
      };
      /**
       * Given some {@link Observer} callbacks, deliver the value represented by the
       * current Notification to the correctly corresponding callback.
       * @param {function(value: T): void} next An Observer `next` callback.
       * @param {function(err: any): void} [error] An Observer `error` callback.
       * @param {function(): void} [complete] An Observer `complete` callback.
       * @return {any}
       */
      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.error);
              case 'C':
                  return complete && complete();
          }
      };
      /**
       * Takes an Observer or its individual callback functions, and calls `observe`
       * or `do` methods accordingly.
       * @param {Observer|function(value: T): void} nextOrObserver An Observer or
       * the `next` callback.
       * @param {function(err: any): void} [error] An Observer `error` callback.
       * @param {function(): void} [complete] An Observer `complete` callback.
       * @return {any}
       */
      Notification.prototype.accept = function (nextOrObserver, error, complete) {
          if (nextOrObserver && typeof nextOrObserver.next === 'function') {
              return this.observe(nextOrObserver);
          }
          else {
              return this.do(nextOrObserver, error, complete);
          }
      };
      /**
       * Returns a simple Observable that just delivers the notification represented
       * by this Notification instance.
       * @return {any}
       */
      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.error);
              case 'C':
                  return Observable_1.Observable.empty();
          }
          throw new Error('unexpected notification kind value');
      };
      /**
       * A shortcut to create a Notification instance of the type `next` from a
       * given value.
       * @param {T} value The `next` value.
       * @return {Notification<T>} The "next" Notification representing the
       * argument.
       */
      Notification.createNext = function (value) {
          if (typeof value !== 'undefined') {
              return new Notification('N', value);
          }
          return Notification.undefinedValueNotification;
      };
      /**
       * A shortcut to create a Notification instance of the type `error` from a
       * given error.
       * @param {any} [err] The `error` error.
       * @return {Notification<T>} The "error" Notification representing the
       * argument.
       */
      Notification.createError = function (err) {
          return new Notification('E', undefined, err);
      };
      /**
       * A shortcut to create a Notification instance of the type `complete`.
       * @return {Notification<any>} The valueless "complete" Notification.
       */
      Notification.createComplete = function () {
          return Notification.completeNotification;
      };
      Notification.completeNotification = new Notification('C');
      Notification.undefinedValueNotification = new Notification('N', undefined);
      return Notification;
  }());
  exports.Notification = Notification;
  //# sourceMappingURL=Notification.js.map
  
  /***/ }),
  
  /***/ 343:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var mergeAll_1 = __webpack_require__(222);
  /**
   * Converts a higher-order Observable into a first-order Observable by
   * concatenating the inner Observables in order.
   *
   * <span class="informal">Flattens an Observable-of-Observables by putting one
   * inner Observable after the other.</span>
   *
   * <img src="./img/concatAll.png" width="100%">
   *
   * Joins every Observable emitted by the source (a higher-order Observable), in
   * a serial fashion. It subscribes to each inner Observable only after the
   * previous inner Observable has completed, and merges all of their values into
   * the returned observable.
   *
   * __Warning:__ If the source Observable emits Observables quickly and
   * endlessly, and the inner 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.
   *
   * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set
   * to `1`.
   *
   * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var higherOrder = clicks.map(ev => Rx.Observable.interval(1000).take(4));
   * var firstOrder = higherOrder.concatAll();
   * firstOrder.subscribe(x => console.log(x));
   *
   * // Results in the following:
   * // (results are not concurrent)
   * // For every click on the "document" it will emit values 0 to 3 spaced
   * // on a 1000ms interval
   * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
   *
   * @see {@link combineAll}
   * @see {@link concat}
   * @see {@link concatMap}
   * @see {@link concatMapTo}
   * @see {@link exhaust}
   * @see {@link mergeAll}
   * @see {@link switch}
   * @see {@link zipAll}
   *
   * @return {Observable} An Observable emitting values from all the inner
   * Observables concatenated.
   * @method concatAll
   * @owner Observable
   */
  function concatAll() {
      return mergeAll_1.mergeAll(1);
  }
  exports.concatAll = concatAll;
  //# sourceMappingURL=concatAll.js.map
  
  /***/ }),
  
  /***/ 344:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  var share_1 = __webpack_require__(225);
  Observable_1.Observable.prototype.share = share_1.share;
  //# sourceMappingURL=share.js.map
  
  /***/ }),
  
  /***/ 345:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  var merge_1 = __webpack_require__(346);
  Observable_1.Observable.prototype.merge = merge_1.merge;
  //# sourceMappingURL=merge.js.map
  
  /***/ }),
  
  /***/ 346:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var merge_1 = __webpack_require__(347);
  var merge_2 = __webpack_require__(217);
  exports.mergeStatic = merge_2.merge;
  /* tslint:enable:max-line-length */
  /**
   * Creates an output Observable which concurrently emits all values from every
   * given input Observable.
   *
   * <span class="informal">Flattens multiple Observables together by blending
   * their values into one Observable.</span>
   *
   * <img src="./img/merge.png" width="100%">
   *
   * `merge` subscribes to each given input Observable (either the source or an
   * Observable given as argument), and simply forwards (without doing any
   * transformation) all the values from all the input Observables to the output
   * Observable. The output Observable only completes once all input Observables
   * have completed. Any error delivered by an input Observable will be immediately
   * emitted on the output Observable.
   *
   * @example <caption>Merge together two Observables: 1s interval and clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var clicksOrTimer = clicks.merge(timer);
   * clicksOrTimer.subscribe(x => console.log(x));
   *
   * @example <caption>Merge together 3 Observables, but only 2 run concurrently</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var concurrent = 2; // the argument
   * var merged = timer1.merge(timer2, timer3, concurrent);
   * merged.subscribe(x => console.log(x));
   *
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   *
   * @param {ObservableInput} other An input Observable to merge with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for managing
   * concurrency of input Observables.
   * @return {Observable} An Observable that emits items that are the result of
   * every input Observable.
   * @method merge
   * @owner Observable
   */
  function merge() {
      var observables = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          observables[_i - 0] = arguments[_i];
      }
      return merge_1.merge.apply(void 0, observables)(this);
  }
  exports.merge = merge;
  //# sourceMappingURL=merge.js.map
  
  /***/ }),
  
  /***/ 347:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var merge_1 = __webpack_require__(217);
  var merge_2 = __webpack_require__(217);
  exports.mergeStatic = merge_2.merge;
  /* tslint:enable:max-line-length */
  /**
   * Creates an output Observable which concurrently emits all values from every
   * given input Observable.
   *
   * <span class="informal">Flattens multiple Observables together by blending
   * their values into one Observable.</span>
   *
   * <img src="./img/merge.png" width="100%">
   *
   * `merge` subscribes to each given input Observable (either the source or an
   * Observable given as argument), and simply forwards (without doing any
   * transformation) all the values from all the input Observables to the output
   * Observable. The output Observable only completes once all input Observables
   * have completed. Any error delivered by an input Observable will be immediately
   * emitted on the output Observable.
   *
   * @example <caption>Merge together two Observables: 1s interval and clicks</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var clicksOrTimer = clicks.merge(timer);
   * clicksOrTimer.subscribe(x => console.log(x));
   *
   * @example <caption>Merge together 3 Observables, but only 2 run concurrently</caption>
   * var timer1 = Rx.Observable.interval(1000).take(10);
   * var timer2 = Rx.Observable.interval(2000).take(6);
   * var timer3 = Rx.Observable.interval(500).take(10);
   * var concurrent = 2; // the argument
   * var merged = timer1.merge(timer2, timer3, concurrent);
   * merged.subscribe(x => console.log(x));
   *
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeMapTo}
   * @see {@link mergeScan}
   *
   * @param {ObservableInput} other An input Observable to merge with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @param {Scheduler} [scheduler=null] The IScheduler to use for managing
   * concurrency of input Observables.
   * @return {Observable} An Observable that emits items that are the result of
   * every input Observable.
   * @method merge
   * @owner Observable
   */
  function merge() {
      var observables = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          observables[_i - 0] = arguments[_i];
      }
      return function (source) { return source.lift.call(merge_1.merge.apply(void 0, [source].concat(observables))); };
  }
  exports.merge = merge;
  //# sourceMappingURL=merge.js.map
  
  /***/ }),
  
  /***/ 348:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  var switchMap_1 = __webpack_require__(349);
  Observable_1.Observable.prototype.switchMap = switchMap_1.switchMap;
  //# sourceMappingURL=switchMap.js.map
  
  /***/ }),
  
  /***/ 349:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var switchMap_1 = __webpack_require__(350);
  /* tslint:enable:max-line-length */
  /**
   * Projects each source value to an Observable which is merged in the output
   * Observable, emitting values only from the most recently projected Observable.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link switch}.</span>
   *
   * <img src="./img/switchMap.png" width="100%">
   *
   * 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 (so-called "inner") Observable. Each time it observes one of these
   * inner Observables, the output Observable begins emitting the items emitted by
   * that inner Observable. When a new inner Observable is emitted, `switchMap`
   * stops emitting items from the earlier-emitted inner Observable and begins
   * emitting items from the new one. It continues to behave like this for
   * subsequent inner Observables.
   *
   * @example <caption>Rerun an interval Observable on every click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.switchMap((ev) => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMap}
   * @see {@link exhaustMap}
   * @see {@link mergeMap}
   * @see {@link switch}
   * @see {@link switchMapTo}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. 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
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and taking only the values from the most recently
   * projected inner Observable.
   * @method switchMap
   * @owner Observable
   */
  function switchMap(project, resultSelector) {
      return switchMap_1.switchMap(project, resultSelector)(this);
  }
  exports.switchMap = switchMap;
  //# sourceMappingURL=switchMap.js.map
  
  /***/ }),
  
  /***/ 350:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(55);
  var subscribeToResult_1 = __webpack_require__(54);
  /* tslint:enable:max-line-length */
  /**
   * Projects each source value to an Observable which is merged in the output
   * Observable, emitting values only from the most recently projected Observable.
   *
   * <span class="informal">Maps each value to an Observable, then flattens all of
   * these inner Observables using {@link switch}.</span>
   *
   * <img src="./img/switchMap.png" width="100%">
   *
   * 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 (so-called "inner") Observable. Each time it observes one of these
   * inner Observables, the output Observable begins emitting the items emitted by
   * that inner Observable. When a new inner Observable is emitted, `switchMap`
   * stops emitting items from the earlier-emitted inner Observable and begins
   * emitting items from the new one. It continues to behave like this for
   * subsequent inner Observables.
   *
   * @example <caption>Rerun an interval Observable on every click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.switchMap((ev) => Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMap}
   * @see {@link exhaustMap}
   * @see {@link mergeMap}
   * @see {@link switch}
   * @see {@link switchMapTo}
   *
   * @param {function(value: T, ?index: number): ObservableInput} project A function
   * that, when applied to an item emitted by the source Observable, returns an
   * Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. 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
   * @return {Observable} An Observable that emits the result of applying the
   * projection function (and the optional `resultSelector`) to each item emitted
   * by the source Observable and taking only the values from the most recently
   * projected inner Observable.
   * @method switchMap
   * @owner Observable
   */
  function switchMap(project, resultSelector) {
      return function switchMapOperatorFunction(source) {
          return source.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, source) {
          return source.subscribe(new SwitchMapSubscriber(subscriber, this.project, this.resultSelector));
      };
      return SwitchMapOperator;
  }());
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  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.closed) {
              _super.prototype._complete.call(this);
          }
      };
      /** @deprecated internal use only */ 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));
  //# sourceMappingURL=switchMap.js.map
  
  /***/ }),
  
  /***/ 351:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  var toArray_1 = __webpack_require__(352);
  Observable_1.Observable.prototype.toArray = toArray_1.toArray;
  //# sourceMappingURL=toArray.js.map
  
  /***/ }),
  
  /***/ 352:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var toArray_1 = __webpack_require__(353);
  /**
   * Collects all source emissions and emits them as an array when the source completes.
   *
   * <span class="informal">Get all values inside an array when the source completes</span>
   *
   * <img src="./img/toArray.png" width="100%">
   *
   * `toArray` will wait until the source Observable completes
   * before emitting the array containing all emissions.
   * When the source Observable errors no array will be emitted.
   *
   * @example <caption>Create array from input</caption>
   * const input = Rx.Observable.interval(100).take(4);
   *
   * input.toArray()
   *   .subscribe(arr => console.log(arr)); // [0,1,2,3]
   *
   * @see {@link buffer}
   *
   * @return {Observable<any[]>|WebSocketSubject<T>|Observable<T>}
   * @method toArray
   * @owner Observable
   */
  function toArray() {
      return toArray_1.toArray()(this);
  }
  exports.toArray = toArray;
  //# sourceMappingURL=toArray.js.map
  
  /***/ }),
  
  /***/ 353:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var reduce_1 = __webpack_require__(354);
  function toArrayReducer(arr, item, index) {
      if (index === 0) {
          return [item];
      }
      arr.push(item);
      return arr;
  }
  function toArray() {
      return reduce_1.reduce(toArrayReducer, []);
  }
  exports.toArray = toArray;
  //# sourceMappingURL=toArray.js.map
  
  /***/ }),
  
  /***/ 354:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var scan_1 = __webpack_require__(355);
  var takeLast_1 = __webpack_require__(356);
  var defaultIfEmpty_1 = __webpack_require__(357);
  var pipe_1 = __webpack_require__(220);
  /* tslint:enable:max-line-length */
  /**
   * Applies an accumulator function over the source Observable, and returns the
   * accumulated result when the source completes, given an optional seed value.
   *
   * <span class="informal">Combines together all values emitted on the source,
   * using an accumulator function that knows how to join a new source value into
   * the accumulation from the past.</span>
   *
   * <img src="./img/reduce.png" width="100%">
   *
   * Like
   * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce),
   * `reduce` applies an `accumulator` function against an accumulation and each
   * value of the source Observable (from the past) to reduce it to a single
   * value, emitted on the output Observable. Note that `reduce` will only emit
   * one value, only when the source Observable completes. It is equivalent to
   * applying operator {@link scan} followed by operator {@link last}.
   *
   * 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.
   *
   * @example <caption>Count the number of click events that happened in 5 seconds</caption>
   * var clicksInFiveSeconds = Rx.Observable.fromEvent(document, 'click')
   *   .takeUntil(Rx.Observable.interval(5000));
   * var ones = clicksInFiveSeconds.mapTo(1);
   * var seed = 0;
   * var count = ones.reduce((acc, one) => acc + one, seed);
   * count.subscribe(x => console.log(x));
   *
   * @see {@link count}
   * @see {@link expand}
   * @see {@link mergeScan}
   * @see {@link scan}
   *
   * @param {function(acc: R, value: T, index: number): R} accumulator The accumulator function
   * called on each source value.
   * @param {R} [seed] The initial accumulation value.
   * @return {Observable<R>} An Observable that emits a single value that is the
   * result of accumulating the values emitted by the source Observable.
   * @method reduce
   * @owner Observable
   */
  function reduce(accumulator, seed) {
      // providing a seed of `undefined` *should* be valid and trigger
      // hasSeed! so don't use `seed !== undefined` checks!
      // For this reason, we have to check it here at the original call site
      // otherwise inside Operator/Subscriber we won't know if `undefined`
      // means they didn't provide anything or if they literally provided `undefined`
      if (arguments.length >= 2) {
          return function reduceOperatorFunctionWithSeed(source) {
              return pipe_1.pipe(scan_1.scan(accumulator, seed), takeLast_1.takeLast(1), defaultIfEmpty_1.defaultIfEmpty(seed))(source);
          };
      }
      return function reduceOperatorFunction(source) {
          return pipe_1.pipe(scan_1.scan(function (acc, value, index) {
              return accumulator(acc, value, index + 1);
          }), takeLast_1.takeLast(1))(source);
      };
  }
  exports.reduce = reduce;
  //# sourceMappingURL=reduce.js.map
  
  /***/ }),
  
  /***/ 355:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(20);
  /* tslint:enable:max-line-length */
  /**
   * Applies an accumulator function over the source Observable, and returns each
   * intermediate result, with an optional seed value.
   *
   * <span class="informal">It's like {@link reduce}, but emits the current
   * accumulation whenever the source emits a value.</span>
   *
   * <img src="./img/scan.png" width="100%">
   *
   * Combines together all values emitted on the source, using an accumulator
   * function that knows how to join a new source value into the accumulation from
   * the past. Is similar to {@link reduce}, but emits the intermediate
   * accumulations.
   *
   * 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.
   *
   * @example <caption>Count the number of click events</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var ones = clicks.mapTo(1);
   * var seed = 0;
   * var count = ones.scan((acc, one) => acc + one, seed);
   * count.subscribe(x => console.log(x));
   *
   * @see {@link expand}
   * @see {@link mergeScan}
   * @see {@link reduce}
   *
   * @param {function(acc: R, value: T, index: number): R} accumulator
   * The accumulator function called on each source value.
   * @param {T|R} [seed] The initial accumulation value.
   * @return {Observable<R>} An observable of the accumulated values.
   * @method scan
   * @owner Observable
   */
  function scan(accumulator, seed) {
      var hasSeed = false;
      // providing a seed of `undefined` *should* be valid and trigger
      // hasSeed! so don't use `seed !== undefined` checks!
      // For this reason, we have to check it here at the original call site
      // otherwise inside Operator/Subscriber we won't know if `undefined`
      // means they didn't provide anything or if they literally provided `undefined`
      if (arguments.length >= 2) {
          hasSeed = true;
      }
      return function scanOperatorFunction(source) {
          return source.lift(new ScanOperator(accumulator, seed, hasSeed));
      };
  }
  exports.scan = scan;
  var ScanOperator = (function () {
      function ScanOperator(accumulator, seed, hasSeed) {
          if (hasSeed === void 0) { hasSeed = false; }
          this.accumulator = accumulator;
          this.seed = seed;
          this.hasSeed = hasSeed;
      }
      ScanOperator.prototype.call = function (subscriber, source) {
          return source.subscribe(new ScanSubscriber(subscriber, this.accumulator, this.seed, this.hasSeed));
      };
      return ScanOperator;
  }());
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  var ScanSubscriber = (function (_super) {
      __extends(ScanSubscriber, _super);
      function ScanSubscriber(destination, accumulator, _seed, hasSeed) {
          _super.call(this, destination);
          this.accumulator = accumulator;
          this._seed = _seed;
          this.hasSeed = hasSeed;
          this.index = 0;
      }
      Object.defineProperty(ScanSubscriber.prototype, "seed", {
          get: function () {
              return this._seed;
          },
          set: function (value) {
              this.hasSeed = true;
              this._seed = value;
          },
          enumerable: true,
          configurable: true
      });
      ScanSubscriber.prototype._next = function (value) {
          if (!this.hasSeed) {
              this.seed = value;
              this.destination.next(value);
          }
          else {
              return this._tryNext(value);
          }
      };
      ScanSubscriber.prototype._tryNext = function (value) {
          var index = this.index++;
          var result;
          try {
              result = this.accumulator(this.seed, value, index);
          }
          catch (err) {
              this.destination.error(err);
          }
          this.seed = result;
          this.destination.next(result);
      };
      return ScanSubscriber;
  }(Subscriber_1.Subscriber));
  //# sourceMappingURL=scan.js.map
  
  /***/ }),
  
  /***/ 356:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(20);
  var ArgumentOutOfRangeError_1 = __webpack_require__(328);
  var EmptyObservable_1 = __webpack_require__(114);
  /**
   * Emits only the last `count` values emitted by the source Observable.
   *
   * <span class="informal">Remembers the latest `count` values, then emits those
   * only when the source completes.</span>
   *
   * <img src="./img/takeLast.png" width="100%">
   *
   * `takeLast` returns an Observable that emits at most the last `count` values
   * emitted by the source Observable. If the source emits fewer than `count`
   * values then all of its values are emitted. This operator must wait until the
   * `complete` notification emission from the source in order to emit the `next`
   * values on the output Observable, because otherwise it is impossible to know
   * whether or not more values will be emitted on the source. For this reason,
   * all values are emitted synchronously, followed by the complete notification.
   *
   * @example <caption>Take the last 3 values of an Observable with many values</caption>
   * var many = Rx.Observable.range(1, 100);
   * var lastThree = many.takeLast(3);
   * lastThree.subscribe(x => console.log(x));
   *
   * @see {@link take}
   * @see {@link takeUntil}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @throws {ArgumentOutOfRangeError} When using `takeLast(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.
   *
   * @param {number} count The maximum number of values to emit from the end of
   * the sequence of values emitted by the source Observable.
   * @return {Observable<T>} An Observable that emits at most the last count
   * values emitted by the source Observable.
   * @method takeLast
   * @owner Observable
   */
  function takeLast(count) {
      return function takeLastOperatorFunction(source) {
          if (count === 0) {
              return new EmptyObservable_1.EmptyObservable();
          }
          else {
              return source.lift(new TakeLastOperator(count));
          }
      };
  }
  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, source) {
          return source.subscribe(new TakeLastSubscriber(subscriber, this.total));
      };
      return TakeLastOperator;
  }());
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  var TakeLastSubscriber = (function (_super) {
      __extends(TakeLastSubscriber, _super);
      function TakeLastSubscriber(destination, total) {
          _super.call(this, destination);
          this.total = total;
          this.ring = new Array();
          this.count = 0;
      }
      TakeLastSubscriber.prototype._next = function (value) {
          var ring = this.ring;
          var total = this.total;
          var count = this.count++;
          if (ring.length < total) {
              ring.push(value);
          }
          else {
              var index = count % total;
              ring[index] = value;
          }
      };
      TakeLastSubscriber.prototype._complete = function () {
          var destination = this.destination;
          var count = this.count;
          if (count > 0) {
              var total = this.count >= this.total ? this.total : this.count;
              var ring = this.ring;
              for (var i = 0; i < total; i++) {
                  var idx = (count++) % total;
                  destination.next(ring[idx]);
              }
          }
          destination.complete();
      };
      return TakeLastSubscriber;
  }(Subscriber_1.Subscriber));
  //# sourceMappingURL=takeLast.js.map
  
  /***/ }),
  
  /***/ 357:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(20);
  /* tslint:enable:max-line-length */
  /**
   * Emits a given value if the source Observable completes without emitting any
   * `next` value, otherwise mirrors the source Observable.
   *
   * <span class="informal">If the source Observable turns out to be empty, then
   * this operator will emit a default value.</span>
   *
   * <img src="./img/defaultIfEmpty.png" width="100%">
   *
   * `defaultIfEmpty` emits the values emitted by the source Observable or a
   * specified default value if the source Observable is empty (completes without
   * having emitted any `next` value).
   *
   * @example <caption>If no clicks happen in 5 seconds, then emit "no clicks"</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var clicksBeforeFive = clicks.takeUntil(Rx.Observable.interval(5000));
   * var result = clicksBeforeFive.defaultIfEmpty('no clicks');
   * result.subscribe(x => console.log(x));
   *
   * @see {@link empty}
   * @see {@link last}
   *
   * @param {any} [defaultValue=null] The default value used if the source
   * Observable is empty.
   * @return {Observable} An Observable that emits either the specified
   * `defaultValue` if the source Observable emits no items, or the values emitted
   * by the source Observable.
   * @method defaultIfEmpty
   * @owner Observable
   */
  function defaultIfEmpty(defaultValue) {
      if (defaultValue === void 0) { defaultValue = null; }
      return function (source) { return source.lift(new DefaultIfEmptyOperator(defaultValue)); };
  }
  exports.defaultIfEmpty = defaultIfEmpty;
  var DefaultIfEmptyOperator = (function () {
      function DefaultIfEmptyOperator(defaultValue) {
          this.defaultValue = defaultValue;
      }
      DefaultIfEmptyOperator.prototype.call = function (subscriber, source) {
          return source.subscribe(new DefaultIfEmptySubscriber(subscriber, this.defaultValue));
      };
      return DefaultIfEmptyOperator;
  }());
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  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));
  //# sourceMappingURL=defaultIfEmpty.js.map
  
  /***/ }),
  
  /***/ 358:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var Observable_1 = __webpack_require__(7);
  var take_1 = __webpack_require__(359);
  Observable_1.Observable.prototype.take = take_1.take;
  //# sourceMappingURL=take.js.map
  
  /***/ }),
  
  /***/ 359:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var take_1 = __webpack_require__(360);
  /**
   * Emits only the first `count` values emitted by the source Observable.
   *
   * <span class="informal">Takes the first `count` values from the source, then
   * completes.</span>
   *
   * <img src="./img/take.png" width="100%">
   *
   * `take` returns an Observable that emits only the first `count` values emitted
   * by the source Observable. If the source emits fewer than `count` values then
   * all of its values are emitted. After that, it completes, regardless if the
   * source completes.
   *
   * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>
   * var interval = Rx.Observable.interval(1000);
   * var five = interval.take(5);
   * five.subscribe(x => console.log(x));
   *
   * @see {@link takeLast}
   * @see {@link takeUntil}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.
   *
   * @param {number} count The maximum number of `next` values to emit.
   * @return {Observable<T>} An Observable that emits only the first `count`
   * values emitted by the source Observable, or all of the values from the source
   * if the source emits fewer than `count` values.
   * @method take
   * @owner Observable
   */
  function take(count) {
      return take_1.take(count)(this);
  }
  exports.take = take;
  //# sourceMappingURL=take.js.map
  
  /***/ }),
  
  /***/ 360:
  /***/ (function(module, exports, __webpack_require__) {
  
  "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 = __webpack_require__(20);
  var ArgumentOutOfRangeError_1 = __webpack_require__(328);
  var EmptyObservable_1 = __webpack_require__(114);
  /**
   * Emits only the first `count` values emitted by the source Observable.
   *
   * <span class="informal">Takes the first `count` values from the source, then
   * completes.</span>
   *
   * <img src="./img/take.png" width="100%">
   *
   * `take` returns an Observable that emits only the first `count` values emitted
   * by the source Observable. If the source emits fewer than `count` values then
   * all of its values are emitted. After that, it completes, regardless if the
   * source completes.
   *
   * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>
   * var interval = Rx.Observable.interval(1000);
   * var five = interval.take(5);
   * five.subscribe(x => console.log(x));
   *
   * @see {@link takeLast}
   * @see {@link takeUntil}
   * @see {@link takeWhile}
   * @see {@link skip}
   *
   * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an
   * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.
   *
   * @param {number} count The maximum number of `next` values to emit.
   * @return {Observable<T>} An Observable that emits only the first `count`
   * values emitted by the source Observable, or all of the values from the source
   * if the source emits fewer than `count` values.
   * @method take
   * @owner Observable
   */
  function take(count) {
      return function (source) {
          if (count === 0) {
              return new EmptyObservable_1.EmptyObservable();
          }
          else {
              return source.lift(new TakeOperator(count));
          }
      };
  }
  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, source) {
          return source.subscribe(new TakeSubscriber(subscriber, this.total));
      };
      return TakeOperator;
  }());
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  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;
          var count = ++this.count;
          if (count <= total) {
              this.destination.next(value);
              if (count === total) {
                  this.destination.complete();
                  this.unsubscribe();
              }
          }
      };
      return TakeSubscriber;
  }(Subscriber_1.Subscriber));
  //# sourceMappingURL=take.js.map
  
  /***/ }),
  
  /***/ 369:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return CardsPage; });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_ionic_angular__ = __webpack_require__(11);
  var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  var __metadata = (this && this.__metadata) || function (k, v) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
  };
  
  
  var CardsPage = /** @class */ (function () {
      function CardsPage(navCtrl) {
          this.navCtrl = navCtrl;
          this.cardItems = [
              {
                  user: {
                      avatar: 'assets/img/marty-avatar.png',
                      name: 'Marty McFly'
                  },
                  date: 'November 5, 1955',
                  image: 'assets/img/advance-card-bttf.png',
                  content: 'Wait a minute. Wait a minute, Doc. Uhhh... Are you telling me that you built a time machine... out of a DeLorean?! Whoa. This is heavy.',
              },
              {
                  user: {
                      avatar: 'assets/img/sarah-avatar.png.jpeg',
                      name: 'Sarah Connor'
                  },
                  date: 'May 12, 1984',
                  image: 'assets/img/advance-card-tmntr.jpg',
                  content: 'I face the unknown future, with a sense of hope. Because if a machine, a Terminator, can learn the value of human life, maybe we can too.'
              },
              {
                  user: {
                      avatar: 'assets/img/ian-avatar.png',
                      name: 'Dr. Ian Malcolm'
                  },
                  date: 'June 28, 1990',
                  image: 'assets/img/advance-card-jp.jpg',
                  content: 'Your scientists were so preoccupied with whether or not they could, that they didn\'t stop to think if they should.'
              }
          ];
      }
      CardsPage = __decorate([
          Object(__WEBPACK_IMPORTED_MODULE_0__angular_core__["m" /* Component */])({
              selector: 'page-cards',template:/*ion-inline-start:"D:\_Ayhant\_Projects\test10\src\pages\cards\cards.html"*/'<ion-header>\n\n  <ion-navbar>\n    <ion-title>{{ \'CARDS_TITLE\' | translate }}</ion-title>\n  </ion-navbar>\n\n</ion-header>\n\n\n<ion-content>\n\n  <ion-card *ngFor="let item of cardItems">\n\n    <ion-item>\n      <ion-avatar item-start>\n        <img [src]="item.user.avatar">\n      </ion-avatar>\n      <h2>{{item.user.name}}</h2>\n      <p>{{item.date}}</p>\n    </ion-item>\n\n    <img [src]="item.image">\n\n    <ion-card-content>\n      <p>{{item.content}}</p>\n    </ion-card-content>\n\n    <ion-row>\n      <ion-col>\n        <button ion-button color="primary" clear small icon-start>\n            <ion-icon name=\'thumbs-up\'></ion-icon>\n            12 Likes\n          </button>\n      </ion-col>\n      <ion-col>\n        <button ion-button color="primary" clear small icon-start>\n            <ion-icon name=\'text\'></ion-icon>\n            4 Comments\n          </button>\n      </ion-col>\n      <ion-col center text-center>\n        <ion-note>\n          11h ago\n        </ion-note>\n      </ion-col>\n    </ion-row>\n  </ion-card>\n</ion-content>'/*ion-inline-end:"D:\_Ayhant\_Projects\test10\src\pages\cards\cards.html"*/
          }),
          __metadata("design:paramtypes", [__WEBPACK_IMPORTED_MODULE_1_ionic_angular__["l" /* NavController */]])
      ], CardsPage);
      return CardsPage;
  }());
  
  //# sourceMappingURL=cards.js.map
  
  /***/ })
  
  });
  //# sourceMappingURL=10.js.map