@alexlit/lint-kit 186.2.2 → 186.3.1

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

@@ -1,155 +0,0 @@
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Observable } from '../Observable';
-import { OuterSubscriber } from '../OuterSubscriber';
-import { InnerSubscriber } from '../InnerSubscriber';
-import { subscribeToResult } from '../util/subscribeToResult';
-import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
-
-/* tslint:disable:max-line-length */
-export function withLatestFrom<T, R>(project: (v1: T) => R): OperatorFunction<T, R>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, R>(source2: O2, project: (v1: T, v2: ObservedValueOf<O2>) => R): OperatorFunction<T, R>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, R>(v2: O2, v3: O3, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>) => R): OperatorFunction<T, R>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, R>(v2: O2, v3: O3, v4: O4, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>) => R): OperatorFunction<T, R>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, R>(v2: O2, v3: O3, v4: O4, v5: O5, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>) => R): OperatorFunction<T, R>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>, R>(v2: O2, v3: O3, v4: O4, v5: O5, v6: O6, project: (v1: T, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>, v6: ObservedValueOf<O6>) => R): OperatorFunction<T, R>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>>(source2: O2): OperatorFunction<T, [T, ObservedValueOf<O2>]>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>>(v2: O2, v3: O3): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>]>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>>(v2: O2, v3: O3, v4: O4): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>]>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>>(v2: O2, v3: O3, v4: O4, v5: O5): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>, ObservedValueOf<O5>]>;
-export function withLatestFrom<T, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>>(v2: O2, v3: O3, v4: O4, v5: O5, v6: O6): OperatorFunction<T, [T, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>, ObservedValueOf<O5>, ObservedValueOf<O6>]>;
-export function withLatestFrom<T, R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, R>;
-export function withLatestFrom<T, R>(array: ObservableInput<any>[]): OperatorFunction<T, R>;
-export function withLatestFrom<T, R>(array: ObservableInput<any>[], project: (...values: Array<any>) => R): OperatorFunction<T, R>;
-
-/* tslint:enable:max-line-length */
-
-/**
- * Combines the source Observable with other Observables to create an Observable
- * whose values are calculated from the latest values of each, only when the
- * source emits.
- *
- * <span class="informal">Whenever the source Observable emits a value, it
- * computes a formula using that value plus the latest values from other input
- * Observables, then emits the output of that formula.</span>
- *
- * ![](withLatestFrom.png)
- *
- * `withLatestFrom` combines each value from the source Observable (the
- * instance) with the latest values from the other input Observables only when
- * the source emits a value, optionally using a `project` function to determine
- * the value to be emitted on the output Observable. All input Observables must
- * emit at least one value before the output Observable will emit a value.
- *
- * ## Example
- * On every click event, emit an array with the latest timer event plus the click event
- * ```ts
- * import { fromEvent, interval } from 'rxjs';
- * import { withLatestFrom } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const timer = interval(1000);
- * const result = clicks.pipe(withLatestFrom(timer));
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link combineLatest}
- *
- * @param {ObservableInput} other An input Observable to combine with the source
- * Observable. More than one input Observables may be given as argument.
- * @param {Function} [project] Projection function for combining values
- * together. Receives all values in order of the Observables passed, where the
- * first parameter is a value from the source Observable. (e.g.
- * `a.pipe(withLatestFrom(b, c), map(([a1, b1, c1]) => a1 + b1 + c1))`). If this is not
- * passed, arrays will be emitted on the output Observable.
- * @return {Observable} An Observable of projected values from the most recent
- * values from each input Observable, or an array of the most recent values from
- * each input Observable.
- * @method withLatestFrom
- * @owner Observable
- */
-export function withLatestFrom<T, R>(...args: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, R> {
-  return (source: Observable<T>) => {
-    let project: any;
-    if (typeof args[args.length - 1] === 'function') {
-      project = args.pop();
-    }
-    const observables = <Observable<any>[]>args;
-    return source.lift(new WithLatestFromOperator(observables, project));
-  };
-}
-
-class WithLatestFromOperator<T, R> implements Operator<T, R> {
-  constructor(private observables: Observable<any>[],
-              private project?: (...values: any[]) => Observable<R>) {
-  }
-
-  call(subscriber: Subscriber<R>, source: any): any {
-    return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-class WithLatestFromSubscriber<T, R> extends OuterSubscriber<T, R> {
-  private values: any[];
-  private toRespond: number[] = [];
-
-  constructor(destination: Subscriber<R>,
-              private observables: Observable<any>[],
-              private project?: (...values: any[]) => Observable<R>) {
-    super(destination);
-    const len = observables.length;
-    this.values = new Array(len);
-
-    for (let i = 0; i < len; i++) {
-      this.toRespond.push(i);
-    }
-
-    for (let i = 0; i < len; i++) {
-      let observable = observables[i];
-      this.add(subscribeToResult<T, R>(this, observable, undefined, i));
-    }
-  }
-
-  notifyNext(_outerValue: T, innerValue: R,
-             outerIndex: number): void {
-    this.values[outerIndex] = innerValue;
-    const toRespond = this.toRespond;
-    if (toRespond.length > 0) {
-      const found = toRespond.indexOf(outerIndex);
-      if (found !== -1) {
-        toRespond.splice(found, 1);
-      }
-    }
-  }
-
-  notifyComplete() {
-    // noop
-  }
-
-  protected _next(value: T) {
-    if (this.toRespond.length === 0) {
-      const args = [value, ...this.values];
-      if (this.project) {
-        this._tryProject(args);
-      } else {
-        this.destination.next!(args);
-      }
-    }
-  }
-
-  private _tryProject(args: any[]) {
-    let result: any;
-    try {
-      result = this.project!.apply(this, args);
-    } catch (err) {
-      this.destination.error!(err);
-      return;
-    }
-    this.destination.next!(result);
-  }
-}

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

@@ -1,43 +0,0 @@
-import { zip as zipStatic } from '../observable/zip';
-import { Observable } from '../Observable';
-import { ObservableInput, OperatorFunction } from '../types';
-
-/* tslint:disable:max-line-length */
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, R>(project: (v1: T) => R): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, R>(v2: ObservableInput<T2>, project: (v1: T, v2: T2) => R): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, project: (v1: T, v2: T2, v3: T3) => R): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3, T4, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3, T4, T5, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3, T4, T5, T6, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): OperatorFunction<T, R> ;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2>(v2: ObservableInput<T2>): OperatorFunction<T, [T, T2]>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>): OperatorFunction<T, [T, T2, T3]>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): OperatorFunction<T, [T, T2, T3, T4]>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): OperatorFunction<T, [T, T2, T3, T4, T5]>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): OperatorFunction<T, [T, T2, T3, T4, T5, T6]> ;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, R>(...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, R>(array: Array<ObservableInput<T>>): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static zip. */
-export function zip<T, TOther, R>(array: Array<ObservableInput<TOther>>, project: (v1: T, ...values: Array<TOther>) => R): OperatorFunction<T, R>;
-/* tslint:enable:max-line-length */
-
-/**
- * @deprecated Deprecated in favor of static {@link zip}.
- */
-export function zip<T, R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, R> {
-  return function zipOperatorFunction(source: Observable<T>) {
-    return source.lift.call(zipStatic<R>(source, ...observables));
-  };
-}

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

@@ -1,12 +0,0 @@
-import { ZipOperator } from '../observable/zip';
-import { Observable } from '../Observable';
-import { OperatorFunction, ObservableInput } from '../types';
-
-export function zipAll<T>(): OperatorFunction<ObservableInput<T>, T[]>;
-export function zipAll<T>(): OperatorFunction<any, T[]>;
-export function zipAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>;
-export function zipAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>;
-
-export function zipAll<T, R>(project?: (...values: Array<any>) => R): OperatorFunction<T, R> {
-  return (source: Observable<T>) => source.lift(new ZipOperator(project));
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduled/scheduleArray.ts

@@ -1,21 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-import { Subscription } from '../Subscription';
-
-export function scheduleArray<T>(input: ArrayLike<T>, scheduler: SchedulerLike) {
-  return new Observable<T>(subscriber => {
-    const sub = new Subscription();
-    let i = 0;
-    sub.add(scheduler.schedule(function () {
-      if (i === input.length) {
-        subscriber.complete();
-        return;
-      }
-      subscriber.next(input[i++]);
-      if (!subscriber.closed) {
-        sub.add(this.schedule());
-      }
-    }));
-    return sub;
-  });
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduled/scheduleIterable.ts

@@ -1,45 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-import { Subscription } from '../Subscription';
-import { iterator as Symbol_iterator } from '../symbol/iterator';
-
-export function scheduleIterable<T>(input: Iterable<T>, scheduler: SchedulerLike) {
-  if (!input) {
-    throw new Error('Iterable cannot be null');
-  }
-  return new Observable<T>(subscriber => {
-    const sub = new Subscription();
-    let iterator: Iterator<T>;
-    sub.add(() => {
-      // Finalize generators
-      if (iterator && typeof iterator.return === 'function') {
-        iterator.return();
-      }
-    });
-    sub.add(scheduler.schedule(() => {
-      iterator = input[Symbol_iterator]();
-      sub.add(scheduler.schedule(function () {
-        if (subscriber.closed) {
-          return;
-        }
-        let value: T;
-        let done: boolean;
-        try {
-          const result = iterator.next();
-          value = result.value;
-          done = result.done;
-        } catch (err) {
-          subscriber.error(err);
-          return;
-        }
-        if (done) {
-          subscriber.complete();
-        } else {
-          subscriber.next(value);
-          this.schedule();
-        }
-      }));
-    }));
-    return sub;
-  });
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduled/scheduleObservable.ts

@@ -1,19 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscription } from '../Subscription';
-import { observable as Symbol_observable } from '../symbol/observable';
-import { InteropObservable, SchedulerLike, Subscribable } from '../types';
-
-export function scheduleObservable<T>(input: InteropObservable<T>, scheduler: SchedulerLike) {
-  return new Observable<T>(subscriber => {
-    const sub = new Subscription();
-    sub.add(scheduler.schedule(() => {
-      const observable: Subscribable<T> = input[Symbol_observable]();
-      sub.add(observable.subscribe({
-        next(value) { sub.add(scheduler.schedule(() => subscriber.next(value))); },
-        error(err) { sub.add(scheduler.schedule(() => subscriber.error(err))); },
-        complete() { sub.add(scheduler.schedule(() => subscriber.complete())); },
-      }));
-    }));
-    return sub;
-  });
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduled/schedulePromise.ts

@@ -1,21 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-import { Subscription } from '../Subscription';
-
-export function schedulePromise<T>(input: PromiseLike<T>, scheduler: SchedulerLike) {
-  return new Observable<T>(subscriber => {
-    const sub = new Subscription();
-    sub.add(scheduler.schedule(() => input.then(
-      value => {
-        sub.add(scheduler.schedule(() => {
-          subscriber.next(value);
-          sub.add(scheduler.schedule(() => subscriber.complete()));
-        }));
-      },
-      err => {
-        sub.add(scheduler.schedule(() => subscriber.error(err)));
-      }
-    )));
-    return sub;
-  });
-}

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

@@ -1,36 +0,0 @@
-import { scheduleObservable } from './scheduleObservable';
-import { schedulePromise } from './schedulePromise';
-import { scheduleArray } from './scheduleArray';
-import { scheduleIterable } from './scheduleIterable';
-import { ObservableInput, SchedulerLike, Observable } from 'rxjs';
-import { isInteropObservable } from '../util/isInteropObservable';
-import { isPromise } from '../util/isPromise';
-import { isArrayLike } from '../util/isArrayLike';
-import { isIterable } from '../util/isIterable';
-
-/**
- * Converts from a common {@link ObservableInput} type to an observable where subscription and emissions
- * are scheduled on the provided scheduler.
- *
- * @see from
- * @see of
- *
- * @param input The observable, array, promise, iterable, etc you would like to schedule
- * @param scheduler The scheduler to use to schedule the subscription and emissions from
- * the returned observable.
- */
-export function scheduled<T>(input: ObservableInput<T>, scheduler: SchedulerLike): Observable<T> {
-  if (input != null) {
-    if (isInteropObservable(input)) {
-      return scheduleObservable(input, scheduler);
-    } else if (isPromise(input)) {
-      return schedulePromise(input, scheduler);
-    } else if (isArrayLike(input)) {
-      return scheduleArray(input, scheduler);
-    }  else if (isIterable(input) || typeof input === 'string') {
-      return scheduleIterable(input, scheduler);
-    }
-  }
-
-  throw new TypeError((input !== null && typeof input || input) + ' is not observable');
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduler/Action.ts

@@ -1,36 +0,0 @@
-import { Scheduler } from '../Scheduler';
-import { Subscription } from '../Subscription';
-import { SchedulerAction } from '../types';
-
-/**
- * A unit of work to be executed in a `scheduler`. An action is typically
- * created from within a {@link SchedulerLike} and an RxJS user does not need to concern
- * themselves about creating and manipulating an Action.
- *
- * ```ts
- * class Action<T> extends Subscription {
- *   new (scheduler: Scheduler, work: (state?: T) => void);
- *   schedule(state?: T, delay: number = 0): Subscription;
- * }
- * ```
- *
- * @class Action<T>
- */
-export class Action<T> extends Subscription {
-  constructor(scheduler: Scheduler, work: (this: SchedulerAction<T>, state?: T) => void) {
-    super();
-  }
-  /**
-   * Schedules this action on its parent {@link SchedulerLike} for execution. May be passed
-   * some context object, `state`. May happen at some point in the future,
-   * according to the `delay` parameter, if specified.
-   * @param {T} [state] Some contextual data that the `work` function uses when
-   * called by the Scheduler.
-   * @param {number} [delay] Time to wait before executing the work, where the
-   * time unit is implicit and defined by the Scheduler.
-   * @return {void}
-   */
-  public schedule(state?: T, delay: number = 0): Subscription {
-    return this;
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts

@@ -1,47 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AnimationFrameScheduler } from './AnimationFrameScheduler';
-import { SchedulerAction } from '../types';
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-export class AnimationFrameAction<T> extends AsyncAction<T> {
-
-  constructor(protected scheduler: AnimationFrameScheduler,
-              protected work: (this: SchedulerAction<T>, state?: T) => void) {
-    super(scheduler, work);
-  }
-
-  protected requestAsyncId(scheduler: AnimationFrameScheduler, id?: any, delay: number = 0): any {
-    // If delay is greater than 0, request as an async action.
-    if (delay !== null && delay > 0) {
-      return super.requestAsyncId(scheduler, id, delay);
-    }
-    // Push the action to the end of the scheduler queue.
-    scheduler.actions.push(this);
-    // If an animation frame has already been requested, don't request another
-    // one. If an animation frame hasn't been requested yet, request one. Return
-    // the current animation frame request id.
-    return scheduler.scheduled || (scheduler.scheduled = requestAnimationFrame(
-      () => scheduler.flush(null)));
-  }
-  protected recycleAsyncId(scheduler: AnimationFrameScheduler, id?: any, delay: number = 0): any {
-    // If delay exists and is greater than 0, or if the delay is null (the
-    // action wasn't rescheduled) but was originally scheduled as an async
-    // action, then recycle as an async action.
-    if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {
-      return super.recycleAsyncId(scheduler, id, delay);
-    }
-    // If the scheduler queue is empty, cancel the requested animation frame and
-    // set the scheduled flag to undefined so the next AnimationFrameAction will
-    // request its own.
-    if (scheduler.actions.length === 0) {
-      cancelAnimationFrame(id);
-      scheduler.scheduled = undefined;
-    }
-    // Return undefined so the action knows to request a new async id if it's rescheduled.
-    return undefined;
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts

@@ -1,31 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsyncScheduler } from './AsyncScheduler';
-
-export class AnimationFrameScheduler extends AsyncScheduler {
-  public flush(action?: AsyncAction<any>): void {
-
-    this.active = true;
-    this.scheduled = undefined;
-
-    const {actions} = this;
-    let error: any;
-    let index: number = -1;
-    let count: number = actions.length;
-    action = action || actions.shift();
-
-    do {
-      if (error = action.execute(action.state, action.delay)) {
-        break;
-      }
-    } while (++index < count && (action = actions.shift()));
-
-    this.active = false;
-
-    if (error) {
-      while (++index < count && (action = actions.shift())) {
-        action.unsubscribe();
-      }
-      throw error;
-    }
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduler/AsapAction.ts

@@ -1,48 +0,0 @@
-import { Immediate } from '../util/Immediate';
-import { AsyncAction } from './AsyncAction';
-import { AsapScheduler } from './AsapScheduler';
-import { SchedulerAction } from '../types';
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-export class AsapAction<T> extends AsyncAction<T> {
-
-  constructor(protected scheduler: AsapScheduler,
-              protected work: (this: SchedulerAction<T>, state?: T) => void) {
-    super(scheduler, work);
-  }
-
-  protected requestAsyncId(scheduler: AsapScheduler, id?: any, delay: number = 0): any {
-    // If delay is greater than 0, request as an async action.
-    if (delay !== null && delay > 0) {
-      return super.requestAsyncId(scheduler, id, delay);
-    }
-    // Push the action to the end of the scheduler queue.
-    scheduler.actions.push(this);
-    // If a microtask has already been scheduled, don't schedule another
-    // one. If a microtask hasn't been scheduled yet, schedule one now. Return
-    // the current scheduled microtask id.
-    return scheduler.scheduled || (scheduler.scheduled = Immediate.setImmediate(
-      scheduler.flush.bind(scheduler, null)
-    ));
-  }
-  protected recycleAsyncId(scheduler: AsapScheduler, id?: any, delay: number = 0): any {
-    // If delay exists and is greater than 0, or if the delay is null (the
-    // action wasn't rescheduled) but was originally scheduled as an async
-    // action, then recycle as an async action.
-    if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {
-      return super.recycleAsyncId(scheduler, id, delay);
-    }
-    // If the scheduler queue is empty, cancel the requested microtask and
-    // set the scheduled flag to undefined so the next AsapAction will schedule
-    // its own.
-    if (scheduler.actions.length === 0) {
-      Immediate.clearImmediate(id);
-      scheduler.scheduled = undefined;
-    }
-    // Return undefined so the action knows to request a new async id if it's rescheduled.
-    return undefined;
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts

@@ -1,31 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsyncScheduler } from './AsyncScheduler';
-
-export class AsapScheduler extends AsyncScheduler {
-  public flush(action?: AsyncAction<any>): void {
-
-    this.active = true;
-    this.scheduled = undefined;
-
-    const {actions} = this;
-    let error: any;
-    let index: number = -1;
-    let count: number = actions.length;
-    action = action || actions.shift();
-
-    do {
-      if (error = action.execute(action.state, action.delay)) {
-        break;
-      }
-    } while (++index < count && (action = actions.shift()));
-
-    this.active = false;
-
-    if (error) {
-      while (++index < count && (action = actions.shift())) {
-        action.unsubscribe();
-      }
-      throw error;
-    }
-  }
-}