text: import { OuterSubscriber } from '../OuterSubscriber';
  import { subscribeToResult } from '../util/subscribeToResult';
  import { Set } from '../util/Set';
  /**
   * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.
   *
   * If a keySelector function is provided, then it will project each value from the source observable into a new value that it will
   * check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the
   * source observable directly with an equality check against previous values.
   *
   * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.
   *
   * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the
   * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`
   * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so
   * that the internal `Set` can be "flushed", basically clearing it of values.
   *
   * @example <caption>A simple example with numbers</caption>
   * Observable.of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1)
   *   .distinct()
   *   .subscribe(x => console.log(x)); // 1, 2, 3, 4
   *
   * @example <caption>An example using a keySelector function</caption>
   * interface Person {
   *    age: number,
   *    name: string
   * }
   *
   * Observable.of<Person>(
   *     { age: 4, name: 'Foo'},
   *     { age: 7, name: 'Bar'},
   *     { age: 5, name: 'Foo'})
   *     .distinct((p: Person) => p.name)
   *     .subscribe(x => console.log(x));
   *
   * // displays:
   * // { age: 4, name: 'Foo' }
   * // { age: 7, name: 'Bar' }
   *
   * @see {@link distinctUntilChanged}
   * @see {@link distinctUntilKeyChanged}
   *
   * @param {function} [keySelector] Optional function to select which value you want to check as distinct.
   * @param {Observable} [flushes] Optional Observable for flushing the internal HashSet of the operator.
   * @return {Observable} An Observable that emits items from the source Observable with distinct values.
   * @method distinct
   * @owner Observable
   */
  export function distinct(keySelector, flushes) {
      return (source) => source.lift(new DistinctOperator(keySelector, flushes));
  }
  class DistinctOperator {
      constructor(keySelector, flushes) {
          this.keySelector = keySelector;
          this.flushes = flushes;
      }
      call(subscriber, source) {
          return source.subscribe(new DistinctSubscriber(subscriber, this.keySelector, this.flushes));
      }
  }
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  export class DistinctSubscriber extends OuterSubscriber {
      constructor(destination, keySelector, flushes) {
          super(destination);
          this.keySelector = keySelector;
          this.values = new Set();
          if (flushes) {
              this.add(subscribeToResult(this, flushes));
          }
      }
      notifyNext(outerValue, innerValue, outerIndex, innerIndex, innerSub) {
          this.values.clear();
      }
      notifyError(error, innerSub) {
          this._error(error);
      }
      _next(value) {
          if (this.keySelector) {
              this._useKeySelector(value);
          }
          else {
              this._finalizeNext(value, value);
          }
      }
      _useKeySelector(value) {
          let key;
          const { destination } = this;
          try {
              key = this.keySelector(value);
          }
          catch (err) {
              destination.error(err);
              return;
          }
          this._finalizeNext(key, value);
      }
      _finalizeNext(key, value) {
          const { values } = this;
          if (!values.has(key)) {
              values.add(key);
              this.destination.next(value);
          }
      }
  }
  //# sourceMappingURL=distinct.js.map