hunk.code_window:     "precommit": "lint-staged",
       "commitmsg": "validate-commit-msg",
       "info": "npm-scripts-info",
       "build_all": "npm-run-all clean_dist build_cjs build_esm5 build_esm2015 build_esm5_for_rollup build_umd generate_packages",
       "build_cjs": "npm-run-all clean_dist_cjs compile_dist_cjs",
       "build_esm5": "npm-run-all clean_dist_esm5 compile_dist_esm5",
       "build_esm5_for_rollup": "npm-run-all clean_dist_esm5_for_rollup compile_dist_esm5_for_rollup",
       "build_esm2015": "npm-run-all clean_dist_esm2015 compile_dist_esm2015",
       "build_esm2015_for_docs": "npm-run-all clean_dist_esm2015 compile_dist_esm2015_for_docs",
  
hunk.labels: keep keep keep replace keep keep keep keep keep
hunk.after_edit:     "build_all": "npm-run-all clean_dist copy_sources build_cjs build_esm5 build_esm2015 build_esm5_for_rollup build_umd generate_packages",
  
hunk.file_path: package.json
hunk.type: replace
file: import { Operator } from '../Operator';
  import { Observable } from '../Observable';
  import { Subscriber } from '../Subscriber';
  import { OperatorFunction } from '../interfaces';
  
  /**
   * Groups pairs of consecutive emissions together and emits them as an array of
   * two values.
   *
   * <span class="informal">Puts the current value and previous value together as
   * an array, and emits that.</span>
   *
   * <img src="./img/pairwise.png" width="100%">
   *
   * The Nth emission from the source Observable will cause the output Observable
   * to emit an array [(N-1)th, Nth] of the previous and the current value, as a
   * pair. For this reason, `pairwise` emits on the second and subsequent
   * emissions from the source Observable, but not on the first emission, because
   * there is no previous value in that case.
   *
   * @example <caption>On every click (starting from the second), emit the relative distance to the previous click</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var pairs = clicks.pairwise();
   * var distance = pairs.map(pair => {
   *   var x0 = pair[0].clientX;
   *   var y0 = pair[0].clientY;
   *   var x1 = pair[1].clientX;
   *   var y1 = pair[1].clientY;
   *   return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
   * });
   * distance.subscribe(x => console.log(x));
   *
   * @see {@link buffer}
   * @see {@link bufferCount}
   *
   * @return {Observable<Array<T>>} An Observable of pairs (as arrays) of
   * consecutive values from the source Observable.
   * @method pairwise
   * @owner Observable
   */
  export function pairwise<T>(): OperatorFunction<T, [T, T]> {
    return (source: Observable<T>) => source.lift(new PairwiseOperator());
  }
  
  class PairwiseOperator<T> implements Operator<T, [T, T]> {
    call(subscriber: Subscriber<[T, T]>, source: any): any {
      return source.subscribe(new PairwiseSubscriber(subscriber));
    }
  }
  
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  class PairwiseSubscriber<T> extends Subscriber<T> {
    private prev: T;
    private hasPrev: boolean = false;
  
    constructor(destination: Subscriber<[T, T]>) {
      super(destination);
    }
  
    _next(value: T): void {
      if (this.hasPrev) {
        this.destination.next([this.prev, value]);
      } else {
        this.hasPrev = true;
      }
  
      this.prev = value;
    }
  }
  