text: 'use strict';
  
  exports.__esModule = true;
  exports['default'] = withLatestFrom;
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
  
  var _utilTryCatch = require('../util/tryCatch');
  
  var _utilTryCatch2 = _interopRequireDefault(_utilTryCatch);
  
  var _utilErrorObject = require('../util/errorObject');
  
  var _OuterSubscriber2 = require('../OuterSubscriber');
  
  var _OuterSubscriber3 = _interopRequireDefault(_OuterSubscriber2);
  
  var _utilSubscribeToResult = require('../util/subscribeToResult');
  
  var _utilSubscribeToResult2 = _interopRequireDefault(_utilSubscribeToResult);
  
  /**
   * @param {Observable} observables the observables to get the latest values from.
   * @param {Function} [project] optional projection function for merging values together. Receives all values in order
   *  of observables passed. (e.g. `a.withLatestFrom(b, c, (a1, b1, c1) => a1 + b1 + c1)`). If this is not passed, arrays
   *  will be returned.
   * @description merges each value from an observable with the latest values from the other passed observables.
   * All observables must emit at least one value before the resulting observable will emit
   *
   * #### example
   * ```
   * A.withLatestFrom(B, C)
   *
   *  A:     ----a-----------------b---------------c-----------|
   *  B:     ---d----------------e--------------f---------|
   *  C:     --x----------------y-------------z-------------|
   * result: ---([a,d,x])---------([b,e,y])--------([c,f,z])---|
   * ```
   */
  
  function withLatestFrom() {
      var project = undefined;
  
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
      }
  
      if (typeof args[args.length - 1] === 'function') {
          project = args.pop();
      }
      var observables = args;
      return this.lift(new WithLatestFromOperator(observables, project));
  }
  
  var WithLatestFromOperator = (function () {
      function WithLatestFromOperator(observables, project) {
          _classCallCheck(this, WithLatestFromOperator);
  
          this.observables = observables;
          this.project = project;
      }
  
      WithLatestFromOperator.prototype.call = function call(subscriber) {
          return new WithLatestFromSubscriber(subscriber, this.observables, this.project);
      };
  
      return WithLatestFromOperator;
  })();
  
  var WithLatestFromSubscriber = (function (_OuterSubscriber) {
      _inherits(WithLatestFromSubscriber, _OuterSubscriber);
  
      function WithLatestFromSubscriber(destination, observables, project) {
          _classCallCheck(this, WithLatestFromSubscriber);
  
          _OuterSubscriber.call(this, destination);
          this.observables = observables;
          this.project = project;
          this.toRespond = [];
          var len = observables.length;
          this.values = new Array(len);
          for (var i = 0; i < len; i++) {
              this.toRespond.push(i);
          }
          for (var i = 0; i < len; i++) {
              var observable = observables[i];
              this.add(_utilSubscribeToResult2['default'](this, observable, observable, i));
          }
      }
  
      WithLatestFromSubscriber.prototype.notifyNext = function notifyNext(observable, value, observableIndex, index) {
          this.values[observableIndex] = value;
          var toRespond = this.toRespond;
          if (toRespond.length > 0) {
              var found = toRespond.indexOf(observableIndex);
              if (found !== -1) {
                  toRespond.splice(found, 1);
              }
          }
      };
  
      WithLatestFromSubscriber.prototype.notifyComplete = function notifyComplete() {
          // noop
      };
  
      WithLatestFromSubscriber.prototype._next = function _next(value) {
          if (this.toRespond.length === 0) {
              var values = this.values;
              var destination = this.destination;
              var project = this.project;
              var args = [value].concat(values);
              if (project) {
                  var result = _utilTryCatch2['default'](this.project).apply(this, args);
                  if (result === _utilErrorObject.errorObject) {
                      destination.error(result.e);
                  } else {
                      destination.next(result);
                  }
              } else {
                  destination.next(args);
              }
          }
      };
  
      return WithLatestFromSubscriber;
  })(_OuterSubscriber3['default']);
  
  module.exports = exports['default'];