lambda-live-debugger 1.7.0 → 1.7.1

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

@@ -71,7 +71,8 @@ export function bindCallback<A extends readonly unknown[], R extends readonly un
  *
  * ## Examples
  *
- * ### Convert jQuery's getJSON to an Observable API
+ * Convert jQuery's getJSON to an Observable API
+ *
  * ```ts
  * import { bindCallback } from 'rxjs';
  * import * as jQuery from 'jquery';
@@ -82,7 +83,8 @@ export function bindCallback<A extends readonly unknown[], R extends readonly un
  * result.subscribe(x => console.log(x), e => console.error(e));
  * ```
  *
- * ### Receive an array of arguments passed to a callback
+ * Receive an array of arguments passed to a callback
+ *
  * ```ts
  * import { bindCallback } from 'rxjs';
  *
@@ -96,7 +98,8 @@ export function bindCallback<A extends readonly unknown[], R extends readonly un
  * });
  * ```
  *
- * ### Compare behaviour with and without async Scheduler
+ * Compare behaviour with and without `asyncScheduler`
+ *
  * ```ts
  * import { bindCallback, asyncScheduler } from 'rxjs';
  *
@@ -117,7 +120,8 @@ export function bindCallback<A extends readonly unknown[], R extends readonly un
  * // I was async!
  * ```
  *
- * ### Use bindCallback on an object method
+ * Use `bindCallback` on an object method
+ *
  * ```ts
  * import { bindCallback } from 'rxjs';
  *
@@ -130,11 +134,11 @@ export function bindCallback<A extends readonly unknown[], R extends readonly un
  * @see {@link bindNodeCallback}
  * @see {@link from}
  *
- * @param {function} func A function with a callback as the last parameter.
- * @param {SchedulerLike} [scheduler] The scheduler on which to schedule the
- * callbacks.
- * @return {function(...params: *): Observable} A function which returns the
- * Observable that delivers the same values the callback would deliver.
+ * @param callbackFunc A function with a callback as the last parameter.
+ * @param resultSelector A mapping function used to transform callback events.
+ * @param scheduler The scheduler on which to schedule the callbacks.
+ * @return A function which returns the Observable that delivers the same
+ * values the callback would deliver.
  */
 export function bindCallback(
   callbackFunc: (...args: [...any[], (...res: any) => void]) => void,

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

@@ -74,7 +74,9 @@ export function bindNodeCallback<A extends readonly unknown[], R extends readonl
  * is falsy, it still won't appear in array emitted by Observable.
  *
  * ## Examples
- * ###  Read a file from the filesystem and get the data as an Observable
+ *
+ *  Read a file from the filesystem and get the data as an Observable
+ *
  * ```ts
  * import * as fs from 'fs';
  * const readFileAsObservable = bindNodeCallback(fs.readFile);
@@ -82,7 +84,8 @@ export function bindNodeCallback<A extends readonly unknown[], R extends readonl
  * result.subscribe(x => console.log(x), e => console.error(e));
  * ```
  *
- * ### Use on function calling callback with multiple arguments
+ * Use on function calling callback with multiple arguments
+ *
  * ```ts
  * someFunction((err, a, b) => {
  *   console.log(err); // null
@@ -96,7 +99,8 @@ export function bindNodeCallback<A extends readonly unknown[], R extends readonl
  * });
  * ```
  *
- * ### Use on function calling callback in regular style
+ * Use on function calling callback in regular style
+ *
  * ```ts
  * someFunction(a => {
  *   console.log(a); // 5
@@ -112,12 +116,11 @@ export function bindNodeCallback<A extends readonly unknown[], R extends readonl
  * @see {@link bindCallback}
  * @see {@link from}
  *
- * @param {function} func Function with a Node.js-style callback as the last parameter.
- * @param {SchedulerLike} [scheduler] The scheduler on which to schedule the
- * callbacks.
- * @return {function(...params: *): Observable} A function which returns the
- * Observable that delivers the same values the Node.js callback would
- * deliver.
+ * @param callbackFunc Function with a Node.js-style callback as the last parameter.
+ * @param resultSelector A mapping function used to transform callback events.
+ * @param scheduler The scheduler on which to schedule the callbacks.
+ * @return A function which returns the Observable that delivers the same values the
+ * Node.js callback would deliver.
  */
 export function bindNodeCallback(
   callbackFunc: (...args: [...any[], (err: any, ...res: any) => void]) => void,

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

@@ -188,15 +188,11 @@ export function combineLatest<T extends Record<string, ObservableInput<any>>>(
  * @see {@link merge}
  * @see {@link withLatestFrom}
  *
- * @param {ObservableInput} [observables] An array of input Observables to combine with each other.
- * An array of Observables must be given as the first argument.
- * @param {function} [project] An optional function to project the values from
- * the combined latest values into a new value on the output Observable.
- * @param {SchedulerLike} [scheduler=null] The {@link SchedulerLike} to use for subscribing to
- * each input Observable.
- * @return {Observable} An Observable of projected values from the most recent
- * values from each input Observable, or an array of the most recent values from
- * each input Observable.
+ * @param args Any number of `ObservableInput`s provided either as an array or as an object
+ * to combine with each other. If the last parameter is the function, it will be used to project the
+ * values from the combined latest values into a new value on the output Observable.
+ * @return An Observable of projected values from the most recent values from each `ObservableInput`,
+ * or an array of the most recent values from each `ObservableInput`.
  */
 export function combineLatest<O extends ObservableInput<any>, R>(...args: any[]): Observable<R> | Observable<ObservedValueOf<O>[]> {
   const scheduler = popScheduler(args);

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

@@ -108,7 +108,7 @@ export function concat<T extends readonly unknown[]>(
  * @see {@link startWith}
  * @see {@link endWith}
  *
- * @param args Input Observables to concatenate.
+ * @param args `ObservableInput`s to concatenate.
  */
 export function concat(...args: any[]): Observable<unknown> {
   return concatAll()(from(args, popScheduler(args)));

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

@@ -43,12 +43,11 @@ import { innerFrom } from './innerFrom';
  *
  * @see {@link Observable}
  *
- * @param {function(): ObservableInput} observableFactory The Observable
- * factory function to invoke for each Observer that subscribes to the output
- * Observable. May also return a Promise, which will be converted on the fly
- * to an Observable.
- * @return {Observable} An Observable whose Observers' subscriptions trigger
- * an invocation of the given Observable factory function.
+ * @param observableFactory The Observable factory function to invoke for each
+ * Observer that subscribes to the output Observable. May also return any
+ * `ObservableInput`, which will be converted on the fly to an Observable.
+ * @return An Observable whose Observers' subscriptions trigger an invocation of the
+ * given Observable factory function.
  */
 export function defer<R extends ObservableInput<any>>(observableFactory: () => R): Observable<ObservedValueOf<R>> {
   return new Observable<ObservedValueOf<R>>((subscriber) => {

package/node_modules/rxjs/src/internal/observable/dom/webSocket.ts

@@ -153,9 +153,8 @@ import { WebSocketSubject, WebSocketSubjectConfig } from './WebSocketSubject';
  * // socket connection closes.
  * ```
  *
- * @param {string|WebSocketSubjectConfig} urlConfigOrSource The WebSocket endpoint as an url or an object with
- * configuration and additional Observers.
- * @return {WebSocketSubject} Subject which allows to both send and receive messages via WebSocket connection.
+ * @param urlConfigOrSource The WebSocket endpoint as an url or an object with configuration and additional Observers.
+ * @return Subject which allows to both send and receive messages via WebSocket connection.
  */
 export function webSocket<T>(urlConfigOrSource: string | WebSocketSubjectConfig<T>): WebSocketSubject<T> {
   return new WebSocketSubject<T>(urlConfigOrSource);

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

@@ -137,11 +137,9 @@ export function forkJoin<T extends Record<string, ObservableInput<any>>>(
  * @see {@link combineLatest}
  * @see {@link zip}
  *
- * @param {...ObservableInput} args Any number of Observables provided either as an array or as an arguments
- * passed directly to the operator.
- * @param {function} [project] Function that takes values emitted by input Observables and returns value
- * that will appear in resulting Observable instead of default array.
- * @return {Observable} Observable emitting either an array of last values emitted by passed Observables
+ * @param args Any number of `ObservableInput`s provided either as an array, as an object
+ * or as arguments passed directly to the operator.
+ * @return Observable emitting either an array of last values emitted by passed Observables
  * or value from project function.
  */
 export function forkJoin(...args: any[]): Observable<any> {

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

@@ -94,10 +94,10 @@ export function from<O extends ObservableInput<any>>(input: O, scheduler: Schedu
  * @see {@link fromEvent}
  * @see {@link fromEventPattern}
  *
- * @param {ObservableInput<T>} A subscription object, a Promise, an Observable-like,
+ * @param input A subscription object, a Promise, an Observable-like,
  * an Array, an iterable, or an array-like object to be converted.
- * @param {SchedulerLike} An optional {@link SchedulerLike} on which to schedule the emission of values.
- * @return {Observable<T>}
+ * @param scheduler An optional {@link SchedulerLike} on which to schedule the emission of values.
+ * @return An Observable converted from {@link ObservableInput}.
  */
 export function from<T>(input: ObservableInput<T>, scheduler?: SchedulerLike): Observable<T> {
   return scheduler ? scheduled(input, scheduler) : innerFrom(input);

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

@@ -227,12 +227,15 @@ export function fromEvent<T, R>(
  * @see {@link bindNodeCallback}
  * @see {@link fromEventPattern}
  *
- * @param {FromEventTarget<T>} target The DOM EventTarget, Node.js
- * EventEmitter, JQuery-like event target, NodeList or HTMLCollection to attach the event handler to.
- * @param {string} eventName The event name of interest, being emitted by the
- * `target`.
- * @param {EventListenerOptions} [options] Options to pass through to addEventListener
- * @return {Observable<T>}
+ * @param target The DOM EventTarget, Node.js EventEmitter, JQuery-like event target,
+ * NodeList or HTMLCollection to attach the event handler to.
+ * @param eventName The event name of interest, being emitted by the `target`.
+ * @param options Options to pass through to the underlying `addListener`,
+ * `addEventListener` or `on` functions.
+ * @param resultSelector A mapping function used to transform events. It takes the
+ * arguments from the event handler and should return a single value.
+ * @return An Observable emitting events registered through `target`'s
+ * listener handlers.
  */
 export function fromEvent<T>(
   target: any,

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

@@ -125,18 +125,15 @@ export function fromEventPattern<T>(
  * @see {@link bindCallback}
  * @see {@link bindNodeCallback}
  *
- * @param {function(handler: Function): any} addHandler A function that takes
- * a `handler` function as argument and attaches it somehow to the actual
- * source of events.
- * @param {function(handler: Function, token?: any): void} [removeHandler] A function that
- * takes a `handler` function as an argument and removes it from the event source. If `addHandler`
- * returns some kind of token, `removeHandler` function will have it as a second parameter.
- * @param {function(...args: any): T} [project] A function to
- * transform results. It takes the arguments from the event handler and
- * should return a single value.
- * @return {Observable<T>} Observable which, when an event happens, emits first parameter
- * passed to registered event handler. Alternatively it emits whatever project function returns
- * at that moment.
+ * @param addHandler A function that takes a `handler` function as argument and attaches it
+ * somehow to the actual source of events.
+ * @param removeHandler A function that takes a `handler` function as an argument and removes
+ * it from the event source. If `addHandler` returns some kind of token, `removeHandler` function
+ * will have it as a second parameter.
+ * @param resultSelector A function to transform results. It takes the arguments from the event
+ * handler and should return a single value.
+ * @return Observable which, when an event happens, emits first parameter passed to registered
+ * event handler. Alternatively it emits whatever project function returns at that moment.
  */
 export function fromEventPattern<T>(
   addHandler: (handler: NodeEventHandler) => any,

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

@@ -80,13 +80,15 @@ export interface GenerateOptions<T, S> extends GenerateBaseOptions<S> {
  * @see {@link from}
  * @see {@link Observable}
  *
- * @param {S} initialState Initial state.
- * @param {function (state: S): boolean} condition Condition to terminate generation (upon returning false).
- * @param {function (state: S): S} iterate Iteration step function.
- * @param {function (state: S): T} resultSelector Selector function for results produced in the sequence. (deprecated)
- * @param {SchedulerLike} [scheduler] A {@link SchedulerLike} on which to run the generator loop. If not provided, defaults to emit immediately.
- * @returns {Observable<T>} The generated sequence.
- * @deprecated Instead of passing separate arguments, use the options argument. Signatures taking separate arguments will be removed in v8.
+ * @param initialState Initial state.
+ * @param condition Condition to terminate generation (upon returning false).
+ * @param iterate Iteration step function.
+ * @param resultSelector Selector function for results produced in the sequence.
+ * @param scheduler A {@link SchedulerLike} on which to run the generator loop.
+ * If not provided, defaults to emit immediately.
+ * @returns The generated sequence.
+ * @deprecated Instead of passing separate arguments, use the options argument.
+ * Signatures taking separate arguments will be removed in v8.
  */
 export function generate<T, S>(
   initialState: S,
@@ -230,13 +232,14 @@ export function generate<T, S>(
  *
  * @see {@link from}
  *
- * @param {S} initialState Initial state.
- * @param {function (state: S): boolean} condition Condition to terminate generation (upon returning false).
- * @param {function (state: S): S} iterate Iteration step function.
- * @param {function (state: S): T} [resultSelector] Selector function for results produced in the sequence.
- * @param {Scheduler} [scheduler] A {@link Scheduler} on which to run the generator loop. If not provided, defaults to emitting immediately.
- * @return {Observable<T>} The generated sequence.
- * @deprecated Instead of passing separate arguments, use the options argument. Signatures taking separate arguments will be removed in v8.
+ * @param initialState Initial state.
+ * @param condition Condition to terminate generation (upon returning false).
+ * @param iterate Iteration step function.
+ * @param scheduler A {@link Scheduler} on which to run the generator loop. If not
+ * provided, defaults to emitting immediately.
+ * @return The generated sequence.
+ * @deprecated Instead of passing separate arguments, use the options argument.
+ * Signatures taking separate arguments will be removed in v8.
  */
 export function generate<S>(
   initialState: S,
@@ -282,8 +285,8 @@ export function generate<S>(
  * @see {@link from}
  * @see {@link Observable}
  *
- * @param {GenerateBaseOptions<S>} options Object that must contain initialState, iterate and might contain condition and scheduler.
- * @returns {Observable<S>} The generated sequence.
+ * @param options Object that must contain initialState, iterate and might contain condition and scheduler.
+ * @returns The generated sequence.
  */
 export function generate<S>(options: GenerateBaseOptions<S>): Observable<S>;
 
@@ -325,8 +328,8 @@ export function generate<S>(options: GenerateBaseOptions<S>): Observable<S>;
  * @see {@link from}
  * @see {@link Observable}
  *
- * @param {GenerateOptions<T, S>} options Object that must contain initialState, iterate, resultSelector and might contain condition and scheduler.
- * @returns {Observable<T>} The generated sequence.
+ * @param options Object that must contain initialState, iterate, resultSelector and might contain condition and scheduler.
+ * @returns The generated sequence.
  */
 export function generate<T, S>(options: GenerateOptions<T, S>): Observable<T>;
 

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

@@ -41,12 +41,11 @@ import { timer } from './timer';
  * @see {@link timer}
  * @see {@link delay}
  *
- * @param {number} [period=0] The interval size in milliseconds (by default)
- * or the time unit determined by the scheduler's clock.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for scheduling
- * the emission of values, and providing a notion of "time".
- * @return {Observable} An Observable that emits a sequential number each time
- * interval.
+ * @param period The interval size in milliseconds (by default) or the time unit determined
+ * by the scheduler's clock.
+ * @param scheduler The {@link SchedulerLike} to use for scheduling the emission of values,
+ * and providing a notion of "time".
+ * @return An Observable that emits a sequential number each time interval.
  */
 export function interval(period = 0, scheduler: SchedulerLike = asyncScheduler): Observable<number> {
   if (period < 0) {

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

@@ -79,13 +79,11 @@ export function merge<A extends readonly unknown[]>(
  * @see {@link mergeMapTo}
  * @see {@link mergeScan}
  *
- * @param {...ObservableInput} observables Input Observables to merge together.
- * @param {number} [concurrent=Infinity] Maximum number of input
- * Observables being subscribed to concurrently.
- * @param {SchedulerLike} [scheduler=null] The {@link SchedulerLike} to use for managing
- * concurrency of input Observables.
- * @return {Observable} an Observable that emits items that are the result of
- * every input Observable.
+ * @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);

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

@@ -73,9 +73,9 @@ export function of<A extends readonly unknown[]>(...values: A): Observable<Value
  * @see {@link from}
  * @see {@link range}
  *
- * @param {...T} values A comma separated list of arguments you want to be emitted
- * @return {Observable} An Observable that emits the arguments
- * described above and then completes.
+ * @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);

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

@@ -5,12 +5,9 @@ import { OperatorSubscriber } from '../operators/OperatorSubscriber';
 import { noop } from '../util/noop';
 import { innerFrom } from './innerFrom';
 
-/* tslint:disable:max-line-length */
 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]>;
 
-/* tslint:enable:max-line-length */
-
 /**
  * When any of the provided Observable emits a complete or an error notification, it immediately subscribes to the next one
  * that was passed.
@@ -69,8 +66,8 @@ export function onErrorResumeNext<A extends readonly unknown[]>(...sources: [...
  * @see {@link concat}
  * @see {@link catchError}
  *
- * @param {...ObservableInput} sources Observables (or anything that *is* observable) passed either directly or as an array.
- * @return {Observable} An Observable that concatenates all sources, one after the other,
+ * @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[]>(

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

@@ -69,12 +69,10 @@ export function pairs(
  * 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 {Object} obj The object to inspect and turn into an
- * Observable sequence.
- * @param {Scheduler} [scheduler] An optional IScheduler to schedule
- * when resulting Observable will emit values.
- * @returns {(Observable<Array<string|T>>)} An observable sequence of
- * [key, value] pairs from the object.
+ * @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) {

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

@@ -64,17 +64,17 @@ export function partition<T>(source: ObservableInput<T>, predicate: (value: T, i
  *
  * @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.
- * @return {[Observable<T>, Observable<T>]} An array with two Observables: one
- * with values that passed the predicate, and another with values that did not
- * pass the predicate.
+ * @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>,

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

@@ -45,8 +45,8 @@ export function race<T extends readonly unknown[]>(...inputs: [...ObservableInpu
  * // a series of 'fast one'
  * ```
  *
- * @param {...Observables} ...observables sources used to race for which Observable emits first.
- * @return {Observable} an Observable that mirrors the output of the first Observable to emit an item.
+ * @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);

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

@@ -46,12 +46,11 @@ export function range(start: number, count: number | undefined, scheduler: Sched
  * @see {@link timer}
  * @see {@link interval}
  *
- * @param {number} [start=0] The value of the first integer in the sequence.
- * @param {number} count The number of sequential integers to generate.
- * @param {SchedulerLike} [scheduler] A {@link SchedulerLike} to use for scheduling
- * the emissions of the notifications.
- * @return {Observable} An Observable of numbers that emits a finite range of
- * sequential integers.
+ * @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) {

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

@@ -24,11 +24,9 @@ import { EMPTY } from './empty';
  *
  * @see {@link defer}
  *
- * @param {function(): ISubscription} resourceFactory A function which creates any resource object
- * that implements `unsubscribe` method.
- * @param {function(resource: ISubscription): Observable<T>} observableFactory A function which
- * creates an Observable, that can use injected resource object.
- * @return {Observable<T>} An Observable that behaves the same as Observable returned by `observableFactory`, but
+ * @param resourceFactory A function which creates any resource object that implements `unsubscribe` method.
+ * @param observableFactory A function which creates an Observable, that can use injected resource object.
+ * @return An Observable that behaves the same as Observable returned by `observableFactory`, but
  * which - when completed, errored or unsubscribed - will also call `unsubscribe` on created resource object.
  */
 export function using<T extends ObservableInput<any>>(

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

@@ -45,8 +45,10 @@ export function zip<A extends readonly unknown[], R>(
  * // { age: 29, name: 'Beer', isDev: false }
  * ```
  *
- * @param sources
- * @return {Observable<R>}
+ * @param args Any number of `ObservableInput`s provided either as an array or as an object
+ * to combine with each other.
+ * @return An Observable of array values of the values emitted at the same index from each
+ * individual `ObservableInput`.
  */
 export function zip(...args: unknown[]): Observable<unknown> {
   const resultSelector = popResultSelector(args);

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

@@ -42,11 +42,11 @@ import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
  * @see {@link sampleTime}
  * @see {@link throttleTime}
  *
- * @param {number} duration Time to wait before emitting the most recent source
- * value, measured 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 rate-limiting behavior.
+ * @param duration Time to wait before emitting the most recent source value,
+ * measured 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 rate-limiting behavior.
  * @return A function that returns an Observable that performs rate-limiting of
  * emissions from the source Observable.
  */

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

@@ -47,8 +47,8 @@ import { arrRemove } from '../util/arrRemove';
  * @see {@link pairwise}
  * @see {@link windowCount}
  *
- * @param {number} bufferSize The maximum size of the buffer emitted.
- * @param {number} [startBufferEvery] Interval at which to start a new buffer.
+ * @param bufferSize The maximum size of the buffer emitted.
+ * @param startBufferEvery Interval at which to start a new buffer.
  * For example if `startBufferEvery` is `2`, then a new buffer will be started
  * on every other value from the source. A new buffer is started at the
  * beginning of the source by default.

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

@@ -7,7 +7,6 @@ import { asyncScheduler } from '../scheduler/async';
 import { popScheduler } from '../util/args';
 import { executeSchedule } from '../util/executeSchedule';
 
-/* tslint:disable:max-line-length */
 export function bufferTime<T>(bufferTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
 export function bufferTime<T>(
   bufferTimeSpan: number,
@@ -20,7 +19,6 @@ export function bufferTime<T>(
   maxBufferSize: number,
   scheduler?: SchedulerLike
 ): OperatorFunction<T, T[]>;
-/* tslint:enable:max-line-length */
 
 /**
  * Buffers the source Observable values for a specific time period.
@@ -67,12 +65,11 @@ export function bufferTime<T>(
  * @see {@link bufferWhen}
  * @see {@link windowTime}
  *
- * @param {number} bufferTimeSpan The amount of time to fill each buffer array.
- * @param {number} [bufferCreationInterval] The interval at which to start new
- * buffers.
- * @param {number} [maxBufferSize] The maximum buffer size.
- * @param {SchedulerLike} [scheduler=async] The scheduler on which to schedule the
- * intervals that determine buffer boundaries.
+ * @param bufferTimeSpan The amount of time to fill each buffer array.
+ * @param otherArgs Other configuration arguments such as:
+ * - `bufferCreationInterval` - the interval at which to start new buffers;
+ * - `maxBufferSize` - the maximum buffer size;
+ * - `scheduler` - the scheduler on which to schedule the intervals that determine buffer boundaries.
  * @return A function that returns an Observable of arrays of buffered values.
  */
 export function bufferTime<T>(bufferTimeSpan: number, ...otherArgs: any[]): OperatorFunction<T, T[]> {

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

@@ -39,8 +39,8 @@ import { innerFrom } from '../observable/innerFrom';
  * @see {@link bufferToggle}
  * @see {@link windowWhen}
  *
- * @param {function(): Observable} closingSelector A function that takes no
- * arguments and returns an Observable that signals buffer closure.
+ * @param closingSelector A function that takes no arguments and returns an
+ * Observable that signals buffer closure.
  * @return A function that returns an Observable of arrays of buffered values.
  */
 export function bufferWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, T[]> {

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

@@ -6,11 +6,9 @@ import { innerFrom } from '../observable/innerFrom';
 import { createOperatorSubscriber } from './OperatorSubscriber';
 import { operate } from '../util/lift';
 
-/* tslint:disable:max-line-length */
 export function catchError<T, O extends ObservableInput<any>>(
   selector: (err: any, caught: Observable<T>) => O
 ): OperatorFunction<T, T | ObservedValueOf<O>>;
-/* tslint:enable:max-line-length */
 
 /**
  * Catches errors on the observable to be handled by returning a new observable or throwing an error.
@@ -98,9 +96,9 @@ export function catchError<T, O extends ObservableInput<any>>(
  * @see {@link retry }
  * @see {@link retryWhen}
  *
- * @param {function} selector a function that takes as arguments `err`, which is the error, and `caught`, which
- * is the source observable, in case you'd like to "retry" that observable by returning it again. Whatever observable
- * is returned by the `selector` will be used to continue the observable chain.
+ * @param selector A function that takes as arguments `err`, which is the error, and `caught`, which
+ * is the source observable, in case you'd like to "retry" that observable by returning it again.
+ * Whatever observable is returned by the `selector` will be used to continue the observable chain.
  * @return A function that returns an Observable that originates from either
  * the source or the Observable returned by the `selector` function.
  */