@alexlit/lint-kit 186.2.2 → 186.3.0

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/mergeScan.ts

@@ -1,146 +0,0 @@
-import { Operator } from '../Operator';
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { ObservableInput, OperatorFunction } from '../types';
-import { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';
-
-/**
- * Applies an accumulator function over the source Observable where the
- * accumulator function itself returns an Observable, then each intermediate
- * Observable returned is merged into the output Observable.
- *
- * <span class="informal">It's like {@link scan}, but the Observables returned
- * by the accumulator are merged into the outer Observable.</span>
- *
- * ## Example
- * Count the number of click events
- * ```ts
- * import { fromEvent, of } from 'rxjs';
- * import { mapTo, mergeScan } from 'rxjs/operators';
- *
- * const click$ = fromEvent(document, 'click');
- * const one$ = click$.pipe(mapTo(1));
- * const seed = 0;
- * const count$ = one$.pipe(
- *   mergeScan((acc, one) => of(acc + one), seed),
- * );
- * count$.subscribe(x => console.log(x));
- *
- * // Results:
- * // 1
- * // 2
- * // 3
- * // 4
- * // ...and so on for each click
- * ```
- *
- * @param {function(acc: R, value: T): Observable<R>} accumulator
- * The accumulator function called on each source value.
- * @param seed The initial accumulation value.
- * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of
- * input Observables being subscribed to concurrently.
- * @return {Observable<R>} An observable of the accumulated values.
- * @method mergeScan
- * @owner Observable
- */
-export function mergeScan<T, R>(accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,
-                                seed: R,
-                                concurrent: number = Number.POSITIVE_INFINITY): OperatorFunction<T, R> {
-  return (source: Observable<T>) => source.lift(new MergeScanOperator(accumulator, seed, concurrent));
-}
-
-export class MergeScanOperator<T, R> implements Operator<T, R> {
-  constructor(private accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,
-              private seed: R,
-              private concurrent: number) {
-  }
-
-  call(subscriber: Subscriber<R>, source: any): any {
-    return source.subscribe(new MergeScanSubscriber(
-      subscriber, this.accumulator, this.seed, this.concurrent
-    ));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-export class MergeScanSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {
-  private hasValue: boolean = false;
-  private hasCompleted: boolean = false;
-  private buffer: Observable<any>[] = [];
-  private active: number = 0;
-  protected index: number = 0;
-
-  constructor(destination: Subscriber<R>,
-              private accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,
-              private acc: R,
-              private concurrent: number) {
-    super(destination);
-  }
-
-  protected _next(value: any): void {
-    if (this.active < this.concurrent) {
-      const index = this.index++;
-      const destination = this.destination;
-      let ish;
-      try {
-        const { accumulator } = this;
-        ish = accumulator(this.acc, value, index);
-      } catch (e) {
-        return destination.error!(e);
-      }
-      this.active++;
-      this._innerSub(ish);
-    } else {
-      this.buffer.push(value);
-    }
-  }
-
-  private _innerSub(ish: any): void {
-    const innerSubscriber = new SimpleInnerSubscriber(this);
-    const destination = this.destination as Subscription;
-    destination.add(innerSubscriber);
-    const innerSubscription = innerSubscribe(ish, innerSubscriber);
-    // The returned subscription will usually be the subscriber that was
-    // passed. However, interop subscribers will be wrapped and for
-    // unsubscriptions to chain correctly, the wrapper needs to be added, too.
-    if (innerSubscription !== innerSubscriber) {
-      destination.add(innerSubscription);
-    }
-  }
-
-  protected _complete(): void {
-    this.hasCompleted = true;
-    if (this.active === 0 && this.buffer.length === 0) {
-      if (this.hasValue === false) {
-        this.destination.next!(this.acc);
-      }
-      this.destination.complete!();
-    }
-    this.unsubscribe();
-  }
-
-  notifyNext(innerValue: R): void {
-    const { destination } = this;
-    this.acc = innerValue;
-    this.hasValue = true;
-    destination.next!(innerValue);
-  }
-
-  notifyComplete(): void {
-    const buffer = this.buffer;
-    this.active--;
-    if (buffer.length > 0) {
-      this._next(buffer.shift());
-    } else if (this.active === 0 && this.hasCompleted) {
-      if (this.hasValue === false) {
-        this.destination.next!(this.acc);
-      }
-      this.destination.complete!();
-    }
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/min.ts

@@ -1,53 +0,0 @@
-import { reduce } from './reduce';
-import { MonoTypeOperatorFunction } from '../types';
-
-/**
- * The Min operator operates on an Observable that emits numbers (or items that can be compared with a provided function),
- * and when source Observable completes it emits a single item: the item with the smallest value.
- *
- * ![](min.png)
- *
- * ## Examples
- * Get the minimal value of a series of numbers
- * ```ts
- * import { of } from 'rxjs';
- * import { min } from 'rxjs/operators';
- *
- * of(5, 4, 7, 2, 8).pipe(
- *   min(),
- * )
- * .subscribe(x => console.log(x)); // -> 2
- * ```
- *
- * Use a comparer function to get the minimal item
- * ```typescript
- * import { of } from 'rxjs';
- * import { min } from 'rxjs/operators';
- *
- * interface Person {
- *   age: number,
- *   name: string
- * }
- * of<Person>(
- *   {age: 7, name: 'Foo'},
- *   {age: 5, name: 'Bar'},
- *   {age: 9, name: 'Beer'},
- * ).pipe(
- *   min<Person>( (a: Person, b: Person) => a.age < b.age ? -1 : 1),
- * )
- * .subscribe((x: Person) => console.log(x.name)); // -> 'Bar'
- * ```
- * @see {@link max}
- *
- * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the
- * value of two items.
- * @return {Observable<R>} An Observable that emits item with the smallest value.
- * @method min
- * @owner Observable
- */
-export function min<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> {
-  const min: (x: T, y: T) => T = (typeof comparer === 'function')
-    ? (x, y) => comparer(x, y) < 0 ? x : y
-    : (x, y) => x < y ? x : y;
-  return reduce(min);
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/multicast.ts

@@ -1,69 +0,0 @@
-import { Subject } from '../Subject';
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Observable } from '../Observable';
-import { ConnectableObservable, connectableObservableDescriptor } from '../observable/ConnectableObservable';
-import { MonoTypeOperatorFunction, OperatorFunction, UnaryFunction, ObservedValueOf, ObservableInput } from '../types';
-
-/* tslint:disable:max-line-length */
-export function multicast<T>(subject: Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-export function multicast<T, O extends ObservableInput<any>>(subject: Subject<T>, selector: (shared: Observable<T>) => O): UnaryFunction<Observable<T>, ConnectableObservable<ObservedValueOf<O>>>;
-export function multicast<T>(subjectFactory: (this: Observable<T>) => Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-export function multicast<T, O extends ObservableInput<any>>(SubjectFactory: (this: Observable<T>) => Subject<T>, selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;
-/* tslint:enable:max-line-length */
-
-/**
- * Returns an Observable that emits the results of invoking a specified selector on items
- * emitted by a ConnectableObservable that shares a single subscription to the underlying stream.
- *
- * ![](multicast.png)
- *
- * @param {Function|Subject} subjectOrSubjectFactory - Factory function to create an intermediate subject through
- * which the source sequence's elements will be multicast to the selector function
- * or Subject to push source elements into.
- * @param {Function} [selector] - Optional selector function that can use the multicasted source stream
- * as many times as needed, without causing multiple subscriptions to the source stream.
- * Subscribers to the given source will receive all notifications of the source from the
- * time of the subscription forward.
- * @return {Observable} An Observable that emits the results of invoking the selector
- * on the items emitted by a `ConnectableObservable` that shares a single subscription to
- * the underlying stream.
- * @method multicast
- * @owner Observable
- */
-export function multicast<T, R>(subjectOrSubjectFactory: Subject<T> | (() => Subject<T>),
-                                selector?: (source: Observable<T>) => Observable<R>): OperatorFunction<T, R> {
-  return function multicastOperatorFunction(source: Observable<T>): Observable<R> {
-    let subjectFactory: () => Subject<T>;
-    if (typeof subjectOrSubjectFactory === 'function') {
-      subjectFactory = <() => Subject<T>>subjectOrSubjectFactory;
-    } else {
-      subjectFactory = function subjectFactory() {
-        return <Subject<T>>subjectOrSubjectFactory;
-      };
-    }
-
-    if (typeof selector === 'function') {
-      return source.lift(new MulticastOperator(subjectFactory, selector));
-    }
-
-    const connectable: any = Object.create(source, connectableObservableDescriptor);
-    connectable.source = source;
-    connectable.subjectFactory = subjectFactory;
-
-    return <ConnectableObservable<R>> connectable;
-  };
-}
-
-export class MulticastOperator<T, R> implements Operator<T, R> {
-  constructor(private subjectFactory: () => Subject<T>,
-              private selector: (source: Observable<T>) => Observable<R>) {
-  }
-  call(subscriber: Subscriber<R>, source: any): any {
-    const { selector } = this;
-    const subject = this.subjectFactory();
-    const subscription = selector(subject).subscribe(subscriber);
-    subscription.add(source.subscribe(subject));
-    return subscription;
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/observeOn.ts

@@ -1,122 +0,0 @@
-import { Observable } from '../Observable';
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { Notification } from '../Notification';
-import { MonoTypeOperatorFunction, PartialObserver, SchedulerAction, SchedulerLike, TeardownLogic } from '../types';
-
-/**
- *
- * Re-emits all notifications from source Observable with specified scheduler.
- *
- * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span>
- *
- * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule
- * notifications emitted by the source Observable. It might be useful, if you do not have control over
- * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.
- *
- * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,
- * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal
- * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits
- * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.
- * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split
- * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source
- * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a
- * little bit more, to ensure that they are emitted at expected moments.
- *
- * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications
- * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`
- * will delay all notifications - including error notifications - while `delay` will pass through error
- * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator
- * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used
- * for notification emissions in general.
- *
- * ## Example
- * Ensure values in subscribe are called just before browser repaint.
- * ```ts
- * import { interval } from 'rxjs';
- * import { observeOn } from 'rxjs/operators';
- *
- * const intervals = interval(10);                // Intervals are scheduled
- *                                                // with async scheduler by default...
- * intervals.pipe(
- *   observeOn(animationFrameScheduler),          // ...but we will observe on animationFrame
- * )                                              // scheduler to ensure smooth animation.
- * .subscribe(val => {
- *   someDiv.style.height = val + 'px';
- * });
- * ```
- *
- * @see {@link delay}
- *
- * @param {SchedulerLike} scheduler Scheduler that will be used to reschedule notifications from source Observable.
- * @param {number} [delay] Number of milliseconds that states with what delay every notification should be rescheduled.
- * @return {Observable<T>} Observable that emits the same notifications as the source Observable,
- * but with provided scheduler.
- *
- * @method observeOn
- * @owner Observable
- */
-export function observeOn<T>(scheduler: SchedulerLike, delay: number = 0): MonoTypeOperatorFunction<T> {
-  return function observeOnOperatorFunction(source: Observable<T>): Observable<T> {
-    return source.lift(new ObserveOnOperator(scheduler, delay));
-  };
-}
-
-export class ObserveOnOperator<T> implements Operator<T, T> {
-  constructor(private scheduler: SchedulerLike, private delay: number = 0) {
-  }
-
-  call(subscriber: Subscriber<T>, source: any): TeardownLogic {
-    return source.subscribe(new ObserveOnSubscriber(subscriber, this.scheduler, this.delay));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-export class ObserveOnSubscriber<T> extends Subscriber<T> {
-  /** @nocollapse */
-  static dispatch(this: SchedulerAction<ObserveOnMessage>, arg: ObserveOnMessage) {
-    const { notification, destination } = arg;
-    notification.observe(destination);
-    this.unsubscribe();
-  }
-
-  constructor(destination: Subscriber<T>,
-              private scheduler: SchedulerLike,
-              private delay: number = 0) {
-    super(destination);
-  }
-
-  private scheduleMessage(notification: Notification<any>): void {
-    const destination = this.destination as Subscription;
-    destination.add(this.scheduler.schedule(
-      ObserveOnSubscriber.dispatch,
-      this.delay,
-      new ObserveOnMessage(notification, this.destination)
-    ));
-  }
-
-  protected _next(value: T): void {
-    this.scheduleMessage(Notification.createNext(value));
-  }
-
-  protected _error(err: any): void {
-    this.scheduleMessage(Notification.createError(err));
-    this.unsubscribe();
-  }
-
-  protected _complete(): void {
-    this.scheduleMessage(Notification.createComplete());
-    this.unsubscribe();
-  }
-}
-
-export class ObserveOnMessage {
-  constructor(public notification: Notification<any>,
-              public destination: PartialObserver<any>) {
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/onErrorResumeNext.ts

@@ -1,175 +0,0 @@
-import { Observable } from '../Observable';
-import { from } from '../observable/from';
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { isArray } from '../util/isArray';
-import { ObservableInput, OperatorFunction } from '../types';
-import { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';
-
-/* tslint:disable:max-line-length */
-export function onErrorResumeNext<T>(): OperatorFunction<T, T>;
-export function onErrorResumeNext<T, T2>(v: ObservableInput<T2>): OperatorFunction<T, T | T2>;
-export function onErrorResumeNext<T, T2, T3>(v: ObservableInput<T2>, v2: ObservableInput<T3>): OperatorFunction<T, T | T2 | T3>;
-export function onErrorResumeNext<T, T2, T3, T4>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>): OperatorFunction<T, T | T2 | T3 | T4>;
-export function onErrorResumeNext<T, T2, T3, T4, T5>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>, v4: ObservableInput<T5>): OperatorFunction<T, T | T2 | T3 | T4 | T5>;
-export function onErrorResumeNext<T, T2, T3, T4, T5, T6>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>, v4: ObservableInput<T5>, v5: ObservableInput<T6>): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
-export function onErrorResumeNext<T, T2, T3, T4, T5, T6, T7>(v: ObservableInput<T2>, v2: ObservableInput<T3>, v3: ObservableInput<T4>, v4: ObservableInput<T5>, v5: ObservableInput<T6>, v6: ObservableInput<T7>): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6 | T7>;
-export function onErrorResumeNext<T, R>(...observables: Array<ObservableInput<any>>): OperatorFunction<T, T | R>;
-export function onErrorResumeNext<T, R>(array: ObservableInput<any>[]): OperatorFunction<T, T | R>;
-/* tslint:enable:max-line-length */
-
-/**
- * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one
- * that was passed.
- *
- * <span class="informal">Execute series of Observables no matter what, even if it means swallowing errors.</span>
- *
- * ![](onErrorResumeNext.png)
- *
- * `onErrorResumeNext` is an operator that accepts a series of Observables, provided either directly as
- * arguments or as an array. If no single Observable is provided, returned Observable will simply behave the same
- * as the source.
- *
- * `onErrorResumeNext` returns an Observable that starts by subscribing and re-emitting values from the source Observable.
- * When its stream of values ends - no matter if Observable completed or emitted an error - `onErrorResumeNext`
- * will subscribe to the first Observable that was passed as an argument to the method. It will start re-emitting
- * its values as well and - again - when that stream ends, `onErrorResumeNext` will proceed to subscribing yet another
- * Observable in provided series, no matter if previous Observable completed or ended with an error. This will
- * be happening until there is no more Observables left in the series, at which point returned Observable will
- * complete - even if the last subscribed stream ended with an error.
- *
- * `onErrorResumeNext` can be therefore thought of as version of {@link concat} operator, which is more permissive
- * when it comes to the errors emitted by its input Observables. While `concat` subscribes to the next Observable
- * in series only if previous one successfully completed, `onErrorResumeNext` subscribes even if it ended with
- * an error.
- *
- * Note that you do not get any access to errors emitted by the Observables. In particular do not
- * expect these errors to appear in error callback passed to {@link Observable#subscribe}. If you want to take
- * specific actions based on what error was emitted by an Observable, you should try out {@link catchError} instead.
- *
- *
- * ## Example
- * Subscribe to the next Observable after map fails
- * ```ts
- * import { of } from 'rxjs';
- * import { onErrorResumeNext, map } from 'rxjs/operators';
- *
- * of(1, 2, 3, 0).pipe(
- *   map(x => {
- *       if (x === 0) { throw Error(); }
- *        return 10 / x;
- *   }),
- *   onErrorResumeNext(of(1, 2, 3)),
- * )
- * .subscribe(
- *   val => console.log(val),
- *   err => console.log(err),          // Will never be called.
- *   () => console.log('that\'s it!')
- * );
- *
- * // Logs:
- * // 10
- * // 5
- * // 3.3333333333333335
- * // 1
- * // 2
- * // 3
- * // "that's it!"
- * ```
- *
- * @see {@link concat}
- * @see {@link catchError}
- *
- * @param {...ObservableInput} observables Observables passed either directly or as an array.
- * @return {Observable} An Observable that emits values from source Observable, but - if it errors - subscribes
- * to the next passed Observable and so on, until it completes or runs out of Observables.
- * @method onErrorResumeNext
- * @owner Observable
- */
-
-export function onErrorResumeNext<T, R>(...nextSources: Array<ObservableInput<any> |
-                                                       Array<ObservableInput<any>>>): OperatorFunction<T, R> {
-  if (nextSources.length === 1 && isArray(nextSources[0])) {
-    nextSources = <Array<Observable<any>>>nextSources[0];
-  }
-
-  return (source: Observable<T>) => source.lift(new OnErrorResumeNextOperator<T, R>(nextSources));
-}
-
-/* tslint:disable:max-line-length */
-export function onErrorResumeNextStatic<R>(v: ObservableInput<R>): Observable<R>;
-export function onErrorResumeNextStatic<T2, T3, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>): Observable<R>;
-export function onErrorResumeNextStatic<T2, T3, T4, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): Observable<R>;
-export function onErrorResumeNextStatic<T2, T3, T4, T5, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): Observable<R>;
-export function onErrorResumeNextStatic<T2, T3, T4, T5, T6, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<R>;
-
-export function onErrorResumeNextStatic<R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;
-export function onErrorResumeNextStatic<R>(array: ObservableInput<any>[]): Observable<R>;
-/* tslint:enable:max-line-length */
-
-export function onErrorResumeNextStatic<T, R>(...nextSources: Array<ObservableInput<any> |
-  Array<ObservableInput<any>> |
-  ((...values: Array<any>) => R)>): Observable<R> {
-  let source: ObservableInput<any>|undefined = undefined;
-
-  if (nextSources.length === 1 && isArray(nextSources[0])) {
-    nextSources = nextSources[0] as ObservableInput<any>[];
-  }
-  // TODO: resolve issue with passing no arguments.
-  source = nextSources.shift()!;
-
-  return from(source).lift(new OnErrorResumeNextOperator<T, R>(nextSources));
-}
-
-class OnErrorResumeNextOperator<T, R> implements Operator<T, R> {
-  constructor(private nextSources: Array<ObservableInput<any>>) {
-  }
-
-  call(subscriber: Subscriber<R>, source: any): any {
-    return source.subscribe(new OnErrorResumeNextSubscriber(subscriber, this.nextSources));
-  }
-}
-
-class OnErrorResumeNextSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {
-  constructor(protected destination: Subscriber<T>,
-              private nextSources: Array<ObservableInput<any>>) {
-    super(destination);
-  }
-
-  notifyError(): void {
-    this.subscribeToNextSource();
-  }
-
-  notifyComplete(): void {
-    this.subscribeToNextSource();
-  }
-
-  protected _error(err: any): void {
-    this.subscribeToNextSource();
-    this.unsubscribe();
-  }
-
-  protected _complete(): void {
-    this.subscribeToNextSource();
-    this.unsubscribe();
-  }
-
-  private subscribeToNextSource(): void {
-    const next = this.nextSources.shift();
-    if (!!next) {
-      const innerSubscriber = new SimpleInnerSubscriber(this);
-      const destination = this.destination as Subscription;
-      destination.add(innerSubscriber);
-      const innerSubscription = innerSubscribe(next, innerSubscriber);
-      // The returned subscription will usually be the subscriber that was
-      // passed. However, interop subscribers will be wrapped and for
-      // unsubscriptions to chain correctly, the wrapper needs to be added, too.
-      if (innerSubscription !== innerSubscriber) {
-        destination.add(innerSubscription);
-      }
-    } else {
-      this.destination.complete();
-    }
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/pairwise.ts

@@ -1,87 +0,0 @@
-import { Operator } from '../Operator';
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { OperatorFunction } from '../types';
-
-/**
- * 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>
- *
- * ![](pairwise.png)
- *
- * 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
- * On every click (starting from the second), emit the relative distance to the previous click
- * ```ts
- * import { fromEvent } from 'rxjs';
- * import { pairwise, map } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const pairs = clicks.pipe(pairwise());
- * const distance = pairs.pipe(
- *   map(pair => {
- *     const x0 = pair[0].clientX;
- *     const y0 = pair[0].clientY;
- *     const x1 = pair[1].clientX;
- *     const 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 {
-    let pair: [T, T] | undefined;
-
-    if (this.hasPrev) {
-      pair = [this.prev, value];
-    } else {
-      this.hasPrev = true;
-    }
-
-    this.prev = value;
-
-    if (pair) {
-      this.destination.next(pair);
-    }
-  }
-}