@bleedingdev/modern-js-utils 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

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

@@ -0,0 +1,56 @@
+import { Observable } from '../Observable';
+import { MonoTypeOperatorFunction, OperatorFunction, TimestampProvider, ObservableInput, ObservedValueOf } from '../types';
+/**
+ * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
+ * internally.
+ *
+ * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
+ * @param windowTime The window time for the underlying {@link ReplaySubject}.
+ * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
+ * @deprecated Will be removed in v8. To create a connectable observable that uses a
+ * {@link ReplaySubject} under the hood, use {@link connectable}.
+ * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
+ * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
+ * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
+ * `publishReplay(size, time, scheduler), refCount()` is equivalent to
+ * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export declare function publishReplay<T>(bufferSize?: number, windowTime?: number, timestampProvider?: TimestampProvider): MonoTypeOperatorFunction<T>;
+/**
+ * Creates an observable, that when subscribed to, will create a {@link ReplaySubject},
+ * and pass an observable from it (using [asObservable](api/index/class/Subject#asObservable)) to
+ * the `selector` function, which then returns an observable that is subscribed to before
+ * "connecting" the source to the internal `ReplaySubject`.
+ *
+ * Since this is deprecated, for additional details see the documentation for {@link connect}.
+ *
+ * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
+ * @param windowTime The window time for the underlying {@link ReplaySubject}.
+ * @param selector A function used to setup the multicast.
+ * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
+ * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
+ * `source.pipe(publishReplay(size, window, selector, scheduler))` is equivalent to
+ * `source.pipe(connect(selector, { connector: () => new ReplaySubject(size, window, scheduler) }))`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export declare function publishReplay<T, O extends ObservableInput<any>>(bufferSize: number | undefined, windowTime: number | undefined, selector: (shared: Observable<T>) => O, timestampProvider?: TimestampProvider): OperatorFunction<T, ObservedValueOf<O>>;
+/**
+ * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
+ * internally.
+ *
+ * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
+ * @param windowTime The window time for the underlying {@link ReplaySubject}.
+ * @param selector Passing `undefined` here determines that this operator will return a {@link ConnectableObservable}.
+ * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
+ * @deprecated Will be removed in v8. To create a connectable observable that uses a
+ * {@link ReplaySubject} under the hood, use {@link connectable}.
+ * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
+ * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
+ * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
+ * `publishReplay(size, time, scheduler), refCount()` is equivalent to
+ * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export declare function publishReplay<T, O extends ObservableInput<any>>(bufferSize: number | undefined, windowTime: number | undefined, selector: undefined, timestampProvider: TimestampProvider): OperatorFunction<T, ObservedValueOf<O>>;
+//# sourceMappingURL=publishReplay.d.ts.map

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

@@ -0,0 +1,6 @@
+import { ObservableInputTuple, OperatorFunction } from '../types';
+/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */
+export declare function race<T, A extends readonly unknown[]>(otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
+/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */
+export declare function race<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
+//# sourceMappingURL=race.d.ts.map

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

@@ -0,0 +1,29 @@
+import { OperatorFunction, ObservableInputTuple } from '../types';
+/**
+ * Creates an Observable that mirrors the first source Observable to emit a next,
+ * error or complete notification from the combination of the Observable to which
+ * the operator is applied and supplied Observables.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { interval, map, raceWith } from '../..';
+ *
+ * const obs1 = interval(7000).pipe(map(() => 'slow one'));
+ * const obs2 = interval(3000).pipe(map(() => 'fast one'));
+ * const obs3 = interval(5000).pipe(map(() => 'medium one'));
+ *
+ * obs1
+ *   .pipe(raceWith(obs2, obs3))
+ *   .subscribe(winner => console.log(winner));
+ *
+ * // Outputs
+ * // a series of 'fast one'
+ * ```
+ *
+ * @param otherSources Sources used to race for which Observable emits first.
+ * @return A function that returns an Observable that mirrors the output of the
+ * first Observable to emit an item.
+ */
+export declare function raceWith<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
+//# sourceMappingURL=raceWith.d.ts.map

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

@@ -0,0 +1,5 @@
+import { OperatorFunction } from '../types';
+export declare function reduce<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
+export declare function reduce<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
+export declare function reduce<V, A, S = A>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
+//# sourceMappingURL=reduce.d.ts.map

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

@@ -0,0 +1,61 @@
+import { MonoTypeOperatorFunction } from '../types';
+/**
+ * Make a {@link ConnectableObservable} behave like a ordinary observable and automates the way
+ * you can connect to it.
+ *
+ * Internally it counts the subscriptions to the observable and subscribes (only once) to the source if
+ * the number of subscriptions is larger than 0. If the number of subscriptions is smaller than 1, it
+ * unsubscribes from the source. This way you can make sure that everything before the *published*
+ * refCount has only a single subscription independently of the number of subscribers to the target
+ * observable.
+ *
+ * Note that using the {@link share} operator is exactly the same as using the `multicast(() => new Subject())` operator
+ * (making the observable hot) and the *refCount* operator in a sequence.
+ *
+ * ![](refCount.png)
+ *
+ * ## Example
+ *
+ * In the following example there are two intervals turned into connectable observables
+ * by using the *publish* operator. The first one uses the *refCount* operator, the
+ * second one does not use it. You will notice that a connectable observable does nothing
+ * until you call its connect function.
+ *
+ * ```ts
+ * import { interval, tap, publish, refCount } from '../..';
+ *
+ * // Turn the interval observable into a ConnectableObservable (hot)
+ * const refCountInterval = interval(400).pipe(
+ *   tap(num => console.log(`refCount ${ num }`)),
+ *   publish(),
+ *   refCount()
+ * );
+ *
+ * const publishedInterval = interval(400).pipe(
+ *   tap(num => console.log(`publish ${ num }`)),
+ *   publish()
+ * );
+ *
+ * refCountInterval.subscribe();
+ * refCountInterval.subscribe();
+ * // 'refCount 0' -----> 'refCount 1' -----> etc
+ * // All subscriptions will receive the same value and the tap (and
+ * // every other operator) before the `publish` operator will be executed
+ * // only once per event independently of the number of subscriptions.
+ *
+ * publishedInterval.subscribe();
+ * // Nothing happens until you call .connect() on the observable.
+ * ```
+ *
+ * @return A function that returns an Observable that automates the connection
+ * to ConnectableObservable.
+ * @see {@link ConnectableObservable}
+ * @see {@link share}
+ * @see {@link publish}
+ * @deprecated Replaced with the {@link share} operator. How `share` is used
+ * will depend on the connectable observable you created just prior to the
+ * `refCount` operator.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export declare function refCount<T>(): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=refCount.d.ts.map

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

@@ -0,0 +1,108 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+export interface RepeatConfig {
+    /**
+     * The number of times to repeat the source. Defaults to `Infinity`.
+     */
+    count?: number;
+    /**
+     * If a `number`, will delay the repeat of the source by that number of milliseconds.
+     * If a function, it will provide the number of times the source has been subscribed to,
+     * and the return value should be a valid observable input that will notify when the source
+     * should be repeated. If the notifier observable is empty, the result will complete.
+     */
+    delay?: number | ((count: number) => ObservableInput<any>);
+}
+/**
+ * Returns an Observable that will resubscribe to the source stream when the source stream completes.
+ *
+ * <span class="informal">Repeats all values emitted on the source. It's like {@link retry}, but for non error cases.</span>
+ *
+ * ![](repeat.png)
+ *
+ * Repeat will output values from a source until the source completes, then it will resubscribe to the
+ * source a specified number of times, with a specified delay. Repeat can be particularly useful in
+ * combination with closing operators like {@link take}, {@link takeUntil}, {@link first}, or {@link takeWhile},
+ * as it can be used to restart a source again from scratch.
+ *
+ * Repeat is very similar to {@link retry}, where {@link retry} will resubscribe to the source in the error case, but
+ * `repeat` will resubscribe if the source completes.
+ *
+ * Note that `repeat` will _not_ catch errors. Use {@link retry} for that.
+ *
+ * - `repeat(0)` returns an empty observable
+ * - `repeat()` will repeat forever
+ * - `repeat({ delay: 200 })` will repeat forever, with a delay of 200ms between repetitions.
+ * - `repeat({ count: 2, delay: 400 })` will repeat twice, with a delay of 400ms between repetitions.
+ * - `repeat({ delay: (count) => timer(count * 1000) })` will repeat forever, but will have a delay that grows by one second for each repetition.
+ *
+ * ## Example
+ *
+ * Repeat a message stream
+ *
+ * ```ts
+ * import { of, repeat } from '../..';
+ *
+ * const source = of('Repeat message');
+ * const result = source.pipe(repeat(3));
+ *
+ * result.subscribe(x => console.log(x));
+ *
+ * // Results
+ * // 'Repeat message'
+ * // 'Repeat message'
+ * // 'Repeat message'
+ * ```
+ *
+ * Repeat 3 values, 2 times
+ *
+ * ```ts
+ * import { interval, take, repeat } from '../..';
+ *
+ * const source = interval(1000);
+ * const result = source.pipe(take(3), repeat(2));
+ *
+ * result.subscribe(x => console.log(x));
+ *
+ * // Results every second
+ * // 0
+ * // 1
+ * // 2
+ * // 0
+ * // 1
+ * // 2
+ * ```
+ *
+ * Defining two complex repeats with delays on the same source.
+ * Note that the second repeat cannot be called until the first
+ * repeat as exhausted it's count.
+ *
+ * ```ts
+ * import { defer, of, repeat } from '../..';
+ *
+ * const source = defer(() => {
+ *    return of(`Hello, it is ${new Date()}`)
+ * });
+ *
+ * source.pipe(
+ *    // Repeat 3 times with a delay of 1 second between repetitions
+ *    repeat({
+ *      count: 3,
+ *      delay: 1000,
+ *    }),
+ *
+ *    // *Then* repeat forever, but with an exponential step-back
+ *    // maxing out at 1 minute.
+ *    repeat({
+ *      delay: (count) => timer(Math.min(60000, 2 ^ count * 1000))
+ *    })
+ * )
+ * ```
+ *
+ * @see {@link repeatWhen}
+ * @see {@link retry}
+ *
+ * @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 declare function repeat<T>(countOrConfig?: number | RepeatConfig): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=repeat.d.ts.map

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

@@ -0,0 +1,38 @@
+import { Observable } from '../Observable';
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source
+ * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable
+ * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise
+ * this method will resubscribe to the source Observable.
+ *
+ * ![](repeatWhen.png)
+ *
+ * ## Example
+ *
+ * Repeat a message stream on click
+ *
+ * ```ts
+ * import { of, fromEvent, repeatWhen } from '../..';
+ *
+ * const source = of('Repeat message');
+ * const documentClick$ = fromEvent(document, 'click');
+ *
+ * const result = source.pipe(repeatWhen(() => documentClick$));
+ *
+ * result.subscribe(data => console.log(data))
+ * ```
+ *
+ * @see {@link repeat}
+ * @see {@link retry}
+ * @see {@link retryWhen}
+ *
+ * @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 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$ })`.
+ */
+export declare function repeatWhen<T>(notifier: (notifications: Observable<void>) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=repeatWhen.d.ts.map

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

@@ -0,0 +1,28 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * The {@link retry} operator configuration object. `retry` either accepts a `number`
+ * or an object described by this interface.
+ */
+export interface RetryConfig {
+    /**
+     * The maximum number of times to retry. If `count` is omitted, `retry` will try to
+     * resubscribe on errors infinite number of times.
+     */
+    count?: number;
+    /**
+     * The number of milliseconds to delay before retrying, OR a function to
+     * return a notifier for delaying. If a function is given, that function should
+     * return a notifier that, when it emits will retry the source. If the notifier
+     * completes _without_ emitting, the resulting observable will complete without error,
+     * if the notifier errors, the error will be pushed to the result.
+     */
+    delay?: number | ((error: any, retryCount: number) => ObservableInput<any>);
+    /**
+     * Whether or not to reset the retry counter when the retried subscription
+     * emits its first value.
+     */
+    resetOnSuccess?: boolean;
+}
+export declare function retry<T>(count?: number): MonoTypeOperatorFunction<T>;
+export declare function retry<T>(config: RetryConfig): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=retry.d.ts.map

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

@@ -0,0 +1,61 @@
+import { Observable } from '../Observable';
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
+ * calls `error`, this method will emit the Throwable that caused the error to the `ObservableInput` returned from `notifier`.
+ * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
+ * subscription. Otherwise this method will resubscribe to the source Observable.
+ *
+ * ![](retryWhen.png)
+ *
+ * Retry an observable sequence on error based on custom criteria.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { interval, map, retryWhen, tap, delayWhen, timer } from '../..';
+ *
+ * const source = interval(1000);
+ * const result = source.pipe(
+ *   map(value => {
+ *     if (value > 5) {
+ *       // error will be picked up by retryWhen
+ *       throw value;
+ *     }
+ *     return value;
+ *   }),
+ *   retryWhen(errors =>
+ *     errors.pipe(
+ *       // log error message
+ *       tap(value => console.log(`Value ${ value } was too high!`)),
+ *       // restart in 5 seconds
+ *       delayWhen(value => timer(value * 1000))
+ *     )
+ *   )
+ * );
+ *
+ * result.subscribe(value => console.log(value));
+ *
+ * // results:
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * // 'Value 6 was too high!'
+ * // - Wait 5 seconds then repeat
+ * ```
+ *
+ * @see {@link retry}
+ *
+ * @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 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.
+ * Instead of `retryWhen(() => notify$)`, use: `retry({ delay: () => notify$ })`.
+ */
+export declare function retryWhen<T>(notifier: (errors: Observable<any>) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=retryWhen.d.ts.map

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

@@ -0,0 +1,43 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Emits the most recently emitted value from the source Observable whenever
+ * another Observable, the `notifier`, emits.
+ *
+ * <span class="informal">It's like {@link sampleTime}, but samples whenever
+ * the `notifier` `ObservableInput` emits something.</span>
+ *
+ * ![](sample.png)
+ *
+ * Whenever the `notifier` `ObservableInput` emits a value, `sample`
+ * looks at the source Observable and emits whichever value it has most recently
+ * emitted since the previous sampling, unless the source has not emitted
+ * anything since the previous sampling. The `notifier` is subscribed to as soon
+ * as the output Observable is subscribed.
+ *
+ * ## Example
+ *
+ * On every click, sample the most recent `seconds` timer
+ *
+ * ```ts
+ * import { fromEvent, interval, sample } from '../..';
+ *
+ * const seconds = interval(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const result = seconds.pipe(sample(clicks));
+ *
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link audit}
+ * @see {@link debounce}
+ * @see {@link sampleTime}
+ * @see {@link throttle}
+ *
+ * @param notifier The `ObservableInput` to use for sampling the
+ * source Observable.
+ * @return A function that returns an Observable that emits the results of
+ * sampling the values emitted by the source Observable whenever the notifier
+ * Observable emits value or completes.
+ */
+export declare function sample<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=sample.d.ts.map

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

@@ -0,0 +1,46 @@
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+/**
+ * Emits the most recently emitted value from the source Observable within
+ * periodic time intervals.
+ *
+ * <span class="informal">Samples the source Observable at periodic time
+ * intervals, emitting what it samples.</span>
+ *
+ * ![](sampleTime.png)
+ *
+ * `sampleTime` periodically looks at the source Observable and emits whichever
+ * value it has most recently emitted since the previous sampling, unless the
+ * source has not emitted anything since the previous sampling. The sampling
+ * happens periodically in time every `period` milliseconds (or the time unit
+ * defined by the optional `scheduler` argument). The sampling starts as soon as
+ * the output Observable is subscribed.
+ *
+ * ## Example
+ *
+ * Every second, emit the most recent click at most once
+ *
+ * ```ts
+ * import { fromEvent, sampleTime } from '../..';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(sampleTime(1000));
+ *
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link auditTime}
+ * @see {@link debounceTime}
+ * @see {@link delay}
+ * @see {@link sample}
+ * @see {@link throttleTime}
+ *
+ * @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.
+ */
+export declare function sampleTime<T>(period: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=sampleTime.d.ts.map

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

@@ -0,0 +1,5 @@
+import { OperatorFunction } from '../types';
+export declare function scan<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
+export declare function scan<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
+export declare function scan<V, A, S>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
+//# sourceMappingURL=scan.d.ts.map

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

@@ -0,0 +1,12 @@
+import { Observable } from '../Observable';
+import { Subscriber } from '../Subscriber';
+/**
+ * A basic scan operation. This is used for `scan` and `reduce`.
+ * @param accumulator The accumulator to use
+ * @param seed The seed value for the state to accumulate
+ * @param hasSeed Whether or not a seed was provided
+ * @param emitOnNext Whether or not to emit the state on next
+ * @param emitBeforeComplete Whether or not to emit the before completion
+ */
+export declare function scanInternals<V, A, S>(accumulator: (acc: V | A | S, value: V, index: number) => A, seed: S, hasSeed: boolean, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<V>, subscriber: Subscriber<any>) => void;
+//# sourceMappingURL=scanInternals.d.ts.map

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

@@ -0,0 +1,60 @@
+import { OperatorFunction, ObservableInput } from '../types';
+/**
+ * Compares all values of two observables in sequence using an optional comparator function
+ * and returns an observable of a single boolean value representing whether or not the two sequences
+ * are equal.
+ *
+ * <span class="informal">Checks to see of all values emitted by both observables are equal, in order.</span>
+ *
+ * ![](sequenceEqual.png)
+ *
+ * `sequenceEqual` subscribes to source observable and `compareTo` `ObservableInput` (that internally
+ * gets converted to an observable) and buffers incoming values from each observable. Whenever either
+ * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom
+ * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the
+ * observables completes, the operator will wait for the other observable to complete; If the other
+ * observable emits before completing, the returned observable will emit `false` and complete. If one observable never
+ * completes or emits after the other completes, the returned observable will never complete.
+ *
+ * ## Example
+ *
+ * Figure out if the Konami code matches
+ *
+ * ```ts
+ * import { from, fromEvent, map, bufferCount, mergeMap, sequenceEqual } from '../..';
+ *
+ * const codes = from([
+ *   'ArrowUp',
+ *   'ArrowUp',
+ *   'ArrowDown',
+ *   'ArrowDown',
+ *   'ArrowLeft',
+ *   'ArrowRight',
+ *   'ArrowLeft',
+ *   'ArrowRight',
+ *   'KeyB',
+ *   'KeyA',
+ *   'Enter', // no start key, clearly.
+ * ]);
+ *
+ * const keys = fromEvent<KeyboardEvent>(document, 'keyup').pipe(map(e => e.code));
+ * const matches = keys.pipe(
+ *   bufferCount(11, 1),
+ *   mergeMap(last11 => from(last11).pipe(sequenceEqual(codes)))
+ * );
+ * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched));
+ * ```
+ *
+ * @see {@link combineLatest}
+ * @see {@link zip}
+ * @see {@link withLatestFrom}
+ *
+ * @param compareTo The `ObservableInput` sequence to compare the source sequence to.
+ * @param comparator An optional function to compare each value pair.
+ *
+ * @return A function that returns an Observable that emits a single boolean
+ * value representing whether or not the values emitted by the source
+ * Observable and provided `ObservableInput` were equal in sequence.
+ */
+export declare function sequenceEqual<T>(compareTo: ObservableInput<T>, comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean>;
+//# sourceMappingURL=sequenceEqual.d.ts.map

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

@@ -0,0 +1,43 @@
+import { MonoTypeOperatorFunction, SubjectLike, ObservableInput } from '../types';
+export interface ShareConfig<T> {
+    /**
+     * The factory used to create the subject that will connect the source observable to
+     * multicast consumers.
+     */
+    connector?: () => SubjectLike<T>;
+    /**
+     * If `true`, the resulting observable will reset internal state on error from source and return to a "cold" state. This
+     * allows the resulting observable to be "retried" in the event of an error.
+     * If `false`, when an error comes from the source it will push the error into the connecting subject, and the subject
+     * will remain the connecting subject, meaning the resulting observable will not go "cold" again, and subsequent retries
+     * or resubscriptions will resubscribe to that same subject. In all cases, RxJS subjects will emit the same error again, however
+     * {@link ReplaySubject} will also push its buffered values before pushing the error.
+     * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
+     * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
+     */
+    resetOnError?: boolean | ((error: any) => ObservableInput<any>);
+    /**
+     * If `true`, the resulting observable will reset internal state on completion from source and return to a "cold" state. This
+     * allows the resulting observable to be "repeated" after it is done.
+     * If `false`, when the source completes, it will push the completion through the connecting subject, and the subject
+     * will remain the connecting subject, meaning the resulting observable will not go "cold" again, and subsequent repeats
+     * or resubscriptions will resubscribe to that same subject.
+     * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
+     * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
+     */
+    resetOnComplete?: boolean | (() => ObservableInput<any>);
+    /**
+     * If `true`, when the number of subscribers to the resulting observable reaches zero due to those subscribers unsubscribing, the
+     * internal state will be reset and the resulting observable will return to a "cold" state. This means that the next
+     * time the resulting observable is subscribed to, a new subject will be created and the source will be subscribed to
+     * again.
+     * If `false`, when the number of subscribers to the resulting observable reaches zero due to unsubscription, the subject
+     * will remain connected to the source, and new subscriptions to the result will be connected through that same subject.
+     * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
+     * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
+     */
+    resetOnRefCountZero?: boolean | (() => ObservableInput<any>);
+}
+export declare function share<T>(): MonoTypeOperatorFunction<T>;
+export declare function share<T>(options: ShareConfig<T>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=share.d.ts.map

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

@@ -0,0 +1,10 @@
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+export interface ShareReplayConfig {
+    bufferSize?: number;
+    windowTime?: number;
+    refCount: boolean;
+    scheduler?: SchedulerLike;
+}
+export declare function shareReplay<T>(config: ShareReplayConfig): MonoTypeOperatorFunction<T>;
+export declare function shareReplay<T>(bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=shareReplay.d.ts.map

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

@@ -0,0 +1,5 @@
+import { Observable } from '../Observable';
+import { MonoTypeOperatorFunction, OperatorFunction, TruthyTypesOf } from '../types';
+export declare function single<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
+export declare function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=single.d.ts.map