lambda-live-debugger 1.12.2 → 1.12.4

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

@@ -1,125 +0,0 @@
-import { Observable } from '../Observable';
-import { innerFrom } from '../observable/innerFrom';
-import { Subject } from '../Subject';
-import { Subscription } from '../Subscription';
-
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source
- * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable
- * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise
- * this method will resubscribe to the source Observable.
- *
- * ![](repeatWhen.png)
- *
- * ## Example
- *
- * Repeat a message stream on click
- *
- * ```ts
- * import { of, fromEvent, repeatWhen } from 'rxjs';
- *
- * const source = of('Repeat message');
- * const documentClick$ = fromEvent(document, 'click');
- *
- * const result = source.pipe(repeatWhen(() => documentClick$));
- *
- * result.subscribe(data => console.log(data))
- * ```
- *
- * @see {@link repeat}
- * @see {@link retry}
- * @see {@link retryWhen}
- *
- * @param notifier Function that receives an Observable of notifications with
- * which a user can `complete` or `error`, aborting the repetition.
- * @return A function that returns an Observable that mirrors the source
- * Observable with the exception of a `complete`.
- * @deprecated Will be removed in v9 or v10. Use {@link repeat}'s {@link RepeatConfig#delay delay} option instead.
- * Instead of `repeatWhen(() => notify$)`, use: `repeat({ delay: () => notify$ })`.
- */
-export function repeatWhen<T>(notifier: (notifications: Observable<void>) => ObservableInput<any>): MonoTypeOperatorFunction<T> {
-  return operate((source, subscriber) => {
-    let innerSub: Subscription | null;
-    let syncResub = false;
-    let completions$: Subject<void>;
-    let isNotifierComplete = false;
-    let isMainComplete = false;
-
-    /**
-     * Checks to see if we can complete the result, completes it, and returns `true` if it was completed.
-     */
-    const checkComplete = () => isMainComplete && isNotifierComplete && (subscriber.complete(), true);
-    /**
-     * Gets the subject to send errors through. If it doesn't exist,
-     * we know we need to setup the notifier.
-     */
-    const getCompletionSubject = () => {
-      if (!completions$) {
-        completions$ = new Subject();
-
-        // If the call to `notifier` throws, it will be caught by the OperatorSubscriber
-        // In the main subscription -- in `subscribeForRepeatWhen`.
-        innerFrom(notifier(completions$)).subscribe(
-          createOperatorSubscriber(
-            subscriber,
-            () => {
-              if (innerSub) {
-                subscribeForRepeatWhen();
-              } else {
-                // If we don't have an innerSub yet, that's because the inner subscription
-                // call hasn't even returned yet. We've arrived here synchronously.
-                // So we flag that we want to resub, such that we can ensure finalization
-                // happens before we resubscribe.
-                syncResub = true;
-              }
-            },
-            () => {
-              isNotifierComplete = true;
-              checkComplete();
-            }
-          )
-        );
-      }
-      return completions$;
-    };
-
-    const subscribeForRepeatWhen = () => {
-      isMainComplete = false;
-
-      innerSub = source.subscribe(
-        createOperatorSubscriber(subscriber, undefined, () => {
-          isMainComplete = true;
-          // Check to see if we are complete, and complete if so.
-          // If we are not complete. Get the subject. This calls the `notifier` function.
-          // If that function fails, it will throw and `.next()` will not be reached on this
-          // line. The thrown error is caught by the _complete handler in this
-          // `OperatorSubscriber` and handled appropriately.
-          !checkComplete() && getCompletionSubject().next();
-        })
-      );
-
-      if (syncResub) {
-        // Ensure that the inner subscription is torn down before
-        // moving on to the next subscription in the synchronous case.
-        // If we don't do this here, all inner subscriptions will not be
-        // torn down until the entire observable is done.
-        innerSub.unsubscribe();
-        // It is important to null this out. Not only to free up memory, but
-        // to make sure code above knows we are in a subscribing state to
-        // handle synchronous resubscription.
-        innerSub = null;
-        // We may need to do this multiple times, so reset the flags.
-        syncResub = false;
-        // Resubscribe
-        subscribeForRepeatWhen();
-      }
-    };
-
-    // Start the subscription
-    subscribeForRepeatWhen();
-  });
-}

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

@@ -1,168 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-import { operate } from '../util/lift';
-import { Subscription } from '../Subscription';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { identity } from '../util/identity';
-import { timer } from '../observable/timer';
-import { innerFrom } from '../observable/innerFrom';
-
-/**
- * The {@link retry} operator configuration object. `retry` either accepts a `number`
- * or an object described by this interface.
- */
-export interface RetryConfig {
-  /**
-   * The maximum number of times to retry. If `count` is omitted, `retry` will try to
-   * resubscribe on errors infinite number of times.
-   */
-  count?: number;
-  /**
-   * The number of milliseconds to delay before retrying, OR a function to
-   * return a notifier for delaying. If a function is given, that function should
-   * return a notifier that, when it emits will retry the source. If the notifier
-   * completes _without_ emitting, the resulting observable will complete without error,
-   * if the notifier errors, the error will be pushed to the result.
-   */
-  delay?: number | ((error: any, retryCount: number) => ObservableInput<any>);
-  /**
-   * Whether or not to reset the retry counter when the retried subscription
-   * emits its first value.
-   */
-  resetOnSuccess?: boolean;
-}
-
-export function retry<T>(count?: number): MonoTypeOperatorFunction<T>;
-export function retry<T>(config: RetryConfig): MonoTypeOperatorFunction<T>;
-
-/**
- * Returns an Observable that mirrors the source Observable with the exception of an `error`.
- *
- * If the source Observable calls `error`, this method will resubscribe to the source Observable for a maximum of
- * `count` resubscriptions rather than propagating the `error` call.
- *
- * ![](retry.png)
- *
- * The number of retries is determined by the `count` parameter. It can be set either by passing a number to
- * `retry` function or by setting `count` property when `retry` is configured using {@link RetryConfig}. If
- * `count` is omitted, `retry` will try to resubscribe on errors infinite number of times.
- *
- * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those
- * emitted during failed subscriptions. For example, if an Observable fails at first but emits `[1, 2]` then
- * succeeds the second time and emits: `[1, 2, 3, 4, 5, complete]` then the complete stream of emissions and
- * notifications would be: `[1, 2, 1, 2, 3, 4, 5, complete]`.
- *
- * ## Example
- *
- * ```ts
- * import { interval, mergeMap, throwError, of, retry } from 'rxjs';
- *
- * const source = interval(1000);
- * const result = source.pipe(
- *   mergeMap(val => val > 5 ? throwError(() => 'Error!') : of(val)),
- *   retry(2) // retry 2 times on error
- * );
- *
- * result.subscribe({
- *   next: value => console.log(value),
- *   error: err => console.log(`${ err }: Retried 2 times then quit!`)
- * });
- *
- * // Output:
- * // 0..1..2..3..4..5..
- * // 0..1..2..3..4..5..
- * // 0..1..2..3..4..5..
- * // 'Error!: Retried 2 times then quit!'
- * ```
- *
- * @see {@link retryWhen}
- *
- * @param configOrCount Either number of retry attempts before failing or a
- * {@link RetryConfig} object.
- * @return A function that returns an Observable that will resubscribe to the
- * source stream when the source stream errors, at most `count` times.
- */
-export function retry<T>(configOrCount: number | RetryConfig = Infinity): MonoTypeOperatorFunction<T> {
-  let config: RetryConfig;
-  if (configOrCount && typeof configOrCount === 'object') {
-    config = configOrCount;
-  } else {
-    config = {
-      count: configOrCount as number,
-    };
-  }
-  const { count = Infinity, delay, resetOnSuccess: resetOnSuccess = false } = config;
-
-  return count <= 0
-    ? identity
-    : operate((source, subscriber) => {
-        let soFar = 0;
-        let innerSub: Subscription | null;
-        const subscribeForRetry = () => {
-          let syncUnsub = false;
-          innerSub = source.subscribe(
-            createOperatorSubscriber(
-              subscriber,
-              (value) => {
-                // If we're resetting on success
-                if (resetOnSuccess) {
-                  soFar = 0;
-                }
-                subscriber.next(value);
-              },
-              // Completions are passed through to consumer.
-              undefined,
-              (err) => {
-                if (soFar++ < count) {
-                  // We are still under our retry count
-                  const resub = () => {
-                    if (innerSub) {
-                      innerSub.unsubscribe();
-                      innerSub = null;
-                      subscribeForRetry();
-                    } else {
-                      syncUnsub = true;
-                    }
-                  };
-
-                  if (delay != null) {
-                    // The user specified a retry delay.
-                    // They gave us a number, use a timer, otherwise, it's a function,
-                    // and we're going to call it to get a notifier.
-                    const notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(err, soFar));
-                    const notifierSubscriber = createOperatorSubscriber(
-                      subscriber,
-                      () => {
-                        // After we get the first notification, we
-                        // unsubscribe from the notifier, because we don't want anymore
-                        // and we resubscribe to the source.
-                        notifierSubscriber.unsubscribe();
-                        resub();
-                      },
-                      () => {
-                        // The notifier completed without emitting.
-                        // The author is telling us they want to complete.
-                        subscriber.complete();
-                      }
-                    );
-                    notifier.subscribe(notifierSubscriber);
-                  } else {
-                    // There was no notifier given. Just resub immediately.
-                    resub();
-                  }
-                } else {
-                  // We're past our maximum number of retries.
-                  // Just send along the error.
-                  subscriber.error(err);
-                }
-              }
-            )
-          );
-          if (syncUnsub) {
-            innerSub.unsubscribe();
-            innerSub = null;
-            subscribeForRetry();
-          }
-        };
-        subscribeForRetry();
-      });
-}

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

@@ -1,113 +0,0 @@
-import { Observable } from '../Observable';
-import { innerFrom } from '../observable/innerFrom';
-import { Subject } from '../Subject';
-import { Subscription } from '../Subscription';
-
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
- * calls `error`, this method will emit the Throwable that caused the error to the `ObservableInput` returned from `notifier`.
- * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
- * subscription. Otherwise this method will resubscribe to the source Observable.
- *
- * ![](retryWhen.png)
- *
- * Retry an observable sequence on error based on custom criteria.
- *
- * ## Example
- *
- * ```ts
- * import { interval, map, retryWhen, tap, delayWhen, timer } from 'rxjs';
- *
- * const source = interval(1000);
- * const result = source.pipe(
- *   map(value => {
- *     if (value > 5) {
- *       // error will be picked up by retryWhen
- *       throw value;
- *     }
- *     return value;
- *   }),
- *   retryWhen(errors =>
- *     errors.pipe(
- *       // log error message
- *       tap(value => console.log(`Value ${ value } was too high!`)),
- *       // restart in 5 seconds
- *       delayWhen(value => timer(value * 1000))
- *     )
- *   )
- * );
- *
- * result.subscribe(value => console.log(value));
- *
- * // results:
- * // 0
- * // 1
- * // 2
- * // 3
- * // 4
- * // 5
- * // 'Value 6 was too high!'
- * // - Wait 5 seconds then repeat
- * ```
- *
- * @see {@link retry}
- *
- * @param notifier Function that receives an Observable of notifications with which a
- * user can `complete` or `error`, aborting the retry.
- * @return A function that returns an Observable that mirrors the source
- * Observable with the exception of an `error`.
- * @deprecated Will be removed in v9 or v10, use {@link retry}'s `delay` option instead.
- * Will be removed in v9 or v10. Use {@link retry}'s {@link RetryConfig#delay delay} option instead.
- * Instead of `retryWhen(() => notify$)`, use: `retry({ delay: () => notify$ })`.
- */
-export function retryWhen<T>(notifier: (errors: Observable<any>) => ObservableInput<any>): MonoTypeOperatorFunction<T> {
-  return operate((source, subscriber) => {
-    let innerSub: Subscription | null;
-    let syncResub = false;
-    let errors$: Subject<any>;
-
-    const subscribeForRetryWhen = () => {
-      innerSub = source.subscribe(
-        createOperatorSubscriber(subscriber, undefined, undefined, (err) => {
-          if (!errors$) {
-            errors$ = new Subject();
-            innerFrom(notifier(errors$)).subscribe(
-              createOperatorSubscriber(subscriber, () =>
-                // If we have an innerSub, this was an asynchronous call, kick off the retry.
-                // Otherwise, if we don't have an innerSub yet, that's because the inner subscription
-                // call hasn't even returned yet. We've arrived here synchronously.
-                // So we flag that we want to resub, such that we can ensure finalization
-                // happens before we resubscribe.
-                innerSub ? subscribeForRetryWhen() : (syncResub = true)
-              )
-            );
-          }
-          if (errors$) {
-            // We have set up the notifier without error.
-            errors$.next(err);
-          }
-        })
-      );
-
-      if (syncResub) {
-        // Ensure that the inner subscription is torn down before
-        // moving on to the next subscription in the synchronous case.
-        // If we don't do this here, all inner subscriptions will not be
-        // torn down until the entire observable is done.
-        innerSub.unsubscribe();
-        innerSub = null;
-        // We may need to do this multiple times, so reset the flag.
-        syncResub = false;
-        // Resubscribe
-        subscribeForRetryWhen();
-      }
-    };
-
-    // Start the subscription
-    subscribeForRetryWhen();
-  });
-}

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

@@ -1,72 +0,0 @@
-import { innerFrom } from '../observable/innerFrom';
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-import { operate } from '../util/lift';
-import { noop } from '../util/noop';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Emits the most recently emitted value from the source Observable whenever
- * another Observable, the `notifier`, emits.
- *
- * <span class="informal">It's like {@link sampleTime}, but samples whenever
- * the `notifier` `ObservableInput` emits something.</span>
- *
- * ![](sample.png)
- *
- * Whenever the `notifier` `ObservableInput` emits a value, `sample`
- * looks at the source Observable and emits whichever value it has most recently
- * emitted since the previous sampling, unless the source has not emitted
- * anything since the previous sampling. The `notifier` is subscribed to as soon
- * as the output Observable is subscribed.
- *
- * ## Example
- *
- * On every click, sample the most recent `seconds` timer
- *
- * ```ts
- * import { fromEvent, interval, sample } from 'rxjs';
- *
- * const seconds = interval(1000);
- * const clicks = fromEvent(document, 'click');
- * const result = seconds.pipe(sample(clicks));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link audit}
- * @see {@link debounce}
- * @see {@link sampleTime}
- * @see {@link throttle}
- *
- * @param notifier The `ObservableInput` to use for sampling the
- * source Observable.
- * @return A function that returns an Observable that emits the results of
- * sampling the values emitted by the source Observable whenever the notifier
- * Observable emits value or completes.
- */
-export function sample<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T> {
-  return operate((source, subscriber) => {
-    let hasValue = false;
-    let lastValue: T | null = null;
-    source.subscribe(
-      createOperatorSubscriber(subscriber, (value) => {
-        hasValue = true;
-        lastValue = value;
-      })
-    );
-    innerFrom(notifier).subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        () => {
-          if (hasValue) {
-            hasValue = false;
-            const value = lastValue!;
-            lastValue = null;
-            subscriber.next(value);
-          }
-        },
-        noop
-      )
-    );
-  });
-}

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

@@ -1,51 +0,0 @@
-import { asyncScheduler } from '../scheduler/async';
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-import { sample } from './sample';
-import { interval } from '../observable/interval';
-
-/**
- * Emits the most recently emitted value from the source Observable within
- * periodic time intervals.
- *
- * <span class="informal">Samples the source Observable at periodic time
- * intervals, emitting what it samples.</span>
- *
- * ![](sampleTime.png)
- *
- * `sampleTime` periodically looks at the source Observable and emits whichever
- * value it has most recently emitted since the previous sampling, unless the
- * source has not emitted anything since the previous sampling. The sampling
- * happens periodically in time every `period` milliseconds (or the time unit
- * defined by the optional `scheduler` argument). The sampling starts as soon as
- * the output Observable is subscribed.
- *
- * ## Example
- *
- * Every second, emit the most recent click at most once
- *
- * ```ts
- * import { fromEvent, sampleTime } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(sampleTime(1000));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link auditTime}
- * @see {@link debounceTime}
- * @see {@link delay}
- * @see {@link sample}
- * @see {@link throttleTime}
- *
- * @param period The sampling period expressed in milliseconds or the time unit
- * determined internally by the optional `scheduler`.
- * @param scheduler The {@link SchedulerLike} to use for managing the timers
- * that handle the sampling.
- * @return A function that returns an Observable that emits the results of
- * sampling the values emitted by the source Observable at the specified time
- * interval.
- */
-export function sampleTime<T>(period: number, scheduler: SchedulerLike = asyncScheduler): MonoTypeOperatorFunction<T> {
-  return sample(interval(period, scheduler));
-}

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

@@ -1,95 +0,0 @@
-import { OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { scanInternals } from './scanInternals';
-
-export function scan<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
-export function scan<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
-export function scan<V, A, S>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
-
-// TODO: link to a "redux pattern" section in the guide (location TBD)
-
-/**
- * Useful for encapsulating and managing state. Applies an accumulator (or "reducer function")
- * to each value from the source after an initial state is established -- either via
- * a `seed` value (second argument), or from the first value from the source.
- *
- * <span class="informal">It's like {@link reduce}, but emits the current
- * accumulation state after each update</span>
- *
- * ![](scan.png)
- *
- * This operator maintains an internal state and emits it after processing each value as follows:
- *
- * 1. First value arrives
- *   - If a `seed` value was supplied (as the second argument to `scan`), let `state = seed` and `value = firstValue`.
- *   - If NO `seed` value was supplied (no second argument), let `state = firstValue` and go to 3.
- * 2. Let `state = accumulator(state, value)`.
- *   - If an error is thrown by `accumulator`, notify the consumer of an error. The process ends.
- * 3. Emit `state`.
- * 4. Next value arrives, let `value = nextValue`, go to 2.
- *
- * ## Examples
- *
- * An average of previous numbers. This example shows how
- * not providing a `seed` can prime the stream with the
- * first value from the source.
- *
- * ```ts
- * import { of, scan, map } from 'rxjs';
- *
- * const numbers$ = of(1, 2, 3);
- *
- * numbers$
- *   .pipe(
- *     // Get the sum of the numbers coming in.
- *     scan((total, n) => total + n),
- *     // Get the average by dividing the sum by the total number
- *     // received so far (which is 1 more than the zero-based index).
- *     map((sum, index) => sum / (index + 1))
- *   )
- *   .subscribe(console.log);
- * ```
- *
- * The Fibonacci sequence. This example shows how you can use
- * a seed to prime accumulation process. Also... you know... Fibonacci.
- * So important to like, computers and stuff that its whiteboarded
- * in job interviews. Now you can show them the Rx version! (Please don't, haha)
- *
- * ```ts
- * import { interval, scan, map, startWith } from 'rxjs';
- *
- * const firstTwoFibs = [0, 1];
- * // An endless stream of Fibonacci numbers.
- * const fibonacci$ = interval(1000).pipe(
- *   // Scan to get the fibonacci numbers (after 0, 1)
- *   scan(([a, b]) => [b, a + b], firstTwoFibs),
- *   // Get the second number in the tuple, it's the one you calculated
- *   map(([, n]) => n),
- *   // Start with our first two digits :)
- *   startWith(...firstTwoFibs)
- * );
- *
- * fibonacci$.subscribe(console.log);
- * ```
- *
- * @see {@link expand}
- * @see {@link mergeScan}
- * @see {@link reduce}
- * @see {@link switchScan}
- *
- * @param accumulator A "reducer function". This will be called for each value after an initial state is
- * acquired.
- * @param seed The initial state. If this is not provided, the first value from the source will
- * be used as the initial state, and emitted without going through the accumulator. All subsequent values
- * will be processed by the accumulator function. If this is provided, all values will go through
- * the accumulator function.
- * @return A function that returns an Observable of the accumulated values.
- */
-export function scan<V, A, S>(accumulator: (acc: V | A | S, value: V, index: number) => A, seed?: S): OperatorFunction<V, V | A> {
-  // providing a seed of `undefined` *should* be valid and trigger
-  // hasSeed! so don't use `seed !== undefined` checks!
-  // For this reason, we have to check it here at the original call site
-  // otherwise inside Operator/Subscriber we won't know if `undefined`
-  // means they didn't provide anything or if they literally provided `undefined`
-  return operate(scanInternals(accumulator, seed as S, arguments.length >= 2, true));
-}

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

@@ -1,62 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * A basic scan operation. This is used for `scan` and `reduce`.
- * @param accumulator The accumulator to use
- * @param seed The seed value for the state to accumulate
- * @param hasSeed Whether or not a seed was provided
- * @param emitOnNext Whether or not to emit the state on next
- * @param emitBeforeComplete Whether or not to emit the before completion
- */
-
-export function scanInternals<V, A, S>(
-  accumulator: (acc: V | A | S, value: V, index: number) => A,
-  seed: S,
-  hasSeed: boolean,
-  emitOnNext: boolean,
-  emitBeforeComplete?: undefined | true
-) {
-  return (source: Observable<V>, subscriber: Subscriber<any>) => {
-    // Whether or not we have state yet. This will only be
-    // false before the first value arrives if we didn't get
-    // a seed value.
-    let hasState = hasSeed;
-    // The state that we're tracking, starting with the seed,
-    // if there is one, and then updated by the return value
-    // from the accumulator on each emission.
-    let state: any = seed;
-    // An index to pass to the accumulator function.
-    let index = 0;
-
-    // Subscribe to our source. All errors and completions are passed through.
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => {
-          // Always increment the index.
-          const i = index++;
-          // Set the state
-          state = hasState
-            ? // We already have state, so we can get the new state from the accumulator
-              accumulator(state, value, i)
-            : // We didn't have state yet, a seed value was not provided, so
-
-              // we set the state to the first value, and mark that we have state now
-              ((hasState = true), value);
-
-          // Maybe send it to the consumer.
-          emitOnNext && subscriber.next(state);
-        },
-        // If an onComplete was given, call it, otherwise
-        // just pass through the complete notification to the consumer.
-        emitBeforeComplete &&
-          (() => {
-            hasState && subscriber.next(state);
-            subscriber.complete();
-          })
-      )
-    );
-  };
-}