text: /** PURE_IMPORTS_START .._OuterSubscriber,.._util_subscribeToResult PURE_IMPORTS_END */
  var __extends = (this && this.__extends) || function (d, b) {
      for (var p in b)
          if (b.hasOwnProperty(p))
              d[p] = b[p];
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
  import { OuterSubscriber } from '../OuterSubscriber';
  import { subscribeToResult } from '../util/subscribeToResult';
  /* tslint:enable:max-line-length */
  /**
   * Projects each source value to the same Observable which is merged multiple
   * times in the output Observable.
   *
   * <span class="informal">It's like {@link mergeMap}, but maps each value always
   * to the same inner Observable.</span>
   *
   * <img src="./img/mergeMapTo.png" width="100%">
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then merges those resulting Observables into one
   * single Observable, which is the output Observable.
   *
   * @example <caption>For each click event, start an interval Observable ticking every 1 second</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var result = clicks.mergeMapTo(Rx.Observable.interval(1000));
   * result.subscribe(x => console.log(x));
   *
   * @see {@link concatMapTo}
   * @see {@link merge}
   * @see {@link mergeAll}
   * @see {@link mergeMap}
   * @see {@link mergeScan}
   * @see {@link switchMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
   * A function to produce the value on the output Observable based on the values
   * and the indices of the source (outer) emission and the inner Observable
   * emission. The arguments passed to this function are:
   * - `outerValue`: the value that came from the source
   * - `innerValue`: the value that came from the projected Observable
   * - `outerIndex`: the "index" of the value that came from the source
   * - `innerIndex`: the "index" of the value from the projected Observable
   * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
   * Observables being subscribed to concurrently.
   * @return {Observable} An Observable that emits items from the given
   * `innerObservable` (and optionally transformed through `resultSelector`) every
   * time a value is emitted on the source Observable.
   * @method mergeMapTo
   * @owner Observable
   */
  export function mergeMapTo(innerObservable, resultSelector, concurrent) {
      if (concurrent === void 0) {
          concurrent = Number.POSITIVE_INFINITY;
      }
      if (typeof resultSelector === 'number') {
          concurrent = resultSelector;
          resultSelector = null;
      }
      return function (source) { return source.lift(new MergeMapToOperator(innerObservable, resultSelector, concurrent)); };
  }
  // TODO: Figure out correct signature here: an Operator<Observable<T>, R>
  //       needs to implement call(observer: Subscriber<R>): Subscriber<Observable<T>>
  export var MergeMapToOperator = /*@__PURE__*/ (/*@__PURE__*/ function () {
      function MergeMapToOperator(ish, resultSelector, concurrent) {
          if (concurrent === void 0) {
              concurrent = Number.POSITIVE_INFINITY;
          }
          this.ish = ish;
          this.resultSelector = resultSelector;
          this.concurrent = concurrent;
      }
      MergeMapToOperator.prototype.call = function (observer, source) {
          return source.subscribe(new MergeMapToSubscriber(observer, this.ish, this.resultSelector, this.concurrent));
      };
      return MergeMapToOperator;
  }());
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  export var MergeMapToSubscriber = /*@__PURE__*/ (/*@__PURE__*/ function (_super) {
      __extends(MergeMapToSubscriber, _super);
      function MergeMapToSubscriber(destination, ish, resultSelector, concurrent) {
          if (concurrent === void 0) {
              concurrent = Number.POSITIVE_INFINITY;
          }
          _super.call(this, destination);
          this.ish = ish;
          this.resultSelector = resultSelector;
          this.concurrent = concurrent;
          this.hasCompleted = false;
          this.buffer = [];
          this.active = 0;
          this.index = 0;
      }
      MergeMapToSubscriber.prototype._next = function (value) {
          if (this.active < this.concurrent) {
              var resultSelector = this.resultSelector;
              var index = this.index++;
              var ish = this.ish;
              var destination = this.destination;
              this.active++;
              this._innerSub(ish, destination, resultSelector, value, index);
          }
          else {
              this.buffer.push(value);
          }
      };
      MergeMapToSubscriber.prototype._innerSub = function (ish, destination, resultSelector, value, index) {
          this.add(subscribeToResult(this, ish, value, index));
      };
      MergeMapToSubscriber.prototype._complete = function () {
          this.hasCompleted = true;
          if (this.active === 0 && this.buffer.length === 0) {
              this.destination.complete();
          }
      };
      MergeMapToSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
          var _a = this, resultSelector = _a.resultSelector, destination = _a.destination;
          if (resultSelector) {
              this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex);
          }
          else {
              destination.next(innerValue);
          }
      };
      MergeMapToSubscriber.prototype.trySelectResult = function (outerValue, innerValue, outerIndex, innerIndex) {
          var _a = this, resultSelector = _a.resultSelector, destination = _a.destination;
          var result;
          try {
              result = resultSelector(outerValue, innerValue, outerIndex, innerIndex);
          }
          catch (err) {
              destination.error(err);
              return;
          }
          destination.next(result);
      };
      MergeMapToSubscriber.prototype.notifyError = function (err) {
          this.destination.error(err);
      };
      MergeMapToSubscriber.prototype.notifyComplete = function (innerSub) {
          var buffer = this.buffer;
          this.remove(innerSub);
          this.active--;
          if (buffer.length > 0) {
              this._next(buffer.shift());
          }
          else if (this.active === 0 && this.hasCompleted) {
              this.destination.complete();
          }
      };
      return MergeMapToSubscriber;
  }(OuterSubscriber));
  //# sourceMappingURL=mergeMapTo.js.map 
  