lambda-live-debugger 1.7.0 → 1.7.1

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

@@ -68,9 +68,8 @@ export function concatMap<T, R, O extends ObservableInput<any>>(
  * @see {@link mergeMap}
  * @see {@link switchMap}
  *
- * @param {function(value: T, ?index: number): ObservableInput} project A function
- * that, when applied to an item emitted by the source Observable, returns an
- * Observable.
+ * @param project A function that, when applied to an item emitted by the source
+ * Observable, returns an Observable.
  * @return A function that returns an Observable that emits the result of
  * applying the projection function (and the optional deprecated
  * `resultSelector`) to each item emitted by the source Observable and taking

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

@@ -64,8 +64,8 @@ export function concatMapTo<T, R, O extends ObservableInput<unknown>>(
  * @see {@link mergeMapTo}
  * @see {@link switchMapTo}
  *
- * @param {ObservableInput} innerObservable An Observable to replace each value from
- * the source Observable.
+ * @param innerObservable An `ObservableInput` to replace each value from the
+ * source Observable.
  * @return A function that returns an Observable of values merged together by
  * joining the passed Observable with itself, one after the other, for each
  * value emitted from the source.

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

@@ -51,12 +51,11 @@ import { createOperatorSubscriber } from './OperatorSubscriber';
  * @see {@link throttle}
  * @see {@link throttleTime}
  *
- * @param {number} dueTime The timeout duration in milliseconds (or the time
- * unit determined internally by the optional `scheduler`) for the window of
- * time required to wait for emission silence before emitting the most recent
- * source value.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
- * managing the timers that handle the timeout for each value.
+ * @param dueTime The timeout duration in milliseconds (or the time unit determined
+ * internally by the optional `scheduler`) for the window of time required to wait
+ * for emission silence before emitting the most recent source value.
+ * @param scheduler The {@link SchedulerLike} to use for managing the timers that
+ * handle the timeout for each value.
  * @return A function that returns an Observable that delays the emissions of
  * the source Observable by the specified `dueTime`, and may drop some values
  * if they occur too frequently.

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

@@ -52,10 +52,10 @@ import { timer } from '../observable/timer';
  * @see {@link audit}
  * @see {@link auditTime}
  *
- * @param {number|Date} due The delay duration in milliseconds (a `number`) or
- * a `Date` until which the emission of the source items is delayed.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
- * managing the timers that handle the time-shift for each item.
+ * @param due The delay duration in milliseconds (a `number`) or a `Date` until
+ * which the emission of the source items is delayed.
+ * @param scheduler The {@link SchedulerLike} to use for managing the timers
+ * that handle the time-shift for each item.
  * @return A function that returns an Observable that delays the emissions of
  * the source Observable by the specified timeout or Date.
  */

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

@@ -1,16 +1,16 @@
 import { distinctUntilChanged } from './distinctUntilChanged';
 import { MonoTypeOperatorFunction } from '../types';
 
-/* tslint:disable:max-line-length */
 export function distinctUntilKeyChanged<T>(key: keyof T): MonoTypeOperatorFunction<T>;
 export function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare: (x: T[K], y: T[K]) => boolean): MonoTypeOperatorFunction<T>;
-/* tslint:enable:max-line-length */
 
 /**
- * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item,
- * using a property accessed by using the key provided to check if the two items are distinct.
+ * Returns an Observable that emits all items emitted by the source Observable that
+ * are distinct by comparison from the previous item, using a property accessed by
+ * using the key provided to check if the two items are distinct.
  *
- * If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted.
+ * If a comparator function is provided, then it will be called for each item to
+ * test for whether that value should be emitted or not.
  *
  * If a comparator function is not provided, an equality check is used by default.
  *
@@ -61,11 +61,15 @@ export function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare: (
  * @see {@link distinct}
  * @see {@link distinctUntilChanged}
  *
- * @param {string} key String key for object property lookup on each item.
- * @param {function} [compare] Optional comparison function called to test if an item is distinct from the previous item in the source.
- * @return A function that returns an Observable that emits items from the
- * source Observable with distinct values based on the key specified.
+ * @param key String key for object property lookup on each item.
+ * @param compare Optional comparison function called to test if an item is distinct
+ * from the previous item in the source.
+ * @return A function that returns an Observable that emits items from the source
+ * Observable with distinct values based on the key specified.
  */
-export function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare?: (x: T[K], y: T[K]) => boolean): MonoTypeOperatorFunction<T> {
-  return distinctUntilChanged((x: T, y: T) => compare ? compare(x[key], y[key]) : x[key] === y[key]);
+export function distinctUntilKeyChanged<T, K extends keyof T>(
+  key: K,
+  compare?: (x: T[K], y: T[K]) => boolean
+): MonoTypeOperatorFunction<T> {
+  return distinctUntilChanged((x: T, y: T) => (compare ? compare(x[key], y[key]) : x[key] === y[key]));
 }

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

@@ -44,12 +44,12 @@ import { take } from './take';
  * @see {@link take}
  *
  * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an
- * ArgumentOutOfRangeError to the Observer's `error` callback if `i < 0` or the
+ * `ArgumentOutOfRangeError` to the Observer's `error` callback if `i < 0` or the
  * Observable has completed before emitting the i-th `next` notification.
  *
- * @param {number} index Is the number `i` for the i-th source emission that has
- * happened since the subscription, starting from the number `0`.
- * @param {T} [defaultValue] The default value returned for missing indices.
+ * @param index Is the number `i` for the i-th source emission that has happened
+ * since the subscription, starting from the number `0`.
+ * @param defaultValue The default value returned for missing indices.
  * @return A function that returns an Observable that emits a single item, if
  * it is found. Otherwise, it will emit the default value if given. If not, it
  * emits an error.

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

@@ -36,8 +36,8 @@ export function every<T>(predicate: (value: T, index: number, source: Observable
  *   .subscribe(x => console.log(x)); // -> false
  * ```
  *
- * @param {function} predicate A function for determining if an item meets a specified condition.
- * @param {any} [thisArg] Optional object to use for `this` in the callback.
+ * @param predicate A function for determining if an item meets a specified condition.
+ * @param thisArg Optional object to use for `this` in the callback.
  * @return A function that returns an Observable of booleans that determines if
  * all items of the source Observable meet the condition specified.
  */

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

@@ -59,9 +59,8 @@ export function exhaustMap<T, I, R>(
  * @see {@link mergeMap}
  * @see {@link switchMap}
  *
- * @param {function(value: T, ?index: number): ObservableInput} project A function
- * that, when applied to an item emitted by the source Observable, returns an
- * Observable.
+ * @param project A function that, when applied to an item emitted by the source
+ * Observable, returns an Observable.
  * @return A function that returns an Observable containing projected
  * Observables of each item of the source, ignoring projected Observables that
  * start before their preceding Observable has completed.

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

@@ -59,12 +59,11 @@ export function expand<T, O extends ObservableInput<unknown>>(
  * @see {@link mergeMap}
  * @see {@link mergeScan}
  *
- * @param {function(value: T, index: number) => Observable} project A function
- * that, when applied to an item emitted by the source or the output Observable,
- * returns an Observable.
- * @param {number} [concurrent=Infinity] Maximum number of input
- * Observables being subscribed to concurrently.
- * @param {SchedulerLike} [scheduler=null] The {@link SchedulerLike} to use for subscribing to
+ * @param project A function that, when applied to an item emitted by the source
+ * or the output Observable, returns an Observable.
+ * @param concurrent Maximum number of input Observables being subscribed to
+ * concurrently.
+ * @param scheduler The {@link SchedulerLike} to use for subscribing to
  * each projected inner Observable.
  * @return A function that returns an Observable that emits the source values
  * and also result of applying the projection function to each value emitted on

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

@@ -58,7 +58,7 @@ import { operate } from '../util/lift';
  * // '[finalize] Called'
  * ```
  *
- * @param {function} callback Function to be called when source terminates.
+ * @param callback Function to be called when source terminates.
  * @return A function that returns an Observable that mirrors the source, but
  * will call the specified function on termination.
  */

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

@@ -55,10 +55,9 @@ export function find<T>(predicate: (value: T, index: number, source: Observable<
  * @see {@link findIndex}
  * @see {@link take}
  *
- * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate
- * A function called with each item to test for condition matching.
- * @param {any} [thisArg] An optional argument to determine the value of `this`
- * in the `predicate` function.
+ * @param predicate A function called with each item to test for condition matching.
+ * @param thisArg An optional argument to determine the value of `this` in the
+ * `predicate` function.
  * @return A function that returns an Observable that emits the first item that
  * matches the condition.
  */

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

@@ -49,10 +49,9 @@ export function findIndex<T>(predicate: (value: T, index: number, source: Observ
  * @see {@link first}
  * @see {@link take}
  *
- * @param {function(value: T, index: number, source: Observable<T>): boolean} predicate
- * A function called with each item to test for condition matching.
- * @param {any} [thisArg] An optional argument to determine the value of `this`
- * in the `predicate` function.
+ * @param predicate A function called with each item to test for condition matching.
+ * @param thisArg An optional argument to determine the value of `this` in the
+ * `predicate` function.
  * @return A function that returns an Observable that emits the index of the
  * first item that matches the condition.
  */

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

@@ -34,8 +34,8 @@ export function first<T, D = T>(
  *
  * If called with no arguments, `first` emits the first value of the source
  * Observable, then completes. If called with a `predicate` function, `first`
- * emits the first value of the source that matches the specified condition. Throws an error if
- * `defaultValue` was not provided and a matching element is not found.
+ * emits the first value of the source that matches the specified condition. Emits an error
+ * notification if `defaultValue` was not provided and a matching element is not found.
  *
  * ## Examples
  *
@@ -66,15 +66,16 @@ export function first<T, D = T>(
  * @see {@link filter}
  * @see {@link find}
  * @see {@link take}
+ * @see {@link last}
  *
- * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
+ * @throws {EmptyError} Delivers an `EmptyError` to the Observer's `error`
  * callback if the Observable completes before any `next` notification was sent.
- * This is how `first()` is different from {@link take}(1) which completes instead.
+ * This is how `first()` is different from `take(1)` which completes instead.
  *
- * @param {function(value: T, index: number, source: Observable<T>): boolean} [predicate]
- * An optional function called with each item to test for condition matching.
- * @param {D} [defaultValue] The default value emitted in case no valid value
- * was found on the source.
+ * @param predicate An optional function called with each item to test for condition
+ * matching.
+ * @param defaultValue The default value emitted in case no valid value was found on
+ * the source.
  * @return A function that returns an Observable that emits the first item that
  * matches the condition.
  */

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

@@ -27,9 +27,9 @@ export function last<T, D = T>(
  *
  * ![](last.png)
  *
- * It will throw an error if the source completes without notification or one that matches the predicate. It
- * returns the last value or if a predicate is provided last value that matches the predicate. It returns the
- * given default value if no notification is emitted or matches the predicate.
+ * It will emit an error notification if the source completes without notification or one that matches
+ * the predicate. It returns the last value or if a predicate is provided last value that matches the
+ * predicate. It returns the given default value if no notification is emitted or matches the predicate.
  *
  * ## Examples
  *
@@ -65,16 +65,17 @@ export function last<T, D = T>(
  * @see {@link skipUntil}
  * @see {@link skipLast}
  * @see {@link skipWhile}
+ * @see {@link first}
  *
- * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
+ * @throws {EmptyError} Delivers an `EmptyError` to the Observer's `error`
  * callback if the Observable completes before any `next` notification was sent.
- * @param {function} [predicate] - The condition any source emitted item has to satisfy.
- * @param {any} [defaultValue] - An optional default value to provide if last
- * predicate isn't met or no values were emitted.
+ *
+ * @param predicate The condition any source emitted item has to satisfy.
+ * @param defaultValue An optional default value to provide if last `predicate`
+ * isn't met or no values were emitted.
  * @return A function that returns an Observable that emits only the last item
- * satisfying the given condition from the source, or a NoSuchElementException
- * if no such items are emitted.
- * @throws - Throws if no items that match the predicate are emitted by the source Observable.
+ * satisfying the given condition from the source, or an error notification
+ * with an `EmptyError` object if no such items are emitted.
  */
 export function last<T, D>(
   predicate?: ((value: T, index: number, source: Observable<T>) => boolean) | null,

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

@@ -36,11 +36,10 @@ export function map<T, R, A>(project: (this: A, value: T, index: number) => R, t
  * @see {@link mapTo}
  * @see {@link pluck}
  *
- * @param {function(value: T, index: number): R} project The function to apply
- * to each `value` emitted by the source Observable. The `index` parameter is
- * the number `i` for the i-th emission that has happened since the
- * subscription, starting from the number `0`.
- * @param {any} [thisArg] An optional argument to define what `this` is in the
+ * @param project The function to apply to each `value` emitted by the source
+ * Observable. The `index` parameter is the number `i` for the i-th emission
+ * that has happened since the subscription, starting from the number `0`.
+ * @param thisArg An optional argument to define what `this` is in the
  * `project` function.
  * @return A function that returns an Observable that emits the values from the
  * source Observable transformed by the given `project` function.

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

@@ -3,8 +3,9 @@ import { MonoTypeOperatorFunction } from '../types';
 import { isFunction } from '../util/isFunction';
 
 /**
- * The Max operator operates on an Observable that emits numbers (or items that can be compared with a provided function),
- * and when source Observable completes it emits a single item: the item with the largest value.
+ * The `max` operator operates on an Observable that emits numbers (or items that
+ * can be compared with a provided function), and when source Observable completes
+ * it emits a single item: the item with the largest value.
  *
  * ![](max.png)
  *
@@ -43,8 +44,8 @@ import { isFunction } from '../util/isFunction';
  *
  * @see {@link min}
  *
- * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the
- * value of two items.
+ * @param comparer Optional comparer function that it will use instead of its
+ * default to compare the value of two items.
  * @return A function that returns an Observable that emits item with the
  * largest value.
  */

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

@@ -1,6 +1,5 @@
 import { ObservableInput, ObservableInputTuple, OperatorFunction, SchedulerLike } from '../types';
 import { operate } from '../util/lift';
-import { argsOrArgArray } from '../util/argsOrArgArray';
 import { mergeAll } from './mergeAll';
 import { popNumber, popScheduler } from '../util/args';
 import { from } from '../observable/from';
@@ -23,7 +22,6 @@ export function merge<T, A extends readonly unknown[]>(
 export function merge<T>(...args: unknown[]): OperatorFunction<T, unknown> {
   const scheduler = popScheduler(args);
   const concurrent = popNumber(args, Infinity);
-  args = argsOrArgArray(args);
 
   return operate((source, subscriber) => {
     mergeAll(concurrent)(from([source, ...(args as ObservableInput<T>[])], scheduler)).subscribe(subscriber);

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

@@ -56,8 +56,8 @@ import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
  * @see {@link switchMap}
  * @see {@link zipAll}
  *
- * @param {number} [concurrent=Infinity] Maximum number of inner
- * Observables being subscribed to concurrently.
+ * @param concurrent Maximum number of inner Observables being subscribed to
+ * concurrently.
  * @return A function that returns an Observable that emits values coming from
  * all the inner Observables emitted by the source Observable.
  */

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

@@ -70,11 +70,9 @@ export function mergeMap<T, R, O extends ObservableInput<any>>(
  * @see {@link mergeScan}
  * @see {@link switchMap}
  *
- * @param {function(value: T, ?index: number): ObservableInput} project A function
- * that, when applied to an item emitted by the source Observable, returns an
- * Observable.
- * @param {number} [concurrent=Infinity] Maximum number of input
- * Observables being subscribed to concurrently.
+ * @param project A function that, when applied to an item emitted by the source
+ * Observable, returns an Observable.
+ * @param concurrent Maximum number of `ObservableInput`s being subscribed to concurrently.
  * @return A function that returns an Observable that emits the result of
  * applying the projection function (and the optional deprecated
  * `resultSelector`) to each item emitted by the source Observable and merging

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

@@ -51,10 +51,10 @@ export function mergeMapTo<T, R, O extends ObservableInput<unknown>>(
  * @see {@link mergeScan}
  * @see {@link switchMapTo}
  *
- * @param {ObservableInput} innerObservable An Observable to replace each value from
- * the source Observable.
- * @param {number} [concurrent=Infinity] Maximum number of input
- * Observables being subscribed to concurrently.
+ * @param innerObservable An `ObservableInput` to replace each value from the
+ * source Observable.
+ * @param concurrent Maximum number of input Observables being subscribed to
+ * concurrently.
  * @return A function that returns an Observable that emits items from the
  * given `innerObservable`.
  * @deprecated Will be removed in v9. Use {@link mergeMap} instead: `mergeMap(() => result)`

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

@@ -61,11 +61,10 @@ import { mergeInternals } from './mergeInternals';
  * @see {@link scan}
  * @see {@link switchScan}
  *
- * @param {function(acc: R, value: T): Observable<R>} accumulator
- * The accumulator function called on each source value.
+ * @param accumulator The accumulator function called on each source value.
  * @param seed The initial accumulation value.
- * @param {number} [concurrent=Infinity] Maximum number of
- * input Observables being subscribed to concurrently.
+ * @param concurrent Maximum number of input Observables being subscribed to
+ * concurrently.
  * @return A function that returns an Observable of the accumulated values.
  */
 export function mergeScan<T, R>(

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

@@ -3,8 +3,9 @@ import { MonoTypeOperatorFunction } from '../types';
 import { isFunction } from '../util/isFunction';
 
 /**
- * The Min operator operates on an Observable that emits numbers (or items that can be compared with a provided function),
- * and when source Observable completes it emits a single item: the item with the smallest value.
+ * The `min` operator operates on an Observable that emits numbers (or items that
+ * can be compared with a provided function), and when source Observable completes
+ * it emits a single item: the item with the smallest value.
  *
  * ![](min.png)
  *
@@ -43,8 +44,8 @@ import { isFunction } from '../util/isFunction';
  *
  * @see {@link max}
  *
- * @param {Function} [comparer] - Optional comparer function that it will use instead of its default to compare the
- * value of two items.
+ * @param comparer Optional comparer function that it will use instead of its
+ * default to compare the value of two items.
  * @return A function that returns an Observable that emits item with the
  * smallest value.
  */

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

@@ -76,7 +76,7 @@ export function onErrorResumeNextWith<T, A extends readonly unknown[]>(
  * @see {@link concat}
  * @see {@link catchError}
  *
- * @param {...ObservableInput} sources Observables passed either directly or as an array.
+ * @param sources `ObservableInput`s passed either directly or as an array.
  * @return A function that returns an Observable that emits values from source
  * Observable, but - if it errors - subscribes to the next passed Observable
  * and so on, until it completes or runs out of Observables.

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

@@ -41,18 +41,17 @@ import { UnaryFunction } from '../types';
  *
  * @see {@link filter}
  *
- * @param {function(value: T, index: number): boolean} 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 {any} [thisArg] An optional argument to determine the value of `this`
- * in the `predicate` function.
+ * @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 A function that returns an array with two Observables: one with
  * values that passed the predicate, and another with values that did not pass
  * the predicate.
- * @deprecated Replaced with the `partition` static creation function. Will be removed in v8.
+ * @deprecated Replaced with the {@link partition} static creation function. Will be removed in v8.
  */
 export function partition<T>(
   predicate: (value: T, index: number) => boolean,

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

@@ -78,7 +78,7 @@ export function publish<T, O extends ObservableInput<any>>(selector: (shared: Ob
  * @see {@link publishReplay}
  * @see {@link publishBehavior}
  *
- * @param {Function} [selector] - Optional selector function which can use the multicasted source sequence as many times
+ * @param selector Optional selector function which can use the multicasted source sequence as many times
  * as needed, without causing multiple subscriptions to the source sequence.
  * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
  * @return A function that returns a ConnectableObservable that upon connection

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

@@ -51,9 +51,8 @@ export function reduce<V, A, S = A>(accumulator: (acc: A | S, value: V, index: n
  * @see {@link mergeScan}
  * @see {@link scan}
  *
- * @param {function(acc: A, value: V, index: number): A} accumulator The accumulator function
- * called on each source value.
- * @param {A} [seed] The initial accumulation value.
+ * @param accumulator The accumulator function called on each source value.
+ * @param seed The initial accumulation value.
  * @return A function that returns an Observable that emits a single value that
  * is the result of accumulating the values emitted by the source Observable.
  */

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

@@ -110,8 +110,8 @@ export interface RepeatConfig {
  * @see {@link repeatWhen}
  * @see {@link retry}
  *
- * @param count The number of times the source Observable items are repeated, a count of 0 will yield
- * an empty Observable.
+ * @param countOrConfig Either the number of times the source Observable items are repeated
+ * (a count of 0 will yield an empty Observable) or a {@link RepeatConfig} object.
  */
 export function repeat<T>(countOrConfig?: number | RepeatConfig): MonoTypeOperatorFunction<T> {
   let count = Infinity;

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

@@ -36,7 +36,7 @@ import { createOperatorSubscriber } from './OperatorSubscriber';
  *
  * @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 `ObservableInput` that mirrors the source
+ * @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$ })`.

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

@@ -76,7 +76,8 @@ export function retry<T>(config: RetryConfig): MonoTypeOperatorFunction<T>;
  *
  * @see {@link retryWhen}
  *
- * @param configOrCount - Either number of retry attempts before failing or a {@link RetryConfig} object.
+ * @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.
  */

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

@@ -58,7 +58,7 @@ import { createOperatorSubscriber } from './OperatorSubscriber';
  *
  * @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 `ObservableInput` that mirrors the source
+ * @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.

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

@@ -38,10 +38,10 @@ import { interval } from '../observable/interval';
  * @see {@link sample}
  * @see {@link throttleTime}
  *
- * @param {number} period The sampling period expressed in milliseconds or the
- * time unit determined internally by the optional `scheduler`.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
- * managing the timers that handle the sampling.
+ * @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.

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

@@ -16,15 +16,15 @@ export function single<T>(predicate?: (value: T, index: number, source: Observab
  * predicate is provided, then it will assert that the observable
  * only emits one value.
  *
- * In the event that the observable is empty, it will throw an
- * {@link EmptyError}.
+ * If the source Observable did not emit `next` before completion, it
+ * will emit an {@link EmptyError} to the Observer's `error` callback.
  *
  * In the event that two values are found that match the predicate,
  * or when there are two values emitted and no predicate, it will
- * throw a {@link SequenceError}
+ * emit a {@link SequenceError} to the Observer's `error` callback.
  *
  * In the event that no values match the predicate, if one is provided,
- * it will throw a {@link NotFoundError}
+ * it will emit a {@link NotFoundError} to the Observer's `error` callback.
  *
  * ## Example
  *
@@ -77,12 +77,16 @@ export function single<T>(predicate?: (value: T, index: number, source: Observab
  * @see {@link findIndex}
  * @see {@link elementAt}
  *
- * @throws {NotFoundError} Delivers an NotFoundError to the Observer's `error`
+ * @throws {NotFoundError} Delivers a `NotFoundError` to the Observer's `error`
  * callback if the Observable completes before any `next` notification was sent.
- * @throws {SequenceError} Delivers a SequenceError if more than one value is emitted that matches the
- * provided predicate. If no predicate is provided, will deliver a SequenceError if more
- * than one value comes from the source
- * @param {Function} predicate - A predicate function to evaluate items emitted by the source Observable.
+ * @throws {SequenceError} Delivers a `SequenceError` if more than one value is
+ * emitted that matches the provided predicate. If no predicate is provided, it
+ * will deliver a `SequenceError` if more than one value comes from the source.
+ * @throws {EmptyError} Delivers an `EmptyError` if no values were `next`ed prior
+ * to completion.
+ *
+ * @param predicate A predicate function to evaluate items emitted by the source
+ * Observable.
  * @return A function that returns an Observable that emits the single item
  * emitted by the source Observable that matches the predicate.
  */

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

@@ -30,7 +30,7 @@ import { filter } from './filter';
  * @see {@link skipUntil}
  * @see {@link skipLast}
  *
- * @param {Number} count - The number of times, items emitted by source Observable should be skipped.
+ * @param count The number of times, items emitted by source Observable should be skipped.
  * @return A function that returns an Observable that skips the first `count`
  * values emitted by the source Observable.
  */

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

@@ -45,7 +45,7 @@ export function skipWhile<T>(predicate: (value: T, index: number) => boolean): M
  * @see {@link skipUntil}
  * @see {@link skipLast}
  *
- * @param {Function} predicate - A function to test each item emitted from the source Observable.
+ * @param predicate A function to test each item emitted from the source Observable.
  * @return A function that returns an Observable that begins emitting items
  * emitted by the source Observable when the specified predicate becomes false.
  */