@bleedingdev/modern-js-utils 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/compiled/inquirer/rxjs/internal/operators/distinctUntilKeyChanged.d.ts

@@ -1,4 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-export declare function distinctUntilKeyChanged<T>(key: keyof T): MonoTypeOperatorFunction<T>;
-export declare function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare: (x: T[K], y: T[K]) => boolean): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=distinctUntilKeyChanged.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/elementAt.d.ts

@@ -1,51 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Emits the single value at the specified `index` in a sequence of emissions
- * from the source Observable.
- *
- * <span class="informal">Emits only the i-th value, then completes.</span>
- *
- * ![](elementAt.png)
- *
- * `elementAt` returns an Observable that emits the item at the specified
- * `index` in the source Observable, or a default value if that `index` is out
- * of range and the `default` argument is provided. If the `default` argument is
- * not given and the `index` is out of range, the output Observable will emit an
- * `ArgumentOutOfRangeError` error.
- *
- * ## Example
- *
- * Emit only the third click event
- *
- * ```ts
- * import { fromEvent, elementAt } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(elementAt(2));
- * result.subscribe(x => console.log(x));
- *
- * // Results in:
- * // click 1 = nothing
- * // click 2 = nothing
- * // click 3 = MouseEvent object logged to console
- * ```
- *
- * @see {@link first}
- * @see {@link last}
- * @see {@link skip}
- * @see {@link single}
- * @see {@link take}
- *
- * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an
- * `ArgumentOutOfRangeError` to the Observer's `error` callback if `i < 0` or the
- * Observable has completed before emitting the i-th `next` notification.
- *
- * @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.
- */
-export declare function elementAt<T, D = T>(index: number, defaultValue?: D): OperatorFunction<T, T | D>;
-//# sourceMappingURL=elementAt.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/endWith.d.ts

@@ -1,7 +0,0 @@
-import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ValueFromArray } from '../types';
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export declare function endWith<T>(scheduler: SchedulerLike): MonoTypeOperatorFunction<T>;
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export declare function endWith<T, A extends unknown[] = T[]>(...valuesAndScheduler: [...A, SchedulerLike]): OperatorFunction<T, T | ValueFromArray<A>>;
-export declare function endWith<T, A extends unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>;
-//# sourceMappingURL=endWith.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/every.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from '../Observable';
-import { Falsy, OperatorFunction } from '../types';
-export declare function every<T>(predicate: BooleanConstructor): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function every<T>(predicate: BooleanConstructor, thisArg: any): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function every<T, A>(predicate: (this: A, value: T, index: number, source: Observable<T>) => boolean, thisArg: A): OperatorFunction<T, boolean>;
-export declare function every<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, boolean>;
-//# sourceMappingURL=every.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/exhaust.d.ts

@@ -1,6 +0,0 @@
-import { exhaustAll } from './exhaustAll';
-/**
- * @deprecated Renamed to {@link exhaustAll}. Will be removed in v8.
- */
-export declare const exhaust: typeof exhaustAll;
-//# sourceMappingURL=exhaust.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/exhaustAll.d.ts

@@ -1,47 +0,0 @@
-import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-/**
- * Converts a higher-order Observable into a first-order Observable by dropping
- * inner Observables while the previous inner Observable has not yet completed.
- *
- * <span class="informal">Flattens an Observable-of-Observables by dropping the
- * next inner Observables while the current inner is still executing.</span>
- *
- * ![](exhaustAll.svg)
- *
- * `exhaustAll` subscribes to an Observable that emits Observables, also known as a
- * higher-order Observable. Each time it observes one of these emitted inner
- * Observables, the output Observable begins emitting the items emitted by that
- * inner Observable. So far, it behaves like {@link mergeAll}. However,
- * `exhaustAll` ignores every new inner Observable if the previous Observable has
- * not yet completed. Once that one completes, it will accept and flatten the
- * next inner Observable and repeat this process.
- *
- * ## Example
- *
- * Run a finite timer for each click, only if there is no currently active timer
- *
- * ```ts
- * import { fromEvent, map, interval, take, exhaustAll } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const higherOrder = clicks.pipe(
- *   map(() => interval(1000).pipe(take(5)))
- * );
- * const result = higherOrder.pipe(exhaustAll());
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link combineLatestAll}
- * @see {@link concatAll}
- * @see {@link switchAll}
- * @see {@link switchMap}
- * @see {@link mergeAll}
- * @see {@link exhaustMap}
- * @see {@link zipAll}
- *
- * @return A function that returns an Observable that takes a source of
- * Observables and propagates the first Observable exclusively until it
- * completes before subscribing to the next.
- */
-export declare function exhaustAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>>;
-//# sourceMappingURL=exhaustAll.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/exhaustMap.d.ts

@@ -1,7 +0,0 @@
-import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
-export declare function exhaustMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): 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 declare function exhaustMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): 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 declare function exhaustMap<T, I, R>(project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
-//# sourceMappingURL=exhaustMap.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/expand.d.ts

@@ -1,9 +0,0 @@
-import { OperatorFunction, ObservableInput, ObservedValueOf, SchedulerLike } from '../types';
-export declare function expand<T, O extends ObservableInput<unknown>>(project: (value: T, index: number) => O, concurrent?: number, scheduler?: SchedulerLike): OperatorFunction<T, ObservedValueOf<O>>;
-/**
- * @deprecated The `scheduler` parameter will be removed in v8. If you need to schedule the inner subscription,
- * use `subscribeOn` within the projection function: `expand((value) => fn(value).pipe(subscribeOn(scheduler)))`.
- * Details: Details: https://rxjs.dev/deprecations/scheduler-argument
- */
-export declare function expand<T, O extends ObservableInput<unknown>>(project: (value: T, index: number) => O, concurrent: number | undefined, scheduler: SchedulerLike): OperatorFunction<T, ObservedValueOf<O>>;
-//# sourceMappingURL=expand.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/filter.d.ts

@@ -1,9 +0,0 @@
-import { OperatorFunction, MonoTypeOperatorFunction, TruthyTypesOf } from '../types';
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function filter<T, S extends T, A>(predicate: (this: A, value: T, index: number) => value is S, thisArg: A): OperatorFunction<T, S>;
-export declare function filter<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>;
-export declare function filter<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function filter<T, A>(predicate: (this: A, value: T, index: number) => boolean, thisArg: A): MonoTypeOperatorFunction<T>;
-export declare function filter<T>(predicate: (value: T, index: number) => boolean): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=filter.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/finalize.d.ts

@@ -1,64 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * Returns an Observable that mirrors the source Observable, but will call a specified function when
- * the source terminates on complete or error.
- * The specified function will also be called when the subscriber explicitly unsubscribes.
- *
- * ## Examples
- *
- * Execute callback function when the observable completes
- *
- * ```ts
- * import { interval, take, finalize } from '../..';
- *
- * // emit value in sequence every 1 second
- * const source = interval(1000);
- * const example = source.pipe(
- *   take(5), //take only the first 5 values
- *   finalize(() => console.log('Sequence complete')) // Execute when the observable completes
- * );
- * const subscribe = example.subscribe(val => console.log(val));
- *
- * // results:
- * // 0
- * // 1
- * // 2
- * // 3
- * // 4
- * // 'Sequence complete'
- * ```
- *
- * Execute callback function when the subscriber explicitly unsubscribes
- *
- * ```ts
- * import { interval, finalize, tap, noop, timer } from '../..';
- *
- * const source = interval(100).pipe(
- *   finalize(() => console.log('[finalize] Called')),
- *   tap({
- *     next: () => console.log('[next] Called'),
- *     error: () => console.log('[error] Not called'),
- *     complete: () => console.log('[tap complete] Not called')
- *   })
- * );
- *
- * const sub = source.subscribe({
- *   next: x => console.log(x),
- *   error: noop,
- *   complete: () => console.log('[complete] Not called')
- * });
- *
- * timer(150).subscribe(() => sub.unsubscribe());
- *
- * // results:
- * // '[next] Called'
- * // 0
- * // '[finalize] Called'
- * ```
- *
- * @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.
- */
-export declare function finalize<T>(callback: () => void): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=finalize.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/find.d.ts

@@ -1,12 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { OperatorFunction, TruthyTypesOf } from '../types';
-export declare function find<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function find<T, S extends T, A>(predicate: (this: A, value: T, index: number, source: Observable<T>) => value is S, thisArg: A): OperatorFunction<T, S | undefined>;
-export declare function find<T, S extends T>(predicate: (value: T, index: number, source: Observable<T>) => value is S): OperatorFunction<T, S | undefined>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function find<T, A>(predicate: (this: A, value: T, index: number, source: Observable<T>) => boolean, thisArg: A): OperatorFunction<T, T | undefined>;
-export declare function find<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, T | undefined>;
-export declare function createFind<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg: any, emit: 'value' | 'index'): (source: Observable<T>, subscriber: Subscriber<any>) => void;
-//# sourceMappingURL=find.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/findIndex.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from '../Observable';
-import { Falsy, OperatorFunction } from '../types';
-export declare function findIndex<T>(predicate: BooleanConstructor): OperatorFunction<T, T extends Falsy ? -1 : number>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function findIndex<T>(predicate: BooleanConstructor, thisArg: any): OperatorFunction<T, T extends Falsy ? -1 : number>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function findIndex<T, A>(predicate: (this: A, value: T, index: number, source: Observable<T>) => boolean, thisArg: A): OperatorFunction<T, number>;
-export declare function findIndex<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, number>;
-//# sourceMappingURL=findIndex.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/first.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, TruthyTypesOf } from '../types';
-export declare function first<T, D = T>(predicate?: null, defaultValue?: D): OperatorFunction<T, T | D>;
-export declare function first<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
-export declare function first<T, D>(predicate: BooleanConstructor, defaultValue: D): OperatorFunction<T, TruthyTypesOf<T> | D>;
-export declare function first<T, S extends T>(predicate: (value: T, index: number, source: Observable<T>) => value is S, defaultValue?: S): OperatorFunction<T, S>;
-export declare function first<T, S extends T, D>(predicate: (value: T, index: number, source: Observable<T>) => value is S, defaultValue: D): OperatorFunction<T, S | D>;
-export declare function first<T, D = T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: D): OperatorFunction<T, T | D>;
-//# sourceMappingURL=first.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/flatMap.d.ts

@@ -1,6 +0,0 @@
-import { mergeMap } from './mergeMap';
-/**
- * @deprecated Renamed to {@link mergeMap}. Will be removed in v8.
- */
-export declare const flatMap: typeof mergeMap;
-//# sourceMappingURL=flatMap.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/groupBy.d.ts

@@ -1,119 +0,0 @@
-import { Observable } from '../Observable';
-import { Subject } from '../Subject';
-import { ObservableInput, OperatorFunction, SubjectLike } from '../types';
-export interface BasicGroupByOptions<K, T> {
-    element?: undefined;
-    duration?: (grouped: GroupedObservable<K, T>) => ObservableInput<any>;
-    connector?: () => SubjectLike<T>;
-}
-export interface GroupByOptionsWithElement<K, E, T> {
-    element: (value: T) => E;
-    duration?: (grouped: GroupedObservable<K, E>) => ObservableInput<any>;
-    connector?: () => SubjectLike<E>;
-}
-export declare function groupBy<T, K>(key: (value: T) => K, options: BasicGroupByOptions<K, T>): OperatorFunction<T, GroupedObservable<K, T>>;
-export declare function groupBy<T, K, E>(key: (value: T) => K, options: GroupByOptionsWithElement<K, E, T>): OperatorFunction<T, GroupedObservable<K, E>>;
-export declare function groupBy<T, K extends T>(key: (value: T) => value is K): OperatorFunction<T, GroupedObservable<true, K> | GroupedObservable<false, Exclude<T, K>>>;
-export declare function groupBy<T, K>(key: (value: T) => K): OperatorFunction<T, GroupedObservable<K, T>>;
-/**
- * @deprecated use the options parameter instead.
- */
-export declare function groupBy<T, K>(key: (value: T) => K, element: void, duration: (grouped: GroupedObservable<K, T>) => Observable<any>): OperatorFunction<T, GroupedObservable<K, T>>;
-/**
- * @deprecated use the options parameter instead.
- */
-export declare function groupBy<T, K, R>(key: (value: T) => K, element?: (value: T) => R, duration?: (grouped: GroupedObservable<K, R>) => Observable<any>): OperatorFunction<T, GroupedObservable<K, R>>;
-/**
- * Groups the items emitted by an Observable according to a specified criterion,
- * and emits these grouped items as `GroupedObservables`, one
- * {@link GroupedObservable} per group.
- *
- * ![](groupBy.png)
- *
- * When the Observable emits an item, a key is computed for this item with the key function.
- *
- * If a {@link GroupedObservable} for this key exists, this {@link GroupedObservable} emits. Otherwise, a new
- * {@link GroupedObservable} for this key is created and emits.
- *
- * A {@link GroupedObservable} represents values belonging to the same group represented by a common key. The common
- * key is available as the `key` field of a {@link GroupedObservable} instance.
- *
- * The elements emitted by {@link GroupedObservable}s are by default the items emitted by the Observable, or elements
- * returned by the element function.
- *
- * ## Examples
- *
- * Group objects by `id` and return as array
- *
- * ```ts
- * import { of, groupBy, mergeMap, reduce } from '../..';
- *
- * of(
- *   { id: 1, name: 'JavaScript' },
- *   { id: 2, name: 'Parcel' },
- *   { id: 2, name: 'webpack' },
- *   { id: 1, name: 'TypeScript' },
- *   { id: 3, name: 'TSLint' }
- * ).pipe(
- *   groupBy(p => p.id),
- *   mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], [])))
- * )
- * .subscribe(p => console.log(p));
- *
- * // displays:
- * // [{ id: 1, name: 'JavaScript' }, { id: 1, name: 'TypeScript'}]
- * // [{ id: 2, name: 'Parcel' }, { id: 2, name: 'webpack'}]
- * // [{ id: 3, name: 'TSLint' }]
- * ```
- *
- * Pivot data on the `id` field
- *
- * ```ts
- * import { of, groupBy, mergeMap, reduce, map } from '../..';
- *
- * of(
- *   { id: 1, name: 'JavaScript' },
- *   { id: 2, name: 'Parcel' },
- *   { id: 2, name: 'webpack' },
- *   { id: 1, name: 'TypeScript' },
- *   { id: 3, name: 'TSLint' }
- * ).pipe(
- *   groupBy(p => p.id, { element: p => p.name }),
- *   mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], [`${ group$.key }`]))),
- *   map(arr => ({ id: parseInt(arr[0], 10), values: arr.slice(1) }))
- * )
- * .subscribe(p => console.log(p));
- *
- * // displays:
- * // { id: 1, values: [ 'JavaScript', 'TypeScript' ] }
- * // { id: 2, values: [ 'Parcel', 'webpack' ] }
- * // { id: 3, values: [ 'TSLint' ] }
- * ```
- *
- * @param key A function that extracts the key
- * for each item.
- * @param element A function that extracts the
- * return element for each item.
- * @param duration
- * A function that returns an Observable to determine how long each group should
- * exist.
- * @param connector Factory function to create an
- * intermediate Subject through which grouped elements are emitted.
- * @return A function that returns an Observable that emits GroupedObservables,
- * each of which corresponds to a unique key value and each of which emits
- * those items from the source Observable that share that key value.
- *
- * @deprecated Use the options parameter instead.
- */
-export declare function groupBy<T, K, R>(key: (value: T) => K, element?: (value: T) => R, duration?: (grouped: GroupedObservable<K, R>) => Observable<any>, connector?: () => Subject<R>): OperatorFunction<T, GroupedObservable<K, R>>;
-/**
- * An observable of values that is the emitted by the result of a {@link groupBy} operator,
- * contains a `key` property for the grouping.
- */
-export interface GroupedObservable<K, T> extends Observable<T> {
-    /**
-     * The key value for the grouped notifications.
-     */
-    readonly key: K;
-}
-//# sourceMappingURL=groupBy.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/ignoreElements.d.ts

@@ -1,38 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.
- *
- * ![](ignoreElements.png)
- *
- * The `ignoreElements` operator suppresses all items emitted by the source Observable,
- * but allows its termination notification (either `error` or `complete`) to pass through unchanged.
- *
- * If you do not care about the items being emitted by an Observable, but you do want to be notified
- * when it completes or when it terminates with an error, you can apply the `ignoreElements` operator
- * to the Observable, which will ensure that it will never call its observers’ `next` handlers.
- *
- * ## Example
- *
- * Ignore all `next` emissions from the source
- *
- * ```ts
- * import { of, ignoreElements } from '../..';
- *
- * of('you', 'talking', 'to', 'me')
- *   .pipe(ignoreElements())
- *   .subscribe({
- *     next: word => console.log(word),
- *     error: err => console.log('error:', err),
- *     complete: () => console.log('the end'),
- *   });
- *
- * // result:
- * // 'the end'
- * ```
- *
- * @return A function that returns an empty Observable that only calls
- * `complete` or `error`, based on which one is called by the source
- * Observable.
- */
-export declare function ignoreElements(): OperatorFunction<unknown, never>;
-//# sourceMappingURL=ignoreElements.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/isEmpty.d.ts

@@ -1,64 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Emits `false` if the input Observable emits any values, or emits `true` if the
- * input Observable completes without emitting any values.
- *
- * <span class="informal">Tells whether any values are emitted by an Observable.</span>
- *
- * ![](isEmpty.png)
- *
- * `isEmpty` transforms an Observable that emits values into an Observable that
- * emits a single boolean value representing whether or not any values were
- * emitted by the source Observable. As soon as the source Observable emits a
- * value, `isEmpty` will emit a `false` and complete.  If the source Observable
- * completes having not emitted anything, `isEmpty` will emit a `true` and
- * complete.
- *
- * A similar effect could be achieved with {@link count}, but `isEmpty` can emit
- * a `false` value sooner.
- *
- * ## Examples
- *
- * Emit `false` for a non-empty Observable
- *
- * ```ts
- * import { Subject, isEmpty } from '../..';
- *
- * const source = new Subject<string>();
- * const result = source.pipe(isEmpty());
- *
- * source.subscribe(x => console.log(x));
- * result.subscribe(x => console.log(x));
- *
- * source.next('a');
- * source.next('b');
- * source.next('c');
- * source.complete();
- *
- * // Outputs
- * // 'a'
- * // false
- * // 'b'
- * // 'c'
- * ```
- *
- * Emit `true` for an empty Observable
- *
- * ```ts
- * import { EMPTY, isEmpty } from '../..';
- *
- * const result = EMPTY.pipe(isEmpty());
- * result.subscribe(x => console.log(x));
- *
- * // Outputs
- * // true
- * ```
- *
- * @see {@link count}
- * @see {@link EMPTY}
- *
- * @return A function that returns an Observable that emits boolean value
- * indicating whether the source Observable was empty or not.
- */
-export declare function isEmpty<T>(): OperatorFunction<T, boolean>;
-//# sourceMappingURL=isEmpty.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/joinAllInternals.d.ts

@@ -1,14 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInput } from '../types';
-/**
- * Collects all of the inner sources from source observable. Then, once the
- * source completes, joins the values using the given static.
- *
- * This is used for {@link combineLatestAll} and {@link zipAll} which both have the
- * same behavior of collecting all inner observables, then operating on them.
- *
- * @param joinFn The type of static join to apply to the sources collected
- * @param project The projection function to apply to the values, if any
- */
-export declare function joinAllInternals<T, R>(joinFn: (sources: ObservableInput<T>[]) => Observable<T>, project?: (...args: any[]) => R): import("../types").UnaryFunction<Observable<ObservableInput<T>>, unknown>;
-//# sourceMappingURL=joinAllInternals.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/last.d.ts

@@ -1,8 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, TruthyTypesOf } from '../types';
-export declare function last<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
-export declare function last<T, D>(predicate: BooleanConstructor, defaultValue: D): OperatorFunction<T, TruthyTypesOf<T> | D>;
-export declare function last<T, D = T>(predicate?: null, defaultValue?: D): OperatorFunction<T, T | D>;
-export declare function last<T, S extends T>(predicate: (value: T, index: number, source: Observable<T>) => value is S, defaultValue?: S): OperatorFunction<T, S>;
-export declare function last<T, D = T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: D): OperatorFunction<T, T | D>;
-//# sourceMappingURL=last.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/map.d.ts

@@ -1,5 +0,0 @@
-import { OperatorFunction } from '../types';
-export declare function map<T, R>(project: (value: T, index: number) => R): OperatorFunction<T, R>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function map<T, R, A>(project: (this: A, value: T, index: number) => R, thisArg: A): OperatorFunction<T, R>;
-//# sourceMappingURL=map.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/mapTo.d.ts

@@ -1,10 +0,0 @@
-import { OperatorFunction } from '../types';
-/** @deprecated To be removed in v9. Use {@link map} instead: `map(() => value)`. */
-export declare function mapTo<R>(value: R): OperatorFunction<unknown, R>;
-/**
- * @deprecated Do not specify explicit type parameters. Signatures with type parameters
- * that cannot be inferred will be removed in v8. `mapTo` itself will be removed in v9,
- * use {@link map} instead: `map(() => value)`.
- * */
-export declare function mapTo<T, R>(value: R): OperatorFunction<T, R>;
-//# sourceMappingURL=mapTo.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/materialize.d.ts

@@ -1,52 +0,0 @@
-import { Notification } from '../Notification';
-import { OperatorFunction, ObservableNotification } from '../types';
-/**
- * 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 '../..';
- *
- * 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 declare function materialize<T>(): OperatorFunction<T, Notification<T> & ObservableNotification<T>>;
-//# sourceMappingURL=materialize.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/max.d.ts

@@ -1,50 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * 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 '../..';
- *
- * 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 '../..';
- *
- * 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 declare function max<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=max.d.ts.map