lambda-live-debugger 1.12.2 → 1.12.4

package/node_modules/rxjs/src/internal/observable/merge.ts

@@ -1,100 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInput, ObservableInputTuple, SchedulerLike } from '../types';
-import { mergeAll } from '../operators/mergeAll';
-import { innerFrom } from './innerFrom';
-import { EMPTY } from './empty';
-import { popNumber, popScheduler } from '../util/args';
-import { from } from './from';
-
-export function merge<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A[number]>;
-export function merge<A extends readonly unknown[]>(...sourcesAndConcurrency: [...ObservableInputTuple<A>, number?]): Observable<A[number]>;
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `mergeAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export function merge<A extends readonly unknown[]>(
-  ...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike?]
-): Observable<A[number]>;
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `mergeAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export function merge<A extends readonly unknown[]>(
-  ...sourcesAndConcurrencyAndScheduler: [...ObservableInputTuple<A>, number?, SchedulerLike?]
-): Observable<A[number]>;
-
-/**
- * Creates an output Observable which concurrently emits all values from every
- * given input Observable.
- *
- * <span class="informal">Flattens multiple Observables together by blending
- * their values into one Observable.</span>
- *
- * ![](merge.png)
- *
- * `merge` subscribes to each given input Observable (as arguments), and simply
- * forwards (without doing any transformation) all the values from all the input
- * Observables to the output Observable. The output Observable only completes
- * once all input Observables have completed. Any error delivered by an input
- * Observable will be immediately emitted on the output Observable.
- *
- * ## Examples
- *
- * Merge together two Observables: 1s interval and clicks
- *
- * ```ts
- * import { merge, fromEvent, interval } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const timer = interval(1000);
- * const clicksOrTimer = merge(clicks, timer);
- * clicksOrTimer.subscribe(x => console.log(x));
- *
- * // Results in the following:
- * // timer will emit ascending values, one every second(1000ms) to console
- * // clicks logs MouseEvents to console every time the "document" is clicked
- * // Since the two streams are merged you see these happening
- * // as they occur.
- * ```
- *
- * Merge together 3 Observables, but run only 2 concurrently
- *
- * ```ts
- * import { interval, take, merge } from 'rxjs';
- *
- * const timer1 = interval(1000).pipe(take(10));
- * const timer2 = interval(2000).pipe(take(6));
- * const timer3 = interval(500).pipe(take(10));
- *
- * const concurrent = 2; // the argument
- * const merged = merge(timer1, timer2, timer3, concurrent);
- * merged.subscribe(x => console.log(x));
- *
- * // Results in the following:
- * // - First timer1 and timer2 will run concurrently
- * // - timer1 will emit a value every 1000ms for 10 iterations
- * // - timer2 will emit a value every 2000ms for 6 iterations
- * // - after timer1 hits its max iteration, timer2 will
- * //   continue, and timer3 will start to run concurrently with timer2
- * // - when timer2 hits its max iteration it terminates, and
- * //   timer3 will continue to emit a value every 500ms until it is complete
- * ```
- *
- * @see {@link mergeAll}
- * @see {@link mergeMap}
- * @see {@link mergeMapTo}
- * @see {@link mergeScan}
- *
- * @param args `ObservableInput`s to merge together. If the last parameter
- * is of type number, `merge` will use it to limit number of concurrently
- * subscribed `ObservableInput`s. If the last parameter is {@link SchedulerLike},
- * it will be used for scheduling the emission of values.
- * @return An Observable that emits items that are the result of every input Observable.
- */
-export function merge(...args: (ObservableInput<unknown> | number | SchedulerLike)[]): Observable<unknown> {
-  const scheduler = popScheduler(args);
-  const concurrent = popNumber(args, Infinity);
-  const sources = args as ObservableInput<unknown>[];
-  return !sources.length
-    ? // No source provided
-      EMPTY
-    : sources.length === 1
-    ? // One source? Just return it.
-      innerFrom(sources[0])
-    : // Merge all sources
-      mergeAll(concurrent)(from(sources, scheduler));
-}

package/node_modules/rxjs/src/internal/observable/never.ts

@@ -1,44 +0,0 @@
-import { Observable } from '../Observable';
-import { noop } from '../util/noop';
-
-/**
- * An Observable that emits no items to the Observer and never completes.
- *
- * ![](never.png)
- *
- * A simple Observable that emits neither values nor errors nor the completion
- * notification. It can be used for testing purposes or for composing with other
- * Observables. Please note that by never emitting a complete notification, this
- * Observable keeps the subscription from being disposed automatically.
- * Subscriptions need to be manually disposed.
- *
- * ##  Example
- *
- * Emit the number 7, then never emit anything else (not even complete)
- *
- * ```ts
- * import { NEVER, startWith } from 'rxjs';
- *
- * const info = () => console.log('Will not be called');
- *
- * const result = NEVER.pipe(startWith(7));
- * result.subscribe({
- *   next: x => console.log(x),
- *   error: info,
- *   complete: info
- * });
- * ```
- *
- * @see {@link Observable}
- * @see {@link EMPTY}
- * @see {@link of}
- * @see {@link throwError}
- */
-export const NEVER = new Observable<never>(noop);
-
-/**
- * @deprecated Replaced with the {@link NEVER} constant. Will be removed in v8.
- */
-export function never() {
-  return NEVER;
-}

package/node_modules/rxjs/src/internal/observable/of.ts

@@ -1,83 +0,0 @@
-import { SchedulerLike, ValueFromArray } from '../types';
-import { Observable } from '../Observable';
-import { popScheduler } from '../util/args';
-import { from } from './from';
-
-// Devs are more likely to pass null or undefined than they are a scheduler
-// without accompanying values. To make things easier for (naughty) devs who
-// use the `strictNullChecks: false` TypeScript compiler option, these
-// overloads with explicit null and undefined values are included.
-
-export function of(value: null): Observable<null>;
-export function of(value: undefined): Observable<undefined>;
-
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export function of(scheduler: SchedulerLike): Observable<never>;
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export function of<A extends readonly unknown[]>(...valuesAndScheduler: [...A, SchedulerLike]): Observable<ValueFromArray<A>>;
-
-export function of(): Observable<never>;
-/** @deprecated Do not specify explicit type parameters. Signatures with type parameters that cannot be inferred will be removed in v8. */
-export function of<T>(): Observable<T>;
-export function of<T>(value: T): Observable<T>;
-export function of<A extends readonly unknown[]>(...values: A): Observable<ValueFromArray<A>>;
-
-/**
- * Converts the arguments to an observable sequence.
- *
- * <span class="informal">Each argument becomes a `next` notification.</span>
- *
- * ![](of.png)
- *
- * Unlike {@link from}, it does not do any flattening and emits each argument in whole
- * as a separate `next` notification.
- *
- * ## Examples
- *
- * Emit the values `10, 20, 30`
- *
- * ```ts
- * import { of } from 'rxjs';
- *
- * of(10, 20, 30)
- *   .subscribe({
- *     next: value => console.log('next:', value),
- *     error: err => console.log('error:', err),
- *     complete: () => console.log('the end'),
- *   });
- *
- * // Outputs
- * // next: 10
- * // next: 20
- * // next: 30
- * // the end
- * ```
- *
- * Emit the array `[1, 2, 3]`
- *
- * ```ts
- * import { of } from 'rxjs';
- *
- * of([1, 2, 3])
- *   .subscribe({
- *     next: value => console.log('next:', value),
- *     error: err => console.log('error:', err),
- *     complete: () => console.log('the end'),
- *   });
- *
- * // Outputs
- * // next: [1, 2, 3]
- * // the end
- * ```
- *
- * @see {@link from}
- * @see {@link range}
- *
- * @param args A comma separated list of arguments you want to be emitted.
- * @return An Observable that synchronously emits the arguments described
- * above and then immediately completes.
- */
-export function of<T>(...args: Array<T | SchedulerLike>): Observable<T> {
-  const scheduler = popScheduler(args);
-  return from(args as T[], scheduler);
-}

package/node_modules/rxjs/src/internal/observable/onErrorResumeNext.ts

@@ -1,98 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInputTuple } from '../types';
-import { argsOrArgArray } from '../util/argsOrArgArray';
-import { OperatorSubscriber } from '../operators/OperatorSubscriber';
-import { noop } from '../util/noop';
-import { innerFrom } from './innerFrom';
-
-export function onErrorResumeNext<A extends readonly unknown[]>(sources: [...ObservableInputTuple<A>]): Observable<A[number]>;
-export function onErrorResumeNext<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A[number]>;
-
-/**
- * When any of the provided Observable emits a complete or an error notification, it immediately subscribes to the next one
- * that was passed.
- *
- * <span class="informal">Execute series of Observables no matter what, even if it means swallowing errors.</span>
- *
- * ![](onErrorResumeNext.png)
- *
- * `onErrorResumeNext` will subscribe to each observable source it is provided, in order.
- * If the source it's subscribed to emits an error or completes, it will move to the next source
- * without error.
- *
- * If `onErrorResumeNext` is provided no arguments, or a single, empty array, it will return {@link EMPTY}.
- *
- * `onErrorResumeNext` is basically {@link concat}, only it will continue, even if one of its
- * sources emits an error.
- *
- * Note that there is no way to handle any errors thrown by sources via the result of
- * `onErrorResumeNext`. If you want to handle errors thrown in any given source, you can
- * always use the {@link catchError} operator on them before passing them into `onErrorResumeNext`.
- *
- * ## Example
- *
- * Subscribe to the next Observable after map fails
- *
- * ```ts
- * import { onErrorResumeNext, of, map } from 'rxjs';
- *
- * onErrorResumeNext(
- *   of(1, 2, 3, 0).pipe(
- *     map(x => {
- *       if (x === 0) {
- *         throw Error();
- *       }
- *       return 10 / x;
- *     })
- *   ),
- *   of(1, 2, 3)
- * )
- * .subscribe({
- *   next: value => console.log(value),
- *   error: err => console.log(err),     // Will never be called.
- *   complete: () => console.log('done')
- * });
- *
- * // Logs:
- * // 10
- * // 5
- * // 3.3333333333333335
- * // 1
- * // 2
- * // 3
- * // 'done'
- * ```
- *
- * @see {@link concat}
- * @see {@link catchError}
- *
- * @param sources `ObservableInput`s passed either directly or as an array.
- * @return An Observable that concatenates all sources, one after the other,
- * ignoring all errors, such that any error causes it to move on to the next source.
- */
-export function onErrorResumeNext<A extends readonly unknown[]>(
-  ...sources: [[...ObservableInputTuple<A>]] | [...ObservableInputTuple<A>]
-): Observable<A[number]> {
-  const nextSources: ObservableInputTuple<A> = argsOrArgArray(sources) as any;
-
-  return new Observable((subscriber) => {
-    let sourceIndex = 0;
-    const subscribeNext = () => {
-      if (sourceIndex < nextSources.length) {
-        let nextSource: Observable<A[number]>;
-        try {
-          nextSource = innerFrom(nextSources[sourceIndex++]);
-        } catch (err) {
-          subscribeNext();
-          return;
-        }
-        const innerSubscriber = new OperatorSubscriber(subscriber, undefined, noop, noop);
-        nextSource.subscribe(innerSubscriber);
-        innerSubscriber.add(subscribeNext);
-      } else {
-        subscriber.complete();
-      }
-    };
-    subscribeNext();
-  });
-}

package/node_modules/rxjs/src/internal/observable/pairs.ts

@@ -1,80 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-import { from } from './from';
-
-/**
- * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
- */
-export function pairs<T>(arr: readonly T[], scheduler?: SchedulerLike): Observable<[string, T]>;
-/**
- * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
- */
-export function pairs<O extends Record<string, unknown>>(obj: O, scheduler?: SchedulerLike): Observable<[keyof O, O[keyof O]]>;
-/**
- * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
- */
-export function pairs<T>(iterable: Iterable<T>, scheduler?: SchedulerLike): Observable<[string, T]>;
-/**
- * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
- */
-export function pairs(
-  n: number | bigint | boolean | ((...args: any[]) => any) | symbol,
-  scheduler?: SchedulerLike
-): Observable<[never, never]>;
-
-/**
- * Convert an object into an Observable of `[key, value]` pairs.
- *
- * <span class="informal">Turn entries of an object into a stream.</span>
- *
- * ![](pairs.png)
- *
- * `pairs` takes an arbitrary object and returns an Observable that emits arrays. Each
- * emitted array has exactly two elements - the first is a key from the object
- * and the second is a value corresponding to that key. Keys are extracted from
- * an object via `Object.keys` function, which means that they will be only
- * enumerable keys that are present on an object directly - not ones inherited
- * via prototype chain.
- *
- * By default, these arrays are emitted synchronously. To change that you can
- * pass a {@link SchedulerLike} as a second argument to `pairs`.
- *
- * ## Example
- *
- * Converts an object to an Observable
- *
- * ```ts
- * import { pairs } from 'rxjs';
- *
- * const obj = {
- *   foo: 42,
- *   bar: 56,
- *   baz: 78
- * };
- *
- * pairs(obj).subscribe({
- *   next: value => console.log(value),
- *   complete: () => console.log('Complete!')
- * });
- *
- * // Logs:
- * // ['foo', 42]
- * // ['bar', 56]
- * // ['baz', 78]
- * // 'Complete!'
- * ```
- *
- * ### Object.entries required
- *
- * In IE, you will need to polyfill `Object.entries` in order to use this.
- * [MDN has a polyfill here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
- *
- * @param obj The object to inspect and turn into an Observable sequence.
- * @param scheduler An optional IScheduler to schedule when resulting
- * Observable will emit values.
- * @returns An observable sequence of [key, value] pairs from the object.
- * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
- */
-export function pairs(obj: any, scheduler?: SchedulerLike) {
-  return from(Object.entries(obj), scheduler as any);
-}

package/node_modules/rxjs/src/internal/observable/partition.ts

@@ -1,88 +0,0 @@
-import { not } from '../util/not';
-import { filter } from '../operators/filter';
-import { ObservableInput } from '../types';
-import { Observable } from '../Observable';
-import { innerFrom } from './innerFrom';
-
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export function partition<T, U extends T, A>(
-  source: ObservableInput<T>,
-  predicate: (this: A, value: T, index: number) => value is U,
-  thisArg: A
-): [Observable<U>, Observable<Exclude<T, U>>];
-export function partition<T, U extends T>(
-  source: ObservableInput<T>,
-  predicate: (value: T, index: number) => value is U
-): [Observable<U>, Observable<Exclude<T, U>>];
-
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export function partition<T, A>(
-  source: ObservableInput<T>,
-  predicate: (this: A, value: T, index: number) => boolean,
-  thisArg: A
-): [Observable<T>, Observable<T>];
-export function partition<T>(source: ObservableInput<T>, predicate: (value: T, index: number) => boolean): [Observable<T>, Observable<T>];
-
-/**
- * Splits the source Observable into two, one with values that satisfy a
- * predicate, and another with values that don't satisfy the predicate.
- *
- * <span class="informal">It's like {@link filter}, but returns two Observables:
- * one like the output of {@link filter}, and the other with values that did not
- * pass the condition.</span>
- *
- * ![](partition.png)
- *
- * `partition` outputs an array with two Observables that partition the values
- * from the source Observable through the given `predicate` function. The first
- * Observable in that array emits source values for which the predicate argument
- * returns true. The second Observable emits source values for which the
- * predicate returns false. The first behaves like {@link filter} and the second
- * behaves like {@link filter} with the predicate negated.
- *
- * ## Example
- *
- * Partition a set of numbers into odds and evens observables
- *
- * ```ts
- * import { of, partition } from 'rxjs';
- *
- * const observableValues = of(1, 2, 3, 4, 5, 6);
- * const [evens$, odds$] = partition(observableValues, value => value % 2 === 0);
- *
- * odds$.subscribe(x => console.log('odds', x));
- * evens$.subscribe(x => console.log('evens', x));
- *
- * // Logs:
- * // odds 1
- * // odds 3
- * // odds 5
- * // evens 2
- * // evens 4
- * // evens 6
- * ```
- *
- * @see {@link filter}
- *
- * @param source The source `ObservableInput` that will be split into a tuple of
- * two Observable elements.
- * @param predicate A function that evaluates each value emitted by the source
- * Observable. If it returns `true`, the value is emitted on the first Observable
- * in the returned array, if `false` the value is emitted on the second Observable
- * in the array. The `index` parameter is the number `i` for the i-th source
- * emission that has happened since the subscription, starting from the number `0`.
- * @param thisArg An optional argument to determine the value of `this` in the
- * `predicate` function.
- * @return An array with two Observables: one with values that passed the
- * predicate, and another with values that did not pass the predicate.
- */
-export function partition<T>(
-  source: ObservableInput<T>,
-  predicate: (this: any, value: T, index: number) => boolean,
-  thisArg?: any
-): [Observable<T>, Observable<T>] {
-  return [filter(predicate, thisArg)(innerFrom(source)), filter(not(predicate, thisArg))(innerFrom(source))] as [
-    Observable<T>,
-    Observable<T>
-  ];
-}

package/node_modules/rxjs/src/internal/observable/race.ts

@@ -1,88 +0,0 @@
-import { Observable } from '../Observable';
-import { innerFrom } from './innerFrom';
-import { Subscription } from '../Subscription';
-import { ObservableInput, ObservableInputTuple } from '../types';
-import { argsOrArgArray } from '../util/argsOrArgArray';
-import { createOperatorSubscriber } from '../operators/OperatorSubscriber';
-import { Subscriber } from '../Subscriber';
-
-export function race<T extends readonly unknown[]>(inputs: [...ObservableInputTuple<T>]): Observable<T[number]>;
-export function race<T extends readonly unknown[]>(...inputs: [...ObservableInputTuple<T>]): Observable<T[number]>;
-
-/**
- * Returns an observable that mirrors the first source observable to emit an item.
- *
- * ![](race.png)
- *
- * `race` returns an observable, that when subscribed to, subscribes to all source observables immediately.
- * As soon as one of the source observables emits a value, the result unsubscribes from the other sources.
- * The resulting observable will forward all notifications, including error and completion, from the "winning"
- * source observable.
- *
- * If one of the used source observable throws an errors before a first notification
- * the race operator will also throw an error, no matter if another source observable
- * could potentially win the race.
- *
- * `race` can be useful for selecting the response from the fastest network connection for
- * HTTP or WebSockets. `race` can also be useful for switching observable context based on user
- * input.
- *
- * ## Example
- *
- * Subscribes to the observable that was the first to start emitting.
- *
- * ```ts
- * import { interval, map, race } from 'rxjs';
- *
- * const obs1 = interval(7000).pipe(map(() => 'slow one'));
- * const obs2 = interval(3000).pipe(map(() => 'fast one'));
- * const obs3 = interval(5000).pipe(map(() => 'medium one'));
- *
- * race(obs1, obs2, obs3)
- *   .subscribe(winner => console.log(winner));
- *
- * // Outputs
- * // a series of 'fast one'
- * ```
- *
- * @param sources Used to race for which `ObservableInput` emits first.
- * @return An Observable that mirrors the output of the first Observable to emit an item.
- */
-export function race<T>(...sources: (ObservableInput<T> | ObservableInput<T>[])[]): Observable<any> {
-  sources = argsOrArgArray(sources);
-  // If only one source was passed, just return it. Otherwise return the race.
-  return sources.length === 1 ? innerFrom(sources[0] as ObservableInput<T>) : new Observable<T>(raceInit(sources as ObservableInput<T>[]));
-}
-
-/**
- * An observable initializer function for both the static version and the
- * operator version of race.
- * @param sources The sources to race
- */
-export function raceInit<T>(sources: ObservableInput<T>[]) {
-  return (subscriber: Subscriber<T>) => {
-    let subscriptions: Subscription[] = [];
-
-    // Subscribe to all of the sources. Note that we are checking `subscriptions` here
-    // Is is an array of all actively "racing" subscriptions, and it is `null` after the
-    // race has been won. So, if we have racer that synchronously "wins", this loop will
-    // stop before it subscribes to any more.
-    for (let i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {
-      subscriptions.push(
-        innerFrom(sources[i] as ObservableInput<T>).subscribe(
-          createOperatorSubscriber(subscriber, (value) => {
-            if (subscriptions) {
-              // We're still racing, but we won! So unsubscribe
-              // all other subscriptions that we have, except this one.
-              for (let s = 0; s < subscriptions.length; s++) {
-                s !== i && subscriptions[s].unsubscribe();
-              }
-              subscriptions = null!;
-            }
-            subscriber.next(value);
-          })
-        )
-      );
-    }
-  };
-}

package/node_modules/rxjs/src/internal/observable/range.ts

@@ -1,93 +0,0 @@
-import { SchedulerLike } from '../types';
-import { Observable } from '../Observable';
-import { EMPTY } from './empty';
-
-export function range(start: number, count?: number): Observable<number>;
-
-/**
- * @deprecated The `scheduler` parameter will be removed in v8. Use `range(start, count).pipe(observeOn(scheduler))` instead. Details: Details: https://rxjs.dev/deprecations/scheduler-argument
- */
-export function range(start: number, count: number | undefined, scheduler: SchedulerLike): Observable<number>;
-
-/**
- * Creates an Observable that emits a sequence of numbers within a specified
- * range.
- *
- * <span class="informal">Emits a sequence of numbers in a range.</span>
- *
- * ![](range.png)
- *
- * `range` operator emits a range of sequential integers, in order, where you
- * select the `start` of the range and its `length`. By default, uses no
- * {@link SchedulerLike} and just delivers the notifications synchronously, but may use
- * an optional {@link SchedulerLike} to regulate those deliveries.
- *
- * ## Example
- *
- * Produce a range of numbers
- *
- * ```ts
- * import { range } from 'rxjs';
- *
- * const numbers = range(1, 3);
- *
- * numbers.subscribe({
- *   next: value => console.log(value),
- *   complete: () => console.log('Complete!')
- * });
- *
- * // Logs:
- * // 1
- * // 2
- * // 3
- * // 'Complete!'
- * ```
- *
- * @see {@link timer}
- * @see {@link interval}
- *
- * @param start The value of the first integer in the sequence.
- * @param count The number of sequential integers to generate.
- * @param scheduler A {@link SchedulerLike} to use for scheduling the emissions
- * of the notifications.
- * @return An Observable of numbers that emits a finite range of sequential integers.
- */
-export function range(start: number, count?: number, scheduler?: SchedulerLike): Observable<number> {
-  if (count == null) {
-    // If one argument was passed, it's the count, not the start.
-    count = start;
-    start = 0;
-  }
-
-  if (count <= 0) {
-    // No count? We're going nowhere. Return EMPTY.
-    return EMPTY;
-  }
-
-  // Where the range should stop.
-  const end = count + start;
-
-  return new Observable(
-    scheduler
-      ? // The deprecated scheduled path.
-        (subscriber) => {
-          let n = start;
-          return scheduler.schedule(function () {
-            if (n < end) {
-              subscriber.next(n++);
-              this.schedule();
-            } else {
-              subscriber.complete();
-            }
-          });
-        }
-      : // Standard synchronous range.
-        (subscriber) => {
-          let n = start;
-          while (n < end && !subscriber.closed) {
-            subscriber.next(n++);
-          }
-          subscriber.complete();
-        }
-  );
-}