text: /* */ 
  "format cjs";
    var FilterObservable = (function (__super__) {
      inherits(FilterObservable, __super__);
  
      function FilterObservable(source, predicate, thisArg) {
        this.source = source;
        this.predicate = bindCallback(predicate, thisArg, 3);
        __super__.call(this);
      }
  
      FilterObservable.prototype.subscribeCore = function (o) {
        return this.source.subscribe(new InnerObserver(o, this.predicate, this));
      };
      
      function innerPredicate(predicate, self) {
        return function(x, i, o) { return self.predicate(x, i, o) && predicate.call(this, x, i, o); }
      }
  
      FilterObservable.prototype.internalFilter = function(predicate, thisArg) {
        return new FilterObservable(this.source, innerPredicate(predicate, this), thisArg);
      };
      
      function InnerObserver(o, predicate, source) {
        this.o = o;
        this.predicate = predicate;
        this.source = source;
        this.i = 0;
        this.isStopped = false;
      }
    
      InnerObserver.prototype.onNext = function(x) {
        if (this.isStopped) { return; }
        var shouldYield = tryCatch(this.predicate)(x, this.i++, this.source);
        if (shouldYield === errorObj) {
          return this.o.onError(shouldYield.e);
        }
        shouldYield && this.o.onNext(x);
      };
      InnerObserver.prototype.onError = function (e) {
        if(!this.isStopped) { this.isStopped = true; this.o.onError(e); }
      };
      InnerObserver.prototype.onCompleted = function () {
        if(!this.isStopped) { this.isStopped = true; this.o.onCompleted(); }
      };
      InnerObserver.prototype.dispose = function() { this.isStopped = true; };
      InnerObserver.prototype.fail = function (e) {
        if (!this.isStopped) {
          this.isStopped = true;
          this.o.onError(e);
          return true;
        }
        return false;
      };
  
      return FilterObservable;
  
    }(ObservableBase));
  
    /**
    *  Filters the elements of an observable sequence based on a predicate by incorporating the element's index.
    * @param {Function} predicate A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
    * @param {Any} [thisArg] Object to use as this when executing callback.
    * @returns {Observable} An observable sequence that contains elements from the input sequence that satisfy the condition.
    */
    observableProto.filter = observableProto.where = function (predicate, thisArg) {
      return this instanceof FilterObservable ? this.internalFilter(predicate, thisArg) :
        new FilterObservable(this, predicate, thisArg);
    };
  