hunk.code_window:           },
             (err) => {
               results.push(err);
               // Since the consuming code can no longer interfere with the synchronous
               // producer, the remaining results are nexted.
               expect(results).to.deep.equal([1, 2, 3, 4, expected]);
             }
           );
       });
  
hunk.labels: keep keep keep replace replace replace keep keep keep keep
hunk.after_edit:             // The error should unsubscribe from the source, meaning we 
               // should not see the number 4.
               expect(results).to.deep.equal([1, 2, 3, expected]);
  
hunk.file_path: spec/Observable-spec.ts
hunk.type: replace
file: import { OperatorFunction, MonoTypeOperatorFunction, Falsy } from '../types';
  import { operate } from '../util/lift';
  import { OperatorSubscriber } from './OperatorSubscriber';
  
  export function takeWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, Exclude<T, Falsy> extends never ? never : T>;
  export function takeWhile<T>(
    predicate: BooleanConstructor,
    inclusive: false
  ): OperatorFunction<T, Exclude<T, Falsy> extends never ? never : T>;
  export function takeWhile<T>(predicate: BooleanConstructor, inclusive: true): MonoTypeOperatorFunction<T>;
  export function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>;
  export function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S, inclusive: false): OperatorFunction<T, S>;
  export function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive?: boolean): MonoTypeOperatorFunction<T>;
  
  /**
   * Emits values emitted by the source Observable so long as each value satisfies
   * the given `predicate`, and then completes as soon as this `predicate` is not
   * satisfied.
   *
   * <span class="informal">Takes values from the source only while they pass the
   * condition given. When the first value does not satisfy, it completes.</span>
   *
   * ![](takeWhile.png)
   *
   * `takeWhile` subscribes and begins mirroring the source Observable. Each value
   * emitted on the source is given to the `predicate` function which returns a
   * boolean, representing a condition to be satisfied by the source values. The
   * output Observable emits the source values until such time as the `predicate`
   * returns false, at which point `takeWhile` stops mirroring the source
   * Observable and completes the output Observable.
   *
   * ## Example
   * Emit click events only while the clientX property is greater than 200
   * ```ts
   * import { fromEvent } from 'rxjs';
   * import { takeWhile } from 'rxjs/operators';
   *
   * const clicks = fromEvent(document, 'click');
   * const result = clicks.pipe(takeWhile(ev => ev.clientX > 200));
   * result.subscribe(x => console.log(x));
   * ```
   *
   * @see {@link take}
   * @see {@link takeLast}
   * @see {@link takeUntil}
   * @see {@link skip}
   *
   * @param {function(value: T, index: number): boolean} predicate A function that
   * evaluates a value emitted by the source Observable and returns a boolean.
   * Also takes the (zero-based) index as the second argument.
   * @param {boolean} inclusive When set to `true` the value that caused
   * `predicate` to return `false` will also be emitted.
   * @return A function that returns an Observable that emits values from the
   * source Observable so long as each value satisfies the condition defined by
   * the `predicate`, then completes.
   */
  export function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive = false): MonoTypeOperatorFunction<T> {
    return operate((source, subscriber) => {
      let index = 0;
      source.subscribe(
        new OperatorSubscriber(subscriber, (value) => {
          const result = predicate(value, index++);
          (result || inclusive) && subscriber.next(value);
          !result && subscriber.complete();
        })
      );
    });
  }
  