lambda-live-debugger 1.12.2 → 1.12.4

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

@@ -1,73 +0,0 @@
-import { Notification } from '../Notification';
-import { OperatorFunction, ObservableNotification } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Represents all of the notifications from the source Observable as `next`
- * emissions marked with their original types within {@link Notification}
- * objects.
- *
- * <span class="informal">Wraps `next`, `error` and `complete` emissions in
- * {@link Notification} objects, emitted as `next` on the output Observable.
- * </span>
- *
- * ![](materialize.png)
- *
- * `materialize` returns an Observable that emits a `next` notification for each
- * `next`, `error`, or `complete` emission of the source Observable. When the
- * source Observable emits `complete`, the output Observable will emit `next` as
- * a Notification of type "complete", and then it will emit `complete` as well.
- * When the source Observable emits `error`, the output will emit `next` as a
- * Notification of type "error", and then `complete`.
- *
- * This operator is useful for producing metadata of the source Observable, to
- * be consumed as `next` emissions. Use it in conjunction with
- * {@link dematerialize}.
- *
- * ## Example
- *
- * Convert a faulty Observable to an Observable of Notifications
- *
- * ```ts
- * import { of, materialize, map } from 'rxjs';
- *
- * const letters = of('a', 'b', 13, 'd');
- * const upperCase = letters.pipe(map((x: any) => x.toUpperCase()));
- * const materialized = upperCase.pipe(materialize());
- *
- * materialized.subscribe(x => console.log(x));
- *
- * // Results in the following:
- * // - Notification { kind: 'N', value: 'A', error: undefined, hasValue: true }
- * // - Notification { kind: 'N', value: 'B', error: undefined, hasValue: true }
- * // - Notification { kind: 'E', value: undefined, error: TypeError { message: x.toUpperCase is not a function }, hasValue: false }
- * ```
- *
- * @see {@link Notification}
- * @see {@link dematerialize}
- *
- * @return A function that returns an Observable that emits
- * {@link Notification} objects that wrap the original emissions from the
- * source Observable with metadata.
- */
-export function materialize<T>(): OperatorFunction<T, Notification<T> & ObservableNotification<T>> {
-  return operate((source, subscriber) => {
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => {
-          subscriber.next(Notification.createNext(value));
-        },
-        () => {
-          subscriber.next(Notification.createComplete());
-          subscriber.complete();
-        },
-        (err) => {
-          subscriber.next(Notification.createError(err));
-          subscriber.complete();
-        }
-      )
-    );
-  });
-}

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

@@ -1,54 +0,0 @@
-import { reduce } from './reduce';
-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.
- *
- * ![](max.png)
- *
- * ## Examples
- *
- * Get the maximal value of a series of numbers
- *
- * ```ts
- * import { of, max } from 'rxjs';
- *
- * of(5, 4, 7, 2, 8)
- *   .pipe(max())
- *   .subscribe(x => console.log(x));
- *
- * // Outputs
- * // 8
- * ```
- *
- * Use a comparer function to get the maximal item
- *
- * ```ts
- * import { of, max } from 'rxjs';
- *
- * of(
- *   { age: 7, name: 'Foo' },
- *   { age: 5, name: 'Bar' },
- *   { age: 9, name: 'Beer' }
- * ).pipe(
- *   max((a, b) => a.age < b.age ? -1 : 1)
- * )
- * .subscribe(x => console.log(x.name));
- *
- * // Outputs
- * // 'Beer'
- * ```
- *
- * @see {@link min}
- *
- * @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.
- */
-export function max<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> {
-  return reduce(isFunction(comparer) ? (x, y) => (comparer(x, y) > 0 ? x : y) : (x, y) => (x > y ? x : y));
-}

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

@@ -1,29 +0,0 @@
-import { ObservableInput, ObservableInputTuple, OperatorFunction, SchedulerLike } from '../types';
-import { operate } from '../util/lift';
-import { mergeAll } from './mergeAll';
-import { popNumber, popScheduler } from '../util/args';
-import { from } from '../observable/from';
-
-/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */
-export function merge<T, A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */
-export function merge<T, A extends readonly unknown[]>(
-  ...sourcesAndConcurrency: [...ObservableInputTuple<A>, number]
-): OperatorFunction<T, T | A[number]>;
-/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */
-export function merge<T, A extends readonly unknown[]>(
-  ...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike]
-): OperatorFunction<T, T | A[number]>;
-/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */
-export function merge<T, A extends readonly unknown[]>(
-  ...sourcesAndConcurrencyAndScheduler: [...ObservableInputTuple<A>, number, SchedulerLike]
-): OperatorFunction<T, T | A[number]>;
-
-export function merge<T>(...args: unknown[]): OperatorFunction<T, unknown> {
-  const scheduler = popScheduler(args);
-  const concurrent = popNumber(args, Infinity);
-
-  return operate((source, subscriber) => {
-    mergeAll(concurrent)(from([source, ...(args as ObservableInput<T>[])], scheduler)).subscribe(subscriber);
-  });
-}

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

@@ -1,66 +0,0 @@
-import { mergeMap } from './mergeMap';
-import { identity } from '../util/identity';
-import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-
-/**
- * Converts a higher-order Observable into a first-order Observable which
- * concurrently delivers all values that are emitted on the inner Observables.
- *
- * <span class="informal">Flattens an Observable-of-Observables.</span>
- *
- * ![](mergeAll.png)
- *
- * `mergeAll` subscribes to an Observable that emits Observables, also known as
- * a higher-order Observable. Each time it observes one of these emitted inner
- * Observables, it subscribes to that and delivers all the values from the
- * inner Observable on the output Observable. The output Observable only
- * completes once all inner Observables have completed. Any error delivered by
- * a inner Observable will be immediately emitted on the output Observable.
- *
- * ## Examples
- *
- * Spawn a new interval Observable for each click event, and blend their outputs as one Observable
- *
- * ```ts
- * import { fromEvent, map, interval, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const higherOrder = clicks.pipe(map(() => interval(1000)));
- * const firstOrder = higherOrder.pipe(mergeAll());
- *
- * firstOrder.subscribe(x => console.log(x));
- * ```
- *
- * Count from 0 to 9 every second for each click, but only allow 2 concurrent timers
- *
- * ```ts
- * import { fromEvent, map, interval, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const higherOrder = clicks.pipe(
- *   map(() => interval(1000).pipe(take(10)))
- * );
- * const firstOrder = higherOrder.pipe(mergeAll(2));
- *
- * firstOrder.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link combineLatestAll}
- * @see {@link concatAll}
- * @see {@link exhaustAll}
- * @see {@link merge}
- * @see {@link mergeMap}
- * @see {@link mergeMapTo}
- * @see {@link mergeScan}
- * @see {@link switchAll}
- * @see {@link switchMap}
- * @see {@link zipAll}
- *
- * @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.
- */
-export function mergeAll<O extends ObservableInput<any>>(concurrent: number = Infinity): OperatorFunction<O, ObservedValueOf<O>> {
-  return mergeMap(identity, concurrent);
-}

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

@@ -1,149 +0,0 @@
-import { Observable } from '../Observable';
-import { innerFrom } from '../observable/innerFrom';
-import { Subscriber } from '../Subscriber';
-import { ObservableInput, SchedulerLike } from '../types';
-import { executeSchedule } from '../util/executeSchedule';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * A process embodying the general "merge" strategy. This is used in
- * `mergeMap` and `mergeScan` because the logic is otherwise nearly identical.
- * @param source The original source observable
- * @param subscriber The consumer subscriber
- * @param project The projection function to get our inner sources
- * @param concurrent The number of concurrent inner subscriptions
- * @param onBeforeNext Additional logic to apply before nexting to our consumer
- * @param expand If `true` this will perform an "expand" strategy, which differs only
- * in that it recurses, and the inner subscription must be schedule-able.
- * @param innerSubScheduler A scheduler to use to schedule inner subscriptions,
- * this is to support the expand strategy, mostly, and should be deprecated
- */
-export function mergeInternals<T, R>(
-  source: Observable<T>,
-  subscriber: Subscriber<R>,
-  project: (value: T, index: number) => ObservableInput<R>,
-  concurrent: number,
-  onBeforeNext?: (innerValue: R) => void,
-  expand?: boolean,
-  innerSubScheduler?: SchedulerLike,
-  additionalFinalizer?: () => void
-) {
-  // Buffered values, in the event of going over our concurrency limit
-  const buffer: T[] = [];
-  // The number of active inner subscriptions.
-  let active = 0;
-  // An index to pass to our accumulator function
-  let index = 0;
-  // Whether or not the outer source has completed.
-  let isComplete = false;
-
-  /**
-   * Checks to see if we can complete our result or not.
-   */
-  const checkComplete = () => {
-    // If the outer has completed, and nothing is left in the buffer,
-    // and we don't have any active inner subscriptions, then we can
-    // Emit the state and complete.
-    if (isComplete && !buffer.length && !active) {
-      subscriber.complete();
-    }
-  };
-
-  // If we're under our concurrency limit, just start the inner subscription, otherwise buffer and wait.
-  const outerNext = (value: T) => (active < concurrent ? doInnerSub(value) : buffer.push(value));
-
-  const doInnerSub = (value: T) => {
-    // If we're expanding, we need to emit the outer values and the inner values
-    // as the inners will "become outers" in a way as they are recursively fed
-    // back to the projection mechanism.
-    expand && subscriber.next(value as any);
-
-    // Increment the number of active subscriptions so we can track it
-    // against our concurrency limit later.
-    active++;
-
-    // A flag used to show that the inner observable completed.
-    // This is checked during finalization to see if we should
-    // move to the next item in the buffer, if there is on.
-    let innerComplete = false;
-
-    // Start our inner subscription.
-    innerFrom(project(value, index++)).subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (innerValue) => {
-          // `mergeScan` has additional handling here. For example
-          // taking the inner value and updating state.
-          onBeforeNext?.(innerValue);
-
-          if (expand) {
-            // If we're expanding, then just recurse back to our outer
-            // handler. It will emit the value first thing.
-            outerNext(innerValue as any);
-          } else {
-            // Otherwise, emit the inner value.
-            subscriber.next(innerValue);
-          }
-        },
-        () => {
-          // Flag that we have completed, so we know to check the buffer
-          // during finalization.
-          innerComplete = true;
-        },
-        // Errors are passed to the destination.
-        undefined,
-        () => {
-          // During finalization, if the inner completed (it wasn't errored or
-          // cancelled), then we want to try the next item in the buffer if
-          // there is one.
-          if (innerComplete) {
-            // We have to wrap this in a try/catch because it happens during
-            // finalization, possibly asynchronously, and we want to pass
-            // any errors that happen (like in a projection function) to
-            // the outer Subscriber.
-            try {
-              // INNER SOURCE COMPLETE
-              // Decrement the active count to ensure that the next time
-              // we try to call `doInnerSub`, the number is accurate.
-              active--;
-              // If we have more values in the buffer, try to process those
-              // Note that this call will increment `active` ahead of the
-              // next conditional, if there were any more inner subscriptions
-              // to start.
-              while (buffer.length && active < concurrent) {
-                const bufferedValue = buffer.shift()!;
-                // Particularly for `expand`, we need to check to see if a scheduler was provided
-                // for when we want to start our inner subscription. Otherwise, we just start
-                // are next inner subscription.
-                if (innerSubScheduler) {
-                  executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue));
-                } else {
-                  doInnerSub(bufferedValue);
-                }
-              }
-              // Check to see if we can complete, and complete if so.
-              checkComplete();
-            } catch (err) {
-              subscriber.error(err);
-            }
-          }
-        }
-      )
-    );
-  };
-
-  // Subscribe to our source observable.
-  source.subscribe(
-    createOperatorSubscriber(subscriber, outerNext, () => {
-      // Outer completed, make a note of it, and check to see if we can complete everything.
-      isComplete = true;
-      checkComplete();
-    })
-  );
-
-  // Additional finalization (for when the destination is torn down).
-  // Other finalization is added implicitly via subscription above.
-  return () => {
-    additionalFinalizer?.();
-  };
-}

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

@@ -1,94 +0,0 @@
-import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
-import { map } from './map';
-import { innerFrom } from '../observable/innerFrom';
-import { operate } from '../util/lift';
-import { mergeInternals } from './mergeInternals';
-import { isFunction } from '../util/isFunction';
-
-/* tslint:disable:max-line-length */
-export function mergeMap<T, O extends ObservableInput<any>>(
-  project: (value: T, index: number) => O,
-  concurrent?: number
-): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export function mergeMap<T, O extends ObservableInput<any>>(
-  project: (value: T, index: number) => O,
-  resultSelector: undefined,
-  concurrent?: number
-): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export function mergeMap<T, R, O extends ObservableInput<any>>(
-  project: (value: T, index: number) => O,
-  resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R,
-  concurrent?: number
-): OperatorFunction<T, R>;
-/* tslint:enable:max-line-length */
-
-/**
- * Projects each source value to an Observable which is merged in the output
- * Observable.
- *
- * <span class="informal">Maps each value to an Observable, then flattens all of
- * these inner Observables using {@link mergeAll}.</span>
- *
- * ![](mergeMap.png)
- *
- * Returns an Observable that emits items based on applying a function that you
- * supply to each item emitted by the source Observable, where that function
- * returns an Observable, and then merging those resulting Observables and
- * emitting the results of this merger.
- *
- * ## Example
- *
- * Map and flatten each letter to an Observable ticking every 1 second
- *
- * ```ts
- * import { of, mergeMap, interval, map } from 'rxjs';
- *
- * const letters = of('a', 'b', 'c');
- * const result = letters.pipe(
- *   mergeMap(x => interval(1000).pipe(map(i => x + i)))
- * );
- *
- * result.subscribe(x => console.log(x));
- *
- * // Results in the following:
- * // a0
- * // b0
- * // c0
- * // a1
- * // b1
- * // c1
- * // continues to list a, b, c every second with respective ascending integers
- * ```
- *
- * @see {@link concatMap}
- * @see {@link exhaustMap}
- * @see {@link merge}
- * @see {@link mergeAll}
- * @see {@link mergeMapTo}
- * @see {@link mergeScan}
- * @see {@link switchMap}
- *
- * @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
- * the results of the Observables obtained from this transformation.
- */
-export function mergeMap<T, R, O extends ObservableInput<any>>(
-  project: (value: T, index: number) => O,
-  resultSelector?: ((outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R) | number,
-  concurrent: number = Infinity
-): OperatorFunction<T, ObservedValueOf<O> | R> {
-  if (isFunction(resultSelector)) {
-    // DEPRECATED PATH
-    return mergeMap((a, i) => map((b: any, ii: number) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent);
-  } else if (typeof resultSelector === 'number') {
-    concurrent = resultSelector;
-  }
-
-  return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent));
-}

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

@@ -1,74 +0,0 @@
-import { OperatorFunction, ObservedValueOf, ObservableInput } from '../types';
-import { mergeMap } from './mergeMap';
-import { isFunction } from '../util/isFunction';
-
-/** @deprecated Will be removed in v9. Use {@link mergeMap} instead: `mergeMap(() => result)` */
-export function mergeMapTo<O extends ObservableInput<unknown>>(
-  innerObservable: O,
-  concurrent?: number
-): OperatorFunction<unknown, ObservedValueOf<O>>;
-/**
- * @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead.
- * Details: https://rxjs.dev/deprecations/resultSelector
- */
-export function mergeMapTo<T, R, O extends ObservableInput<unknown>>(
-  innerObservable: O,
-  resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R,
-  concurrent?: number
-): OperatorFunction<T, R>;
-/* tslint:enable:max-line-length */
-
-/**
- * Projects each source value to the same Observable which is merged multiple
- * times in the output Observable.
- *
- * <span class="informal">It's like {@link mergeMap}, but maps each value always
- * to the same inner Observable.</span>
- *
- * ![](mergeMapTo.png)
- *
- * Maps each source value to the given Observable `innerObservable` regardless
- * of the source value, and then merges those resulting Observables into one
- * single Observable, which is the output Observable.
- *
- * ## Example
- *
- * For each click event, start an interval Observable ticking every 1 second
- *
- * ```ts
- * import { fromEvent, mergeMapTo, interval } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(mergeMapTo(interval(1000)));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link concatMapTo}
- * @see {@link merge}
- * @see {@link mergeAll}
- * @see {@link mergeMap}
- * @see {@link mergeScan}
- * @see {@link switchMapTo}
- *
- * @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)`
- */
-export function mergeMapTo<T, R, O extends ObservableInput<unknown>>(
-  innerObservable: O,
-  resultSelector?: ((outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R) | number,
-  concurrent: number = Infinity
-): OperatorFunction<T, ObservedValueOf<O> | R> {
-  if (isFunction(resultSelector)) {
-    return mergeMap(() => innerObservable, resultSelector, concurrent);
-  }
-  if (typeof resultSelector === 'number') {
-    concurrent = resultSelector;
-  }
-  return mergeMap(() => innerObservable, concurrent);
-}

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

@@ -1,92 +0,0 @@
-import { ObservableInput, OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { mergeInternals } from './mergeInternals';
-
-/**
- * Applies an accumulator function over the source Observable where the
- * accumulator function itself returns an Observable, then each intermediate
- * Observable returned is merged into the output Observable.
- *
- * <span class="informal">It's like {@link scan}, but the Observables returned
- * by the accumulator are merged into the outer Observable.</span>
- *
- * The first parameter of the `mergeScan` is an `accumulator` function which is
- * being called every time the source Observable emits a value. `mergeScan` will
- * subscribe to the value returned by the `accumulator` function and will emit
- * values to the subscriber emitted by inner Observable.
- *
- * The `accumulator` function is being called with three parameters passed to it:
- * `acc`, `value` and `index`. The `acc` parameter is used as the state parameter
- * whose value is initially set to the `seed` parameter (the second parameter
- * passed to the `mergeScan` operator).
- *
- * `mergeScan` internally keeps the value of the `acc` parameter: as long as the
- * source Observable emits without inner Observable emitting, the `acc` will be
- * set to `seed`. The next time the inner Observable emits a value, `mergeScan`
- * will internally remember it and it will be passed to the `accumulator`
- * function as `acc` parameter the next time source emits.
- *
- * The `value` parameter of the `accumulator` function is the value emitted by the
- * source Observable, while the `index` is a number which represent the order of the
- * current emission by the source Observable. It starts with 0.
- *
- * The last parameter to the `mergeScan` is the `concurrent` value which defaults
- * to Infinity. It represents the maximum number of inner Observable subscriptions
- * at a time.
- *
- * ## Example
- *
- * Count the number of click events
- *
- * ```ts
- * import { fromEvent, map, mergeScan, of } from 'rxjs';
- *
- * const click$ = fromEvent(document, 'click');
- * const one$ = click$.pipe(map(() => 1));
- * const seed = 0;
- * const count$ = one$.pipe(
- *   mergeScan((acc, one) => of(acc + one), seed)
- * );
- *
- * count$.subscribe(x => console.log(x));
- *
- * // Results:
- * // 1
- * // 2
- * // 3
- * // 4
- * // ...and so on for each click
- * ```
- *
- * @see {@link scan}
- * @see {@link switchScan}
- *
- * @param accumulator The accumulator function called on each source value.
- * @param seed The initial accumulation value.
- * @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>(
-  accumulator: (acc: R, value: T, index: number) => ObservableInput<R>,
-  seed: R,
-  concurrent = Infinity
-): OperatorFunction<T, R> {
-  return operate((source, subscriber) => {
-    // The accumulated state.
-    let state = seed;
-
-    return mergeInternals(
-      source,
-      subscriber,
-      (value, index) => accumulator(state, value, index),
-      concurrent,
-      (value) => {
-        state = value;
-      },
-      false,
-      undefined,
-      () => (state = null!)
-    );
-  });
-}

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

@@ -1,49 +0,0 @@
-import { ObservableInputTuple, OperatorFunction } from '../types';
-import { merge } from './merge';
-
-/**
- * Merge the values from all observables to a single observable result.
- *
- * Creates an observable, that when subscribed to, subscribes to the source
- * observable, and all other sources provided as arguments. All values from
- * every source are emitted from the resulting subscription.
- *
- * When all sources complete, the resulting observable will complete.
- *
- * When any source errors, the resulting observable will error.
- *
- * ## Example
- *
- * Joining all outputs from multiple user input event streams
- *
- * ```ts
- * import { fromEvent, map, mergeWith } from 'rxjs';
- *
- * const clicks$ = fromEvent(document, 'click').pipe(map(() => 'click'));
- * const mousemoves$ = fromEvent(document, 'mousemove').pipe(map(() => 'mousemove'));
- * const dblclicks$ = fromEvent(document, 'dblclick').pipe(map(() => 'dblclick'));
- *
- * mousemoves$
- *   .pipe(mergeWith(clicks$, dblclicks$))
- *   .subscribe(x => console.log(x));
- *
- * // result (assuming user interactions)
- * // 'mousemove'
- * // 'mousemove'
- * // 'mousemove'
- * // 'click'
- * // 'click'
- * // 'dblclick'
- * ```
- *
- * @see {@link merge}
- *
- * @param otherSources the sources to combine the current source with.
- * @return A function that returns an Observable that merges the values from
- * all given Observables.
- */
-export function mergeWith<T, A extends readonly unknown[]>(
-  ...otherSources: [...ObservableInputTuple<A>]
-): OperatorFunction<T, T | A[number]> {
-  return merge(...otherSources);
-}