@alexlit/lint-kit 186.2.2 → 186.3.0

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

@@ -1,69 +0,0 @@
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError';
-import { Observable } from '../Observable';
-import { MonoTypeOperatorFunction, TeardownLogic } from '../types';
-import { filter } from './filter';
-import { throwIfEmpty } from './throwIfEmpty';
-import { defaultIfEmpty } from './defaultIfEmpty';
-import { take } from './take';
-
-/**
- * Emits the single value at the specified `index` in a sequence of emissions
- * from the source Observable.
- *
- * <span class="informal">Emits only the i-th value, then completes.</span>
- *
- * ![](elementAt.png)
- *
- * `elementAt` returns an Observable that emits the item at the specified
- * `index` in the source Observable, or a default value if that `index` is out
- * of range and the `default` argument is provided. If the `default` argument is
- * not given and the `index` is out of range, the output Observable will emit an
- * `ArgumentOutOfRangeError` error.
- *
- * ## Example
- * Emit only the third click event
- * ```ts
- * import { fromEvent } from 'rxjs';
- * import { elementAt } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(elementAt(2));
- * result.subscribe(x => console.log(x));
- *
- * // Results in:
- * // click 1 = nothing
- * // click 2 = nothing
- * // click 3 = MouseEvent object logged to console
- * ```
- *
- * @see {@link first}
- * @see {@link last}
- * @see {@link skip}
- * @see {@link single}
- * @see {@link take}
- *
- * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an
- * ArgumentOutOrRangeError to the Observer's `error` callback if `i < 0` or the
- * Observable has completed before emitting the i-th `next` notification.
- *
- * @param {number} index Is the number `i` for the i-th source emission that has
- * happened since the subscription, starting from the number `0`.
- * @param {T} [defaultValue] The default value returned for missing indices.
- * @return {Observable} An Observable that emits a single item, if it is found.
- * Otherwise, will emit the default value if given. If not, then emits an error.
- * @method elementAt
- * @owner Observable
- */
-export function elementAt<T>(index: number, defaultValue?: T): MonoTypeOperatorFunction<T> {
-  if (index < 0) { throw new ArgumentOutOfRangeError(); }
-  const hasDefaultValue = arguments.length >= 2;
-  return (source: Observable<T>) => source.pipe(
-    filter((v, i) => i === index),
-    take(1),
-    hasDefaultValue
-      ? defaultIfEmpty(defaultValue)
-      : throwIfEmpty(() => new ArgumentOutOfRangeError()),
-  );
-}

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

@@ -1,67 +0,0 @@
-import { Observable } from '../Observable';
-import { concat } from '../observable/concat';
-import { of } from '../observable/of';
-import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction } from '../types';
-
-/* tslint:disable:max-line-length */
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T>(scheduler: SchedulerLike): MonoTypeOperatorFunction<T>;
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T, A>(v1: A, scheduler: SchedulerLike): OperatorFunction<T, T | A>;
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T, A, B>(v1: A, v2: B, scheduler: SchedulerLike): OperatorFunction<T, T | A | B>;
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T, A, B, C>(v1: A, v2: B, v3: C, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C>;
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T, A, B, C, D>(v1: A, v2: B, v3: C, v4: D, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C | D>;
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T, A, B, C, D, E>(v1: A, v2: B, v3: C, v4: D, v5: E, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C | D | E>;
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T, A, B, C, D, E, F>(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C | D | E | F>;
-
-export function endWith<T, A>(v1: A): OperatorFunction<T, T | A>;
-export function endWith<T, A, B>(v1: A, v2: B): OperatorFunction<T, T | A | B>;
-export function endWith<T, A, B, C>(v1: A, v2: B, v3: C): OperatorFunction<T, T | A | B | C>;
-export function endWith<T, A, B, C, D>(v1: A, v2: B, v3: C, v4: D): OperatorFunction<T, T | A | B | C | D>;
-export function endWith<T, A, B, C, D, E>(v1: A, v2: B, v3: C, v4: D, v5: E): OperatorFunction<T, T | A | B | C | D | E>;
-export function endWith<T, A, B, C, D, E, F>(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F): OperatorFunction<T, T | A | B | C | D | E | F>;
-export function endWith<T, Z = T>(...array: Z[]): OperatorFunction<T, T | Z>;
-/** @deprecated use {@link scheduled} and {@link concatAll} (e.g. `scheduled([source, [a, b, c]], scheduler).pipe(concatAll())`) */
-export function endWith<T, Z = T>(...array: Array<Z | SchedulerLike>): OperatorFunction<T, T | Z>;
-/* tslint:enable:max-line-length */
-
-/**
- * Returns an Observable that emits the items you specify as arguments after it finishes emitting
- * items emitted by the source Observable.
- *
- * ![](endWith.png)
- *
- * ## Example
- * ### After the source observable completes, appends an emission and then completes too.
- *
- * ```ts
- * import { of } from 'rxjs';
- * import { endWith } from 'rxjs/operators';
- *
- * of('hi', 'how are you?', 'sorry, I have to go now').pipe(
- *   endWith('goodbye!'),
- * )
- * .subscribe(word => console.log(word));
- * // result:
- * // 'hi'
- * // 'how are you?'
- * // 'sorry, I have to go now'
- * // 'goodbye!'
- * ```
- *
- * @param {...T} values - Items you want the modified Observable to emit last.
- * @param {SchedulerLike} [scheduler] - A {@link SchedulerLike} to use for scheduling
- * the emissions of the `next` notifications.
- * @return {Observable} An Observable that emits the items emitted by the source Observable
- *  and then emits the items in the specified Iterable.
- * @method endWith
- * @owner Observable
- */
-export function endWith<T>(...array: Array<T | SchedulerLike>): MonoTypeOperatorFunction<T> {
-  return (source: Observable<T>) => concat(source, of(...array)) as Observable<T>;
-}

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

@@ -1,81 +0,0 @@
-import { Operator } from '../Operator';
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { Observer, OperatorFunction } from '../types';
-
-/**
- * Returns an Observable that emits whether or not every item of the source satisfies the condition specified.
- *
- * ## Example
- * A simple example emitting true if all elements are less than 5, false otherwise
- * ```ts
- * import { of } from 'rxjs';
- * import { every } from 'rxjs/operators';
- *
- *  of(1, 2, 3, 4, 5, 6).pipe(
- *     every(x => x < 5),
- * )
- * .subscribe(x => console.log(x)); // -> false
- * ```
- *
- * @param {function} predicate A function for determining if an item meets a specified condition.
- * @param {any} [thisArg] Optional object to use for `this` in the callback.
- * @return {Observable} An Observable of booleans that determines if all items of the source Observable meet the condition specified.
- * @method every
- * @owner Observable
- */
-export function every<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean,
-                         thisArg?: any): OperatorFunction<T, boolean> {
-  return (source: Observable<T>) => source.lift(new EveryOperator(predicate, thisArg, source));
-}
-
-class EveryOperator<T> implements Operator<T, boolean> {
-  constructor(private predicate: (value: T, index: number, source: Observable<T>) => boolean,
-              private thisArg?: any,
-              private source?: Observable<T>) {
-  }
-
-  call(observer: Subscriber<boolean>, source: any): any {
-    return source.subscribe(new EverySubscriber(observer, this.predicate, this.thisArg, this.source));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-class EverySubscriber<T> extends Subscriber<T> {
-  private index: number = 0;
-
-  constructor(destination: Observer<boolean>,
-              private predicate: (value: T, index: number, source: Observable<T>) => boolean,
-              private thisArg: any,
-              private source?: Observable<T>) {
-    super(destination);
-    this.thisArg = thisArg || this;
-  }
-
-  private notifyComplete(everyValueMatch: boolean): void {
-    this.destination.next(everyValueMatch);
-    this.destination.complete();
-  }
-
-  protected _next(value: T): void {
-    let result = false;
-    try {
-      result = this.predicate.call(this.thisArg, value, this.index++, this.source);
-    } catch (err) {
-      this.destination.error(err);
-      return;
-    }
-
-    if (!result) {
-      this.notifyComplete(false);
-    }
-  }
-
-  protected _complete(): void {
-    this.notifyComplete(true);
-  }
-}

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

@@ -1,97 +0,0 @@
-import { Operator } from '../Operator';
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { ObservableInput, OperatorFunction, TeardownLogic } from '../types';
-import { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';
-
-export function exhaust<T>(): OperatorFunction<ObservableInput<T>, T>;
-export function exhaust<R>(): OperatorFunction<any, R>;
-
-/**
- * Converts a higher-order Observable into a first-order Observable by dropping
- * inner Observables while the previous inner Observable has not yet completed.
- *
- * <span class="informal">Flattens an Observable-of-Observables by dropping the
- * next inner Observables while the current inner is still executing.</span>
- *
- * ![](exhaust.png)
- *
- * `exhaust` subscribes to an Observable that emits Observables, also known as a
- * higher-order Observable. Each time it observes one of these emitted inner
- * Observables, the output Observable begins emitting the items emitted by that
- * inner Observable. So far, it behaves like {@link mergeAll}. However,
- * `exhaust` ignores every new inner Observable if the previous Observable has
- * not yet completed. Once that one completes, it will accept and flatten the
- * next inner Observable and repeat this process.
- *
- * ## Example
- * Run a finite timer for each click, only if there is no currently active timer
- * ```ts
- * import { fromEvent, interval } from 'rxjs';
- * import { exhaust, map, take } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const higherOrder = clicks.pipe(
- *   map((ev) => interval(1000).pipe(take(5))),
- * );
- * const result = higherOrder.pipe(exhaust());
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link combineAll}
- * @see {@link concatAll}
- * @see {@link switchAll}
- * @see {@link switchMap}
- * @see {@link mergeAll}
- * @see {@link exhaustMap}
- * @see {@link zipAll}
- *
- * @return {Observable} An Observable that takes a source of Observables and propagates the first observable
- * exclusively until it completes before subscribing to the next.
- * @method exhaust
- * @owner Observable
- */
-export function exhaust<T>(): OperatorFunction<any, T> {
-  return (source: Observable<T>) => source.lift(new SwitchFirstOperator<T>());
-}
-
-class SwitchFirstOperator<T> implements Operator<T, T> {
-  call(subscriber: Subscriber<T>, source: any): TeardownLogic {
-    return source.subscribe(new SwitchFirstSubscriber(subscriber));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-class SwitchFirstSubscriber<T> extends SimpleOuterSubscriber<T, T> {
-  private hasCompleted: boolean = false;
-  private hasSubscription: boolean = false;
-
-  constructor(destination: Subscriber<T>) {
-    super(destination);
-  }
-
-  protected _next(value: T): void {
-    if (!this.hasSubscription) {
-      this.hasSubscription = true;
-      this.add(innerSubscribe(value, new SimpleInnerSubscriber(this)));
-    }
-  }
-
-  protected _complete(): void {
-    this.hasCompleted = true;
-    if (!this.hasSubscription) {
-      this.destination.complete!();
-    }
-  }
-
-  notifyComplete(): void {
-    this.hasSubscription = false;
-    if (this.hasCompleted) {
-      this.destination.complete!();
-    }
-  }
-}

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

@@ -1,157 +0,0 @@
-import { Operator } from '../Operator';
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
-import { map } from './map';
-import { from } from '../observable/from';
-import { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';
-
-/* tslint:disable:max-line-length */
-export function exhaustMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated resultSelector is no longer supported. Use inner map instead. */
-export function exhaustMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated resultSelector is no longer supported. Use inner map instead. */
-export function exhaustMap<T, I, R>(project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
-/* tslint:enable:max-line-length */
-
-/**
- * Projects each source value to an Observable which is merged in the output
- * Observable only if the previous projected Observable has completed.
- *
- * <span class="informal">Maps each value to an Observable, then flattens all of
- * these inner Observables using {@link exhaust}.</span>
- *
- * ![](exhaustMap.png)
- *
- * Returns an Observable that emits items based on applying a function that you
- * supply to each item emitted by the source Observable, where that function
- * returns an (so-called "inner") Observable. When it projects a source value to
- * an Observable, the output Observable begins emitting the items emitted by
- * that projected Observable. However, `exhaustMap` ignores every new projected
- * Observable if the previous projected Observable has not yet completed. Once
- * that one completes, it will accept and flatten the next projected Observable
- * and repeat this process.
- *
- * ## Example
- * Run a finite timer for each click, only if there is no currently active timer
- * ```ts
- * import { fromEvent, interval } from 'rxjs';
- * import { exhaustMap, take } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   exhaustMap(ev => interval(1000).pipe(take(5)))
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link concatMap}
- * @see {@link exhaust}
- * @see {@link mergeMap}
- * @see {@link switchMap}
- *
- * @param {function(value: T, ?index: number): ObservableInput} project A function
- * that, when applied to an item emitted by the source Observable, returns an
- * Observable.
- * @return {Observable} An Observable containing projected Observables
- * of each item of the source, ignoring projected Observables that start before
- * their preceding Observable has completed.
- * @method exhaustMap
- * @owner Observable
- */
-export function exhaustMap<T, R, O extends ObservableInput<any>>(
-  project: (value: T, index: number) => O,
-  resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R,
-): OperatorFunction<T, ObservedValueOf<O>|R> {
-  if (resultSelector) {
-    // DEPRECATED PATH
-    return (source: Observable<T>) => source.pipe(
-      exhaustMap((a, i) => from(project(a, i)).pipe(
-        map((b: any, ii: any) => resultSelector(a, b, i, ii)),
-      )),
-    );
-  }
-  return (source: Observable<T>) =>
-    source.lift(new ExhaustMapOperator(project));
-}
-
-class ExhaustMapOperator<T, R> implements Operator<T, R> {
-  constructor(private project: (value: T, index: number) => ObservableInput<R>) {
-  }
-
-  call(subscriber: Subscriber<R>, source: any): any {
-    return source.subscribe(new ExhaustMapSubscriber(subscriber, this.project));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-class ExhaustMapSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {
-  private hasSubscription = false;
-  private hasCompleted = false;
-  private index = 0;
-
-  constructor(destination: Subscriber<R>,
-              private project: (value: T, index: number) => ObservableInput<R>) {
-    super(destination);
-  }
-
-  protected _next(value: T): void {
-    if (!this.hasSubscription) {
-      this.tryNext(value);
-    }
-  }
-
-  private tryNext(value: T): void {
-    let result: ObservableInput<R>;
-    const index = this.index++;
-    try {
-      result = this.project(value, index);
-    } catch (err) {
-      this.destination.error!(err);
-      return;
-    }
-    this.hasSubscription = true;
-    this._innerSub(result);
-  }
-
-  private _innerSub(result: ObservableInput<R>): void {
-    const innerSubscriber = new SimpleInnerSubscriber(this);
-    const destination = this.destination as Subscription;
-    destination.add(innerSubscriber);
-    const innerSubscription = innerSubscribe(result, 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.hasSubscription) {
-      this.destination.complete!();
-    }
-    this.unsubscribe();
-  }
-
-  notifyNext(innerValue: R): void {
-    this.destination.next!(innerValue);
-  }
-
-  notifyError(err: any): void {
-    this.destination.error!(err);
-  }
-
-  notifyComplete(): void {
-    this.hasSubscription = false;
-    if (this.hasCompleted) {
-      this.destination.complete!();
-    }
-  }
-}

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

@@ -1,174 +0,0 @@
-import { Observable } from '../Observable';
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { MonoTypeOperatorFunction, OperatorFunction, ObservableInput, SchedulerLike } from '../types';
-import { SimpleOuterSubscriber, innerSubscribe, SimpleInnerSubscriber } from '../innerSubscribe';
-
-/* tslint:disable:max-line-length */
-export function expand<T, R>(project: (value: T, index: number) => ObservableInput<R>, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, R>;
-export function expand<T>(project: (value: T, index: number) => ObservableInput<T>, concurrent?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-/* tslint:enable:max-line-length */
-
-/**
- * Recursively projects each source value to an Observable which is merged in
- * the output Observable.
- *
- * <span class="informal">It's similar to {@link mergeMap}, but applies the
- * projection function to every source value as well as every output value.
- * It's recursive.</span>
- *
- * ![](expand.png)
- *
- * Returns an Observable that emits items based on applying a function that you
- * supply to each item emitted by the source Observable, where that function
- * returns an Observable, and then merging those resulting Observables and
- * emitting the results of this merger. *Expand* will re-emit on the output
- * Observable every source value. Then, each output value is given to the
- * `project` function which returns an inner Observable to be merged on the
- * output Observable. Those output values resulting from the projection are also
- * given to the `project` function to produce new output values. This is how
- * *expand* behaves recursively.
- *
- * ## Example
- * Start emitting the powers of two on every click, at most 10 of them
- * ```ts
- * import { fromEvent, of } from 'rxjs';
- * import { expand, mapTo, delay, take } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const powersOfTwo = clicks.pipe(
- *   mapTo(1),
- *   expand(x => of(2 * x).pipe(delay(1000))),
- *   take(10),
- * );
- * powersOfTwo.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link mergeMap}
- * @see {@link mergeScan}
- *
- * @param {function(value: T, index: number) => Observable} project A function
- * that, when applied to an item emitted by the source or the output Observable,
- * returns an Observable.
- * @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
- * Observables being subscribed to concurrently.
- * @param {SchedulerLike} [scheduler=null] The {@link SchedulerLike} to use for subscribing to
- * each projected inner Observable.
- * @return {Observable} An Observable that emits the source values and also
- * result of applying the projection function to each value emitted on the
- * output Observable and and merging the results of the Observables obtained
- * from this transformation.
- * @method expand
- * @owner Observable
- */
-export function expand<T, R>(project: (value: T, index: number) => ObservableInput<R>,
-                             concurrent: number = Number.POSITIVE_INFINITY,
-                             scheduler?: SchedulerLike): OperatorFunction<T, R> {
-  concurrent = (concurrent || 0) < 1 ? Number.POSITIVE_INFINITY : concurrent;
-
-  return (source: Observable<T>) => source.lift(new ExpandOperator(project, concurrent, scheduler));
-}
-
-export class ExpandOperator<T, R> implements Operator<T, R> {
-  constructor(private project: (value: T, index: number) => ObservableInput<R>,
-              private concurrent: number,
-              private scheduler?: SchedulerLike) {
-  }
-
-  call(subscriber: Subscriber<R>, source: any): any {
-    return source.subscribe(new ExpandSubscriber(subscriber, this.project, this.concurrent, this.scheduler));
-  }
-}
-
-interface DispatchArg<T, R> {
-  subscriber: ExpandSubscriber<T, R>;
-  result: ObservableInput<R>;
-  value: any;
-  index: number;
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-export class ExpandSubscriber<T, R> extends SimpleOuterSubscriber<T, R> {
-  private index: number = 0;
-  private active: number = 0;
-  private hasCompleted: boolean = false;
-  private buffer?: any[];
-
-  constructor(destination: Subscriber<R>,
-              private project: (value: T, index: number) => ObservableInput<R>,
-              private concurrent: number,
-              private scheduler?: SchedulerLike) {
-    super(destination);
-    if (concurrent < Number.POSITIVE_INFINITY) {
-      this.buffer = [];
-    }
-  }
-
-  private static dispatch<T, R>(arg: DispatchArg<T, R>): void {
-    const {subscriber, result, value, index} = arg;
-    subscriber.subscribeToProjection(result, value, index);
-  }
-
-  protected _next(value: any): void {
-    const destination = this.destination;
-
-    if (destination.closed) {
-      this._complete();
-      return;
-    }
-
-    const index = this.index++;
-    if (this.active < this.concurrent) {
-      destination.next!(value);
-      try {
-        const { project } = this;
-        const result = project(value, index);
-        if (!this.scheduler) {
-          this.subscribeToProjection(result, value, index);
-        } else {
-          const state: DispatchArg<T, R> = { subscriber: this, result, value, index };
-          const destination = this.destination as Subscription;
-          destination.add(this.scheduler.schedule<DispatchArg<T, R>>(ExpandSubscriber.dispatch as any, 0, state));
-        }
-      } catch (e) {
-        destination.error!(e);
-      }
-    } else {
-      this.buffer!.push(value);
-    }
-  }
-
-  private subscribeToProjection(result: any, value: T, index: number): void {
-    this.active++;
-    const destination = this.destination as Subscription;
-    destination.add(innerSubscribe(result, new SimpleInnerSubscriber(this)));
-  }
-
-  protected _complete(): void {
-    this.hasCompleted = true;
-    if (this.hasCompleted && this.active === 0) {
-      this.destination.complete!();
-    }
-    this.unsubscribe();
-  }
-
-  notifyNext(innerValue: R): void {
-    this._next(innerValue);
-  }
-
-  notifyComplete(): void {
-    const buffer = this.buffer;
-    this.active--;
-    if (buffer && buffer.length > 0) {
-      this._next(buffer.shift());
-    }
-    if (this.hasCompleted && this.active === 0) {
-      this.destination.complete!();
-    }
-  }
-}