taskninja 1.1.5 → 1.1.6

package/src/node_modules/rxjs/src/internal/operators/withLatestFrom.ts

@@ -1,111 +0,0 @@
-import { OperatorFunction, ObservableInputTuple } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { innerFrom } from '../observable/innerFrom';
-import { identity } from '../util/identity';
-import { noop } from '../util/noop';
-import { popResultSelector } from '../util/args';
-
-export function withLatestFrom<T, O extends unknown[]>(...inputs: [...ObservableInputTuple<O>]): OperatorFunction<T, [T, ...O]>;
-
-export function withLatestFrom<T, O extends unknown[], R>(
-  ...inputs: [...ObservableInputTuple<O>, (...value: [T, ...O]) => R]
-): OperatorFunction<T, R>;
-
-/**
- * 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, withLatestFrom } from 'rxjs';
- *
- * 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 inputs An input Observable to combine with the source Observable. More
- * than one input Observables may be given as argument. If the last parameter is
- * a function, it will be used as a projection function for combining values
- * together. When the function is called, it 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 A function that returns 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.
- */
-export function withLatestFrom<T, R>(...inputs: any[]): OperatorFunction<T, R | any[]> {
-  const project = popResultSelector(inputs) as ((...args: any[]) => R) | undefined;
-
-  return operate((source, subscriber) => {
-    const len = inputs.length;
-    const otherValues = new Array(len);
-    // An array of whether or not the other sources have emitted. Matched with them by index.
-    // TODO: At somepoint, we should investigate the performance implications here, and look
-    // into using a `Set()` and checking the `size` to see if we're ready.
-    let hasValue = inputs.map(() => false);
-    // Flipped true when we have at least one value from all other sources and
-    // we are ready to start emitting values.
-    let ready = false;
-
-    // Other sources. Note that here we are not checking `subscriber.closed`,
-    // this causes all inputs to be subscribed to, even if nothing can be emitted
-    // from them. This is an important distinction because subscription constitutes
-    // a side-effect.
-    for (let i = 0; i < len; i++) {
-      innerFrom(inputs[i]).subscribe(
-        createOperatorSubscriber(
-          subscriber,
-          (value) => {
-            otherValues[i] = value;
-            if (!ready && !hasValue[i]) {
-              // If we're not ready yet, flag to show this observable has emitted.
-              hasValue[i] = true;
-              // Intentionally terse code.
-              // If all of our other observables have emitted, set `ready` to `true`,
-              // so we know we can start emitting values, then clean up the `hasValue` array,
-              // because we don't need it anymore.
-              (ready = hasValue.every(identity)) && (hasValue = null!);
-            }
-          },
-          // Completing one of the other sources has
-          // no bearing on the completion of our result.
-          noop
-        )
-      );
-    }
-
-    // Source subscription
-    source.subscribe(
-      createOperatorSubscriber(subscriber, (value) => {
-        if (ready) {
-          // We have at least one value from the other sources. Go ahead and emit.
-          const values = [value, ...otherValues];
-          subscriber.next(project ? project(...values) : values);
-        }
-      })
-    );
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/zip.ts

@@ -1,26 +0,0 @@
-import { zip as zipStatic } from '../observable/zip';
-import { ObservableInput, ObservableInputTuple, OperatorFunction, Cons } from '../types';
-import { operate } from '../util/lift';
-
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export function zip<T, A extends readonly unknown[]>(otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export function zip<T, A extends readonly unknown[], R>(
-  otherInputsAndProject: [...ObservableInputTuple<A>],
-  project: (...values: Cons<T, A>) => R
-): OperatorFunction<T, R>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export function zip<T, A extends readonly unknown[]>(...otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export function zip<T, A extends readonly unknown[], R>(
-  ...otherInputsAndProject: [...ObservableInputTuple<A>, (...values: Cons<T, A>) => R]
-): OperatorFunction<T, R>;
-
-/**
- * @deprecated Replaced with {@link zipWith}. Will be removed in v8.
- */
-export function zip<T, R>(...sources: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, any> {
-  return operate((source, subscriber) => {
-    zipStatic(source as ObservableInput<any>, ...(sources as Array<ObservableInput<any>>)).subscribe(subscriber);
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/zipAll.ts

@@ -1,20 +0,0 @@
-import { OperatorFunction, ObservableInput } from '../types';
-import { zip } from '../observable/zip';
-import { joinAllInternals } from './joinAllInternals';
-
-/**
- * Collects all observable inner sources from the source, once the source completes,
- * it will subscribe to all inner sources, combining their values by index and emitting
- * them.
- *
- * @see {@link zipWith}
- * @see {@link zip}
- */
-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: T[]) => R) {
-  return joinAllInternals(zip, project);
-}

package/src/node_modules/rxjs/src/internal/operators/zipWith.ts

@@ -1,29 +0,0 @@
-import { ObservableInputTuple, OperatorFunction, Cons } from '../types';
-import { zip } from './zip';
-
-/**
- * Subscribes to the source, and the observable inputs provided as arguments, and combines their values, by index, into arrays.
- *
- * What is meant by "combine by index": The first value from each will be made into a single array, then emitted,
- * then the second value from each will be combined into a single array and emitted, then the third value
- * from each will be combined into a single array and emitted, and so on.
- *
- * This will continue until it is no longer able to combine values of the same index into an array.
- *
- * After the last value from any one completed source is emitted in an array, the resulting observable will complete,
- * as there is no way to continue "zipping" values together by index.
- *
- * Use-cases for this operator are limited. There are memory concerns if one of the streams is emitting
- * values at a much faster rate than the others. Usage should likely be limited to streams that emit
- * at a similar pace, or finite streams of known length.
- *
- * In many cases, authors want `combineLatestWith` and not `zipWith`.
- *
- * @param otherInputs other observable inputs to collate values from.
- * @return A function that returns an Observable that emits items by index
- * combined from the source Observable and provided Observables, in form of an
- * array.
- */
-export function zipWith<T, A extends readonly unknown[]>(...otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>> {
-  return zip(...otherInputs);
-}

package/src/node_modules/rxjs/src/internal/scheduled/scheduleArray.ts

@@ -1,27 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-
-export function scheduleArray<T>(input: ArrayLike<T>, scheduler: SchedulerLike) {
-  return new Observable<T>((subscriber) => {
-    // The current array index.
-    let i = 0;
-    // Start iterating over the array like on a schedule.
-    return scheduler.schedule(function () {
-      if (i === input.length) {
-        // If we have hit the end of the array like in the
-        // previous job, we can complete.
-        subscriber.complete();
-      } else {
-        // Otherwise let's next the value at the current index,
-        // then increment our index.
-        subscriber.next(input[i++]);
-        // If the last emission didn't cause us to close the subscriber
-        // (via take or some side effect), reschedule the job and we'll
-        // make another pass.
-        if (!subscriber.closed) {
-          this.schedule();
-        }
-      }
-    });
-  });
-}

package/src/node_modules/rxjs/src/internal/scheduled/scheduleAsyncIterable.ts

@@ -1,31 +0,0 @@
-import { SchedulerLike } from '../types';
-import { Observable } from '../Observable';
-import { executeSchedule } from '../util/executeSchedule';
-
-export function scheduleAsyncIterable<T>(input: AsyncIterable<T>, scheduler: SchedulerLike) {
-  if (!input) {
-    throw new Error('Iterable cannot be null');
-  }
-  return new Observable<T>((subscriber) => {
-    executeSchedule(subscriber, scheduler, () => {
-      const iterator = input[Symbol.asyncIterator]();
-      executeSchedule(
-        subscriber,
-        scheduler,
-        () => {
-          iterator.next().then((result) => {
-            if (result.done) {
-              // This will remove the subscriptions from
-              // the parent subscription.
-              subscriber.complete();
-            } else {
-              subscriber.next(result.value);
-            }
-          });
-        },
-        0,
-        true
-      );
-    });
-  });
-}

package/src/node_modules/rxjs/src/internal/scheduled/scheduleIterable.ts

@@ -1,60 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-import { iterator as Symbol_iterator } from '../symbol/iterator';
-import { isFunction } from '../util/isFunction';
-import { executeSchedule } from '../util/executeSchedule';
-
-/**
- * Used in {@link scheduled} to create an observable from an Iterable.
- * @param input The iterable to create an observable from
- * @param scheduler The scheduler to use
- */
-export function scheduleIterable<T>(input: Iterable<T>, scheduler: SchedulerLike) {
-  return new Observable<T>((subscriber) => {
-    let iterator: Iterator<T, T>;
-
-    // Schedule the initial creation of the iterator from
-    // the iterable. This is so the code in the iterable is
-    // not called until the scheduled job fires.
-    executeSchedule(subscriber, scheduler, () => {
-      // Create the iterator.
-      iterator = (input as any)[Symbol_iterator]();
-
-      executeSchedule(
-        subscriber,
-        scheduler,
-        () => {
-          let value: T;
-          let done: boolean | undefined;
-          try {
-            // Pull the value out of the iterator
-            ({ value, done } = iterator.next());
-          } catch (err) {
-            // We got an error while pulling from the iterator
-            subscriber.error(err);
-            return;
-          }
-
-          if (done) {
-            // If it is "done" we just complete. This mimics the
-            // behavior of JavaScript's `for..of` consumption of
-            // iterables, which will not emit the value from an iterator
-            // result of `{ done: true: value: 'here' }`.
-            subscriber.complete();
-          } else {
-            // The iterable is not done, emit the value.
-            subscriber.next(value);
-          }
-        },
-        0,
-        true
-      );
-    });
-
-    // During finalization, if we see this iterator has a `return` method,
-    // then we know it is a Generator, and not just an Iterator. So we call
-    // the `return()` function. This will ensure that any `finally { }` blocks
-    // inside of the generator we can hit will be hit properly.
-    return () => isFunction(iterator?.return) && iterator.return();
-  });
-}

package/src/node_modules/rxjs/src/internal/scheduled/scheduleObservable.ts

@@ -1,8 +0,0 @@
-import { innerFrom } from '../observable/innerFrom';
-import { observeOn } from '../operators/observeOn';
-import { subscribeOn } from '../operators/subscribeOn';
-import { InteropObservable, SchedulerLike } from '../types';
-
-export function scheduleObservable<T>(input: InteropObservable<T>, scheduler: SchedulerLike) {
-  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
-}

package/src/node_modules/rxjs/src/internal/scheduled/schedulePromise.ts

@@ -1,8 +0,0 @@
-import { innerFrom } from '../observable/innerFrom';
-import { observeOn } from '../operators/observeOn';
-import { subscribeOn } from '../operators/subscribeOn';
-import { SchedulerLike } from '../types';
-
-export function schedulePromise<T>(input: PromiseLike<T>, scheduler: SchedulerLike) {
-  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
-}

package/src/node_modules/rxjs/src/internal/scheduled/scheduleReadableStreamLike.ts

@@ -1,8 +0,0 @@
-import { SchedulerLike, ReadableStreamLike } from '../types';
-import { Observable } from '../Observable';
-import { scheduleAsyncIterable } from './scheduleAsyncIterable';
-import { readableStreamLikeToAsyncGenerator } from '../util/isReadableStreamLike';
-
-export function scheduleReadableStreamLike<T>(input: ReadableStreamLike<T>, scheduler: SchedulerLike): Observable<T> {
-  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
-}

package/src/node_modules/rxjs/src/internal/scheduled/scheduled.ts

@@ -1,50 +0,0 @@
-import { scheduleObservable } from './scheduleObservable';
-import { schedulePromise } from './schedulePromise';
-import { scheduleArray } from './scheduleArray';
-import { scheduleIterable } from './scheduleIterable';
-import { scheduleAsyncIterable } from './scheduleAsyncIterable';
-import { isInteropObservable } from '../util/isInteropObservable';
-import { isPromise } from '../util/isPromise';
-import { isArrayLike } from '../util/isArrayLike';
-import { isIterable } from '../util/isIterable';
-import { ObservableInput, SchedulerLike } from '../types';
-import { Observable } from '../Observable';
-import { isAsyncIterable } from '../util/isAsyncIterable';
-import { createInvalidObservableTypeError } from '../util/throwUnobservableError';
-import { isReadableStreamLike } from '../util/isReadableStreamLike';
-import { scheduleReadableStreamLike } from './scheduleReadableStreamLike';
-
-/**
- * Converts from a common {@link ObservableInput} type to an observable where subscription and emissions
- * are scheduled on the provided scheduler.
- *
- * @see {@link from}
- * @see {@link 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);
-    }
-    if (isArrayLike(input)) {
-      return scheduleArray(input, scheduler);
-    }
-    if (isPromise(input)) {
-      return schedulePromise(input, scheduler);
-    }
-    if (isAsyncIterable(input)) {
-      return scheduleAsyncIterable(input, scheduler);
-    }
-    if (isIterable(input)) {
-      return scheduleIterable(input, scheduler);
-    }
-    if (isReadableStreamLike(input)) {
-      return scheduleReadableStreamLike(input, scheduler);
-    }
-  }
-  throw createInvalidObservableTypeError(input);
-}

package/src/node_modules/rxjs/src/internal/scheduler/Action.ts

@@ -1,34 +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;
- * }
- * ```
- */
-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 state Some contextual data that the `work` function uses when called by the
-   * Scheduler.
-   * @param delay Time to wait before executing the work, where the time unit is implicit
-   * and defined by the Scheduler.
-   * @return A subscription in order to be able to unsubscribe the scheduled work.
-   */
-  public schedule(state?: T, delay: number = 0): Subscription {
-    return this;
-  }
-}

package/src/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts

@@ -1,43 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AnimationFrameScheduler } from './AnimationFrameScheduler';
-import { SchedulerAction } from '../types';
-import { animationFrameProvider } from './animationFrameProvider';
-import { TimerHandle } from './timerHandle';
-
-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?: TimerHandle, delay: number = 0): TimerHandle {
-    // 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 = animationFrameProvider.requestAnimationFrame(() => scheduler.flush(undefined)));
-  }
-
-  protected recycleAsyncId(scheduler: AnimationFrameScheduler, id?: TimerHandle, delay: number = 0): TimerHandle | undefined {
-    // 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 : this.delay > 0) {
-      return super.recycleAsyncId(scheduler, id, delay);
-    }
-    // If the scheduler queue has no remaining actions with the same async id,
-    // cancel the requested animation frame and set the scheduled flag to
-    // undefined so the next AnimationFrameAction will request its own.
-    const { actions } = scheduler;
-    if (id != null && id === scheduler._scheduled && actions[actions.length - 1]?.id !== id) {
-      animationFrameProvider.cancelAnimationFrame(id as number);
-      scheduler._scheduled = undefined;
-    }
-    // Return undefined so the action knows to request a new async id if it's rescheduled.
-    return undefined;
-  }
-}

package/src/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts

@@ -1,43 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsyncScheduler } from './AsyncScheduler';
-
-export class AnimationFrameScheduler extends AsyncScheduler {
-  public flush(action?: AsyncAction<any>): void {
-    this._active = true;
-    // The async id that effects a call to flush is stored in _scheduled.
-    // Before executing an action, it's necessary to check the action's async
-    // id to determine whether it's supposed to be executed in the current
-    // flush.
-    // Previous implementations of this method used a count to determine this,
-    // but that was unsound, as actions that are unsubscribed - i.e. cancelled -
-    // are removed from the actions array and that can shift actions that are
-    // scheduled to be executed in a subsequent flush into positions at which
-    // they are executed within the current flush.
-    let flushId;
-    if (action) {
-      flushId = action.id;
-    } else {
-      flushId = this._scheduled;
-      this._scheduled = undefined;
-    }
-
-    const { actions } = this;
-    let error: any;
-    action = action || actions.shift()!;
-
-    do {
-      if ((error = action.execute(action.state, action.delay))) {
-        break;
-      }
-    } while ((action = actions[0]) && action.id === flushId && actions.shift());
-
-    this._active = false;
-
-    if (error) {
-      while ((action = actions[0]) && action.id === flushId && actions.shift()) {
-        action.unsubscribe();
-      }
-      throw error;
-    }
-  }
-}

package/src/node_modules/rxjs/src/internal/scheduler/AsapAction.ts

@@ -1,45 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsapScheduler } from './AsapScheduler';
-import { SchedulerAction } from '../types';
-import { immediateProvider } from './immediateProvider';
-import { TimerHandle } from './timerHandle';
-
-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?: TimerHandle, delay: number = 0): TimerHandle {
-    // 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 = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, undefined)));
-  }
-
-  protected recycleAsyncId(scheduler: AsapScheduler, id?: TimerHandle, delay: number = 0): TimerHandle | undefined {
-    // 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 : this.delay > 0) {
-      return super.recycleAsyncId(scheduler, id, delay);
-    }
-    // If the scheduler queue has no remaining actions with the same async id,
-    // cancel the requested microtask and set the scheduled flag to undefined
-    // so the next AsapAction will request its own.
-    const { actions } = scheduler;
-    if (id != null && actions[actions.length - 1]?.id !== id) {
-      immediateProvider.clearImmediate(id);
-      if (scheduler._scheduled === id) {
-        scheduler._scheduled = undefined;
-      }
-    }
-    // Return undefined so the action knows to request a new async id if it's rescheduled.
-    return undefined;
-  }
-}

package/src/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts

@@ -1,38 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsyncScheduler } from './AsyncScheduler';
-
-export class AsapScheduler extends AsyncScheduler {
-  public flush(action?: AsyncAction<any>): void {
-    this._active = true;
-    // The async id that effects a call to flush is stored in _scheduled.
-    // Before executing an action, it's necessary to check the action's async
-    // id to determine whether it's supposed to be executed in the current
-    // flush.
-    // Previous implementations of this method used a count to determine this,
-    // but that was unsound, as actions that are unsubscribed - i.e. cancelled -
-    // are removed from the actions array and that can shift actions that are
-    // scheduled to be executed in a subsequent flush into positions at which
-    // they are executed within the current flush.
-    const flushId = this._scheduled;
-    this._scheduled = undefined;
-
-    const { actions } = this;
-    let error: any;
-    action = action || actions.shift()!;
-
-    do {
-      if ((error = action.execute(action.state, action.delay))) {
-        break;
-      }
-    } while ((action = actions[0]) && action.id === flushId && actions.shift());
-
-    this._active = false;
-
-    if (error) {
-      while ((action = actions[0]) && action.id === flushId && actions.shift()) {
-        action.unsubscribe();
-      }
-      throw error;
-    }
-  }
-}