{"version":3,"file":"static/js/vendor.initial~5f1b8bf5.ec0b277d.js","mappings":"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","sources":["../../../../node_modules/.pnpm/rtl-css-js@1.16.0_patch_hash=tqjrras4zdrejdoe3v3v3qjygi/node_modules/rtl-css-js/dist/esm/convert-7f74cdb7.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/BehaviorSubject.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/InnerSubscriber.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Notification.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Observable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Observer.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/OuterSubscriber.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Scheduler.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Subject.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/SubjectSubscription.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Subscriber.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/Subscription.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/dom/ajax.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/empty.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/from.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/interval.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/of.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/observable/throw.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/catch.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/combineLatest.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/concatMap.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/count.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/delay.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/do.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/filter.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/map.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/mergeMap.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/retryWhen.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/share.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/add/operator/take.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ArrayLikeObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ArrayObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ConnectableObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/EmptyObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ErrorObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/FromObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/IntervalObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/IteratorObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/PromiseObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/ScalarObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/dom/AjaxObservable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/dom/ajax.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/empty.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/from.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/interval.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/of.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/observable/throw.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/catch.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/combineLatest.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/concatMap.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/count.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/delay.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/do.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/filter.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/map.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/mergeMap.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/retryWhen.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/share.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operator/take.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/catchError.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/combineLatest.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/concatMap.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/count.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/delay.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/filter.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/map.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/mergeMap.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/multicast.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/observeOn.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/refCount.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/retryWhen.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/share.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/take.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/operators/tap.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/Action.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/AsyncAction.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/AsyncScheduler.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/scheduler/async.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/symbol/iterator.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/symbol/observable.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/symbol/rxSubscriber.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/ArgumentOutOfRangeError.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/ObjectUnsubscribedError.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/UnsubscriptionError.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/errorObject.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isArray.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isArrayLike.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isDate.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isFunction.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isNumeric.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isObject.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isPromise.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/isScheduler.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/noop.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/pipe.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/root.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/subscribeToResult.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/toSubscriber.js","../../../../node_modules/.pnpm/rxjs@5.5.12/node_modules/rxjs/util/tryCatch.js"],"sourcesContent":["/**\n * Takes an array of [keyValue1, keyValue2] pairs and creates an object of {keyValue1: keyValue2, keyValue2: keyValue1}\n * @param {Array} array the array of pairs\n * @return {Object} the {key, value} pair object\n */\nfunction arrayToObject(array) {\n  return array.reduce(function (obj, _ref) {\n    var prop1 = _ref[0],\n        prop2 = _ref[1];\n    obj[prop1] = prop2;\n    obj[prop2] = prop1;\n    return obj;\n  }, {});\n}\n\nfunction isBoolean(val) {\n  return typeof val === 'boolean';\n}\n\nfunction isFunction(val) {\n  return typeof val === 'function';\n}\n\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\nfunction isNullOrUndefined(val) {\n  return val === null || typeof val === 'undefined';\n}\n\nfunction isObject(val) {\n  return val && typeof val === 'object';\n}\n\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\nfunction includes(inclusive, inclusee) {\n  return inclusive.indexOf(inclusee) !== -1;\n}\n/**\n * Flip the sign of a CSS value, possibly with a unit.\n *\n * We can't just negate the value with unary minus due to the units.\n *\n * @private\n * @param {String} value - the original value (for example 77%)\n * @return {String} the result (for example -77%)\n */\n\n\nfunction flipSign(value) {\n  if (parseFloat(value) === 0) {\n    // Don't mangle zeroes\n    return value;\n  }\n\n  if (value[0] === '-') {\n    return value.slice(1);\n  }\n\n  return \"-\" + value;\n}\n\nfunction flipTransformSign(match, prefix, offset, suffix) {\n  return prefix + flipSign(offset) + suffix;\n}\n/**\n * Takes a percentage for background position and inverts it.\n * This was copied and modified from CSSJanus:\n * https://github.com/cssjanus/cssjanus/blob/4245f834365f6cfb0239191a151432fb85abab23/src/cssjanus.js#L152-L175\n * @param {String} value - the original value (for example 77%)\n * @return {String} the result (for example 23%)\n */\n\n\nfunction calculateNewBackgroundPosition(value) {\n  var idx = value.indexOf('.');\n\n  if (idx === -1) {\n    value = 100 - parseFloat(value) + \"%\";\n  } else {\n    // Two off, one for the \"%\" at the end, one for the dot itself\n    var len = value.length - idx - 2;\n    value = 100 - parseFloat(value);\n    value = value.toFixed(len) + \"%\";\n  }\n\n  return value;\n}\n/**\n * This takes a list of CSS values and converts it to an array\n * @param {String} value - something like `1px`, `1px 2em`, or `3pt rgb(150, 230, 550) 40px calc(100% - 5px)`\n * @return {Array} the split values (for example: `['3pt', 'rgb(150, 230, 550)', '40px', 'calc(100% - 5px)']`)\n */\n\n\nfunction getValuesAsList(value) {\n  return value.replace(/ +/g, ' ') // remove all extraneous spaces\n  .split(' ').map(function (i) {\n    return i.trim();\n  }) // get rid of extra space before/after each item\n  .filter(Boolean) // get rid of empty strings\n  // join items which are within parenthese\n  // luckily `calc (100% - 5px)` is invalid syntax and it must be `calc(100% - 5px)`, otherwise this would be even more complex\n  .reduce(function (_ref2, item) {\n    var list = _ref2.list,\n        state = _ref2.state;\n    var openParansCount = (item.match(/\\(/g) || []).length;\n    var closedParansCount = (item.match(/\\)/g) || []).length;\n\n    if (state.parensDepth > 0) {\n      list[list.length - 1] = list[list.length - 1] + \" \" + item;\n    } else {\n      list.push(item);\n    }\n\n    state.parensDepth += openParansCount - closedParansCount;\n    return {\n      list: list,\n      state: state\n    };\n  }, {\n    list: [],\n    state: {\n      parensDepth: 0\n    }\n  }).list;\n}\n/**\n * This is intended for properties that are `top right bottom left` and will switch them to `top left bottom right`\n * @param {String} value - `1px 2px 3px 4px` for example, but also handles cases where there are too few/too many and\n * simply returns the value in those cases (which is the correct behavior)\n * @return {String} the result - `1px 4px 3px 2px` for example.\n */\n\n\nfunction handleQuartetValues(value) {\n  var splitValues = getValuesAsList(value);\n\n  if (splitValues.length <= 3 || splitValues.length > 4) {\n    return value;\n  }\n\n  var top = splitValues[0],\n      right = splitValues[1],\n      bottom = splitValues[2],\n      left = splitValues[3];\n  return [top, left, bottom, right].join(' ');\n}\n/**\n *\n * @param {String|Number|Object} value css property value to test\n * @returns If the css property value can(should?) have an RTL equivalent\n */\n\n\nfunction canConvertValue(value) {\n  return !isBoolean(value) && !isNullOrUndefined(value);\n}\n/**\n * Splits a shadow style into its separate shadows using the comma delimiter, but creating an exception\n * for comma separated values in parentheses often used for rgba colours.\n * @param {String} value\n * @returns {Array} array of all box shadow values in the string\n */\n\n\nfunction splitShadow(value) {\n  var shadows = [];\n  var start = 0;\n  var end = 0;\n  var rgba = false;\n\n  while (end < value.length) {\n    if (!rgba && value[end] === ',') {\n      shadows.push(value.substring(start, end).trim());\n      end++;\n      start = end;\n    } else if (value[end] === \"(\") {\n      rgba = true;\n      end++;\n    } else if (value[end] === ')') {\n      rgba = false;\n      end++;\n    } else {\n      end++;\n    }\n  } // push the last shadow value if there is one\n  // istanbul ignore next\n\n\n  if (start != end) {\n    shadows.push(value.substring(start, end + 1));\n  }\n\n  return shadows;\n}\n\nvar propertyValueConverters = {\n  padding: function padding(_ref) {\n    var value = _ref.value;\n\n    if (isNumber(value)) {\n      return value;\n    }\n\n    return handleQuartetValues(value);\n  },\n  textShadow: function textShadow(_ref2) {\n    var value = _ref2.value;\n    var flippedShadows = splitShadow(value).map(function (shadow) {\n      // intentionally leaving off the `g` flag here because we only want to change the first number (which is the offset-x)\n      return shadow.replace(/(^|\\s)(-*)([.|\\d]+)/, function (match, whiteSpace, negative, number) {\n        if (number === '0') {\n          return match;\n        }\n\n        var doubleNegative = negative === '' ? '-' : '';\n        return \"\" + whiteSpace + doubleNegative + number;\n      });\n    });\n    return flippedShadows.join(',');\n  },\n  borderColor: function borderColor(_ref3) {\n    var value = _ref3.value;\n    return handleQuartetValues(value);\n  },\n  borderRadius: function borderRadius(_ref4) {\n    var value = _ref4.value;\n\n    if (isNumber(value)) {\n      return value;\n    }\n\n    if (includes(value, '/')) {\n      var _value$split = value.split('/'),\n          radius1 = _value$split[0],\n          radius2 = _value$split[1];\n\n      var convertedRadius1 = propertyValueConverters.borderRadius({\n        value: radius1.trim()\n      });\n      var convertedRadius2 = propertyValueConverters.borderRadius({\n        value: radius2.trim()\n      });\n      return convertedRadius1 + \" / \" + convertedRadius2;\n    }\n\n    var splitValues = getValuesAsList(value);\n\n    switch (splitValues.length) {\n      case 2:\n        {\n          return splitValues.reverse().join(' ');\n        }\n\n      case 4:\n        {\n          var topLeft = splitValues[0],\n              topRight = splitValues[1],\n              bottomRight = splitValues[2],\n              bottomLeft = splitValues[3];\n          return [topRight, topLeft, bottomLeft, bottomRight].join(' ');\n        }\n\n      default:\n        {\n          return value;\n        }\n    }\n  },\n  background: function background(_ref5) {\n    var value = _ref5.value,\n        valuesToConvert = _ref5.valuesToConvert,\n        isRtl = _ref5.isRtl,\n        bgImgDirectionRegex = _ref5.bgImgDirectionRegex,\n        bgPosDirectionRegex = _ref5.bgPosDirectionRegex;\n\n    if (isNumber(value)) {\n      return value;\n    } // Yeah, this is in need of a refactor 🙃...\n    // but this property is a tough cookie 🍪\n    // get the backgroundPosition out of the string by removing everything that couldn't be the backgroundPosition value\n\n\n    var backgroundPositionValue = value.replace(/(url\\(.*?\\))|(rgba?\\(.*?\\))|(hsl\\(.*?\\))|(#[a-fA-F0-9]+)|((^| )(\\D)+( |$))/g, '').trim(); // replace that backgroundPosition value with the converted version\n\n    value = value.replace(backgroundPositionValue, propertyValueConverters.backgroundPosition({\n      value: backgroundPositionValue,\n      valuesToConvert: valuesToConvert,\n      isRtl: isRtl,\n      bgPosDirectionRegex: bgPosDirectionRegex\n    })); // do the backgroundImage value replacing on the whole value (because why not?)\n\n    return propertyValueConverters.backgroundImage({\n      value: value,\n      valuesToConvert: valuesToConvert,\n      bgImgDirectionRegex: bgImgDirectionRegex\n    });\n  },\n  backgroundImage: function backgroundImage(_ref6) {\n    var value = _ref6.value,\n        valuesToConvert = _ref6.valuesToConvert,\n        bgImgDirectionRegex = _ref6.bgImgDirectionRegex;\n\n    if (!includes(value, 'url(') && !includes(value, 'linear-gradient(')) {\n      return value;\n    }\n\n    return value.replace(bgImgDirectionRegex, function (match, g1, group2) {\n      return match.replace(group2, valuesToConvert[group2]);\n    });\n  },\n  backgroundPosition: function backgroundPosition(_ref7) {\n    var value = _ref7.value,\n        valuesToConvert = _ref7.valuesToConvert,\n        isRtl = _ref7.isRtl,\n        bgPosDirectionRegex = _ref7.bgPosDirectionRegex;\n    return value // intentionally only grabbing the first instance of this because that represents `left`\n    .replace(isRtl ? /^((-|\\d|\\.)+%)/ : null, function (match, group) {\n      return calculateNewBackgroundPosition(group);\n    }).replace(bgPosDirectionRegex, function (match) {\n      return valuesToConvert[match];\n    });\n  },\n  backgroundPositionX: function backgroundPositionX(_ref8) {\n    var value = _ref8.value,\n        valuesToConvert = _ref8.valuesToConvert,\n        isRtl = _ref8.isRtl,\n        bgPosDirectionRegex = _ref8.bgPosDirectionRegex;\n\n    if (isNumber(value)) {\n      return value;\n    }\n\n    return propertyValueConverters.backgroundPosition({\n      value: value,\n      valuesToConvert: valuesToConvert,\n      isRtl: isRtl,\n      bgPosDirectionRegex: bgPosDirectionRegex\n    });\n  },\n  transition: function transition(_ref9) {\n    var value = _ref9.value,\n        propertiesToConvert = _ref9.propertiesToConvert;\n    return value.split(/,\\s*/g).map(function (transition) {\n      var values = transition.split(' '); // Property is always defined first\n\n      values[0] = propertiesToConvert[values[0]] || values[0];\n      return values.join(' ');\n    }).join(', ');\n  },\n  transitionProperty: function transitionProperty(_ref10) {\n    var value = _ref10.value,\n        propertiesToConvert = _ref10.propertiesToConvert;\n    return value.split(/,\\s*/g).map(function (prop) {\n      return propertiesToConvert[prop] || prop;\n    }).join(', ');\n  },\n  transform: function transform(_ref11) {\n    var value = _ref11.value;\n    // This was copied and modified from CSSJanus:\n    // https://github.com/cssjanus/cssjanus/blob/4a40f001b1ba35567112d8b8e1d9d95eda4234c3/src/cssjanus.js#L152-L153\n    var nonAsciiPattern = \"[^\\\\u0020-\\\\u007e]\";\n    var escapePattern = \"(?:\" + '(?:(?:\\\\[0-9a-f]{1,6})(?:\\\\r\\\\n|\\\\s)?)' + \"|\\\\\\\\[^\\\\r\\\\n\\\\f0-9a-f])\";\n    var signedQuantPattern = \"((?:-?\" + ('(?:[0-9]*\\\\.[0-9]+|[0-9]+)' + \"(?:\\\\s*\" + '(?:em|ex|px|cm|mm|in|pt|pc|deg|rad|grad|ms|s|hz|khz|%)' + \"|\" + (\"-?\" + (\"(?:[_a-z]|\" + nonAsciiPattern + \"|\" + escapePattern + \")\") + (\"(?:[_a-z0-9-]|\" + nonAsciiPattern + \"|\" + escapePattern + \")\") + \"*\") + \")?\") + \")|(?:inherit|auto))\";\n    var translateXRegExp = new RegExp(\"(translateX\\\\s*\\\\(\\\\s*)\" + signedQuantPattern + \"(\\\\s*\\\\))\", 'gi');\n    var translateRegExp = new RegExp(\"(translate\\\\s*\\\\(\\\\s*)\" + signedQuantPattern + \"((?:\\\\s*,\\\\s*\" + signedQuantPattern + \"){0,1}\\\\s*\\\\))\", 'gi');\n    var translate3dRegExp = new RegExp(\"(translate3d\\\\s*\\\\(\\\\s*)\" + signedQuantPattern + \"((?:\\\\s*,\\\\s*\" + signedQuantPattern + \"){0,2}\\\\s*\\\\))\", 'gi');\n    var rotateRegExp = new RegExp(\"(rotate[ZY]?\\\\s*\\\\(\\\\s*)\" + signedQuantPattern + \"(\\\\s*\\\\))\", 'gi');\n    return value.replace(translateXRegExp, flipTransformSign).replace(translateRegExp, flipTransformSign).replace(translate3dRegExp, flipTransformSign).replace(rotateRegExp, flipTransformSign);\n  }\n};\npropertyValueConverters.objectPosition = propertyValueConverters.backgroundPosition;\npropertyValueConverters.margin = propertyValueConverters.padding;\npropertyValueConverters.borderWidth = propertyValueConverters.padding;\npropertyValueConverters.boxShadow = propertyValueConverters.textShadow;\npropertyValueConverters.webkitBoxShadow = propertyValueConverters.boxShadow;\npropertyValueConverters.mozBoxShadow = propertyValueConverters.boxShadow;\npropertyValueConverters.WebkitBoxShadow = propertyValueConverters.boxShadow;\npropertyValueConverters.MozBoxShadow = propertyValueConverters.boxShadow;\npropertyValueConverters.borderStyle = propertyValueConverters.borderColor;\npropertyValueConverters.webkitTransform = propertyValueConverters.transform;\npropertyValueConverters.mozTransform = propertyValueConverters.transform;\npropertyValueConverters.WebkitTransform = propertyValueConverters.transform;\npropertyValueConverters.MozTransform = propertyValueConverters.transform;\npropertyValueConverters.transformOrigin = propertyValueConverters.backgroundPosition;\npropertyValueConverters.webkitTransformOrigin = propertyValueConverters.transformOrigin;\npropertyValueConverters.mozTransformOrigin = propertyValueConverters.transformOrigin;\npropertyValueConverters.WebkitTransformOrigin = propertyValueConverters.transformOrigin;\npropertyValueConverters.MozTransformOrigin = propertyValueConverters.transformOrigin;\npropertyValueConverters.webkitTransition = propertyValueConverters.transition;\npropertyValueConverters.mozTransition = propertyValueConverters.transition;\npropertyValueConverters.WebkitTransition = propertyValueConverters.transition;\npropertyValueConverters.MozTransition = propertyValueConverters.transition;\npropertyValueConverters.webkitTransitionProperty = propertyValueConverters.transitionProperty;\npropertyValueConverters.mozTransitionProperty = propertyValueConverters.transitionProperty;\npropertyValueConverters.WebkitTransitionProperty = propertyValueConverters.transitionProperty;\npropertyValueConverters.MozTransitionProperty = propertyValueConverters.transitionProperty; // kebab-case versions\n\npropertyValueConverters['text-shadow'] = propertyValueConverters.textShadow;\npropertyValueConverters['border-color'] = propertyValueConverters.borderColor;\npropertyValueConverters['border-radius'] = propertyValueConverters.borderRadius;\npropertyValueConverters['background-image'] = propertyValueConverters.backgroundImage;\npropertyValueConverters['background-position'] = propertyValueConverters.backgroundPosition;\npropertyValueConverters['background-position-x'] = propertyValueConverters.backgroundPositionX;\npropertyValueConverters['object-position'] = propertyValueConverters.objectPosition;\npropertyValueConverters['border-width'] = propertyValueConverters.padding;\npropertyValueConverters['box-shadow'] = propertyValueConverters.textShadow;\npropertyValueConverters['-webkit-box-shadow'] = propertyValueConverters.textShadow;\npropertyValueConverters['-moz-box-shadow'] = propertyValueConverters.textShadow;\npropertyValueConverters['border-style'] = propertyValueConverters.borderColor;\npropertyValueConverters['-webkit-transform'] = propertyValueConverters.transform;\npropertyValueConverters['-moz-transform'] = propertyValueConverters.transform;\npropertyValueConverters['transform-origin'] = propertyValueConverters.transformOrigin;\npropertyValueConverters['-webkit-transform-origin'] = propertyValueConverters.transformOrigin;\npropertyValueConverters['-moz-transform-origin'] = propertyValueConverters.transformOrigin;\npropertyValueConverters['-webkit-transition'] = propertyValueConverters.transition;\npropertyValueConverters['-moz-transition'] = propertyValueConverters.transition;\npropertyValueConverters['transition-property'] = propertyValueConverters.transitionProperty;\npropertyValueConverters['-webkit-transition-property'] = propertyValueConverters.transitionProperty;\npropertyValueConverters['-moz-transition-property'] = propertyValueConverters.transitionProperty;\n\nvar propertiesToConvert = arrayToObject([['paddingLeft', 'paddingRight'], ['marginLeft', 'marginRight'], ['left', 'right'], ['borderLeft', 'borderRight'], ['borderLeftColor', 'borderRightColor'], ['borderLeftStyle', 'borderRightStyle'], ['borderLeftWidth', 'borderRightWidth'], ['borderTopLeftRadius', 'borderTopRightRadius'], ['borderBottomLeftRadius', 'borderBottomRightRadius'], // kebab-case versions\n['padding-left', 'padding-right'], ['margin-left', 'margin-right'], ['border-left', 'border-right'], ['border-left-color', 'border-right-color'], ['border-left-style', 'border-right-style'], ['border-left-width', 'border-right-width'], ['border-top-left-radius', 'border-top-right-radius'], ['border-bottom-left-radius', 'border-bottom-right-radius']]);\nvar propsToIgnore = ['content']; // this is the same as the propertiesToConvert except for values\n\nvar valuesToConvert = arrayToObject([['ltr', 'rtl'], ['left', 'right'], ['w-resize', 'e-resize'], ['sw-resize', 'se-resize'], ['nw-resize', 'ne-resize']]); // Sorry for the regex 😞, but basically thisis used to replace _every_ instance of\n// `ltr`, `rtl`, `right`, and `left` in `backgroundimage` with the corresponding opposite.\n// A situation we're accepting here:\n// url('/left/right/rtl/ltr.png') will be changed to url('/right/left/ltr/rtl.png')\n// Definite trade-offs here, but I think it's a good call.\n\nvar bgImgDirectionRegex = new RegExp('(^|\\\\W|_)((ltr)|(rtl)|(left)|(right))(\\\\W|_|$)', 'g');\nvar bgPosDirectionRegex = new RegExp('(left)|(right)');\n/**\n * converts properties and values in the CSS in JS object to their corresponding RTL values\n * @param {Object} object the CSS in JS object\n * @return {Object} the RTL converted object\n */\n\nfunction convert(object) {\n  return Object.keys(object).reduce(function (newObj, originalKey) {\n    var originalValue = object[originalKey];\n\n    if (isString(originalValue)) {\n      // you're welcome to later code 😺\n      originalValue = originalValue.trim();\n    } // Some properties should never be transformed\n\n\n    if (includes(propsToIgnore, originalKey)) {\n      newObj[originalKey] = originalValue;\n      return newObj;\n    }\n\n    var _convertProperty = convertProperty(originalKey, originalValue),\n        key = _convertProperty.key,\n        value = _convertProperty.value;\n\n    newObj[key] = value;\n    return newObj;\n  }, Array.isArray(object) ? [] : {});\n}\n/**\n * Converts a property and its value to the corresponding RTL key and value\n * @param {String} originalKey the original property key\n * @param {Number|String|Object} originalValue the original css property value\n * @return {Object} the new {key, value} pair\n */\n\nfunction convertProperty(originalKey, originalValue) {\n  var isNoFlip = /\\/\\*\\s?@noflip\\s?\\*\\//.test(originalValue);\n  var key = isNoFlip ? originalKey : getPropertyDoppelganger(originalKey);\n  var value = isNoFlip ? originalValue : getValueDoppelganger(key, originalValue);\n  return {\n    key: key,\n    value: value\n  };\n}\n/**\n * This gets the RTL version of the given property if it has a corresponding RTL property\n * @param {String} property the name of the property\n * @return {String} the name of the RTL property\n */\n\nfunction getPropertyDoppelganger(property) {\n  return propertiesToConvert[property] || property;\n}\n/**\n * This converts the given value to the RTL version of that value based on the key\n * @param {String} key this is the key (note: this should be the RTL version of the originalKey)\n * @param {String|Number|Object} originalValue the original css property value. If it's an object, then we'll convert that as well\n * @return {String|Number|Object} the converted value\n */\n\nfunction getValueDoppelganger(key, originalValue) {\n  if (!canConvertValue(originalValue)) {\n    return originalValue;\n  }\n\n  if (isObject(originalValue)) {\n    return convert(originalValue); // recursion 🌀\n  }\n\n  var isNum = isNumber(originalValue);\n  var isFunc = isFunction(originalValue);\n  var importantlessValue = isNum || isFunc ? originalValue : originalValue.replace(/ !important.*?$/, '');\n  var isImportant = !isNum && importantlessValue.length !== originalValue.length;\n  var valueConverter = propertyValueConverters[key];\n  var newValue;\n\n  if (valueConverter) {\n    newValue = valueConverter({\n      value: importantlessValue,\n      valuesToConvert: valuesToConvert,\n      propertiesToConvert: propertiesToConvert,\n      isRtl: true,\n      bgImgDirectionRegex: bgImgDirectionRegex,\n      bgPosDirectionRegex: bgPosDirectionRegex\n    });\n  } else {\n    newValue = valuesToConvert[importantlessValue] || importantlessValue;\n  }\n\n  if (isImportant) {\n    return newValue + \" !important\";\n  }\n\n  return newValue;\n}\n\nexport { propertiesToConvert as a, propsToIgnore as b, convert as c, convertProperty as d, getValueDoppelganger as e, arrayToObject as f, getPropertyDoppelganger as g, calculateNewBackgroundPosition as h, canConvertValue as i, flipTransformSign as j, flipSign as k, handleQuartetValues as l, includes as m, isBoolean as n, isFunction as o, propertyValueConverters as p, isNumber as q, isNullOrUndefined as r, isObject as s, isString as t, getValuesAsList as u, valuesToConvert as v, splitShadow as w };\n","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('./Subject');\nvar ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError');\n/**\n * @class BehaviorSubject<T>\n */\nvar BehaviorSubject = (function (_super) {\n    __extends(BehaviorSubject, _super);\n    function BehaviorSubject(_value) {\n        _super.call(this);\n        this._value = _value;\n    }\n    Object.defineProperty(BehaviorSubject.prototype, \"value\", {\n        get: function () {\n            return this.getValue();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /** @deprecated internal use only */ BehaviorSubject.prototype._subscribe = function (subscriber) {\n        var subscription = _super.prototype._subscribe.call(this, subscriber);\n        if (subscription && !subscription.closed) {\n            subscriber.next(this._value);\n        }\n        return subscription;\n    };\n    BehaviorSubject.prototype.getValue = function () {\n        if (this.hasError) {\n            throw this.thrownError;\n        }\n        else if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return this._value;\n        }\n    };\n    BehaviorSubject.prototype.next = function (value) {\n        _super.prototype.next.call(this, this._value = value);\n    };\n    return BehaviorSubject;\n}(Subject_1.Subject));\nexports.BehaviorSubject = BehaviorSubject;\n//# sourceMappingURL=BehaviorSubject.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar InnerSubscriber = (function (_super) {\n    __extends(InnerSubscriber, _super);\n    function InnerSubscriber(parent, outerValue, outerIndex) {\n        _super.call(this);\n        this.parent = parent;\n        this.outerValue = outerValue;\n        this.outerIndex = outerIndex;\n        this.index = 0;\n    }\n    InnerSubscriber.prototype._next = function (value) {\n        this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);\n    };\n    InnerSubscriber.prototype._error = function (error) {\n        this.parent.notifyError(error, this);\n        this.unsubscribe();\n    };\n    InnerSubscriber.prototype._complete = function () {\n        this.parent.notifyComplete(this);\n        this.unsubscribe();\n    };\n    return InnerSubscriber;\n}(Subscriber_1.Subscriber));\nexports.InnerSubscriber = InnerSubscriber;\n//# sourceMappingURL=InnerSubscriber.js.map","\"use strict\";\nvar Observable_1 = require('./Observable');\n/**\n * Represents a push-based event or value that an {@link Observable} can emit.\n * This class is particularly useful for operators that manage notifications,\n * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and\n * others. Besides wrapping the actual delivered value, it also annotates it\n * with metadata of, for instance, what type of push message it is (`next`,\n * `error`, or `complete`).\n *\n * @see {@link materialize}\n * @see {@link dematerialize}\n * @see {@link observeOn}\n *\n * @class Notification<T>\n */\nvar Notification = (function () {\n    function Notification(kind, value, error) {\n        this.kind = kind;\n        this.value = value;\n        this.error = error;\n        this.hasValue = kind === 'N';\n    }\n    /**\n     * Delivers to the given `observer` the value wrapped by this Notification.\n     * @param {Observer} observer\n     * @return\n     */\n    Notification.prototype.observe = function (observer) {\n        switch (this.kind) {\n            case 'N':\n                return observer.next && observer.next(this.value);\n            case 'E':\n                return observer.error && observer.error(this.error);\n            case 'C':\n                return observer.complete && observer.complete();\n        }\n    };\n    /**\n     * Given some {@link Observer} callbacks, deliver the value represented by the\n     * current Notification to the correctly corresponding callback.\n     * @param {function(value: T): void} next An Observer `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.do = function (next, error, complete) {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return next && next(this.value);\n            case 'E':\n                return error && error(this.error);\n            case 'C':\n                return complete && complete();\n        }\n    };\n    /**\n     * Takes an Observer or its individual callback functions, and calls `observe`\n     * or `do` methods accordingly.\n     * @param {Observer|function(value: T): void} nextOrObserver An Observer or\n     * the `next` callback.\n     * @param {function(err: any): void} [error] An Observer `error` callback.\n     * @param {function(): void} [complete] An Observer `complete` callback.\n     * @return {any}\n     */\n    Notification.prototype.accept = function (nextOrObserver, error, complete) {\n        if (nextOrObserver && typeof nextOrObserver.next === 'function') {\n            return this.observe(nextOrObserver);\n        }\n        else {\n            return this.do(nextOrObserver, error, complete);\n        }\n    };\n    /**\n     * Returns a simple Observable that just delivers the notification represented\n     * by this Notification instance.\n     * @return {any}\n     */\n    Notification.prototype.toObservable = function () {\n        var kind = this.kind;\n        switch (kind) {\n            case 'N':\n                return Observable_1.Observable.of(this.value);\n            case 'E':\n                return Observable_1.Observable.throw(this.error);\n            case 'C':\n                return Observable_1.Observable.empty();\n        }\n        throw new Error('unexpected notification kind value');\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `next` from a\n     * given value.\n     * @param {T} value The `next` value.\n     * @return {Notification<T>} The \"next\" Notification representing the\n     * argument.\n     */\n    Notification.createNext = function (value) {\n        if (typeof value !== 'undefined') {\n            return new Notification('N', value);\n        }\n        return Notification.undefinedValueNotification;\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `error` from a\n     * given error.\n     * @param {any} [err] The `error` error.\n     * @return {Notification<T>} The \"error\" Notification representing the\n     * argument.\n     */\n    Notification.createError = function (err) {\n        return new Notification('E', undefined, err);\n    };\n    /**\n     * A shortcut to create a Notification instance of the type `complete`.\n     * @return {Notification<any>} The valueless \"complete\" Notification.\n     */\n    Notification.createComplete = function () {\n        return Notification.completeNotification;\n    };\n    Notification.completeNotification = new Notification('C');\n    Notification.undefinedValueNotification = new Notification('N', undefined);\n    return Notification;\n}());\nexports.Notification = Notification;\n//# sourceMappingURL=Notification.js.map","\"use strict\";\nvar root_1 = require('./util/root');\nvar toSubscriber_1 = require('./util/toSubscriber');\nvar observable_1 = require('./symbol/observable');\nvar pipe_1 = require('./util/pipe');\n/**\n * A representation of any set of values over any amount of time. This is the most basic building block\n * of RxJS.\n *\n * @class Observable<T>\n */\nvar Observable = (function () {\n    /**\n     * @constructor\n     * @param {Function} subscribe the function that is called when the Observable is\n     * initially subscribed to. This function is given a Subscriber, to which new values\n     * can be `next`ed, or an `error` method can be called to raise an error, or\n     * `complete` can be called to notify of a successful completion.\n     */\n    function Observable(subscribe) {\n        this._isScalar = false;\n        if (subscribe) {\n            this._subscribe = subscribe;\n        }\n    }\n    /**\n     * Creates a new Observable, with this Observable as the source, and the passed\n     * operator defined as the new observable's operator.\n     * @method lift\n     * @param {Operator} operator the operator defining the operation to take on the observable\n     * @return {Observable} a new observable with the Operator applied\n     */\n    Observable.prototype.lift = function (operator) {\n        var observable = new Observable();\n        observable.source = this;\n        observable.operator = operator;\n        return observable;\n    };\n    /**\n     * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.\n     *\n     * <span class=\"informal\">Use it when you have all these Observables, but still nothing is happening.</span>\n     *\n     * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It\n     * might be for example a function that you passed to a {@link create} static factory, but most of the time it is\n     * a library implementation, which defines what and when will be emitted by an Observable. This means that calling\n     * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often\n     * thought.\n     *\n     * Apart from starting the execution of an Observable, this method allows you to listen for values\n     * that an Observable emits, as well as for when it completes or errors. You can achieve this in two\n     * following ways.\n     *\n     * The first way is creating an object that implements {@link Observer} interface. It should have methods\n     * defined by that interface, but note that it should be just a regular JavaScript object, which you can create\n     * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do\n     * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also\n     * that your object does not have to implement all methods. If you find yourself creating a method that doesn't\n     * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will\n     * be left uncaught.\n     *\n     * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.\n     * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent\n     * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,\n     * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,\n     * since `subscribe` recognizes these functions by where they were placed in function call. When it comes\n     * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.\n     *\n     * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.\n     * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean\n     * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback\n     * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.\n     *\n     * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.\n     * It is an Observable itself that decides when these functions will be called. For example {@link of}\n     * by default emits all its values synchronously. Always check documentation for how given Observable\n     * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.\n     *\n     * @example <caption>Subscribe with an Observer</caption>\n     * const sumObserver = {\n     *   sum: 0,\n     *   next(value) {\n     *     console.log('Adding: ' + value);\n     *     this.sum = this.sum + value;\n     *   },\n     *   error() { // We actually could just remove this method,\n     *   },        // since we do not really care about errors right now.\n     *   complete() {\n     *     console.log('Sum equals: ' + this.sum);\n     *   }\n     * };\n     *\n     * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.\n     * .subscribe(sumObserver);\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Subscribe with functions</caption>\n     * let sum = 0;\n     *\n     * Rx.Observable.of(1, 2, 3)\n     * .subscribe(\n     *   function(value) {\n     *     console.log('Adding: ' + value);\n     *     sum = sum + value;\n     *   },\n     *   undefined,\n     *   function() {\n     *     console.log('Sum equals: ' + sum);\n     *   }\n     * );\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Cancel a subscription</caption>\n     * const subscription = Rx.Observable.interval(1000).subscribe(\n     *   num => console.log(num),\n     *   undefined,\n     *   () => console.log('completed!') // Will not be called, even\n     * );                                // when cancelling subscription\n     *\n     *\n     * setTimeout(() => {\n     *   subscription.unsubscribe();\n     *   console.log('unsubscribed!');\n     * }, 2500);\n     *\n     * // Logs:\n     * // 0 after 1s\n     * // 1 after 2s\n     * // \"unsubscribed!\" after 2.5s\n     *\n     *\n     * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,\n     *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed\n     *  Observable.\n     * @param {Function} error (optional) A handler for a terminal event resulting from an error. If no error handler is provided,\n     *  the error will be thrown as unhandled.\n     * @param {Function} complete (optional) A handler for a terminal event resulting from successful completion.\n     * @return {ISubscription} a subscription reference to the registered handlers\n     * @method subscribe\n     */\n    Observable.prototype.subscribe = function (observerOrNext, error, complete) {\n        var operator = this.operator;\n        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);\n        if (operator) {\n            operator.call(sink, this.source);\n        }\n        else {\n            sink.add(this.source || !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));\n        }\n        if (sink.syncErrorThrowable) {\n            sink.syncErrorThrowable = false;\n            if (sink.syncErrorThrown) {\n                throw sink.syncErrorValue;\n            }\n        }\n        return sink;\n    };\n    Observable.prototype._trySubscribe = function (sink) {\n        try {\n            return this._subscribe(sink);\n        }\n        catch (err) {\n            sink.syncErrorThrown = true;\n            sink.syncErrorValue = err;\n            sink.error(err);\n        }\n    };\n    /**\n     * @method forEach\n     * @param {Function} next a handler for each value emitted by the observable\n     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise\n     * @return {Promise} a promise that either resolves on observable completion or\n     *  rejects with the handled error\n     */\n    Observable.prototype.forEach = function (next, PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            // Must be declared in a separate statement to avoid a RefernceError when\n            // accessing subscription below in the closure due to Temporal Dead Zone.\n            var subscription;\n            subscription = _this.subscribe(function (value) {\n                if (subscription) {\n                    // if there is a subscription, then we can surmise\n                    // the next handling is asynchronous. Any errors thrown\n                    // need to be rejected explicitly and unsubscribe must be\n                    // called manually\n                    try {\n                        next(value);\n                    }\n                    catch (err) {\n                        reject(err);\n                        subscription.unsubscribe();\n                    }\n                }\n                else {\n                    // if there is NO subscription, then we're getting a nexted\n                    // value synchronously during subscription. We can just call it.\n                    // If it errors, Observable's `subscribe` will ensure the\n                    // unsubscription logic is called, then synchronously rethrow the error.\n                    // After that, Promise will trap the error and send it\n                    // down the rejection path.\n                    next(value);\n                }\n            }, reject, resolve);\n        });\n    };\n    /** @deprecated internal use only */ Observable.prototype._subscribe = function (subscriber) {\n        return this.source.subscribe(subscriber);\n    };\n    /**\n     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable\n     * @method Symbol.observable\n     * @return {Observable} this instance of the observable\n     */\n    Observable.prototype[observable_1.observable] = function () {\n        return this;\n    };\n    /* tslint:enable:max-line-length */\n    /**\n     * Used to stitch together functional operators into a chain.\n     * @method pipe\n     * @return {Observable} the Observable result of all of the operators having\n     * been called in the order they were passed in.\n     *\n     * @example\n     *\n     * import { map, filter, scan } from 'rxjs/operators';\n     *\n     * Rx.Observable.interval(1000)\n     *   .pipe(\n     *     filter(x => x % 2 === 0),\n     *     map(x => x + x),\n     *     scan((acc, x) => acc + x)\n     *   )\n     *   .subscribe(x => console.log(x))\n     */\n    Observable.prototype.pipe = function () {\n        var operations = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operations[_i - 0] = arguments[_i];\n        }\n        if (operations.length === 0) {\n            return this;\n        }\n        return pipe_1.pipeFromArray(operations)(this);\n    };\n    /* tslint:enable:max-line-length */\n    Observable.prototype.toPromise = function (PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            var value;\n            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });\n        });\n    };\n    // HACK: Since TypeScript inherits static properties too, we have to\n    // fight against TypeScript here so Subject can have a different static create signature\n    /**\n     * Creates a new cold Observable by calling the Observable constructor\n     * @static true\n     * @owner Observable\n     * @method create\n     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor\n     * @return {Observable} a new cold observable\n     */\n    Observable.create = function (subscribe) {\n        return new Observable(subscribe);\n    };\n    return Observable;\n}());\nexports.Observable = Observable;\n//# sourceMappingURL=Observable.js.map","\"use strict\";\nexports.empty = {\n    closed: true,\n    next: function (value) { },\n    error: function (err) { throw err; },\n    complete: function () { }\n};\n//# sourceMappingURL=Observer.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar OuterSubscriber = (function (_super) {\n    __extends(OuterSubscriber, _super);\n    function OuterSubscriber() {\n        _super.apply(this, arguments);\n    }\n    OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    OuterSubscriber.prototype.notifyError = function (error, innerSub) {\n        this.destination.error(error);\n    };\n    OuterSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.destination.complete();\n    };\n    return OuterSubscriber;\n}(Subscriber_1.Subscriber));\nexports.OuterSubscriber = OuterSubscriber;\n//# sourceMappingURL=OuterSubscriber.js.map","\"use strict\";\n/**\n * An execution context and a data structure to order tasks and schedule their\n * execution. Provides a notion of (potentially virtual) time, through the\n * `now()` getter method.\n *\n * Each unit of work in a Scheduler is called an {@link Action}.\n *\n * ```ts\n * class Scheduler {\n *   now(): number;\n *   schedule(work, delay?, state?): Subscription;\n * }\n * ```\n *\n * @class Scheduler\n */\nvar Scheduler = (function () {\n    function Scheduler(SchedulerAction, now) {\n        if (now === void 0) { now = Scheduler.now; }\n        this.SchedulerAction = SchedulerAction;\n        this.now = now;\n    }\n    /**\n     * Schedules a function, `work`, for execution. May happen at some point in\n     * the future, according to the `delay` parameter, if specified. May be passed\n     * some context object, `state`, which will be passed to the `work` function.\n     *\n     * The given arguments will be processed an stored as an Action object in a\n     * queue of actions.\n     *\n     * @param {function(state: ?T): ?Subscription} work A function representing a\n     * task, or some unit of work to be executed by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler itself.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @return {Subscription} A subscription in order to be able to unsubscribe\n     * the scheduled work.\n     */\n    Scheduler.prototype.schedule = function (work, delay, state) {\n        if (delay === void 0) { delay = 0; }\n        return new this.SchedulerAction(this, work).schedule(state, delay);\n    };\n    Scheduler.now = Date.now ? Date.now : function () { return +new Date(); };\n    return Scheduler;\n}());\nexports.Scheduler = Scheduler;\n//# sourceMappingURL=Scheduler.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('./Observable');\nvar Subscriber_1 = require('./Subscriber');\nvar Subscription_1 = require('./Subscription');\nvar ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError');\nvar SubjectSubscription_1 = require('./SubjectSubscription');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * @class SubjectSubscriber<T>\n */\nvar SubjectSubscriber = (function (_super) {\n    __extends(SubjectSubscriber, _super);\n    function SubjectSubscriber(destination) {\n        _super.call(this, destination);\n        this.destination = destination;\n    }\n    return SubjectSubscriber;\n}(Subscriber_1.Subscriber));\nexports.SubjectSubscriber = SubjectSubscriber;\n/**\n * @class Subject<T>\n */\nvar Subject = (function (_super) {\n    __extends(Subject, _super);\n    function Subject() {\n        _super.call(this);\n        this.observers = [];\n        this.closed = false;\n        this.isStopped = false;\n        this.hasError = false;\n        this.thrownError = null;\n    }\n    Subject.prototype[rxSubscriber_1.rxSubscriber] = function () {\n        return new SubjectSubscriber(this);\n    };\n    Subject.prototype.lift = function (operator) {\n        var subject = new AnonymousSubject(this, this);\n        subject.operator = operator;\n        return subject;\n    };\n    Subject.prototype.next = function (value) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        if (!this.isStopped) {\n            var observers = this.observers;\n            var len = observers.length;\n            var copy = observers.slice();\n            for (var i = 0; i < len; i++) {\n                copy[i].next(value);\n            }\n        }\n    };\n    Subject.prototype.error = function (err) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.hasError = true;\n        this.thrownError = err;\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].error(err);\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.complete = function () {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        this.isStopped = true;\n        var observers = this.observers;\n        var len = observers.length;\n        var copy = observers.slice();\n        for (var i = 0; i < len; i++) {\n            copy[i].complete();\n        }\n        this.observers.length = 0;\n    };\n    Subject.prototype.unsubscribe = function () {\n        this.isStopped = true;\n        this.closed = true;\n        this.observers = null;\n    };\n    Subject.prototype._trySubscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else {\n            return _super.prototype._trySubscribe.call(this, subscriber);\n        }\n    };\n    /** @deprecated internal use only */ Subject.prototype._subscribe = function (subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n        }\n        else if (this.hasError) {\n            subscriber.error(this.thrownError);\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else if (this.isStopped) {\n            subscriber.complete();\n            return Subscription_1.Subscription.EMPTY;\n        }\n        else {\n            this.observers.push(subscriber);\n            return new SubjectSubscription_1.SubjectSubscription(this, subscriber);\n        }\n    };\n    Subject.prototype.asObservable = function () {\n        var observable = new Observable_1.Observable();\n        observable.source = this;\n        return observable;\n    };\n    Subject.create = function (destination, source) {\n        return new AnonymousSubject(destination, source);\n    };\n    return Subject;\n}(Observable_1.Observable));\nexports.Subject = Subject;\n/**\n * @class AnonymousSubject<T>\n */\nvar AnonymousSubject = (function (_super) {\n    __extends(AnonymousSubject, _super);\n    function AnonymousSubject(destination, source) {\n        _super.call(this);\n        this.destination = destination;\n        this.source = source;\n    }\n    AnonymousSubject.prototype.next = function (value) {\n        var destination = this.destination;\n        if (destination && destination.next) {\n            destination.next(value);\n        }\n    };\n    AnonymousSubject.prototype.error = function (err) {\n        var destination = this.destination;\n        if (destination && destination.error) {\n            this.destination.error(err);\n        }\n    };\n    AnonymousSubject.prototype.complete = function () {\n        var destination = this.destination;\n        if (destination && destination.complete) {\n            this.destination.complete();\n        }\n    };\n    /** @deprecated internal use only */ AnonymousSubject.prototype._subscribe = function (subscriber) {\n        var source = this.source;\n        if (source) {\n            return this.source.subscribe(subscriber);\n        }\n        else {\n            return Subscription_1.Subscription.EMPTY;\n        }\n    };\n    return AnonymousSubject;\n}(Subject));\nexports.AnonymousSubject = AnonymousSubject;\n//# sourceMappingURL=Subject.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = require('./Subscription');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SubjectSubscription = (function (_super) {\n    __extends(SubjectSubscription, _super);\n    function SubjectSubscription(subject, subscriber) {\n        _super.call(this);\n        this.subject = subject;\n        this.subscriber = subscriber;\n        this.closed = false;\n    }\n    SubjectSubscription.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.closed = true;\n        var subject = this.subject;\n        var observers = subject.observers;\n        this.subject = null;\n        if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {\n            return;\n        }\n        var subscriberIndex = observers.indexOf(this.subscriber);\n        if (subscriberIndex !== -1) {\n            observers.splice(subscriberIndex, 1);\n        }\n    };\n    return SubjectSubscription;\n}(Subscription_1.Subscription));\nexports.SubjectSubscription = SubjectSubscription;\n//# sourceMappingURL=SubjectSubscription.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isFunction_1 = require('./util/isFunction');\nvar Subscription_1 = require('./Subscription');\nvar Observer_1 = require('./Observer');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * Implements the {@link Observer} interface and extends the\n * {@link Subscription} class. While the {@link Observer} is the public API for\n * consuming the values of an {@link Observable}, all Observers get converted to\n * a Subscriber, in order to provide Subscription-like capabilities such as\n * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for\n * implementing operators, but it is rarely used as a public API.\n *\n * @class Subscriber<T>\n */\nvar Subscriber = (function (_super) {\n    __extends(Subscriber, _super);\n    /**\n     * @param {Observer|function(value: T): void} [destinationOrNext] A partially\n     * defined Observer or a `next` callback function.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     */\n    function Subscriber(destinationOrNext, error, complete) {\n        _super.call(this);\n        this.syncErrorValue = null;\n        this.syncErrorThrown = false;\n        this.syncErrorThrowable = false;\n        this.isStopped = false;\n        switch (arguments.length) {\n            case 0:\n                this.destination = Observer_1.empty;\n                break;\n            case 1:\n                if (!destinationOrNext) {\n                    this.destination = Observer_1.empty;\n                    break;\n                }\n                if (typeof destinationOrNext === 'object') {\n                    // HACK(benlesh): To resolve an issue where Node users may have multiple\n                    // copies of rxjs in their node_modules directory.\n                    if (isTrustedSubscriber(destinationOrNext)) {\n                        var trustedSubscriber = destinationOrNext[rxSubscriber_1.rxSubscriber]();\n                        this.syncErrorThrowable = trustedSubscriber.syncErrorThrowable;\n                        this.destination = trustedSubscriber;\n                        trustedSubscriber.add(this);\n                    }\n                    else {\n                        this.syncErrorThrowable = true;\n                        this.destination = new SafeSubscriber(this, destinationOrNext);\n                    }\n                    break;\n                }\n            default:\n                this.syncErrorThrowable = true;\n                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n                break;\n        }\n    }\n    Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { return this; };\n    /**\n     * A static factory for a Subscriber, given a (potentially partial) definition\n     * of an Observer.\n     * @param {function(x: ?T): void} [next] The `next` callback of an Observer.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)\n     * Observer represented by the given arguments.\n     */\n    Subscriber.create = function (next, error, complete) {\n        var subscriber = new Subscriber(next, error, complete);\n        subscriber.syncErrorThrowable = false;\n        return subscriber;\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `next` from\n     * the Observable, with a value. The Observable may call this method 0 or more\n     * times.\n     * @param {T} [value] The `next` value.\n     * @return {void}\n     */\n    Subscriber.prototype.next = function (value) {\n        if (!this.isStopped) {\n            this._next(value);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `error` from\n     * the Observable, with an attached {@link Error}. Notifies the Observer that\n     * the Observable has experienced an error condition.\n     * @param {any} [err] The `error` exception.\n     * @return {void}\n     */\n    Subscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._error(err);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive a valueless notification of type\n     * `complete` from the Observable. Notifies the Observer that the Observable\n     * has finished sending push-based notifications.\n     * @return {void}\n     */\n    Subscriber.prototype.complete = function () {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._complete();\n        }\n    };\n    Subscriber.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.isStopped = true;\n        _super.prototype.unsubscribe.call(this);\n    };\n    Subscriber.prototype._next = function (value) {\n        this.destination.next(value);\n    };\n    Subscriber.prototype._error = function (err) {\n        this.destination.error(err);\n        this.unsubscribe();\n    };\n    Subscriber.prototype._complete = function () {\n        this.destination.complete();\n        this.unsubscribe();\n    };\n    /** @deprecated internal use only */ Subscriber.prototype._unsubscribeAndRecycle = function () {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        this._parent = null;\n        this._parents = null;\n        this.unsubscribe();\n        this.closed = false;\n        this.isStopped = false;\n        this._parent = _parent;\n        this._parents = _parents;\n        return this;\n    };\n    return Subscriber;\n}(Subscription_1.Subscription));\nexports.Subscriber = Subscriber;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SafeSubscriber = (function (_super) {\n    __extends(SafeSubscriber, _super);\n    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {\n        _super.call(this);\n        this._parentSubscriber = _parentSubscriber;\n        var next;\n        var context = this;\n        if (isFunction_1.isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            next = observerOrNext.next;\n            error = observerOrNext.error;\n            complete = observerOrNext.complete;\n            if (observerOrNext !== Observer_1.empty) {\n                context = Object.create(observerOrNext);\n                if (isFunction_1.isFunction(context.unsubscribe)) {\n                    this.add(context.unsubscribe.bind(context));\n                }\n                context.unsubscribe = this.unsubscribe.bind(this);\n            }\n        }\n        this._context = context;\n        this._next = next;\n        this._error = error;\n        this._complete = complete;\n    }\n    SafeSubscriber.prototype.next = function (value) {\n        if (!this.isStopped && this._next) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (!_parentSubscriber.syncErrorThrowable) {\n                this.__tryOrUnsub(this._next, value);\n            }\n            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._error) {\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(this._error, err);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, this._error, err);\n                    this.unsubscribe();\n                }\n            }\n            else if (!_parentSubscriber.syncErrorThrowable) {\n                this.unsubscribe();\n                throw err;\n            }\n            else {\n                _parentSubscriber.syncErrorValue = err;\n                _parentSubscriber.syncErrorThrown = true;\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.complete = function () {\n        var _this = this;\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._complete) {\n                var wrappedComplete = function () { return _this._complete.call(_this._context); };\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(wrappedComplete);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n                    this.unsubscribe();\n                }\n            }\n            else {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            this.unsubscribe();\n            throw err;\n        }\n    };\n    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            parent.syncErrorValue = err;\n            parent.syncErrorThrown = true;\n            return true;\n        }\n        return false;\n    };\n    /** @deprecated internal use only */ SafeSubscriber.prototype._unsubscribe = function () {\n        var _parentSubscriber = this._parentSubscriber;\n        this._context = null;\n        this._parentSubscriber = null;\n        _parentSubscriber.unsubscribe();\n    };\n    return SafeSubscriber;\n}(Subscriber));\nfunction isTrustedSubscriber(obj) {\n    return obj instanceof Subscriber || ('syncErrorThrowable' in obj && obj[rxSubscriber_1.rxSubscriber]);\n}\n//# sourceMappingURL=Subscriber.js.map","\"use strict\";\nvar isArray_1 = require('./util/isArray');\nvar isObject_1 = require('./util/isObject');\nvar isFunction_1 = require('./util/isFunction');\nvar tryCatch_1 = require('./util/tryCatch');\nvar errorObject_1 = require('./util/errorObject');\nvar UnsubscriptionError_1 = require('./util/UnsubscriptionError');\n/**\n * Represents a disposable resource, such as the execution of an Observable. A\n * Subscription has one important method, `unsubscribe`, that takes no argument\n * and just disposes the resource held by the subscription.\n *\n * Additionally, subscriptions may be grouped together through the `add()`\n * method, which will attach a child Subscription to the current Subscription.\n * When a Subscription is unsubscribed, all its children (and its grandchildren)\n * will be unsubscribed as well.\n *\n * @class Subscription\n */\nvar Subscription = (function () {\n    /**\n     * @param {function(): void} [unsubscribe] A function describing how to\n     * perform the disposal of resources when the `unsubscribe` method is called.\n     */\n    function Subscription(unsubscribe) {\n        /**\n         * A flag to indicate whether this Subscription has already been unsubscribed.\n         * @type {boolean}\n         */\n        this.closed = false;\n        this._parent = null;\n        this._parents = null;\n        this._subscriptions = null;\n        if (unsubscribe) {\n            this._unsubscribe = unsubscribe;\n        }\n    }\n    /**\n     * Disposes the resources held by the subscription. May, for instance, cancel\n     * an ongoing Observable execution or cancel any other type of work that\n     * started when the Subscription was created.\n     * @return {void}\n     */\n    Subscription.prototype.unsubscribe = function () {\n        var hasErrors = false;\n        var errors;\n        if (this.closed) {\n            return;\n        }\n        var _a = this, _parent = _a._parent, _parents = _a._parents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;\n        this.closed = true;\n        this._parent = null;\n        this._parents = null;\n        // null out _subscriptions first so any child subscriptions that attempt\n        // to remove themselves from this subscription will noop\n        this._subscriptions = null;\n        var index = -1;\n        var len = _parents ? _parents.length : 0;\n        // if this._parent is null, then so is this._parents, and we\n        // don't have to remove ourselves from any parent subscriptions.\n        while (_parent) {\n            _parent.remove(this);\n            // if this._parents is null or index >= len,\n            // then _parent is set to null, and the loop exits\n            _parent = ++index < len && _parents[index] || null;\n        }\n        if (isFunction_1.isFunction(_unsubscribe)) {\n            var trial = tryCatch_1.tryCatch(_unsubscribe).call(this);\n            if (trial === errorObject_1.errorObject) {\n                hasErrors = true;\n                errors = errors || (errorObject_1.errorObject.e instanceof UnsubscriptionError_1.UnsubscriptionError ?\n                    flattenUnsubscriptionErrors(errorObject_1.errorObject.e.errors) : [errorObject_1.errorObject.e]);\n            }\n        }\n        if (isArray_1.isArray(_subscriptions)) {\n            index = -1;\n            len = _subscriptions.length;\n            while (++index < len) {\n                var sub = _subscriptions[index];\n                if (isObject_1.isObject(sub)) {\n                    var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub);\n                    if (trial === errorObject_1.errorObject) {\n                        hasErrors = true;\n                        errors = errors || [];\n                        var err = errorObject_1.errorObject.e;\n                        if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {\n                            errors = errors.concat(flattenUnsubscriptionErrors(err.errors));\n                        }\n                        else {\n                            errors.push(err);\n                        }\n                    }\n                }\n            }\n        }\n        if (hasErrors) {\n            throw new UnsubscriptionError_1.UnsubscriptionError(errors);\n        }\n    };\n    /**\n     * Adds a tear down to be called during the unsubscribe() of this\n     * Subscription.\n     *\n     * If the tear down being added is a subscription that is already\n     * unsubscribed, is the same reference `add` is being called on, or is\n     * `Subscription.EMPTY`, it will not be added.\n     *\n     * If this subscription is already in an `closed` state, the passed\n     * tear down logic will be executed immediately.\n     *\n     * @param {TeardownLogic} teardown The additional logic to execute on\n     * teardown.\n     * @return {Subscription} Returns the Subscription used or created to be\n     * added to the inner subscriptions list. This Subscription can be used with\n     * `remove()` to remove the passed teardown logic from the inner subscriptions\n     * list.\n     */\n    Subscription.prototype.add = function (teardown) {\n        if (!teardown || (teardown === Subscription.EMPTY)) {\n            return Subscription.EMPTY;\n        }\n        if (teardown === this) {\n            return this;\n        }\n        var subscription = teardown;\n        switch (typeof teardown) {\n            case 'function':\n                subscription = new Subscription(teardown);\n            case 'object':\n                if (subscription.closed || typeof subscription.unsubscribe !== 'function') {\n                    return subscription;\n                }\n                else if (this.closed) {\n                    subscription.unsubscribe();\n                    return subscription;\n                }\n                else if (typeof subscription._addParent !== 'function' /* quack quack */) {\n                    var tmp = subscription;\n                    subscription = new Subscription();\n                    subscription._subscriptions = [tmp];\n                }\n                break;\n            default:\n                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n        }\n        var subscriptions = this._subscriptions || (this._subscriptions = []);\n        subscriptions.push(subscription);\n        subscription._addParent(this);\n        return subscription;\n    };\n    /**\n     * Removes a Subscription from the internal list of subscriptions that will\n     * unsubscribe during the unsubscribe process of this Subscription.\n     * @param {Subscription} subscription The subscription to remove.\n     * @return {void}\n     */\n    Subscription.prototype.remove = function (subscription) {\n        var subscriptions = this._subscriptions;\n        if (subscriptions) {\n            var subscriptionIndex = subscriptions.indexOf(subscription);\n            if (subscriptionIndex !== -1) {\n                subscriptions.splice(subscriptionIndex, 1);\n            }\n        }\n    };\n    Subscription.prototype._addParent = function (parent) {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        if (!_parent || _parent === parent) {\n            // If we don't have a parent, or the new parent is the same as the\n            // current parent, then set this._parent to the new parent.\n            this._parent = parent;\n        }\n        else if (!_parents) {\n            // If there's already one parent, but not multiple, allocate an Array to\n            // store the rest of the parent Subscriptions.\n            this._parents = [parent];\n        }\n        else if (_parents.indexOf(parent) === -1) {\n            // Only add the new parent to the _parents list if it's not already there.\n            _parents.push(parent);\n        }\n    };\n    Subscription.EMPTY = (function (empty) {\n        empty.closed = true;\n        return empty;\n    }(new Subscription()));\n    return Subscription;\n}());\nexports.Subscription = Subscription;\nfunction flattenUnsubscriptionErrors(errors) {\n    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError_1.UnsubscriptionError) ? err.errors : err); }, []);\n}\n//# sourceMappingURL=Subscription.js.map","\"use strict\";\nvar Observable_1 = require('../../../Observable');\nvar ajax_1 = require('../../../observable/dom/ajax');\nObservable_1.Observable.ajax = ajax_1.ajax;\n//# sourceMappingURL=ajax.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar empty_1 = require('../../observable/empty');\nObservable_1.Observable.empty = empty_1.empty;\n//# sourceMappingURL=empty.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar from_1 = require('../../observable/from');\nObservable_1.Observable.from = from_1.from;\n//# sourceMappingURL=from.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar interval_1 = require('../../observable/interval');\nObservable_1.Observable.interval = interval_1.interval;\n//# sourceMappingURL=interval.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar of_1 = require('../../observable/of');\nObservable_1.Observable.of = of_1.of;\n//# sourceMappingURL=of.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar throw_1 = require('../../observable/throw');\nObservable_1.Observable.throw = throw_1._throw;\n//# sourceMappingURL=throw.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar catch_1 = require('../../operator/catch');\nObservable_1.Observable.prototype.catch = catch_1._catch;\nObservable_1.Observable.prototype._catch = catch_1._catch;\n//# sourceMappingURL=catch.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar combineLatest_1 = require('../../operator/combineLatest');\nObservable_1.Observable.prototype.combineLatest = combineLatest_1.combineLatest;\n//# sourceMappingURL=combineLatest.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar concatMap_1 = require('../../operator/concatMap');\nObservable_1.Observable.prototype.concatMap = concatMap_1.concatMap;\n//# sourceMappingURL=concatMap.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar count_1 = require('../../operator/count');\nObservable_1.Observable.prototype.count = count_1.count;\n//# sourceMappingURL=count.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar delay_1 = require('../../operator/delay');\nObservable_1.Observable.prototype.delay = delay_1.delay;\n//# sourceMappingURL=delay.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar do_1 = require('../../operator/do');\nObservable_1.Observable.prototype.do = do_1._do;\nObservable_1.Observable.prototype._do = do_1._do;\n//# sourceMappingURL=do.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar filter_1 = require('../../operator/filter');\nObservable_1.Observable.prototype.filter = filter_1.filter;\n//# sourceMappingURL=filter.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar map_1 = require('../../operator/map');\nObservable_1.Observable.prototype.map = map_1.map;\n//# sourceMappingURL=map.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar mergeMap_1 = require('../../operator/mergeMap');\nObservable_1.Observable.prototype.mergeMap = mergeMap_1.mergeMap;\nObservable_1.Observable.prototype.flatMap = mergeMap_1.mergeMap;\n//# sourceMappingURL=mergeMap.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar retryWhen_1 = require('../../operator/retryWhen');\nObservable_1.Observable.prototype.retryWhen = retryWhen_1.retryWhen;\n//# sourceMappingURL=retryWhen.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar share_1 = require('../../operator/share');\nObservable_1.Observable.prototype.share = share_1.share;\n//# sourceMappingURL=share.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar take_1 = require('../../operator/take');\nObservable_1.Observable.prototype.take = take_1.take;\n//# sourceMappingURL=take.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar ScalarObservable_1 = require('./ScalarObservable');\nvar EmptyObservable_1 = require('./EmptyObservable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayLikeObservable = (function (_super) {\n    __extends(ArrayLikeObservable, _super);\n    function ArrayLikeObservable(arrayLike, scheduler) {\n        _super.call(this);\n        this.arrayLike = arrayLike;\n        this.scheduler = scheduler;\n        if (!scheduler && arrayLike.length === 1) {\n            this._isScalar = true;\n            this.value = arrayLike[0];\n        }\n    }\n    ArrayLikeObservable.create = function (arrayLike, scheduler) {\n        var length = arrayLike.length;\n        if (length === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else if (length === 1) {\n            return new ScalarObservable_1.ScalarObservable(arrayLike[0], scheduler);\n        }\n        else {\n            return new ArrayLikeObservable(arrayLike, scheduler);\n        }\n    };\n    ArrayLikeObservable.dispatch = function (state) {\n        var arrayLike = state.arrayLike, index = state.index, length = state.length, subscriber = state.subscriber;\n        if (subscriber.closed) {\n            return;\n        }\n        if (index >= length) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(arrayLike[index]);\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ ArrayLikeObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, arrayLike = _a.arrayLike, scheduler = _a.scheduler;\n        var length = arrayLike.length;\n        if (scheduler) {\n            return scheduler.schedule(ArrayLikeObservable.dispatch, 0, {\n                arrayLike: arrayLike, index: index, length: length, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < length && !subscriber.closed; i++) {\n                subscriber.next(arrayLike[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayLikeObservable;\n}(Observable_1.Observable));\nexports.ArrayLikeObservable = ArrayLikeObservable;\n//# sourceMappingURL=ArrayLikeObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar ScalarObservable_1 = require('./ScalarObservable');\nvar EmptyObservable_1 = require('./EmptyObservable');\nvar isScheduler_1 = require('../util/isScheduler');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ArrayObservable = (function (_super) {\n    __extends(ArrayObservable, _super);\n    function ArrayObservable(array, scheduler) {\n        _super.call(this);\n        this.array = array;\n        this.scheduler = scheduler;\n        if (!scheduler && array.length === 1) {\n            this._isScalar = true;\n            this.value = array[0];\n        }\n    }\n    ArrayObservable.create = function (array, scheduler) {\n        return new ArrayObservable(array, scheduler);\n    };\n    /**\n     * Creates an Observable that emits some values you specify as arguments,\n     * immediately one after the other, and then emits a complete notification.\n     *\n     * <span class=\"informal\">Emits the arguments you provide, then completes.\n     * </span>\n     *\n     * <img src=\"./img/of.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the arguments given, and the complete notification thereafter. It can\n     * be used for composing with other Observables, such as with {@link concat}.\n     * By default, it uses a `null` IScheduler, which means the `next`\n     * notifications are sent synchronously, although with a different IScheduler\n     * it is possible to determine when those notifications will be delivered.\n     *\n     * @example <caption>Emit 10, 20, 30, then 'a', 'b', 'c', then start ticking every second.</caption>\n     * var numbers = Rx.Observable.of(10, 20, 30);\n     * var letters = Rx.Observable.of('a', 'b', 'c');\n     * var interval = Rx.Observable.interval(1000);\n     * var result = numbers.concat(letters).concat(interval);\n     * result.subscribe(x => console.log(x));\n     *\n     * @see {@link create}\n     * @see {@link empty}\n     * @see {@link never}\n     * @see {@link throw}\n     *\n     * @param {...T} values Arguments that represent `next` values to be emitted.\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emissions of the `next` notifications.\n     * @return {Observable<T>} An Observable that emits each given input value.\n     * @static true\n     * @name of\n     * @owner Observable\n     */\n    ArrayObservable.of = function () {\n        var array = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            array[_i - 0] = arguments[_i];\n        }\n        var scheduler = array[array.length - 1];\n        if (isScheduler_1.isScheduler(scheduler)) {\n            array.pop();\n        }\n        else {\n            scheduler = null;\n        }\n        var len = array.length;\n        if (len > 1) {\n            return new ArrayObservable(array, scheduler);\n        }\n        else if (len === 1) {\n            return new ScalarObservable_1.ScalarObservable(array[0], scheduler);\n        }\n        else {\n            return new EmptyObservable_1.EmptyObservable(scheduler);\n        }\n    };\n    ArrayObservable.dispatch = function (state) {\n        var array = state.array, index = state.index, count = state.count, subscriber = state.subscriber;\n        if (index >= count) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(array[index]);\n        if (subscriber.closed) {\n            return;\n        }\n        state.index = index + 1;\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ ArrayObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var array = this.array;\n        var count = array.length;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ArrayObservable.dispatch, 0, {\n                array: array, index: index, count: count, subscriber: subscriber\n            });\n        }\n        else {\n            for (var i = 0; i < count && !subscriber.closed; i++) {\n                subscriber.next(array[i]);\n            }\n            subscriber.complete();\n        }\n    };\n    return ArrayObservable;\n}(Observable_1.Observable));\nexports.ArrayObservable = ArrayObservable;\n//# sourceMappingURL=ArrayObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('../Subject');\nvar Observable_1 = require('../Observable');\nvar Subscriber_1 = require('../Subscriber');\nvar Subscription_1 = require('../Subscription');\nvar refCount_1 = require('../operators/refCount');\n/**\n * @class ConnectableObservable<T>\n */\nvar ConnectableObservable = (function (_super) {\n    __extends(ConnectableObservable, _super);\n    function ConnectableObservable(/** @deprecated internal use only */ source, \n        /** @deprecated internal use only */ subjectFactory) {\n        _super.call(this);\n        this.source = source;\n        this.subjectFactory = subjectFactory;\n        /** @deprecated internal use only */ this._refCount = 0;\n        this._isComplete = false;\n    }\n    /** @deprecated internal use only */ ConnectableObservable.prototype._subscribe = function (subscriber) {\n        return this.getSubject().subscribe(subscriber);\n    };\n    /** @deprecated internal use only */ ConnectableObservable.prototype.getSubject = function () {\n        var subject = this._subject;\n        if (!subject || subject.isStopped) {\n            this._subject = this.subjectFactory();\n        }\n        return this._subject;\n    };\n    ConnectableObservable.prototype.connect = function () {\n        var connection = this._connection;\n        if (!connection) {\n            this._isComplete = false;\n            connection = this._connection = new Subscription_1.Subscription();\n            connection.add(this.source\n                .subscribe(new ConnectableSubscriber(this.getSubject(), this)));\n            if (connection.closed) {\n                this._connection = null;\n                connection = Subscription_1.Subscription.EMPTY;\n            }\n            else {\n                this._connection = connection;\n            }\n        }\n        return connection;\n    };\n    ConnectableObservable.prototype.refCount = function () {\n        return refCount_1.refCount()(this);\n    };\n    return ConnectableObservable;\n}(Observable_1.Observable));\nexports.ConnectableObservable = ConnectableObservable;\nvar connectableProto = ConnectableObservable.prototype;\nexports.connectableObservableDescriptor = {\n    operator: { value: null },\n    _refCount: { value: 0, writable: true },\n    _subject: { value: null, writable: true },\n    _connection: { value: null, writable: true },\n    _subscribe: { value: connectableProto._subscribe },\n    _isComplete: { value: connectableProto._isComplete, writable: true },\n    getSubject: { value: connectableProto.getSubject },\n    connect: { value: connectableProto.connect },\n    refCount: { value: connectableProto.refCount }\n};\nvar ConnectableSubscriber = (function (_super) {\n    __extends(ConnectableSubscriber, _super);\n    function ConnectableSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    ConnectableSubscriber.prototype._error = function (err) {\n        this._unsubscribe();\n        _super.prototype._error.call(this, err);\n    };\n    ConnectableSubscriber.prototype._complete = function () {\n        this.connectable._isComplete = true;\n        this._unsubscribe();\n        _super.prototype._complete.call(this);\n    };\n    /** @deprecated internal use only */ ConnectableSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (connectable) {\n            this.connectable = null;\n            var connection = connectable._connection;\n            connectable._refCount = 0;\n            connectable._subject = null;\n            connectable._connection = null;\n            if (connection) {\n                connection.unsubscribe();\n            }\n        }\n    };\n    return ConnectableSubscriber;\n}(Subject_1.SubjectSubscriber));\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    /** @deprecated internal use only */ RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=ConnectableObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar EmptyObservable = (function (_super) {\n    __extends(EmptyObservable, _super);\n    function EmptyObservable(scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable that emits no items to the Observer and immediately\n     * emits a complete notification.\n     *\n     * <span class=\"informal\">Just emits 'complete', and nothing else.\n     * </span>\n     *\n     * <img src=\"./img/empty.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the complete notification. It can be used for composing with other\n     * Observables, such as in a {@link mergeMap}.\n     *\n     * @example <caption>Emit the number 7, then complete.</caption>\n     * var result = Rx.Observable.empty().startWith(7);\n     * result.subscribe(x => console.log(x));\n     *\n     * @example <caption>Map and flatten only odd numbers to the sequence 'a', 'b', 'c'</caption>\n     * var interval = Rx.Observable.interval(1000);\n     * var result = interval.mergeMap(x =>\n     *   x % 2 === 1 ? Rx.Observable.of('a', 'b', 'c') : Rx.Observable.empty()\n     * );\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following to the console:\n     * // x is equal to the count on the interval eg(0,1,2,3,...)\n     * // x will occur every 1000ms\n     * // if x % 2 is equal to 1 print abc\n     * // if x % 2 is not equal to 1 nothing will be output\n     *\n     * @see {@link create}\n     * @see {@link never}\n     * @see {@link of}\n     * @see {@link throw}\n     *\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emission of the complete notification.\n     * @return {Observable} An \"empty\" Observable: emits only the complete\n     * notification.\n     * @static true\n     * @name empty\n     * @owner Observable\n     */\n    EmptyObservable.create = function (scheduler) {\n        return new EmptyObservable(scheduler);\n    };\n    EmptyObservable.dispatch = function (arg) {\n        var subscriber = arg.subscriber;\n        subscriber.complete();\n    };\n    /** @deprecated internal use only */ EmptyObservable.prototype._subscribe = function (subscriber) {\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(EmptyObservable.dispatch, 0, { subscriber: subscriber });\n        }\n        else {\n            subscriber.complete();\n        }\n    };\n    return EmptyObservable;\n}(Observable_1.Observable));\nexports.EmptyObservable = EmptyObservable;\n//# sourceMappingURL=EmptyObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ErrorObservable = (function (_super) {\n    __extends(ErrorObservable, _super);\n    function ErrorObservable(error, scheduler) {\n        _super.call(this);\n        this.error = error;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable that emits no items to the Observer and immediately\n     * emits an error notification.\n     *\n     * <span class=\"informal\">Just emits 'error', and nothing else.\n     * </span>\n     *\n     * <img src=\"./img/throw.png\" width=\"100%\">\n     *\n     * This static operator is useful for creating a simple Observable that only\n     * emits the error notification. It can be used for composing with other\n     * Observables, such as in a {@link mergeMap}.\n     *\n     * @example <caption>Emit the number 7, then emit an error.</caption>\n     * var result = Rx.Observable.throw(new Error('oops!')).startWith(7);\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @example <caption>Map and flatten numbers to the sequence 'a', 'b', 'c', but throw an error for 13</caption>\n     * var interval = Rx.Observable.interval(1000);\n     * var result = interval.mergeMap(x =>\n     *   x === 13 ?\n     *     Rx.Observable.throw('Thirteens are bad') :\n     *     Rx.Observable.of('a', 'b', 'c')\n     * );\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @see {@link create}\n     * @see {@link empty}\n     * @see {@link never}\n     * @see {@link of}\n     *\n     * @param {any} error The particular Error to pass to the error notification.\n     * @param {Scheduler} [scheduler] A {@link IScheduler} to use for scheduling\n     * the emission of the error notification.\n     * @return {Observable} An error Observable: emits only the error notification\n     * using the given error argument.\n     * @static true\n     * @name throw\n     * @owner Observable\n     */\n    ErrorObservable.create = function (error, scheduler) {\n        return new ErrorObservable(error, scheduler);\n    };\n    ErrorObservable.dispatch = function (arg) {\n        var error = arg.error, subscriber = arg.subscriber;\n        subscriber.error(error);\n    };\n    /** @deprecated internal use only */ ErrorObservable.prototype._subscribe = function (subscriber) {\n        var error = this.error;\n        var scheduler = this.scheduler;\n        subscriber.syncErrorThrowable = true;\n        if (scheduler) {\n            return scheduler.schedule(ErrorObservable.dispatch, 0, {\n                error: error, subscriber: subscriber\n            });\n        }\n        else {\n            subscriber.error(error);\n        }\n    };\n    return ErrorObservable;\n}(Observable_1.Observable));\nexports.ErrorObservable = ErrorObservable;\n//# sourceMappingURL=ErrorObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isArray_1 = require('../util/isArray');\nvar isArrayLike_1 = require('../util/isArrayLike');\nvar isPromise_1 = require('../util/isPromise');\nvar PromiseObservable_1 = require('./PromiseObservable');\nvar IteratorObservable_1 = require('./IteratorObservable');\nvar ArrayObservable_1 = require('./ArrayObservable');\nvar ArrayLikeObservable_1 = require('./ArrayLikeObservable');\nvar iterator_1 = require('../symbol/iterator');\nvar Observable_1 = require('../Observable');\nvar observeOn_1 = require('../operators/observeOn');\nvar observable_1 = require('../symbol/observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar FromObservable = (function (_super) {\n    __extends(FromObservable, _super);\n    function FromObservable(ish, scheduler) {\n        _super.call(this, null);\n        this.ish = ish;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Creates an Observable from an Array, an array-like object, a Promise, an\n     * iterable object, or an Observable-like object.\n     *\n     * <span class=\"informal\">Converts almost anything to an Observable.</span>\n     *\n     * <img src=\"./img/from.png\" width=\"100%\">\n     *\n     * Convert various other objects and data types into Observables. `from`\n     * converts a Promise or an array-like or an\n     * [iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)\n     * object into an Observable that emits the items in that promise or array or\n     * iterable. A String, in this context, is treated as an array of characters.\n     * Observable-like objects (contains a function named with the ES2015 Symbol\n     * for Observable) can also be converted through this operator.\n     *\n     * @example <caption>Converts an array to an Observable</caption>\n     * var array = [10, 20, 30];\n     * var result = Rx.Observable.from(array);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 10 20 30\n     *\n     * @example <caption>Convert an infinite iterable (from a generator) to an Observable</caption>\n     * function* generateDoubles(seed) {\n     *   var i = seed;\n     *   while (true) {\n     *     yield i;\n     *     i = 2 * i; // double it\n     *   }\n     * }\n     *\n     * var iterator = generateDoubles(3);\n     * var result = Rx.Observable.from(iterator).take(10);\n     * result.subscribe(x => console.log(x));\n     *\n     * // Results in the following:\n     * // 3 6 12 24 48 96 192 384 768 1536\n     *\n     * @see {@link create}\n     * @see {@link fromEvent}\n     * @see {@link fromEventPattern}\n     * @see {@link fromPromise}\n     *\n     * @param {ObservableInput<T>} ish A subscribable object, a Promise, an\n     * Observable-like, an Array, an iterable or an array-like object to be\n     * converted.\n     * @param {Scheduler} [scheduler] The scheduler on which to schedule the\n     * emissions of values.\n     * @return {Observable<T>} The Observable whose values are originally from the\n     * input object that was converted.\n     * @static true\n     * @name from\n     * @owner Observable\n     */\n    FromObservable.create = function (ish, scheduler) {\n        if (ish != null) {\n            if (typeof ish[observable_1.observable] === 'function') {\n                if (ish instanceof Observable_1.Observable && !scheduler) {\n                    return ish;\n                }\n                return new FromObservable(ish, scheduler);\n            }\n            else if (isArray_1.isArray(ish)) {\n                return new ArrayObservable_1.ArrayObservable(ish, scheduler);\n            }\n            else if (isPromise_1.isPromise(ish)) {\n                return new PromiseObservable_1.PromiseObservable(ish, scheduler);\n            }\n            else if (typeof ish[iterator_1.iterator] === 'function' || typeof ish === 'string') {\n                return new IteratorObservable_1.IteratorObservable(ish, scheduler);\n            }\n            else if (isArrayLike_1.isArrayLike(ish)) {\n                return new ArrayLikeObservable_1.ArrayLikeObservable(ish, scheduler);\n            }\n        }\n        throw new TypeError((ish !== null && typeof ish || ish) + ' is not observable');\n    };\n    /** @deprecated internal use only */ FromObservable.prototype._subscribe = function (subscriber) {\n        var ish = this.ish;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            return ish[observable_1.observable]().subscribe(subscriber);\n        }\n        else {\n            return ish[observable_1.observable]().subscribe(new observeOn_1.ObserveOnSubscriber(subscriber, scheduler, 0));\n        }\n    };\n    return FromObservable;\n}(Observable_1.Observable));\nexports.FromObservable = FromObservable;\n//# sourceMappingURL=FromObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isNumeric_1 = require('../util/isNumeric');\nvar Observable_1 = require('../Observable');\nvar async_1 = require('../scheduler/async');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar IntervalObservable = (function (_super) {\n    __extends(IntervalObservable, _super);\n    function IntervalObservable(period, scheduler) {\n        if (period === void 0) { period = 0; }\n        if (scheduler === void 0) { scheduler = async_1.async; }\n        _super.call(this);\n        this.period = period;\n        this.scheduler = scheduler;\n        if (!isNumeric_1.isNumeric(period) || period < 0) {\n            this.period = 0;\n        }\n        if (!scheduler || typeof scheduler.schedule !== 'function') {\n            this.scheduler = async_1.async;\n        }\n    }\n    /**\n     * Creates an Observable that emits sequential numbers every specified\n     * interval of time, on a specified IScheduler.\n     *\n     * <span class=\"informal\">Emits incremental numbers periodically in time.\n     * </span>\n     *\n     * <img src=\"./img/interval.png\" width=\"100%\">\n     *\n     * `interval` returns an Observable that emits an infinite sequence of\n     * ascending integers, with a constant interval of time of your choosing\n     * between those emissions. The first emission is not sent immediately, but\n     * only after the first period has passed. By default, this operator uses the\n     * `async` IScheduler to provide a notion of time, but you may pass any\n     * IScheduler to it.\n     *\n     * @example <caption>Emits ascending numbers, one every second (1000ms)</caption>\n     * var numbers = Rx.Observable.interval(1000);\n     * numbers.subscribe(x => console.log(x));\n     *\n     * @see {@link timer}\n     * @see {@link delay}\n     *\n     * @param {number} [period=0] The interval size in milliseconds (by default)\n     * or the time unit determined by the scheduler's clock.\n     * @param {Scheduler} [scheduler=async] The IScheduler to use for scheduling\n     * the emission of values, and providing a notion of \"time\".\n     * @return {Observable} An Observable that emits a sequential number each time\n     * interval.\n     * @static true\n     * @name interval\n     * @owner Observable\n     */\n    IntervalObservable.create = function (period, scheduler) {\n        if (period === void 0) { period = 0; }\n        if (scheduler === void 0) { scheduler = async_1.async; }\n        return new IntervalObservable(period, scheduler);\n    };\n    IntervalObservable.dispatch = function (state) {\n        var index = state.index, subscriber = state.subscriber, period = state.period;\n        subscriber.next(index);\n        if (subscriber.closed) {\n            return;\n        }\n        state.index += 1;\n        this.schedule(state, period);\n    };\n    /** @deprecated internal use only */ IntervalObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var period = this.period;\n        var scheduler = this.scheduler;\n        subscriber.add(scheduler.schedule(IntervalObservable.dispatch, period, {\n            index: index, subscriber: subscriber, period: period\n        }));\n    };\n    return IntervalObservable;\n}(Observable_1.Observable));\nexports.IntervalObservable = IntervalObservable;\n//# sourceMappingURL=IntervalObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Observable_1 = require('../Observable');\nvar iterator_1 = require('../symbol/iterator');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar IteratorObservable = (function (_super) {\n    __extends(IteratorObservable, _super);\n    function IteratorObservable(iterator, scheduler) {\n        _super.call(this);\n        this.scheduler = scheduler;\n        if (iterator == null) {\n            throw new Error('iterator cannot be null.');\n        }\n        this.iterator = getIterator(iterator);\n    }\n    IteratorObservable.create = function (iterator, scheduler) {\n        return new IteratorObservable(iterator, scheduler);\n    };\n    IteratorObservable.dispatch = function (state) {\n        var index = state.index, hasError = state.hasError, iterator = state.iterator, subscriber = state.subscriber;\n        if (hasError) {\n            subscriber.error(state.error);\n            return;\n        }\n        var result = iterator.next();\n        if (result.done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(result.value);\n        state.index = index + 1;\n        if (subscriber.closed) {\n            if (typeof iterator.return === 'function') {\n                iterator.return();\n            }\n            return;\n        }\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ IteratorObservable.prototype._subscribe = function (subscriber) {\n        var index = 0;\n        var _a = this, iterator = _a.iterator, scheduler = _a.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(IteratorObservable.dispatch, 0, {\n                index: index, iterator: iterator, subscriber: subscriber\n            });\n        }\n        else {\n            do {\n                var result = iterator.next();\n                if (result.done) {\n                    subscriber.complete();\n                    break;\n                }\n                else {\n                    subscriber.next(result.value);\n                }\n                if (subscriber.closed) {\n                    if (typeof iterator.return === 'function') {\n                        iterator.return();\n                    }\n                    break;\n                }\n            } while (true);\n        }\n    };\n    return IteratorObservable;\n}(Observable_1.Observable));\nexports.IteratorObservable = IteratorObservable;\nvar StringIterator = (function () {\n    function StringIterator(str, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = str.length; }\n        this.str = str;\n        this.idx = idx;\n        this.len = len;\n    }\n    StringIterator.prototype[iterator_1.iterator] = function () { return (this); };\n    StringIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.str.charAt(this.idx++)\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return StringIterator;\n}());\nvar ArrayIterator = (function () {\n    function ArrayIterator(arr, idx, len) {\n        if (idx === void 0) { idx = 0; }\n        if (len === void 0) { len = toLength(arr); }\n        this.arr = arr;\n        this.idx = idx;\n        this.len = len;\n    }\n    ArrayIterator.prototype[iterator_1.iterator] = function () { return this; };\n    ArrayIterator.prototype.next = function () {\n        return this.idx < this.len ? {\n            done: false,\n            value: this.arr[this.idx++]\n        } : {\n            done: true,\n            value: undefined\n        };\n    };\n    return ArrayIterator;\n}());\nfunction getIterator(obj) {\n    var i = obj[iterator_1.iterator];\n    if (!i && typeof obj === 'string') {\n        return new StringIterator(obj);\n    }\n    if (!i && obj.length !== undefined) {\n        return new ArrayIterator(obj);\n    }\n    if (!i) {\n        throw new TypeError('object is not iterable');\n    }\n    return obj[iterator_1.iterator]();\n}\nvar maxSafeInteger = Math.pow(2, 53) - 1;\nfunction toLength(o) {\n    var len = +o.length;\n    if (isNaN(len)) {\n        return 0;\n    }\n    if (len === 0 || !numberIsFinite(len)) {\n        return len;\n    }\n    len = sign(len) * Math.floor(Math.abs(len));\n    if (len <= 0) {\n        return 0;\n    }\n    if (len > maxSafeInteger) {\n        return maxSafeInteger;\n    }\n    return len;\n}\nfunction numberIsFinite(value) {\n    return typeof value === 'number' && root_1.root.isFinite(value);\n}\nfunction sign(value) {\n    var valueAsNumber = +value;\n    if (valueAsNumber === 0) {\n        return valueAsNumber;\n    }\n    if (isNaN(valueAsNumber)) {\n        return valueAsNumber;\n    }\n    return valueAsNumber < 0 ? -1 : 1;\n}\n//# sourceMappingURL=IteratorObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar PromiseObservable = (function (_super) {\n    __extends(PromiseObservable, _super);\n    function PromiseObservable(promise, scheduler) {\n        _super.call(this);\n        this.promise = promise;\n        this.scheduler = scheduler;\n    }\n    /**\n     * Converts a Promise to an Observable.\n     *\n     * <span class=\"informal\">Returns an Observable that just emits the Promise's\n     * resolved value, then completes.</span>\n     *\n     * Converts an ES2015 Promise or a Promises/A+ spec compliant Promise to an\n     * Observable. If the Promise resolves with a value, the output Observable\n     * emits that resolved value as a `next`, and then completes. If the Promise\n     * is rejected, then the output Observable emits the corresponding Error.\n     *\n     * @example <caption>Convert the Promise returned by Fetch to an Observable</caption>\n     * var result = Rx.Observable.fromPromise(fetch('http://myserver.com/'));\n     * result.subscribe(x => console.log(x), e => console.error(e));\n     *\n     * @see {@link bindCallback}\n     * @see {@link from}\n     *\n     * @param {PromiseLike<T>} promise The promise to be converted.\n     * @param {Scheduler} [scheduler] An optional IScheduler to use for scheduling\n     * the delivery of the resolved value (or the rejection).\n     * @return {Observable<T>} An Observable which wraps the Promise.\n     * @static true\n     * @name fromPromise\n     * @owner Observable\n     */\n    PromiseObservable.create = function (promise, scheduler) {\n        return new PromiseObservable(promise, scheduler);\n    };\n    /** @deprecated internal use only */ PromiseObservable.prototype._subscribe = function (subscriber) {\n        var _this = this;\n        var promise = this.promise;\n        var scheduler = this.scheduler;\n        if (scheduler == null) {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    subscriber.next(this.value);\n                    subscriber.complete();\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.next(value);\n                        subscriber.complete();\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.error(err);\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n        else {\n            if (this._isScalar) {\n                if (!subscriber.closed) {\n                    return scheduler.schedule(dispatchNext, 0, { value: this.value, subscriber: subscriber });\n                }\n            }\n            else {\n                promise.then(function (value) {\n                    _this.value = value;\n                    _this._isScalar = true;\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchNext, 0, { value: value, subscriber: subscriber }));\n                    }\n                }, function (err) {\n                    if (!subscriber.closed) {\n                        subscriber.add(scheduler.schedule(dispatchError, 0, { err: err, subscriber: subscriber }));\n                    }\n                })\n                    .then(null, function (err) {\n                    // escape the promise trap, throw unhandled errors\n                    root_1.root.setTimeout(function () { throw err; });\n                });\n            }\n        }\n    };\n    return PromiseObservable;\n}(Observable_1.Observable));\nexports.PromiseObservable = PromiseObservable;\nfunction dispatchNext(arg) {\n    var value = arg.value, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.next(value);\n        subscriber.complete();\n    }\n}\nfunction dispatchError(arg) {\n    var err = arg.err, subscriber = arg.subscriber;\n    if (!subscriber.closed) {\n        subscriber.error(err);\n    }\n}\n//# sourceMappingURL=PromiseObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar ScalarObservable = (function (_super) {\n    __extends(ScalarObservable, _super);\n    function ScalarObservable(value, scheduler) {\n        _super.call(this);\n        this.value = value;\n        this.scheduler = scheduler;\n        this._isScalar = true;\n        if (scheduler) {\n            this._isScalar = false;\n        }\n    }\n    ScalarObservable.create = function (value, scheduler) {\n        return new ScalarObservable(value, scheduler);\n    };\n    ScalarObservable.dispatch = function (state) {\n        var done = state.done, value = state.value, subscriber = state.subscriber;\n        if (done) {\n            subscriber.complete();\n            return;\n        }\n        subscriber.next(value);\n        if (subscriber.closed) {\n            return;\n        }\n        state.done = true;\n        this.schedule(state);\n    };\n    /** @deprecated internal use only */ ScalarObservable.prototype._subscribe = function (subscriber) {\n        var value = this.value;\n        var scheduler = this.scheduler;\n        if (scheduler) {\n            return scheduler.schedule(ScalarObservable.dispatch, 0, {\n                done: false, value: value, subscriber: subscriber\n            });\n        }\n        else {\n            subscriber.next(value);\n            if (!subscriber.closed) {\n                subscriber.complete();\n            }\n        }\n    };\n    return ScalarObservable;\n}(Observable_1.Observable));\nexports.ScalarObservable = ScalarObservable;\n//# sourceMappingURL=ScalarObservable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../../util/root');\nvar tryCatch_1 = require('../../util/tryCatch');\nvar errorObject_1 = require('../../util/errorObject');\nvar Observable_1 = require('../../Observable');\nvar Subscriber_1 = require('../../Subscriber');\nvar map_1 = require('../../operators/map');\nfunction getCORSRequest() {\n    if (root_1.root.XMLHttpRequest) {\n        return new root_1.root.XMLHttpRequest();\n    }\n    else if (!!root_1.root.XDomainRequest) {\n        return new root_1.root.XDomainRequest();\n    }\n    else {\n        throw new Error('CORS is not supported by your browser');\n    }\n}\nfunction getXMLHttpRequest() {\n    if (root_1.root.XMLHttpRequest) {\n        return new root_1.root.XMLHttpRequest();\n    }\n    else {\n        var progId = void 0;\n        try {\n            var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];\n            for (var i = 0; i < 3; i++) {\n                try {\n                    progId = progIds[i];\n                    if (new root_1.root.ActiveXObject(progId)) {\n                        break;\n                    }\n                }\n                catch (e) {\n                }\n            }\n            return new root_1.root.ActiveXObject(progId);\n        }\n        catch (e) {\n            throw new Error('XMLHttpRequest is not supported by your browser');\n        }\n    }\n}\nfunction ajaxGet(url, headers) {\n    if (headers === void 0) { headers = null; }\n    return new AjaxObservable({ method: 'GET', url: url, headers: headers });\n}\nexports.ajaxGet = ajaxGet;\n;\nfunction ajaxPost(url, body, headers) {\n    return new AjaxObservable({ method: 'POST', url: url, body: body, headers: headers });\n}\nexports.ajaxPost = ajaxPost;\n;\nfunction ajaxDelete(url, headers) {\n    return new AjaxObservable({ method: 'DELETE', url: url, headers: headers });\n}\nexports.ajaxDelete = ajaxDelete;\n;\nfunction ajaxPut(url, body, headers) {\n    return new AjaxObservable({ method: 'PUT', url: url, body: body, headers: headers });\n}\nexports.ajaxPut = ajaxPut;\n;\nfunction ajaxPatch(url, body, headers) {\n    return new AjaxObservable({ method: 'PATCH', url: url, body: body, headers: headers });\n}\nexports.ajaxPatch = ajaxPatch;\n;\nvar mapResponse = map_1.map(function (x, index) { return x.response; });\nfunction ajaxGetJSON(url, headers) {\n    return mapResponse(new AjaxObservable({\n        method: 'GET',\n        url: url,\n        responseType: 'json',\n        headers: headers\n    }));\n}\nexports.ajaxGetJSON = ajaxGetJSON;\n;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar AjaxObservable = (function (_super) {\n    __extends(AjaxObservable, _super);\n    function AjaxObservable(urlOrRequest) {\n        _super.call(this);\n        var request = {\n            async: true,\n            createXHR: function () {\n                return this.crossDomain ? getCORSRequest.call(this) : getXMLHttpRequest();\n            },\n            crossDomain: false,\n            withCredentials: false,\n            headers: {},\n            method: 'GET',\n            responseType: 'json',\n            timeout: 0\n        };\n        if (typeof urlOrRequest === 'string') {\n            request.url = urlOrRequest;\n        }\n        else {\n            for (var prop in urlOrRequest) {\n                if (urlOrRequest.hasOwnProperty(prop)) {\n                    request[prop] = urlOrRequest[prop];\n                }\n            }\n        }\n        this.request = request;\n    }\n    /** @deprecated internal use only */ AjaxObservable.prototype._subscribe = function (subscriber) {\n        return new AjaxSubscriber(subscriber, this.request);\n    };\n    /**\n     * Creates an observable for an Ajax request with either a request object with\n     * url, headers, etc or a string for a URL.\n     *\n     * @example\n     * source = Rx.Observable.ajax('/products');\n     * source = Rx.Observable.ajax({ url: 'products', method: 'GET' });\n     *\n     * @param {string|Object} request Can be one of the following:\n     *   A string of the URL to make the Ajax call.\n     *   An object with the following properties\n     *   - url: URL of the request\n     *   - body: The body of the request\n     *   - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE\n     *   - async: Whether the request is async\n     *   - headers: Optional headers\n     *   - crossDomain: true if a cross domain request, else false\n     *   - createXHR: a function to override if you need to use an alternate\n     *   XMLHttpRequest implementation.\n     *   - resultSelector: a function to use to alter the output value type of\n     *   the Observable. Gets {@link AjaxResponse} as an argument.\n     * @return {Observable} An observable sequence containing the XMLHttpRequest.\n     * @static true\n     * @name ajax\n     * @owner Observable\n    */\n    AjaxObservable.create = (function () {\n        var create = function (urlOrRequest) {\n            return new AjaxObservable(urlOrRequest);\n        };\n        create.get = ajaxGet;\n        create.post = ajaxPost;\n        create.delete = ajaxDelete;\n        create.put = ajaxPut;\n        create.patch = ajaxPatch;\n        create.getJSON = ajaxGetJSON;\n        return create;\n    })();\n    return AjaxObservable;\n}(Observable_1.Observable));\nexports.AjaxObservable = AjaxObservable;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AjaxSubscriber = (function (_super) {\n    __extends(AjaxSubscriber, _super);\n    function AjaxSubscriber(destination, request) {\n        _super.call(this, destination);\n        this.request = request;\n        this.done = false;\n        var headers = request.headers = request.headers || {};\n        // force CORS if requested\n        if (!request.crossDomain && !headers['X-Requested-With']) {\n            headers['X-Requested-With'] = 'XMLHttpRequest';\n        }\n        // ensure content type is set\n        if (!('Content-Type' in headers) && !(root_1.root.FormData && request.body instanceof root_1.root.FormData) && typeof request.body !== 'undefined') {\n            headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';\n        }\n        // properly serialize body\n        request.body = this.serializeBody(request.body, request.headers['Content-Type']);\n        this.send();\n    }\n    AjaxSubscriber.prototype.next = function (e) {\n        this.done = true;\n        var _a = this, xhr = _a.xhr, request = _a.request, destination = _a.destination;\n        var response = new AjaxResponse(e, xhr, request);\n        destination.next(response);\n    };\n    AjaxSubscriber.prototype.send = function () {\n        var _a = this, request = _a.request, _b = _a.request, user = _b.user, method = _b.method, url = _b.url, async = _b.async, password = _b.password, headers = _b.headers, body = _b.body;\n        var createXHR = request.createXHR;\n        var xhr = tryCatch_1.tryCatch(createXHR).call(request);\n        if (xhr === errorObject_1.errorObject) {\n            this.error(errorObject_1.errorObject.e);\n        }\n        else {\n            this.xhr = xhr;\n            // set up the events before open XHR\n            // https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest\n            // You need to add the event listeners before calling open() on the request.\n            // Otherwise the progress events will not fire.\n            this.setupEvents(xhr, request);\n            // open XHR\n            var result = void 0;\n            if (user) {\n                result = tryCatch_1.tryCatch(xhr.open).call(xhr, method, url, async, user, password);\n            }\n            else {\n                result = tryCatch_1.tryCatch(xhr.open).call(xhr, method, url, async);\n            }\n            if (result === errorObject_1.errorObject) {\n                this.error(errorObject_1.errorObject.e);\n                return null;\n            }\n            // timeout, responseType and withCredentials can be set once the XHR is open\n            if (async) {\n                xhr.timeout = request.timeout;\n                xhr.responseType = request.responseType;\n            }\n            if ('withCredentials' in xhr) {\n                xhr.withCredentials = !!request.withCredentials;\n            }\n            // set headers\n            this.setHeaders(xhr, headers);\n            // finally send the request\n            result = body ? tryCatch_1.tryCatch(xhr.send).call(xhr, body) : tryCatch_1.tryCatch(xhr.send).call(xhr);\n            if (result === errorObject_1.errorObject) {\n                this.error(errorObject_1.errorObject.e);\n                return null;\n            }\n        }\n        return xhr;\n    };\n    AjaxSubscriber.prototype.serializeBody = function (body, contentType) {\n        if (!body || typeof body === 'string') {\n            return body;\n        }\n        else if (root_1.root.FormData && body instanceof root_1.root.FormData) {\n            return body;\n        }\n        if (contentType) {\n            var splitIndex = contentType.indexOf(';');\n            if (splitIndex !== -1) {\n                contentType = contentType.substring(0, splitIndex);\n            }\n        }\n        switch (contentType) {\n            case 'application/x-www-form-urlencoded':\n                return Object.keys(body).map(function (key) { return (encodeURIComponent(key) + \"=\" + encodeURIComponent(body[key])); }).join('&');\n            case 'application/json':\n                return JSON.stringify(body);\n            default:\n                return body;\n        }\n    };\n    AjaxSubscriber.prototype.setHeaders = function (xhr, headers) {\n        for (var key in headers) {\n            if (headers.hasOwnProperty(key)) {\n                xhr.setRequestHeader(key, headers[key]);\n            }\n        }\n    };\n    AjaxSubscriber.prototype.setupEvents = function (xhr, request) {\n        var progressSubscriber = request.progressSubscriber;\n        function xhrTimeout(e) {\n            var _a = xhrTimeout, subscriber = _a.subscriber, progressSubscriber = _a.progressSubscriber, request = _a.request;\n            if (progressSubscriber) {\n                progressSubscriber.error(e);\n            }\n            subscriber.error(new AjaxTimeoutError(this, request)); //TODO: Make betterer.\n        }\n        ;\n        xhr.ontimeout = xhrTimeout;\n        xhrTimeout.request = request;\n        xhrTimeout.subscriber = this;\n        xhrTimeout.progressSubscriber = progressSubscriber;\n        if (xhr.upload && 'withCredentials' in xhr) {\n            if (progressSubscriber) {\n                var xhrProgress_1;\n                xhrProgress_1 = function (e) {\n                    var progressSubscriber = xhrProgress_1.progressSubscriber;\n                    progressSubscriber.next(e);\n                };\n                if (root_1.root.XDomainRequest) {\n                    xhr.onprogress = xhrProgress_1;\n                }\n                else {\n                    xhr.upload.onprogress = xhrProgress_1;\n                }\n                xhrProgress_1.progressSubscriber = progressSubscriber;\n            }\n            var xhrError_1;\n            xhrError_1 = function (e) {\n                var _a = xhrError_1, progressSubscriber = _a.progressSubscriber, subscriber = _a.subscriber, request = _a.request;\n                if (progressSubscriber) {\n                    progressSubscriber.error(e);\n                }\n                subscriber.error(new AjaxError('ajax error', this, request));\n            };\n            xhr.onerror = xhrError_1;\n            xhrError_1.request = request;\n            xhrError_1.subscriber = this;\n            xhrError_1.progressSubscriber = progressSubscriber;\n        }\n        function xhrReadyStateChange(e) {\n            var _a = xhrReadyStateChange, subscriber = _a.subscriber, progressSubscriber = _a.progressSubscriber, request = _a.request;\n            if (this.readyState === 4) {\n                // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)\n                var status_1 = this.status === 1223 ? 204 : this.status;\n                var response = (this.responseType === 'text' ? (this.response || this.responseText) : this.response);\n                // fix status code when it is 0 (0 status is undocumented).\n                // Occurs when accessing file resources or on Android 4.1 stock browser\n                // while retrieving files from application cache.\n                if (status_1 === 0) {\n                    status_1 = response ? 200 : 0;\n                }\n                if (200 <= status_1 && status_1 < 300) {\n                    if (progressSubscriber) {\n                        progressSubscriber.complete();\n                    }\n                    subscriber.next(e);\n                    subscriber.complete();\n                }\n                else {\n                    if (progressSubscriber) {\n                        progressSubscriber.error(e);\n                    }\n                    subscriber.error(new AjaxError('ajax error ' + status_1, this, request));\n                }\n            }\n        }\n        ;\n        xhr.onreadystatechange = xhrReadyStateChange;\n        xhrReadyStateChange.subscriber = this;\n        xhrReadyStateChange.progressSubscriber = progressSubscriber;\n        xhrReadyStateChange.request = request;\n    };\n    AjaxSubscriber.prototype.unsubscribe = function () {\n        var _a = this, done = _a.done, xhr = _a.xhr;\n        if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {\n            xhr.abort();\n        }\n        _super.prototype.unsubscribe.call(this);\n    };\n    return AjaxSubscriber;\n}(Subscriber_1.Subscriber));\nexports.AjaxSubscriber = AjaxSubscriber;\n/**\n * A normalized AJAX response.\n *\n * @see {@link ajax}\n *\n * @class AjaxResponse\n */\nvar AjaxResponse = (function () {\n    function AjaxResponse(originalEvent, xhr, request) {\n        this.originalEvent = originalEvent;\n        this.xhr = xhr;\n        this.request = request;\n        this.status = xhr.status;\n        this.responseType = xhr.responseType || request.responseType;\n        this.response = parseXhrResponse(this.responseType, xhr);\n    }\n    return AjaxResponse;\n}());\nexports.AjaxResponse = AjaxResponse;\n/**\n * A normalized AJAX error.\n *\n * @see {@link ajax}\n *\n * @class AjaxError\n */\nvar AjaxError = (function (_super) {\n    __extends(AjaxError, _super);\n    function AjaxError(message, xhr, request) {\n        _super.call(this, message);\n        this.message = message;\n        this.xhr = xhr;\n        this.request = request;\n        this.status = xhr.status;\n        this.responseType = xhr.responseType || request.responseType;\n        this.response = parseXhrResponse(this.responseType, xhr);\n    }\n    return AjaxError;\n}(Error));\nexports.AjaxError = AjaxError;\nfunction parseXhrResponse(responseType, xhr) {\n    switch (responseType) {\n        case 'json':\n            if ('response' in xhr) {\n                //IE does not support json as responseType, parse it internally\n                return xhr.responseType ? xhr.response : JSON.parse(xhr.response || xhr.responseText || 'null');\n            }\n            else {\n                // HACK(benlesh): TypeScript shennanigans\n                // tslint:disable-next-line:no-any latest TS seems to think xhr is \"never\" here.\n                return JSON.parse(xhr.responseText || 'null');\n            }\n        case 'xml':\n            return xhr.responseXML;\n        case 'text':\n        default:\n            // HACK(benlesh): TypeScript shennanigans\n            // tslint:disable-next-line:no-any latest TS seems to think xhr is \"never\" here.\n            return ('response' in xhr) ? xhr.response : xhr.responseText;\n    }\n}\n/**\n * @see {@link ajax}\n *\n * @class AjaxTimeoutError\n */\nvar AjaxTimeoutError = (function (_super) {\n    __extends(AjaxTimeoutError, _super);\n    function AjaxTimeoutError(xhr, request) {\n        _super.call(this, 'ajax timeout', xhr, request);\n    }\n    return AjaxTimeoutError;\n}(AjaxError));\nexports.AjaxTimeoutError = AjaxTimeoutError;\n//# sourceMappingURL=AjaxObservable.js.map","\"use strict\";\nvar AjaxObservable_1 = require('./AjaxObservable');\nexports.ajax = AjaxObservable_1.AjaxObservable.create;\n//# sourceMappingURL=ajax.js.map","\"use strict\";\nvar EmptyObservable_1 = require('./EmptyObservable');\nexports.empty = EmptyObservable_1.EmptyObservable.create;\n//# sourceMappingURL=empty.js.map","\"use strict\";\nvar FromObservable_1 = require('./FromObservable');\nexports.from = FromObservable_1.FromObservable.create;\n//# sourceMappingURL=from.js.map","\"use strict\";\nvar IntervalObservable_1 = require('./IntervalObservable');\nexports.interval = IntervalObservable_1.IntervalObservable.create;\n//# sourceMappingURL=interval.js.map","\"use strict\";\nvar ArrayObservable_1 = require('./ArrayObservable');\nexports.of = ArrayObservable_1.ArrayObservable.of;\n//# sourceMappingURL=of.js.map","\"use strict\";\nvar ErrorObservable_1 = require('./ErrorObservable');\nexports._throw = ErrorObservable_1.ErrorObservable.create;\n//# sourceMappingURL=throw.js.map","\"use strict\";\nvar catchError_1 = require('../operators/catchError');\n/**\n * Catches errors on the observable to be handled by returning a new observable or throwing an error.\n *\n * <img src=\"./img/catch.png\" width=\"100%\">\n *\n * @example <caption>Continues with a different Observable when there's an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n == 4) {\n * \t     throw 'four!';\n *     }\n *\t   return n;\n *   })\n *   .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, I, II, III, IV, V\n *\n * @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n === 4) {\n * \t     throw 'four!';\n *     }\n * \t   return n;\n *   })\n *   .catch((err, caught) => caught)\n *   .take(30)\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, 1, 2, 3, ...\n *\n * @example <caption>Throws a new error when the source Observable throws an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n *     if (n == 4) {\n *       throw 'four!';\n *     }\n *     return n;\n *   })\n *   .catch(err => {\n *     throw 'error in source. Details: ' + err;\n *   })\n *   .subscribe(\n *     x => console.log(x),\n *     err => console.log(err)\n *   );\n *   // 1, 2, 3, error in source. Details: four!\n *\n * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which\n *  is the source observable, in case you'd like to \"retry\" that observable by returning it again. Whatever observable\n *  is returned by the `selector` will be used to continue the observable chain.\n * @return {Observable} An observable that originates from either the source or the observable returned by the\n *  catch `selector` function.\n * @method catch\n * @name catch\n * @owner Observable\n */\nfunction _catch(selector) {\n    return catchError_1.catchError(selector)(this);\n}\nexports._catch = _catch;\n//# sourceMappingURL=catch.js.map","\"use strict\";\nvar combineLatest_1 = require('../operators/combineLatest');\n/* tslint:enable:max-line-length */\n/**\n * Combines multiple Observables to create an Observable whose values are\n * calculated from the latest values of each of its input Observables.\n *\n * <span class=\"informal\">Whenever any input Observable emits a value, it\n * computes a formula using the latest values from all the inputs, then emits\n * the output of that formula.</span>\n *\n * <img src=\"./img/combineLatest.png\" width=\"100%\">\n *\n * `combineLatest` combines the values from this Observable with values from\n * Observables passed as arguments. This is done by subscribing to each\n * Observable, in order, and collecting an array of each of the most recent\n * values any time any of the input Observables emits, then either taking that\n * array and passing it as arguments to an optional `project` function and\n * emitting the return value of that, or just emitting the array of recent\n * values directly if there is no `project` function.\n *\n * @example <caption>Dynamically calculate the Body-Mass Index from an Observable of weight and one for height</caption>\n * var weight = Rx.Observable.of(70, 72, 76, 79, 75);\n * var height = Rx.Observable.of(1.76, 1.77, 1.78);\n * var bmi = weight.combineLatest(height, (w, h) => w / (h * h));\n * bmi.subscribe(x => console.log('BMI is ' + x));\n *\n * // With output to console:\n * // BMI is 24.212293388429753\n * // BMI is 23.93948099205209\n * // BMI is 23.671253629592222\n *\n * @see {@link combineAll}\n * @see {@link merge}\n * @see {@link withLatestFrom}\n *\n * @param {ObservableInput} other An input Observable to combine with the source\n * Observable. More than one input Observables may be given as argument.\n * @param {function} [project] An optional function to project the values from\n * the combined latest values into a new value on the output Observable.\n * @return {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @method combineLatest\n * @owner Observable\n */\nfunction combineLatest() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    return combineLatest_1.combineLatest.apply(void 0, observables)(this);\n}\nexports.combineLatest = combineLatest;\n//# sourceMappingURL=combineLatest.js.map","\"use strict\";\nvar concatMap_1 = require('../operators/concatMap');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable, in a serialized fashion waiting for each one to complete before\n * merging the next.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link concatAll}.</span>\n *\n * <img src=\"./img/concatMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. Each new inner Observable is\n * concatenated with the previous inner Observable.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set\n * to `1`.\n *\n * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.concatMap(ev => Rx.Observable.interval(1000).take(4));\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // (results are not concurrent)\n * // For every click on the \"document\" it will emit values 0 to 3 spaced\n * // on a 1000ms interval\n * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3\n *\n * @see {@link concat}\n * @see {@link concatAll}\n * @see {@link concatMapTo}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and taking values from each projected inner\n * Observable sequentially.\n * @method concatMap\n * @owner Observable\n */\nfunction concatMap(project, resultSelector) {\n    return concatMap_1.concatMap(project, resultSelector)(this);\n}\nexports.concatMap = concatMap;\n//# sourceMappingURL=concatMap.js.map","\"use strict\";\nvar count_1 = require('../operators/count');\n/**\n * Counts the number of emissions on the source and emits that number when the\n * source completes.\n *\n * <span class=\"informal\">Tells how many values were emitted, when the source\n * completes.</span>\n *\n * <img src=\"./img/count.png\" width=\"100%\">\n *\n * `count` transforms an Observable that emits values into an Observable that\n * emits a single value that represents the number of values emitted by the\n * source Observable. If the source Observable terminates with an error, `count`\n * will pass this error notification along without emitting a value first. If\n * the source Observable does not terminate at all, `count` will neither emit\n * a value nor terminate. This operator takes an optional `predicate` function\n * as argument, in which case the output emission will represent the number of\n * source values that matched `true` with the `predicate`.\n *\n * @example <caption>Counts how many seconds have passed before the first click happened</caption>\n * var seconds = Rx.Observable.interval(1000);\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var secondsBeforeClick = seconds.takeUntil(clicks);\n * var result = secondsBeforeClick.count();\n * result.subscribe(x => console.log(x));\n *\n * @example <caption>Counts how many odd numbers are there between 1 and 7</caption>\n * var numbers = Rx.Observable.range(1, 7);\n * var result = numbers.count(i => i % 2 === 1);\n * result.subscribe(x => console.log(x));\n *\n * // Results in:\n * // 4\n *\n * @see {@link max}\n * @see {@link min}\n * @see {@link reduce}\n *\n * @param {function(value: T, i: number, source: Observable<T>): boolean} [predicate] A\n * boolean function to select what values are to be counted. It is provided with\n * arguments of:\n * - `value`: the value from the source Observable.\n * - `index`: the (zero-based) \"index\" of the value from the source Observable.\n * - `source`: the source Observable instance itself.\n * @return {Observable} An Observable of one number that represents the count as\n * described above.\n * @method count\n * @owner Observable\n */\nfunction count(predicate) {\n    return count_1.count(predicate)(this);\n}\nexports.count = count;\n//# sourceMappingURL=count.js.map","\"use strict\";\nvar async_1 = require('../scheduler/async');\nvar delay_1 = require('../operators/delay');\n/**\n * Delays the emission of items from the source Observable by a given timeout or\n * until a given Date.\n *\n * <span class=\"informal\">Time shifts each item by some specified amount of\n * milliseconds.</span>\n *\n * <img src=\"./img/delay.png\" width=\"100%\">\n *\n * If the delay argument is a Number, this operator time shifts the source\n * Observable by that amount of time expressed in milliseconds. The relative\n * time intervals between the values are preserved.\n *\n * If the delay argument is a Date, this operator time shifts the start of the\n * Observable execution until the given date occurs.\n *\n * @example <caption>Delay each click by one second</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @example <caption>Delay all clicks until a future date happens</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var date = new Date('March 15, 2050 12:00:00'); // in the future\n * var delayedClicks = clicks.delay(date); // click emitted only after that date\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @see {@link debounceTime}\n * @see {@link delayWhen}\n *\n * @param {number|Date} delay The delay duration in milliseconds (a `number`) or\n * a `Date` until which the emission of the source items is delayed.\n * @param {Scheduler} [scheduler=async] The IScheduler to use for\n * managing the timers that handle the time-shift for each item.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by the specified timeout or Date.\n * @method delay\n * @owner Observable\n */\nfunction delay(delay, scheduler) {\n    if (scheduler === void 0) { scheduler = async_1.async; }\n    return delay_1.delay(delay, scheduler)(this);\n}\nexports.delay = delay;\n//# sourceMappingURL=delay.js.map","\"use strict\";\nvar tap_1 = require('../operators/tap');\n/* tslint:enable:max-line-length */\n/**\n * Perform a side effect for every emission on the source Observable, but return\n * an Observable that is identical to the source.\n *\n * <span class=\"informal\">Intercepts each emission on the source and runs a\n * function, but returns an output which is identical to the source as long as errors don't occur.</span>\n *\n * <img src=\"./img/do.png\" width=\"100%\">\n *\n * Returns a mirrored Observable of the source Observable, but modified so that\n * the provided Observer is called to perform a side effect for every value,\n * error, and completion emitted by the source. Any errors that are thrown in\n * the aforementioned Observer or handlers are safely sent down the error path\n * of the output Observable.\n *\n * This operator is useful for debugging your Observables for the correct values\n * or performing other side effects.\n *\n * Note: this is different to a `subscribe` on the Observable. If the Observable\n * returned by `do` is not subscribed, the side effects specified by the\n * Observer will never happen. `do` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks\n *   .do(ev => console.log(ev))\n *   .map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link map}\n * @see {@link subscribe}\n *\n * @param {Observer|function} [nextOrObserver] A normal Observer object or a\n * callback for `next`.\n * @param {function} [error] Callback for errors in the source.\n * @param {function} [complete] Callback for the completion of the source.\n * @return {Observable} An Observable identical to the source, but runs the\n * specified Observer or callback(s) for each item.\n * @method do\n * @name do\n * @owner Observable\n */\nfunction _do(nextOrObserver, error, complete) {\n    return tap_1.tap(nextOrObserver, error, complete)(this);\n}\nexports._do = _do;\n//# sourceMappingURL=do.js.map","\"use strict\";\nvar filter_1 = require('../operators/filter');\n/* tslint:enable:max-line-length */\n/**\n * Filter items emitted by the source Observable by only emitting those that\n * satisfy a specified predicate.\n *\n * <span class=\"informal\">Like\n * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),\n * it only emits a value from the source if it passes a criterion function.</span>\n *\n * <img src=\"./img/filter.png\" width=\"100%\">\n *\n * Similar to the well-known `Array.prototype.filter` method, this operator\n * takes values from the source Observable, passes them through a `predicate`\n * function and only emits those values that yielded `true`.\n *\n * @example <caption>Emit only click events whose target was a DIV element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');\n * clicksOnDivs.subscribe(x => console.log(x));\n *\n * @see {@link distinct}\n * @see {@link distinctUntilChanged}\n * @see {@link distinctUntilKeyChanged}\n * @see {@link ignoreElements}\n * @see {@link partition}\n * @see {@link skip}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted, if `false` the value is not passed to the output\n * Observable. The `index` parameter is the number `i` for the i-th source\n * emission that has happened since the subscription, starting from the number\n * `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable} An Observable of values from the source that were\n * allowed by the `predicate` function.\n * @method filter\n * @owner Observable\n */\nfunction filter(predicate, thisArg) {\n    return filter_1.filter(predicate, thisArg)(this);\n}\nexports.filter = filter;\n//# sourceMappingURL=filter.js.map","\"use strict\";\nvar map_1 = require('../operators/map');\n/**\n * Applies a given `project` function to each value emitted by the source\n * Observable, and emits the resulting values as an Observable.\n *\n * <span class=\"informal\">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),\n * it passes each source value through a transformation function to get\n * corresponding output values.</span>\n *\n * <img src=\"./img/map.png\" width=\"100%\">\n *\n * Similar to the well known `Array.prototype.map` function, this operator\n * applies a projection to each value and emits that projection in the output\n * Observable.\n *\n * @example <caption>Map every click to the clientX position of that click</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks.map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link mapTo}\n * @see {@link pluck}\n *\n * @param {function(value: T, index: number): R} project The function to apply\n * to each `value` emitted by the source Observable. The `index` parameter is\n * the number `i` for the i-th emission that has happened since the\n * subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to define what `this` is in the\n * `project` function.\n * @return {Observable<R>} An Observable that emits the values from the source\n * Observable transformed by the given `project` function.\n * @method map\n * @owner Observable\n */\nfunction map(project, thisArg) {\n    return map_1.map(project, thisArg)(this);\n}\nexports.map = map;\n//# sourceMappingURL=map.js.map","\"use strict\";\nvar mergeMap_1 = require('../operators/mergeMap');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link mergeAll}.</span>\n *\n * <img src=\"./img/mergeMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an Observable, and then merging those resulting Observables and\n * emitting the results of this merger.\n *\n * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>\n * var letters = Rx.Observable.of('a', 'b', 'c');\n * var result = letters.mergeMap(x =>\n *   Rx.Observable.interval(1000).map(i => x+i)\n * );\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // a0\n * // b0\n * // c0\n * // a1\n * // b1\n * // c1\n * // continues to list a,b,c with respective ascending integers\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link merge}\n * @see {@link mergeAll}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and merging the results of the Observables obtained\n * from this transformation.\n * @method mergeMap\n * @owner Observable\n */\nfunction mergeMap(project, resultSelector, concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return mergeMap_1.mergeMap(project, resultSelector, concurrent)(this);\n}\nexports.mergeMap = mergeMap;\n//# sourceMappingURL=mergeMap.js.map","\"use strict\";\nvar retryWhen_1 = require('../operators/retryWhen');\n/**\n * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable\n * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.\n * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child\n * subscription. Otherwise this method will resubscribe to the source Observable.\n *\n * <img src=\"./img/retryWhen.png\" width=\"100%\">\n *\n * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a\n * user can `complete` or `error`, aborting the retry.\n * @return {Observable} The source Observable modified with retry logic.\n * @method retryWhen\n * @owner Observable\n */\nfunction retryWhen(notifier) {\n    return retryWhen_1.retryWhen(notifier)(this);\n}\nexports.retryWhen = retryWhen;\n//# sourceMappingURL=retryWhen.js.map","\"use strict\";\nvar share_1 = require('../operators/share');\n/**\n * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one\n * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will\n * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.\n *\n * This behaves similarly to .publish().refCount(), with a behavior difference when the source observable emits complete.\n * .publish().refCount() will not resubscribe to the original source, however .share() will resubscribe to the original source.\n * Observable.of(\"test\").publish().refCount() will not re-emit \"test\" on new subscriptions, Observable.of(\"test\").share() will\n * re-emit \"test\" to new subscriptions.\n *\n * <img src=\"./img/share.png\" width=\"100%\">\n *\n * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.\n * @method share\n * @owner Observable\n */\nfunction share() {\n    return share_1.share()(this);\n}\nexports.share = share;\n;\n//# sourceMappingURL=share.js.map","\"use strict\";\nvar take_1 = require('../operators/take');\n/**\n * Emits only the first `count` values emitted by the source Observable.\n *\n * <span class=\"informal\">Takes the first `count` values from the source, then\n * completes.</span>\n *\n * <img src=\"./img/take.png\" width=\"100%\">\n *\n * `take` returns an Observable that emits only the first `count` values emitted\n * by the source Observable. If the source emits fewer than `count` values then\n * all of its values are emitted. After that, it completes, regardless if the\n * source completes.\n *\n * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>\n * var interval = Rx.Observable.interval(1000);\n * var five = interval.take(5);\n * five.subscribe(x => console.log(x));\n *\n * @see {@link takeLast}\n * @see {@link takeUntil}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.\n *\n * @param {number} count The maximum number of `next` values to emit.\n * @return {Observable<T>} An Observable that emits only the first `count`\n * values emitted by the source Observable, or all of the values from the source\n * if the source emits fewer than `count` values.\n * @method take\n * @owner Observable\n */\nfunction take(count) {\n    return take_1.take(count)(this);\n}\nexports.take = take;\n//# sourceMappingURL=take.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\n/**\n * Catches errors on the observable to be handled by returning a new observable or throwing an error.\n *\n * <img src=\"./img/catch.png\" width=\"100%\">\n *\n * @example <caption>Continues with a different Observable when there's an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n == 4) {\n * \t     throw 'four!';\n *     }\n *\t   return n;\n *   })\n *   .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, I, II, III, IV, V\n *\n * @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n * \t   if (n === 4) {\n * \t     throw 'four!';\n *     }\n * \t   return n;\n *   })\n *   .catch((err, caught) => caught)\n *   .take(30)\n *   .subscribe(x => console.log(x));\n *   // 1, 2, 3, 1, 2, 3, ...\n *\n * @example <caption>Throws a new error when the source Observable throws an error</caption>\n *\n * Observable.of(1, 2, 3, 4, 5)\n *   .map(n => {\n *     if (n == 4) {\n *       throw 'four!';\n *     }\n *     return n;\n *   })\n *   .catch(err => {\n *     throw 'error in source. Details: ' + err;\n *   })\n *   .subscribe(\n *     x => console.log(x),\n *     err => console.log(err)\n *   );\n *   // 1, 2, 3, error in source. Details: four!\n *\n * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which\n *  is the source observable, in case you'd like to \"retry\" that observable by returning it again. Whatever observable\n *  is returned by the `selector` will be used to continue the observable chain.\n * @return {Observable} An observable that originates from either the source or the observable returned by the\n *  catch `selector` function.\n * @name catchError\n */\nfunction catchError(selector) {\n    return function catchErrorOperatorFunction(source) {\n        var operator = new CatchOperator(selector);\n        var caught = source.lift(operator);\n        return (operator.caught = caught);\n    };\n}\nexports.catchError = catchError;\nvar CatchOperator = (function () {\n    function CatchOperator(selector) {\n        this.selector = selector;\n    }\n    CatchOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new CatchSubscriber(subscriber, this.selector, this.caught));\n    };\n    return CatchOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar CatchSubscriber = (function (_super) {\n    __extends(CatchSubscriber, _super);\n    function CatchSubscriber(destination, selector, caught) {\n        _super.call(this, destination);\n        this.selector = selector;\n        this.caught = caught;\n    }\n    // NOTE: overriding `error` instead of `_error` because we don't want\n    // to have this flag this subscriber as `isStopped`. We can mimic the\n    // behavior of the RetrySubscriber (from the `retry` operator), where\n    // we unsubscribe from our source chain, reset our Subscriber flags,\n    // then subscribe to the selector result.\n    CatchSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var result = void 0;\n            try {\n                result = this.selector(err, this.caught);\n            }\n            catch (err2) {\n                _super.prototype.error.call(this, err2);\n                return;\n            }\n            this._unsubscribeAndRecycle();\n            this.add(subscribeToResult_1.subscribeToResult(this, result));\n        }\n    };\n    return CatchSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=catchError.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar ArrayObservable_1 = require('../observable/ArrayObservable');\nvar isArray_1 = require('../util/isArray');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\nvar none = {};\n/* tslint:enable:max-line-length */\n/**\n * Combines multiple Observables to create an Observable whose values are\n * calculated from the latest values of each of its input Observables.\n *\n * <span class=\"informal\">Whenever any input Observable emits a value, it\n * computes a formula using the latest values from all the inputs, then emits\n * the output of that formula.</span>\n *\n * <img src=\"./img/combineLatest.png\" width=\"100%\">\n *\n * `combineLatest` combines the values from this Observable with values from\n * Observables passed as arguments. This is done by subscribing to each\n * Observable, in order, and collecting an array of each of the most recent\n * values any time any of the input Observables emits, then either taking that\n * array and passing it as arguments to an optional `project` function and\n * emitting the return value of that, or just emitting the array of recent\n * values directly if there is no `project` function.\n *\n * @example <caption>Dynamically calculate the Body-Mass Index from an Observable of weight and one for height</caption>\n * var weight = Rx.Observable.of(70, 72, 76, 79, 75);\n * var height = Rx.Observable.of(1.76, 1.77, 1.78);\n * var bmi = weight.combineLatest(height, (w, h) => w / (h * h));\n * bmi.subscribe(x => console.log('BMI is ' + x));\n *\n * // With output to console:\n * // BMI is 24.212293388429753\n * // BMI is 23.93948099205209\n * // BMI is 23.671253629592222\n *\n * @see {@link combineAll}\n * @see {@link merge}\n * @see {@link withLatestFrom}\n *\n * @param {ObservableInput} other An input Observable to combine with the source\n * Observable. More than one input Observables may be given as argument.\n * @param {function} [project] An optional function to project the values from\n * the combined latest values into a new value on the output Observable.\n * @return {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @method combineLatest\n * @owner Observable\n */\nfunction combineLatest() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i - 0] = arguments[_i];\n    }\n    var project = null;\n    if (typeof observables[observables.length - 1] === 'function') {\n        project = observables.pop();\n    }\n    // if the first and only other argument besides the resultSelector is an array\n    // assume it's been called with `combineLatest([obs1, obs2, obs3], project)`\n    if (observables.length === 1 && isArray_1.isArray(observables[0])) {\n        observables = observables[0].slice();\n    }\n    return function (source) { return source.lift.call(new ArrayObservable_1.ArrayObservable([source].concat(observables)), new CombineLatestOperator(project)); };\n}\nexports.combineLatest = combineLatest;\nvar CombineLatestOperator = (function () {\n    function CombineLatestOperator(project) {\n        this.project = project;\n    }\n    CombineLatestOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new CombineLatestSubscriber(subscriber, this.project));\n    };\n    return CombineLatestOperator;\n}());\nexports.CombineLatestOperator = CombineLatestOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar CombineLatestSubscriber = (function (_super) {\n    __extends(CombineLatestSubscriber, _super);\n    function CombineLatestSubscriber(destination, project) {\n        _super.call(this, destination);\n        this.project = project;\n        this.active = 0;\n        this.values = [];\n        this.observables = [];\n    }\n    CombineLatestSubscriber.prototype._next = function (observable) {\n        this.values.push(none);\n        this.observables.push(observable);\n    };\n    CombineLatestSubscriber.prototype._complete = function () {\n        var observables = this.observables;\n        var len = observables.length;\n        if (len === 0) {\n            this.destination.complete();\n        }\n        else {\n            this.active = len;\n            this.toRespond = len;\n            for (var i = 0; i < len; i++) {\n                var observable = observables[i];\n                this.add(subscribeToResult_1.subscribeToResult(this, observable, observable, i));\n            }\n        }\n    };\n    CombineLatestSubscriber.prototype.notifyComplete = function (unused) {\n        if ((this.active -= 1) === 0) {\n            this.destination.complete();\n        }\n    };\n    CombineLatestSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        var values = this.values;\n        var oldVal = values[outerIndex];\n        var toRespond = !this.toRespond\n            ? 0\n            : oldVal === none ? --this.toRespond : this.toRespond;\n        values[outerIndex] = innerValue;\n        if (toRespond === 0) {\n            if (this.project) {\n                this._tryProject(values);\n            }\n            else {\n                this.destination.next(values.slice());\n            }\n        }\n    };\n    CombineLatestSubscriber.prototype._tryProject = function (values) {\n        var result;\n        try {\n            result = this.project.apply(this, values);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return CombineLatestSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\nexports.CombineLatestSubscriber = CombineLatestSubscriber;\n//# sourceMappingURL=combineLatest.js.map","\"use strict\";\nvar mergeMap_1 = require('./mergeMap');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable, in a serialized fashion waiting for each one to complete before\n * merging the next.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link concatAll}.</span>\n *\n * <img src=\"./img/concatMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. Each new inner Observable is\n * concatenated with the previous inner Observable.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set\n * to `1`.\n *\n * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.concatMap(ev => Rx.Observable.interval(1000).take(4));\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // (results are not concurrent)\n * // For every click on the \"document\" it will emit values 0 to 3 spaced\n * // on a 1000ms interval\n * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3\n *\n * @see {@link concat}\n * @see {@link concatAll}\n * @see {@link concatMapTo}\n * @see {@link exhaustMap}\n * @see {@link mergeMap}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and taking values from each projected inner\n * Observable sequentially.\n * @method concatMap\n * @owner Observable\n */\nfunction concatMap(project, resultSelector) {\n    return mergeMap_1.mergeMap(project, resultSelector, 1);\n}\nexports.concatMap = concatMap;\n//# sourceMappingURL=concatMap.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/**\n * Counts the number of emissions on the source and emits that number when the\n * source completes.\n *\n * <span class=\"informal\">Tells how many values were emitted, when the source\n * completes.</span>\n *\n * <img src=\"./img/count.png\" width=\"100%\">\n *\n * `count` transforms an Observable that emits values into an Observable that\n * emits a single value that represents the number of values emitted by the\n * source Observable. If the source Observable terminates with an error, `count`\n * will pass this error notification along without emitting a value first. If\n * the source Observable does not terminate at all, `count` will neither emit\n * a value nor terminate. This operator takes an optional `predicate` function\n * as argument, in which case the output emission will represent the number of\n * source values that matched `true` with the `predicate`.\n *\n * @example <caption>Counts how many seconds have passed before the first click happened</caption>\n * var seconds = Rx.Observable.interval(1000);\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var secondsBeforeClick = seconds.takeUntil(clicks);\n * var result = secondsBeforeClick.count();\n * result.subscribe(x => console.log(x));\n *\n * @example <caption>Counts how many odd numbers are there between 1 and 7</caption>\n * var numbers = Rx.Observable.range(1, 7);\n * var result = numbers.count(i => i % 2 === 1);\n * result.subscribe(x => console.log(x));\n *\n * // Results in:\n * // 4\n *\n * @see {@link max}\n * @see {@link min}\n * @see {@link reduce}\n *\n * @param {function(value: T, i: number, source: Observable<T>): boolean} [predicate] A\n * boolean function to select what values are to be counted. It is provided with\n * arguments of:\n * - `value`: the value from the source Observable.\n * - `index`: the (zero-based) \"index\" of the value from the source Observable.\n * - `source`: the source Observable instance itself.\n * @return {Observable} An Observable of one number that represents the count as\n * described above.\n * @method count\n * @owner Observable\n */\nfunction count(predicate) {\n    return function (source) { return source.lift(new CountOperator(predicate, source)); };\n}\nexports.count = count;\nvar CountOperator = (function () {\n    function CountOperator(predicate, source) {\n        this.predicate = predicate;\n        this.source = source;\n    }\n    CountOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new CountSubscriber(subscriber, this.predicate, this.source));\n    };\n    return CountOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar CountSubscriber = (function (_super) {\n    __extends(CountSubscriber, _super);\n    function CountSubscriber(destination, predicate, source) {\n        _super.call(this, destination);\n        this.predicate = predicate;\n        this.source = source;\n        this.count = 0;\n        this.index = 0;\n    }\n    CountSubscriber.prototype._next = function (value) {\n        if (this.predicate) {\n            this._tryPredicate(value);\n        }\n        else {\n            this.count++;\n        }\n    };\n    CountSubscriber.prototype._tryPredicate = function (value) {\n        var result;\n        try {\n            result = this.predicate(value, this.index++, this.source);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        if (result) {\n            this.count++;\n        }\n    };\n    CountSubscriber.prototype._complete = function () {\n        this.destination.next(this.count);\n        this.destination.complete();\n    };\n    return CountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=count.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar async_1 = require('../scheduler/async');\nvar isDate_1 = require('../util/isDate');\nvar Subscriber_1 = require('../Subscriber');\nvar Notification_1 = require('../Notification');\n/**\n * Delays the emission of items from the source Observable by a given timeout or\n * until a given Date.\n *\n * <span class=\"informal\">Time shifts each item by some specified amount of\n * milliseconds.</span>\n *\n * <img src=\"./img/delay.png\" width=\"100%\">\n *\n * If the delay argument is a Number, this operator time shifts the source\n * Observable by that amount of time expressed in milliseconds. The relative\n * time intervals between the values are preserved.\n *\n * If the delay argument is a Date, this operator time shifts the start of the\n * Observable execution until the given date occurs.\n *\n * @example <caption>Delay each click by one second</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @example <caption>Delay all clicks until a future date happens</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var date = new Date('March 15, 2050 12:00:00'); // in the future\n * var delayedClicks = clicks.delay(date); // click emitted only after that date\n * delayedClicks.subscribe(x => console.log(x));\n *\n * @see {@link debounceTime}\n * @see {@link delayWhen}\n *\n * @param {number|Date} delay The delay duration in milliseconds (a `number`) or\n * a `Date` until which the emission of the source items is delayed.\n * @param {Scheduler} [scheduler=async] The IScheduler to use for\n * managing the timers that handle the time-shift for each item.\n * @return {Observable} An Observable that delays the emissions of the source\n * Observable by the specified timeout or Date.\n * @method delay\n * @owner Observable\n */\nfunction delay(delay, scheduler) {\n    if (scheduler === void 0) { scheduler = async_1.async; }\n    var absoluteDelay = isDate_1.isDate(delay);\n    var delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay);\n    return function (source) { return source.lift(new DelayOperator(delayFor, scheduler)); };\n}\nexports.delay = delay;\nvar DelayOperator = (function () {\n    function DelayOperator(delay, scheduler) {\n        this.delay = delay;\n        this.scheduler = scheduler;\n    }\n    DelayOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DelaySubscriber(subscriber, this.delay, this.scheduler));\n    };\n    return DelayOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DelaySubscriber = (function (_super) {\n    __extends(DelaySubscriber, _super);\n    function DelaySubscriber(destination, delay, scheduler) {\n        _super.call(this, destination);\n        this.delay = delay;\n        this.scheduler = scheduler;\n        this.queue = [];\n        this.active = false;\n        this.errored = false;\n    }\n    DelaySubscriber.dispatch = function (state) {\n        var source = state.source;\n        var queue = source.queue;\n        var scheduler = state.scheduler;\n        var destination = state.destination;\n        while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) {\n            queue.shift().notification.observe(destination);\n        }\n        if (queue.length > 0) {\n            var delay_1 = Math.max(0, queue[0].time - scheduler.now());\n            this.schedule(state, delay_1);\n        }\n        else {\n            this.unsubscribe();\n            source.active = false;\n        }\n    };\n    DelaySubscriber.prototype._schedule = function (scheduler) {\n        this.active = true;\n        this.add(scheduler.schedule(DelaySubscriber.dispatch, this.delay, {\n            source: this, destination: this.destination, scheduler: scheduler\n        }));\n    };\n    DelaySubscriber.prototype.scheduleNotification = function (notification) {\n        if (this.errored === true) {\n            return;\n        }\n        var scheduler = this.scheduler;\n        var message = new DelayMessage(scheduler.now() + this.delay, notification);\n        this.queue.push(message);\n        if (this.active === false) {\n            this._schedule(scheduler);\n        }\n    };\n    DelaySubscriber.prototype._next = function (value) {\n        this.scheduleNotification(Notification_1.Notification.createNext(value));\n    };\n    DelaySubscriber.prototype._error = function (err) {\n        this.errored = true;\n        this.queue = [];\n        this.destination.error(err);\n    };\n    DelaySubscriber.prototype._complete = function () {\n        this.scheduleNotification(Notification_1.Notification.createComplete());\n    };\n    return DelaySubscriber;\n}(Subscriber_1.Subscriber));\nvar DelayMessage = (function () {\n    function DelayMessage(time, notification) {\n        this.time = time;\n        this.notification = notification;\n    }\n    return DelayMessage;\n}());\n//# sourceMappingURL=delay.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/* tslint:enable:max-line-length */\n/**\n * Filter items emitted by the source Observable by only emitting those that\n * satisfy a specified predicate.\n *\n * <span class=\"informal\">Like\n * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),\n * it only emits a value from the source if it passes a criterion function.</span>\n *\n * <img src=\"./img/filter.png\" width=\"100%\">\n *\n * Similar to the well-known `Array.prototype.filter` method, this operator\n * takes values from the source Observable, passes them through a `predicate`\n * function and only emits those values that yielded `true`.\n *\n * @example <caption>Emit only click events whose target was a DIV element</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var clicksOnDivs = clicks.filter(ev => ev.target.tagName === 'DIV');\n * clicksOnDivs.subscribe(x => console.log(x));\n *\n * @see {@link distinct}\n * @see {@link distinctUntilChanged}\n * @see {@link distinctUntilKeyChanged}\n * @see {@link ignoreElements}\n * @see {@link partition}\n * @see {@link skip}\n *\n * @param {function(value: T, index: number): boolean} predicate A function that\n * evaluates each value emitted by the source Observable. If it returns `true`,\n * the value is emitted, if `false` the value is not passed to the output\n * Observable. The `index` parameter is the number `i` for the i-th source\n * emission that has happened since the subscription, starting from the number\n * `0`.\n * @param {any} [thisArg] An optional argument to determine the value of `this`\n * in the `predicate` function.\n * @return {Observable} An Observable of values from the source that were\n * allowed by the `predicate` function.\n * @method filter\n * @owner Observable\n */\nfunction filter(predicate, thisArg) {\n    return function filterOperatorFunction(source) {\n        return source.lift(new FilterOperator(predicate, thisArg));\n    };\n}\nexports.filter = filter;\nvar FilterOperator = (function () {\n    function FilterOperator(predicate, thisArg) {\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n    }\n    FilterOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));\n    };\n    return FilterOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar FilterSubscriber = (function (_super) {\n    __extends(FilterSubscriber, _super);\n    function FilterSubscriber(destination, predicate, thisArg) {\n        _super.call(this, destination);\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n        this.count = 0;\n    }\n    // the try catch block below is left specifically for\n    // optimization and perf reasons. a tryCatcher is not necessary here.\n    FilterSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.predicate.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        if (result) {\n            this.destination.next(value);\n        }\n    };\n    return FilterSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=filter.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/**\n * Applies a given `project` function to each value emitted by the source\n * Observable, and emits the resulting values as an Observable.\n *\n * <span class=\"informal\">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map),\n * it passes each source value through a transformation function to get\n * corresponding output values.</span>\n *\n * <img src=\"./img/map.png\" width=\"100%\">\n *\n * Similar to the well known `Array.prototype.map` function, this operator\n * applies a projection to each value and emits that projection in the output\n * Observable.\n *\n * @example <caption>Map every click to the clientX position of that click</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks.map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link mapTo}\n * @see {@link pluck}\n *\n * @param {function(value: T, index: number): R} project The function to apply\n * to each `value` emitted by the source Observable. The `index` parameter is\n * the number `i` for the i-th emission that has happened since the\n * subscription, starting from the number `0`.\n * @param {any} [thisArg] An optional argument to define what `this` is in the\n * `project` function.\n * @return {Observable<R>} An Observable that emits the values from the source\n * Observable transformed by the given `project` function.\n * @method map\n * @owner Observable\n */\nfunction map(project, thisArg) {\n    return function mapOperation(source) {\n        if (typeof project !== 'function') {\n            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');\n        }\n        return source.lift(new MapOperator(project, thisArg));\n    };\n}\nexports.map = map;\nvar MapOperator = (function () {\n    function MapOperator(project, thisArg) {\n        this.project = project;\n        this.thisArg = thisArg;\n    }\n    MapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));\n    };\n    return MapOperator;\n}());\nexports.MapOperator = MapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MapSubscriber = (function (_super) {\n    __extends(MapSubscriber, _super);\n    function MapSubscriber(destination, project, thisArg) {\n        _super.call(this, destination);\n        this.project = project;\n        this.count = 0;\n        this.thisArg = thisArg || this;\n    }\n    // NOTE: This looks unoptimized, but it's actually purposefully NOT\n    // using try/catch optimizations.\n    MapSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.project.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return MapSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=map.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar subscribeToResult_1 = require('../util/subscribeToResult');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\n/* tslint:enable:max-line-length */\n/**\n * Projects each source value to an Observable which is merged in the output\n * Observable.\n *\n * <span class=\"informal\">Maps each value to an Observable, then flattens all of\n * these inner Observables using {@link mergeAll}.</span>\n *\n * <img src=\"./img/mergeMap.png\" width=\"100%\">\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an Observable, and then merging those resulting Observables and\n * emitting the results of this merger.\n *\n * @example <caption>Map and flatten each letter to an Observable ticking every 1 second</caption>\n * var letters = Rx.Observable.of('a', 'b', 'c');\n * var result = letters.mergeMap(x =>\n *   Rx.Observable.interval(1000).map(i => x+i)\n * );\n * result.subscribe(x => console.log(x));\n *\n * // Results in the following:\n * // a0\n * // b0\n * // c0\n * // a1\n * // b1\n * // c1\n * // continues to list a,b,c with respective ascending integers\n *\n * @see {@link concatMap}\n * @see {@link exhaustMap}\n * @see {@link merge}\n * @see {@link mergeAll}\n * @see {@link mergeMapTo}\n * @see {@link mergeScan}\n * @see {@link switchMap}\n *\n * @param {function(value: T, ?index: number): ObservableInput} project A function\n * that, when applied to an item emitted by the source Observable, returns an\n * Observable.\n * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]\n * A function to produce the value on the output Observable based on the values\n * and the indices of the source (outer) emission and the inner Observable\n * emission. The arguments passed to this function are:\n * - `outerValue`: the value that came from the source\n * - `innerValue`: the value that came from the projected Observable\n * - `outerIndex`: the \"index\" of the value that came from the source\n * - `innerIndex`: the \"index\" of the value from the projected Observable\n * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input\n * Observables being subscribed to concurrently.\n * @return {Observable} An Observable that emits the result of applying the\n * projection function (and the optional `resultSelector`) to each item emitted\n * by the source Observable and merging the results of the Observables obtained\n * from this transformation.\n * @method mergeMap\n * @owner Observable\n */\nfunction mergeMap(project, resultSelector, concurrent) {\n    if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n    return function mergeMapOperatorFunction(source) {\n        if (typeof resultSelector === 'number') {\n            concurrent = resultSelector;\n            resultSelector = null;\n        }\n        return source.lift(new MergeMapOperator(project, resultSelector, concurrent));\n    };\n}\nexports.mergeMap = mergeMap;\nvar MergeMapOperator = (function () {\n    function MergeMapOperator(project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n    }\n    MergeMapOperator.prototype.call = function (observer, source) {\n        return source.subscribe(new MergeMapSubscriber(observer, this.project, this.resultSelector, this.concurrent));\n    };\n    return MergeMapOperator;\n}());\nexports.MergeMapOperator = MergeMapOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar MergeMapSubscriber = (function (_super) {\n    __extends(MergeMapSubscriber, _super);\n    function MergeMapSubscriber(destination, project, resultSelector, concurrent) {\n        if (concurrent === void 0) { concurrent = Number.POSITIVE_INFINITY; }\n        _super.call(this, destination);\n        this.project = project;\n        this.resultSelector = resultSelector;\n        this.concurrent = concurrent;\n        this.hasCompleted = false;\n        this.buffer = [];\n        this.active = 0;\n        this.index = 0;\n    }\n    MergeMapSubscriber.prototype._next = function (value) {\n        if (this.active < this.concurrent) {\n            this._tryNext(value);\n        }\n        else {\n            this.buffer.push(value);\n        }\n    };\n    MergeMapSubscriber.prototype._tryNext = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.active++;\n        this._innerSub(result, value, index);\n    };\n    MergeMapSubscriber.prototype._innerSub = function (ish, value, index) {\n        this.add(subscribeToResult_1.subscribeToResult(this, ish, value, index));\n    };\n    MergeMapSubscriber.prototype._complete = function () {\n        this.hasCompleted = true;\n        if (this.active === 0 && this.buffer.length === 0) {\n            this.destination.complete();\n        }\n    };\n    MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        if (this.resultSelector) {\n            this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        else {\n            this.destination.next(innerValue);\n        }\n    };\n    MergeMapSubscriber.prototype._notifyResultSelector = function (outerValue, innerValue, outerIndex, innerIndex) {\n        var result;\n        try {\n            result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    MergeMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        var buffer = this.buffer;\n        this.remove(innerSub);\n        this.active--;\n        if (buffer.length > 0) {\n            this._next(buffer.shift());\n        }\n        else if (this.active === 0 && this.hasCompleted) {\n            this.destination.complete();\n        }\n    };\n    return MergeMapSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\nexports.MergeMapSubscriber = MergeMapSubscriber;\n//# sourceMappingURL=mergeMap.js.map","\"use strict\";\nvar ConnectableObservable_1 = require('../observable/ConnectableObservable');\n/* tslint:enable:max-line-length */\n/**\n * Returns an Observable that emits the results of invoking a specified selector on items\n * emitted by a ConnectableObservable that shares a single subscription to the underlying stream.\n *\n * <img src=\"./img/multicast.png\" width=\"100%\">\n *\n * @param {Function|Subject} subjectOrSubjectFactory - Factory function to create an intermediate subject through\n * which the source sequence's elements will be multicast to the selector function\n * or Subject to push source elements into.\n * @param {Function} [selector] - Optional selector function that can use the multicasted source stream\n * as many times as needed, without causing multiple subscriptions to the source stream.\n * Subscribers to the given source will receive all notifications of the source from the\n * time of the subscription forward.\n * @return {Observable} An Observable that emits the results of invoking the selector\n * on the items emitted by a `ConnectableObservable` that shares a single subscription to\n * the underlying stream.\n * @method multicast\n * @owner Observable\n */\nfunction multicast(subjectOrSubjectFactory, selector) {\n    return function multicastOperatorFunction(source) {\n        var subjectFactory;\n        if (typeof subjectOrSubjectFactory === 'function') {\n            subjectFactory = subjectOrSubjectFactory;\n        }\n        else {\n            subjectFactory = function subjectFactory() {\n                return subjectOrSubjectFactory;\n            };\n        }\n        if (typeof selector === 'function') {\n            return source.lift(new MulticastOperator(subjectFactory, selector));\n        }\n        var connectable = Object.create(source, ConnectableObservable_1.connectableObservableDescriptor);\n        connectable.source = source;\n        connectable.subjectFactory = subjectFactory;\n        return connectable;\n    };\n}\nexports.multicast = multicast;\nvar MulticastOperator = (function () {\n    function MulticastOperator(subjectFactory, selector) {\n        this.subjectFactory = subjectFactory;\n        this.selector = selector;\n    }\n    MulticastOperator.prototype.call = function (subscriber, source) {\n        var selector = this.selector;\n        var subject = this.subjectFactory();\n        var subscription = selector(subject).subscribe(subscriber);\n        subscription.add(source.subscribe(subject));\n        return subscription;\n    };\n    return MulticastOperator;\n}());\nexports.MulticastOperator = MulticastOperator;\n//# sourceMappingURL=multicast.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar Notification_1 = require('../Notification');\n/**\n *\n * Re-emits all notifications from source Observable with specified scheduler.\n *\n * <span class=\"informal\">Ensure a specific scheduler is used, from outside of an Observable.</span>\n *\n * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule\n * notifications emitted by the source Observable. It might be useful, if you do not have control over\n * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.\n *\n * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,\n * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal\n * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits\n * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.\n * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split\n * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source\n * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a\n * little bit more, to ensure that they are emitted at expected moments.\n *\n * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications\n * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`\n * will delay all notifications - including error notifications - while `delay` will pass through error\n * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator\n * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used\n * for notification emissions in general.\n *\n * @example <caption>Ensure values in subscribe are called just before browser repaint.</caption>\n * const intervals = Rx.Observable.interval(10); // Intervals are scheduled\n *                                               // with async scheduler by default...\n *\n * intervals\n * .observeOn(Rx.Scheduler.animationFrame)       // ...but we will observe on animationFrame\n * .subscribe(val => {                           // scheduler to ensure smooth animation.\n *   someDiv.style.height = val + 'px';\n * });\n *\n * @see {@link delay}\n *\n * @param {IScheduler} scheduler Scheduler that will be used to reschedule notifications from source Observable.\n * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.\n * @return {Observable<T>} Observable that emits the same notifications as the source Observable,\n * but with provided scheduler.\n *\n * @method observeOn\n * @owner Observable\n */\nfunction observeOn(scheduler, delay) {\n    if (delay === void 0) { delay = 0; }\n    return function observeOnOperatorFunction(source) {\n        return source.lift(new ObserveOnOperator(scheduler, delay));\n    };\n}\nexports.observeOn = observeOn;\nvar ObserveOnOperator = (function () {\n    function ObserveOnOperator(scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ObserveOnSubscriber(subscriber, this.scheduler, this.delay));\n    };\n    return ObserveOnOperator;\n}());\nexports.ObserveOnOperator = ObserveOnOperator;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ObserveOnSubscriber = (function (_super) {\n    __extends(ObserveOnSubscriber, _super);\n    function ObserveOnSubscriber(destination, scheduler, delay) {\n        if (delay === void 0) { delay = 0; }\n        _super.call(this, destination);\n        this.scheduler = scheduler;\n        this.delay = delay;\n    }\n    ObserveOnSubscriber.dispatch = function (arg) {\n        var notification = arg.notification, destination = arg.destination;\n        notification.observe(destination);\n        this.unsubscribe();\n    };\n    ObserveOnSubscriber.prototype.scheduleMessage = function (notification) {\n        this.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));\n    };\n    ObserveOnSubscriber.prototype._next = function (value) {\n        this.scheduleMessage(Notification_1.Notification.createNext(value));\n    };\n    ObserveOnSubscriber.prototype._error = function (err) {\n        this.scheduleMessage(Notification_1.Notification.createError(err));\n    };\n    ObserveOnSubscriber.prototype._complete = function () {\n        this.scheduleMessage(Notification_1.Notification.createComplete());\n    };\n    return ObserveOnSubscriber;\n}(Subscriber_1.Subscriber));\nexports.ObserveOnSubscriber = ObserveOnSubscriber;\nvar ObserveOnMessage = (function () {\n    function ObserveOnMessage(notification, destination) {\n        this.notification = notification;\n        this.destination = destination;\n    }\n    return ObserveOnMessage;\n}());\nexports.ObserveOnMessage = ObserveOnMessage;\n//# sourceMappingURL=observeOn.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nfunction refCount() {\n    return function refCountOperatorFunction(source) {\n        return source.lift(new RefCountOperator(source));\n    };\n}\nexports.refCount = refCount;\nvar RefCountOperator = (function () {\n    function RefCountOperator(connectable) {\n        this.connectable = connectable;\n    }\n    RefCountOperator.prototype.call = function (subscriber, source) {\n        var connectable = this.connectable;\n        connectable._refCount++;\n        var refCounter = new RefCountSubscriber(subscriber, connectable);\n        var subscription = source.subscribe(refCounter);\n        if (!refCounter.closed) {\n            refCounter.connection = connectable.connect();\n        }\n        return subscription;\n    };\n    return RefCountOperator;\n}());\nvar RefCountSubscriber = (function (_super) {\n    __extends(RefCountSubscriber, _super);\n    function RefCountSubscriber(destination, connectable) {\n        _super.call(this, destination);\n        this.connectable = connectable;\n    }\n    /** @deprecated internal use only */ RefCountSubscriber.prototype._unsubscribe = function () {\n        var connectable = this.connectable;\n        if (!connectable) {\n            this.connection = null;\n            return;\n        }\n        this.connectable = null;\n        var refCount = connectable._refCount;\n        if (refCount <= 0) {\n            this.connection = null;\n            return;\n        }\n        connectable._refCount = refCount - 1;\n        if (refCount > 1) {\n            this.connection = null;\n            return;\n        }\n        ///\n        // Compare the local RefCountSubscriber's connection Subscription to the\n        // connection Subscription on the shared ConnectableObservable. In cases\n        // where the ConnectableObservable source synchronously emits values, and\n        // the RefCountSubscriber's downstream Observers synchronously unsubscribe,\n        // execution continues to here before the RefCountOperator has a chance to\n        // supply the RefCountSubscriber with the shared connection Subscription.\n        // For example:\n        // ```\n        // Observable.range(0, 10)\n        //   .publish()\n        //   .refCount()\n        //   .take(5)\n        //   .subscribe();\n        // ```\n        // In order to account for this case, RefCountSubscriber should only dispose\n        // the ConnectableObservable's shared connection Subscription if the\n        // connection Subscription exists, *and* either:\n        //   a. RefCountSubscriber doesn't have a reference to the shared connection\n        //      Subscription yet, or,\n        //   b. RefCountSubscriber's connection Subscription reference is identical\n        //      to the shared connection Subscription\n        ///\n        var connection = this.connection;\n        var sharedConnection = connectable._connection;\n        this.connection = null;\n        if (sharedConnection && (!connection || sharedConnection === connection)) {\n            sharedConnection.unsubscribe();\n        }\n    };\n    return RefCountSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=refCount.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subject_1 = require('../Subject');\nvar tryCatch_1 = require('../util/tryCatch');\nvar errorObject_1 = require('../util/errorObject');\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\n/**\n * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable\n * calls `error`, this method will emit the Throwable that caused the error to the Observable returned from `notifier`.\n * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child\n * subscription. Otherwise this method will resubscribe to the source Observable.\n *\n * <img src=\"./img/retryWhen.png\" width=\"100%\">\n *\n * @param {function(errors: Observable): Observable} notifier - Receives an Observable of notifications with which a\n * user can `complete` or `error`, aborting the retry.\n * @return {Observable} The source Observable modified with retry logic.\n * @method retryWhen\n * @owner Observable\n */\nfunction retryWhen(notifier) {\n    return function (source) { return source.lift(new RetryWhenOperator(notifier, source)); };\n}\nexports.retryWhen = retryWhen;\nvar RetryWhenOperator = (function () {\n    function RetryWhenOperator(notifier, source) {\n        this.notifier = notifier;\n        this.source = source;\n    }\n    RetryWhenOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new RetryWhenSubscriber(subscriber, this.notifier, this.source));\n    };\n    return RetryWhenOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar RetryWhenSubscriber = (function (_super) {\n    __extends(RetryWhenSubscriber, _super);\n    function RetryWhenSubscriber(destination, notifier, source) {\n        _super.call(this, destination);\n        this.notifier = notifier;\n        this.source = source;\n    }\n    RetryWhenSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var errors = this.errors;\n            var retries = this.retries;\n            var retriesSubscription = this.retriesSubscription;\n            if (!retries) {\n                errors = new Subject_1.Subject();\n                retries = tryCatch_1.tryCatch(this.notifier)(errors);\n                if (retries === errorObject_1.errorObject) {\n                    return _super.prototype.error.call(this, errorObject_1.errorObject.e);\n                }\n                retriesSubscription = subscribeToResult_1.subscribeToResult(this, retries);\n            }\n            else {\n                this.errors = null;\n                this.retriesSubscription = null;\n            }\n            this._unsubscribeAndRecycle();\n            this.errors = errors;\n            this.retries = retries;\n            this.retriesSubscription = retriesSubscription;\n            errors.next(err);\n        }\n    };\n    /** @deprecated internal use only */ RetryWhenSubscriber.prototype._unsubscribe = function () {\n        var _a = this, errors = _a.errors, retriesSubscription = _a.retriesSubscription;\n        if (errors) {\n            errors.unsubscribe();\n            this.errors = null;\n        }\n        if (retriesSubscription) {\n            retriesSubscription.unsubscribe();\n            this.retriesSubscription = null;\n        }\n        this.retries = null;\n    };\n    RetryWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        var _a = this, errors = _a.errors, retries = _a.retries, retriesSubscription = _a.retriesSubscription;\n        this.errors = null;\n        this.retries = null;\n        this.retriesSubscription = null;\n        this._unsubscribeAndRecycle();\n        this.errors = errors;\n        this.retries = retries;\n        this.retriesSubscription = retriesSubscription;\n        this.source.subscribe(this);\n    };\n    return RetryWhenSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=retryWhen.js.map","\"use strict\";\nvar multicast_1 = require('./multicast');\nvar refCount_1 = require('./refCount');\nvar Subject_1 = require('../Subject');\nfunction shareSubjectFactory() {\n    return new Subject_1.Subject();\n}\n/**\n * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one\n * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will\n * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`.\n * This is an alias for .multicast(() => new Subject()).refCount().\n *\n * <img src=\"./img/share.png\" width=\"100%\">\n *\n * @return {Observable<T>} An Observable that upon connection causes the source Observable to emit items to its Observers.\n * @method share\n * @owner Observable\n */\nfunction share() {\n    return function (source) { return refCount_1.refCount()(multicast_1.multicast(shareSubjectFactory)(source)); };\n}\nexports.share = share;\n;\n//# sourceMappingURL=share.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar ArgumentOutOfRangeError_1 = require('../util/ArgumentOutOfRangeError');\nvar EmptyObservable_1 = require('../observable/EmptyObservable');\n/**\n * Emits only the first `count` values emitted by the source Observable.\n *\n * <span class=\"informal\">Takes the first `count` values from the source, then\n * completes.</span>\n *\n * <img src=\"./img/take.png\" width=\"100%\">\n *\n * `take` returns an Observable that emits only the first `count` values emitted\n * by the source Observable. If the source emits fewer than `count` values then\n * all of its values are emitted. After that, it completes, regardless if the\n * source completes.\n *\n * @example <caption>Take the first 5 seconds of an infinite 1-second interval Observable</caption>\n * var interval = Rx.Observable.interval(1000);\n * var five = interval.take(5);\n * five.subscribe(x => console.log(x));\n *\n * @see {@link takeLast}\n * @see {@link takeUntil}\n * @see {@link takeWhile}\n * @see {@link skip}\n *\n * @throws {ArgumentOutOfRangeError} When using `take(i)`, it delivers an\n * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0`.\n *\n * @param {number} count The maximum number of `next` values to emit.\n * @return {Observable<T>} An Observable that emits only the first `count`\n * values emitted by the source Observable, or all of the values from the source\n * if the source emits fewer than `count` values.\n * @method take\n * @owner Observable\n */\nfunction take(count) {\n    return function (source) {\n        if (count === 0) {\n            return new EmptyObservable_1.EmptyObservable();\n        }\n        else {\n            return source.lift(new TakeOperator(count));\n        }\n    };\n}\nexports.take = take;\nvar TakeOperator = (function () {\n    function TakeOperator(total) {\n        this.total = total;\n        if (this.total < 0) {\n            throw new ArgumentOutOfRangeError_1.ArgumentOutOfRangeError;\n        }\n    }\n    TakeOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new TakeSubscriber(subscriber, this.total));\n    };\n    return TakeOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar TakeSubscriber = (function (_super) {\n    __extends(TakeSubscriber, _super);\n    function TakeSubscriber(destination, total) {\n        _super.call(this, destination);\n        this.total = total;\n        this.count = 0;\n    }\n    TakeSubscriber.prototype._next = function (value) {\n        var total = this.total;\n        var count = ++this.count;\n        if (count <= total) {\n            this.destination.next(value);\n            if (count === total) {\n                this.destination.complete();\n                this.unsubscribe();\n            }\n        }\n    };\n    return TakeSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=take.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\n/* tslint:enable:max-line-length */\n/**\n * Perform a side effect for every emission on the source Observable, but return\n * an Observable that is identical to the source.\n *\n * <span class=\"informal\">Intercepts each emission on the source and runs a\n * function, but returns an output which is identical to the source as long as errors don't occur.</span>\n *\n * <img src=\"./img/do.png\" width=\"100%\">\n *\n * Returns a mirrored Observable of the source Observable, but modified so that\n * the provided Observer is called to perform a side effect for every value,\n * error, and completion emitted by the source. Any errors that are thrown in\n * the aforementioned Observer or handlers are safely sent down the error path\n * of the output Observable.\n *\n * This operator is useful for debugging your Observables for the correct values\n * or performing other side effects.\n *\n * Note: this is different to a `subscribe` on the Observable. If the Observable\n * returned by `do` is not subscribed, the side effects specified by the\n * Observer will never happen. `do` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * @example <caption>Map every click to the clientX position of that click, while also logging the click event</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var positions = clicks\n *   .do(ev => console.log(ev))\n *   .map(ev => ev.clientX);\n * positions.subscribe(x => console.log(x));\n *\n * @see {@link map}\n * @see {@link subscribe}\n *\n * @param {Observer|function} [nextOrObserver] A normal Observer object or a\n * callback for `next`.\n * @param {function} [error] Callback for errors in the source.\n * @param {function} [complete] Callback for the completion of the source.\n * @return {Observable} An Observable identical to the source, but runs the\n * specified Observer or callback(s) for each item.\n * @name tap\n */\nfunction tap(nextOrObserver, error, complete) {\n    return function tapOperatorFunction(source) {\n        return source.lift(new DoOperator(nextOrObserver, error, complete));\n    };\n}\nexports.tap = tap;\nvar DoOperator = (function () {\n    function DoOperator(nextOrObserver, error, complete) {\n        this.nextOrObserver = nextOrObserver;\n        this.error = error;\n        this.complete = complete;\n    }\n    DoOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DoSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));\n    };\n    return DoOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar DoSubscriber = (function (_super) {\n    __extends(DoSubscriber, _super);\n    function DoSubscriber(destination, nextOrObserver, error, complete) {\n        _super.call(this, destination);\n        var safeSubscriber = new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n        safeSubscriber.syncErrorThrowable = true;\n        this.add(safeSubscriber);\n        this.safeSubscriber = safeSubscriber;\n    }\n    DoSubscriber.prototype._next = function (value) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.next(value);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.next(value);\n        }\n    };\n    DoSubscriber.prototype._error = function (err) {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.error(err);\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.error(err);\n        }\n    };\n    DoSubscriber.prototype._complete = function () {\n        var safeSubscriber = this.safeSubscriber;\n        safeSubscriber.complete();\n        if (safeSubscriber.syncErrorThrown) {\n            this.destination.error(safeSubscriber.syncErrorValue);\n        }\n        else {\n            this.destination.complete();\n        }\n    };\n    return DoSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=tap.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = require('../Subscription');\n/**\n * A unit of work to be executed in a {@link Scheduler}. An action is typically\n * created from within a Scheduler and an RxJS user does not need to concern\n * themselves about creating and manipulating an Action.\n *\n * ```ts\n * class Action<T> extends Subscription {\n *   new (scheduler: Scheduler, work: (state?: T) => void);\n *   schedule(state?: T, delay: number = 0): Subscription;\n * }\n * ```\n *\n * @class Action<T>\n */\nvar Action = (function (_super) {\n    __extends(Action, _super);\n    function Action(scheduler, work) {\n        _super.call(this);\n    }\n    /**\n     * Schedules this action on its parent Scheduler for execution. May be passed\n     * some context object, `state`. May happen at some point in the future,\n     * according to the `delay` parameter, if specified.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler.\n     * @return {void}\n     */\n    Action.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        return this;\n    };\n    return Action;\n}(Subscription_1.Subscription));\nexports.Action = Action;\n//# sourceMappingURL=Action.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Action_1 = require('./Action');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AsyncAction = (function (_super) {\n    __extends(AsyncAction, _super);\n    function AsyncAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.pending = false;\n        this.work = work;\n    }\n    AsyncAction.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        if (this.closed) {\n            return this;\n        }\n        // Always replace the current state with the new state.\n        this.state = state;\n        // Set the pending flag indicating that this action has been scheduled, or\n        // has recursively rescheduled itself.\n        this.pending = true;\n        var id = this.id;\n        var scheduler = this.scheduler;\n        //\n        // Important implementation note:\n        //\n        // Actions only execute once by default, unless rescheduled from within the\n        // scheduled callback. This allows us to implement single and repeat\n        // actions via the same code path, without adding API surface area, as well\n        // as mimic traditional recursion but across asynchronous boundaries.\n        //\n        // However, JS runtimes and timers distinguish between intervals achieved by\n        // serial `setTimeout` calls vs. a single `setInterval` call. An interval of\n        // serial `setTimeout` calls can be individually delayed, which delays\n        // scheduling the next `setTimeout`, and so on. `setInterval` attempts to\n        // guarantee the interval callback will be invoked more precisely to the\n        // interval period, regardless of load.\n        //\n        // Therefore, we use `setInterval` to schedule single and repeat actions.\n        // If the action reschedules itself with the same delay, the interval is not\n        // canceled. If the action doesn't reschedule, or reschedules with a\n        // different delay, the interval will be canceled after scheduled callback\n        // execution.\n        //\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, delay);\n        }\n        this.delay = delay;\n        // If this action has already an async Id, don't request a new one.\n        this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);\n        return this;\n    };\n    AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        return root_1.root.setInterval(scheduler.flush.bind(scheduler, this), delay);\n    };\n    AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If this action is rescheduled with the same delay time, don't clear the interval id.\n        if (delay !== null && this.delay === delay && this.pending === false) {\n            return id;\n        }\n        // Otherwise, if the action's delay time is different from the current delay,\n        // or the action has been rescheduled before it's executed, clear the interval id\n        return root_1.root.clearInterval(id) && undefined || undefined;\n    };\n    /**\n     * Immediately executes this action and the `work` it contains.\n     * @return {any}\n     */\n    AsyncAction.prototype.execute = function (state, delay) {\n        if (this.closed) {\n            return new Error('executing a cancelled action');\n        }\n        this.pending = false;\n        var error = this._execute(state, delay);\n        if (error) {\n            return error;\n        }\n        else if (this.pending === false && this.id != null) {\n            // Dequeue if the action didn't reschedule itself. Don't call\n            // unsubscribe(), because the action could reschedule later.\n            // For example:\n            // ```\n            // scheduler.schedule(function doWork(counter) {\n            //   /* ... I'm a busy worker bee ... */\n            //   var originalAction = this;\n            //   /* wait 100ms before rescheduling the action */\n            //   setTimeout(function () {\n            //     originalAction.schedule(counter + 1);\n            //   }, 100);\n            // }, 1000);\n            // ```\n            this.id = this.recycleAsyncId(this.scheduler, this.id, null);\n        }\n    };\n    AsyncAction.prototype._execute = function (state, delay) {\n        var errored = false;\n        var errorValue = undefined;\n        try {\n            this.work(state);\n        }\n        catch (e) {\n            errored = true;\n            errorValue = !!e && e || new Error(e);\n        }\n        if (errored) {\n            this.unsubscribe();\n            return errorValue;\n        }\n    };\n    /** @deprecated internal use only */ AsyncAction.prototype._unsubscribe = function () {\n        var id = this.id;\n        var scheduler = this.scheduler;\n        var actions = scheduler.actions;\n        var index = actions.indexOf(this);\n        this.work = null;\n        this.state = null;\n        this.pending = false;\n        this.scheduler = null;\n        if (index !== -1) {\n            actions.splice(index, 1);\n        }\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, null);\n        }\n        this.delay = null;\n    };\n    return AsyncAction;\n}(Action_1.Action));\nexports.AsyncAction = AsyncAction;\n//# sourceMappingURL=AsyncAction.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Scheduler_1 = require('../Scheduler');\nvar AsyncScheduler = (function (_super) {\n    __extends(AsyncScheduler, _super);\n    function AsyncScheduler() {\n        _super.apply(this, arguments);\n        this.actions = [];\n        /**\n         * A flag to indicate whether the Scheduler is currently executing a batch of\n         * queued actions.\n         * @type {boolean}\n         */\n        this.active = false;\n        /**\n         * An internal ID used to track the latest asynchronous task such as those\n         * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and\n         * others.\n         * @type {any}\n         */\n        this.scheduled = undefined;\n    }\n    AsyncScheduler.prototype.flush = function (action) {\n        var actions = this.actions;\n        if (this.active) {\n            actions.push(action);\n            return;\n        }\n        var error;\n        this.active = true;\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (action = actions.shift()); // exhaust the scheduler queue\n        this.active = false;\n        if (error) {\n            while (action = actions.shift()) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AsyncScheduler;\n}(Scheduler_1.Scheduler));\nexports.AsyncScheduler = AsyncScheduler;\n//# sourceMappingURL=AsyncScheduler.js.map","\"use strict\";\nvar AsyncAction_1 = require('./AsyncAction');\nvar AsyncScheduler_1 = require('./AsyncScheduler');\n/**\n *\n * Async Scheduler\n *\n * <span class=\"informal\">Schedule task as if you used setTimeout(task, duration)</span>\n *\n * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript\n * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating\n * in intervals.\n *\n * If you just want to \"defer\" task, that is to perform it right after currently\n * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),\n * better choice will be the {@link asap} scheduler.\n *\n * @example <caption>Use async scheduler to delay task</caption>\n * const task = () => console.log('it works!');\n *\n * Rx.Scheduler.async.schedule(task, 2000);\n *\n * // After 2 seconds logs:\n * // \"it works!\"\n *\n *\n * @example <caption>Use async scheduler to repeat task in intervals</caption>\n * function task(state) {\n *   console.log(state);\n *   this.schedule(state + 1, 1000); // `this` references currently executing Action,\n *                                   // which we reschedule with new state and delay\n * }\n *\n * Rx.Scheduler.async.schedule(task, 3000, 0);\n *\n * // Logs:\n * // 0 after 3s\n * // 1 after 4s\n * // 2 after 5s\n * // 3 after 6s\n *\n * @static true\n * @name async\n * @owner Scheduler\n */\nexports.async = new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);\n//# sourceMappingURL=async.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nfunction symbolIteratorPonyfill(root) {\n    var Symbol = root.Symbol;\n    if (typeof Symbol === 'function') {\n        if (!Symbol.iterator) {\n            Symbol.iterator = Symbol('iterator polyfill');\n        }\n        return Symbol.iterator;\n    }\n    else {\n        // [for Mozilla Gecko 27-35:](https://mzl.la/2ewE1zC)\n        var Set_1 = root.Set;\n        if (Set_1 && typeof new Set_1()['@@iterator'] === 'function') {\n            return '@@iterator';\n        }\n        var Map_1 = root.Map;\n        // required for compatability with es6-shim\n        if (Map_1) {\n            var keys = Object.getOwnPropertyNames(Map_1.prototype);\n            for (var i = 0; i < keys.length; ++i) {\n                var key = keys[i];\n                // according to spec, Map.prototype[@@iterator] and Map.orototype.entries must be equal.\n                if (key !== 'entries' && key !== 'size' && Map_1.prototype[key] === Map_1.prototype['entries']) {\n                    return key;\n                }\n            }\n        }\n        return '@@iterator';\n    }\n}\nexports.symbolIteratorPonyfill = symbolIteratorPonyfill;\nexports.iterator = symbolIteratorPonyfill(root_1.root);\n/**\n * @deprecated use iterator instead\n */\nexports.$$iterator = exports.iterator;\n//# sourceMappingURL=iterator.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nfunction getSymbolObservable(context) {\n    var $$observable;\n    var Symbol = context.Symbol;\n    if (typeof Symbol === 'function') {\n        if (Symbol.observable) {\n            $$observable = Symbol.observable;\n        }\n        else {\n            $$observable = Symbol('observable');\n            Symbol.observable = $$observable;\n        }\n    }\n    else {\n        $$observable = '@@observable';\n    }\n    return $$observable;\n}\nexports.getSymbolObservable = getSymbolObservable;\nexports.observable = getSymbolObservable(root_1.root);\n/**\n * @deprecated use observable instead\n */\nexports.$$observable = exports.observable;\n//# sourceMappingURL=observable.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nvar Symbol = root_1.root.Symbol;\nexports.rxSubscriber = (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?\n    Symbol.for('rxSubscriber') : '@@rxSubscriber';\n/**\n * @deprecated use rxSubscriber instead\n */\nexports.$$rxSubscriber = exports.rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an element was queried at a certain index of an\n * Observable, but no such index or position exists in that sequence.\n *\n * @see {@link elementAt}\n * @see {@link take}\n * @see {@link takeLast}\n *\n * @class ArgumentOutOfRangeError\n */\nvar ArgumentOutOfRangeError = (function (_super) {\n    __extends(ArgumentOutOfRangeError, _super);\n    function ArgumentOutOfRangeError() {\n        var err = _super.call(this, 'argument out of range');\n        this.name = err.name = 'ArgumentOutOfRangeError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ArgumentOutOfRangeError;\n}(Error));\nexports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;\n//# sourceMappingURL=ArgumentOutOfRangeError.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when an action is invalid because the object has been\n * unsubscribed.\n *\n * @see {@link Subject}\n * @see {@link BehaviorSubject}\n *\n * @class ObjectUnsubscribedError\n */\nvar ObjectUnsubscribedError = (function (_super) {\n    __extends(ObjectUnsubscribedError, _super);\n    function ObjectUnsubscribedError() {\n        var err = _super.call(this, 'object unsubscribed');\n        this.name = err.name = 'ObjectUnsubscribedError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return ObjectUnsubscribedError;\n}(Error));\nexports.ObjectUnsubscribedError = ObjectUnsubscribedError;\n//# sourceMappingURL=ObjectUnsubscribedError.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when one or more errors have occurred during the\n * `unsubscribe` of a {@link Subscription}.\n */\nvar UnsubscriptionError = (function (_super) {\n    __extends(UnsubscriptionError, _super);\n    function UnsubscriptionError(errors) {\n        _super.call(this);\n        this.errors = errors;\n        var err = Error.call(this, errors ?\n            errors.length + \" errors occurred during unsubscription:\\n  \" + errors.map(function (err, i) { return ((i + 1) + \") \" + err.toString()); }).join('\\n  ') : '');\n        this.name = err.name = 'UnsubscriptionError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return UnsubscriptionError;\n}(Error));\nexports.UnsubscriptionError = UnsubscriptionError;\n//# sourceMappingURL=UnsubscriptionError.js.map","\"use strict\";\n// typeof any so that it we don't have to cast when comparing a result to the error object\nexports.errorObject = { e: {} };\n//# sourceMappingURL=errorObject.js.map","\"use strict\";\nexports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArray.js.map","\"use strict\";\nexports.isArrayLike = (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArrayLike.js.map","\"use strict\";\nfunction isDate(value) {\n    return value instanceof Date && !isNaN(+value);\n}\nexports.isDate = isDate;\n//# sourceMappingURL=isDate.js.map","\"use strict\";\nfunction isFunction(x) {\n    return typeof x === 'function';\n}\nexports.isFunction = isFunction;\n//# sourceMappingURL=isFunction.js.map","\"use strict\";\nvar isArray_1 = require('../util/isArray');\nfunction isNumeric(val) {\n    // parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n    // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n    // subtraction forces infinities to NaN\n    // adding 1 corrects loss of precision from parseFloat (#15100)\n    return !isArray_1.isArray(val) && (val - parseFloat(val) + 1) >= 0;\n}\nexports.isNumeric = isNumeric;\n;\n//# sourceMappingURL=isNumeric.js.map","\"use strict\";\nfunction isObject(x) {\n    return x != null && typeof x === 'object';\n}\nexports.isObject = isObject;\n//# sourceMappingURL=isObject.js.map","\"use strict\";\nfunction isPromise(value) {\n    return value && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\nexports.isPromise = isPromise;\n//# sourceMappingURL=isPromise.js.map","\"use strict\";\nfunction isScheduler(value) {\n    return value && typeof value.schedule === 'function';\n}\nexports.isScheduler = isScheduler;\n//# sourceMappingURL=isScheduler.js.map","\"use strict\";\n/* tslint:disable:no-empty */\nfunction noop() { }\nexports.noop = noop;\n//# sourceMappingURL=noop.js.map","\"use strict\";\nvar noop_1 = require('./noop');\n/* tslint:enable:max-line-length */\nfunction pipe() {\n    var fns = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        fns[_i - 0] = arguments[_i];\n    }\n    return pipeFromArray(fns);\n}\nexports.pipe = pipe;\n/* @internal */\nfunction pipeFromArray(fns) {\n    if (!fns) {\n        return noop_1.noop;\n    }\n    if (fns.length === 1) {\n        return fns[0];\n    }\n    return function piped(input) {\n        return fns.reduce(function (prev, fn) { return fn(prev); }, input);\n    };\n}\nexports.pipeFromArray = pipeFromArray;\n//# sourceMappingURL=pipe.js.map","\"use strict\";\n// CommonJS / Node have global context exposed as \"global\" variable.\n// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake\n// the global \"global\" var for now.\nvar __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\nvar _root = __window || __global || __self;\nexports.root = _root;\n// Workaround Closure Compiler restriction: The body of a goog.module cannot use throw.\n// This is needed when used with angular/tsickle which inserts a goog.module statement.\n// Wrap in IIFE\n(function () {\n    if (!_root) {\n        throw new Error('RxJS could not find any global context (window, self, global)');\n    }\n})();\n//# sourceMappingURL=root.js.map","\"use strict\";\nvar root_1 = require('./root');\nvar isArrayLike_1 = require('./isArrayLike');\nvar isPromise_1 = require('./isPromise');\nvar isObject_1 = require('./isObject');\nvar Observable_1 = require('../Observable');\nvar iterator_1 = require('../symbol/iterator');\nvar InnerSubscriber_1 = require('../InnerSubscriber');\nvar observable_1 = require('../symbol/observable');\nfunction subscribeToResult(outerSubscriber, result, outerValue, outerIndex) {\n    var destination = new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex);\n    if (destination.closed) {\n        return null;\n    }\n    if (result instanceof Observable_1.Observable) {\n        if (result._isScalar) {\n            destination.next(result.value);\n            destination.complete();\n            return null;\n        }\n        else {\n            destination.syncErrorThrowable = true;\n            return result.subscribe(destination);\n        }\n    }\n    else if (isArrayLike_1.isArrayLike(result)) {\n        for (var i = 0, len = result.length; i < len && !destination.closed; i++) {\n            destination.next(result[i]);\n        }\n        if (!destination.closed) {\n            destination.complete();\n        }\n    }\n    else if (isPromise_1.isPromise(result)) {\n        result.then(function (value) {\n            if (!destination.closed) {\n                destination.next(value);\n                destination.complete();\n            }\n        }, function (err) { return destination.error(err); })\n            .then(null, function (err) {\n            // Escaping the Promise trap: globally throw unhandled errors\n            root_1.root.setTimeout(function () { throw err; });\n        });\n        return destination;\n    }\n    else if (result && typeof result[iterator_1.iterator] === 'function') {\n        var iterator = result[iterator_1.iterator]();\n        do {\n            var item = iterator.next();\n            if (item.done) {\n                destination.complete();\n                break;\n            }\n            destination.next(item.value);\n            if (destination.closed) {\n                break;\n            }\n        } while (true);\n    }\n    else if (result && typeof result[observable_1.observable] === 'function') {\n        var obs = result[observable_1.observable]();\n        if (typeof obs.subscribe !== 'function') {\n            destination.error(new TypeError('Provided object does not correctly implement Symbol.observable'));\n        }\n        else {\n            return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex));\n        }\n    }\n    else {\n        var value = isObject_1.isObject(result) ? 'an invalid object' : \"'\" + result + \"'\";\n        var msg = (\"You provided \" + value + \" where a stream was expected.\")\n            + ' You can provide an Observable, Promise, Array, or Iterable.';\n        destination.error(new TypeError(msg));\n    }\n    return null;\n}\nexports.subscribeToResult = subscribeToResult;\n//# sourceMappingURL=subscribeToResult.js.map","\"use strict\";\nvar Subscriber_1 = require('../Subscriber');\nvar rxSubscriber_1 = require('../symbol/rxSubscriber');\nvar Observer_1 = require('../Observer');\nfunction toSubscriber(nextOrObserver, error, complete) {\n    if (nextOrObserver) {\n        if (nextOrObserver instanceof Subscriber_1.Subscriber) {\n            return nextOrObserver;\n        }\n        if (nextOrObserver[rxSubscriber_1.rxSubscriber]) {\n            return nextOrObserver[rxSubscriber_1.rxSubscriber]();\n        }\n    }\n    if (!nextOrObserver && !error && !complete) {\n        return new Subscriber_1.Subscriber(Observer_1.empty);\n    }\n    return new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n}\nexports.toSubscriber = toSubscriber;\n//# sourceMappingURL=toSubscriber.js.map","\"use strict\";\nvar errorObject_1 = require('./errorObject');\nvar tryCatchTarget;\nfunction tryCatcher() {\n    try {\n        return tryCatchTarget.apply(this, arguments);\n    }\n    catch (e) {\n        errorObject_1.errorObject.e = e;\n        return errorObject_1.errorObject;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\nexports.tryCatch = tryCatch;\n;\n//# sourceMappingURL=tryCatch.js.map"],"names":["arrayToObject","array","reduce","obj","_ref","prop1","prop2","isNumber","val","includes","inclusive","inclusee","indexOf","flipTransformSign","match","prefix","offset","suffix","value","parseFloat","slice","getValuesAsList","replace","split","map","i","trim","filter","Boolean","_ref2","item","list","state","openParansCount","length","closedParansCount","parensDepth","push","handleQuartetValues","splitValues","top","right","bottom","join","propertyValueConverters","padding","textShadow","flippedShadows","shadows","start","end","rgba","substring","splitShadow","shadow","whiteSpace","negative","number","borderColor","_ref3","borderRadius","_ref4","_value$split","radius1","radius2","reverse","topLeft","topRight","bottomRight","background","_ref5","valuesToConvert","isRtl","bgImgDirectionRegex","bgPosDirectionRegex","backgroundPositionValue","backgroundPosition","backgroundImage","_ref6","g1","group2","_ref7","group","idx","len","toFixed","calculateNewBackgroundPosition","backgroundPositionX","_ref8","transition","_ref9","propertiesToConvert","values","transitionProperty","_ref10","prop","transform","_ref11","nonAsciiPattern","escapePattern","signedQuantPattern","translateXRegExp","RegExp","translateRegExp","translate3dRegExp","rotateRegExp","objectPosition","margin","borderWidth","boxShadow","webkitBoxShadow","mozBoxShadow","WebkitBoxShadow","MozBoxShadow","borderStyle","webkitTransform","mozTransform","WebkitTransform","MozTransform","transformOrigin","webkitTransformOrigin","mozTransformOrigin","WebkitTransformOrigin","MozTransformOrigin","webkitTransition","mozTransition","WebkitTransition","MozTransition","webkitTransitionProperty","mozTransitionProperty","WebkitTransitionProperty","MozTransitionProperty","propsToIgnore","convert","object","Object","keys","newObj","originalKey","originalValue","_convertProperty","convertProperty","key","Array","isArray","property","isNoFlip","test","canConvertValue","newValue","isNum","isFunc","isFunction","importantlessValue","isImportant","valueConverter","getValueDoppelganger","__extends","this","d","b","p","hasOwnProperty","__","constructor","prototype","create","Subject_1","ObjectUnsubscribedError_1","BehaviorSubject","_super","_value","call","defineProperty","get","getValue","enumerable","configurable","_subscribe","subscriber","subscription","closed","next","hasError","thrownError","ObjectUnsubscribedError","Subject","exports","InnerSubscriber","parent","outerValue","outerIndex","index","_next","notifyNext","_error","error","notifyError","unsubscribe","_complete","notifyComplete","Subscriber","Observable_1","Notification","kind","hasValue","observe","observer","complete","do","accept","nextOrObserver","toObservable","Observable","of","throw","empty","Error","createNext","undefinedValueNotification","createError","err","undefined","createComplete","completeNotification","root_1","toSubscriber_1","observable_1","pipe_1","subscribe","_isScalar","lift","operator","observable","source","observerOrNext","sink","toSubscriber","add","syncErrorThrowable","_trySubscribe","syncErrorThrown","syncErrorValue","forEach","PromiseCtor","_this","root","Rx","config","Promise","resolve","reject","pipe","operations","_i","arguments","pipeFromArray","toPromise","x","OuterSubscriber","apply","innerValue","innerIndex","innerSub","destination","Scheduler","SchedulerAction","now","schedule","work","delay","Date","Subscriber_1","Subscription_1","SubjectSubscription_1","rxSubscriber_1","SubjectSubscriber","observers","isStopped","rxSubscriber","subject","AnonymousSubject","copy","Subscription","EMPTY","SubjectSubscription","asObservable","subscriberIndex","splice","isFunction_1","Observer_1","destinationOrNext","isTrustedSubscriber","trustedSubscriber","SafeSubscriber","_unsubscribeAndRecycle","_parent","_parents","_parentSubscriber","context","bind","_context","__tryOrSetError","__tryOrUnsub","wrappedComplete","fn","_unsubscribe","isArray_1","isObject_1","tryCatch_1","errorObject_1","UnsubscriptionError_1","_subscriptions","errors","hasErrors","_a","remove","tryCatch","errorObject","e","UnsubscriptionError","flattenUnsubscriptionErrors","sub","isObject","concat","teardown","_addParent","tmp","subscriptions","subscriptionIndex","errs","ajax_1","ajax","empty_1","from_1","from","interval_1","interval","of_1","throw_1","_throw","catch_1","catch","_catch","combineLatest_1","combineLatest","concatMap_1","concatMap","count_1","count","delay_1","do_1","_do","filter_1","map_1","mergeMap_1","mergeMap","flatMap","retryWhen_1","retryWhen","share_1","share","take_1","take","ScalarObservable_1","EmptyObservable_1","ArrayLikeObservable","arrayLike","scheduler","EmptyObservable","ScalarObservable","dispatch","isScheduler_1","ArrayObservable","isScheduler","pop","refCount_1","ConnectableObservable","subjectFactory","_refCount","_isComplete","getSubject","_subject","connect","connection","_connection","ConnectableSubscriber","refCount","connectableProto","connectableObservableDescriptor","writable","connectable","RefCountSubscriber","RefCountOperator","refCounter","sharedConnection","arg","ErrorObservable","isArrayLike_1","isPromise_1","PromiseObservable_1","IteratorObservable_1","ArrayObservable_1","ArrayLikeObservable_1","iterator_1","observeOn_1","FromObservable","ish","isPromise","PromiseObservable","iterator","IteratorObservable","isArrayLike","TypeError","ObserveOnSubscriber","isNumeric_1","async_1","IntervalObservable","period","async","isNumeric","StringIterator","ArrayIterator","getIterator","result","done","return","str","charAt","arr","o","isNaN","isFinite","valueAsNumber","sign","Math","floor","abs","maxSafeInteger","toLength","pow","promise","then","setTimeout","dispatchNext","dispatchError","getCORSRequest","XMLHttpRequest","XDomainRequest","ajaxGet","url","headers","AjaxObservable","method","ajaxPost","body","ajaxDelete","ajaxPut","ajaxPatch","mapResponse","response","ajaxGetJSON","responseType","urlOrRequest","request","createXHR","crossDomain","progId","progIds","ActiveXObject","getXMLHttpRequest","withCredentials","timeout","AjaxSubscriber","post","delete","put","patch","getJSON","FormData","serializeBody","send","xhr","AjaxResponse","_b","user","password","setupEvents","open","setHeaders","contentType","splitIndex","encodeURIComponent","JSON","stringify","setRequestHeader","progressSubscriber","xhrTimeout","AjaxTimeoutError","ontimeout","upload","xhrProgress_1","xhrError_1","onprogress","AjaxError","onerror","xhrReadyStateChange","readyState","status_1","status","responseText","onreadystatechange","abort","originalEvent","parseXhrResponse","message","parse","responseXML","AjaxObservable_1","FromObservable_1","IntervalObservable_1","ErrorObservable_1","catchError_1","selector","catchError","observables","project","resultSelector","predicate","tap_1","tap","thisArg","concurrent","Number","POSITIVE_INFINITY","notifier","OuterSubscriber_1","subscribeToResult_1","CatchOperator","caught","CatchSubscriber","err2","subscribeToResult","none","CombineLatestOperator","CombineLatestSubscriber","active","toRespond","unused","oldVal","_tryProject","CountOperator","CountSubscriber","_tryPredicate","isDate_1","Notification_1","delayFor","isDate","DelayOperator","DelaySubscriber","queue","errored","time","shift","notification","max","_schedule","scheduleNotification","DelayMessage","FilterOperator","FilterSubscriber","MapOperator","MapSubscriber","MergeMapOperator","MergeMapSubscriber","hasCompleted","buffer","_tryNext","_innerSub","_notifyResultSelector","ConnectableObservable_1","multicast","subjectOrSubjectFactory","MulticastOperator","observeOn","ObserveOnOperator","scheduleMessage","ObserveOnMessage","RetryWhenOperator","RetryWhenSubscriber","retries","retriesSubscription","multicast_1","shareSubjectFactory","ArgumentOutOfRangeError_1","TakeOperator","total","ArgumentOutOfRangeError","TakeSubscriber","DoOperator","DoSubscriber","safeSubscriber","Action","AsyncAction","pending","id","recycleAsyncId","requestAsyncId","setInterval","flush","clearInterval","execute","_execute","errorValue","actions","AsyncScheduler","scheduled","action","AsyncAction_1","AsyncScheduler_1","symbolIteratorPonyfill","Symbol","Set_1","Set","Map_1","Map","getOwnPropertyNames","$$iterator","getSymbolObservable","$$observable","for","$$rxSubscriber","name","stack","toString","noop","noop_1","fns","input","prev","__window","window","__self","self","WorkerGlobalScope","__global","g","_root","InnerSubscriber_1","outerSubscriber","obs","msg","tryCatchTarget","tryCatcher"],"sourceRoot":""}