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

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

@@ -1,14 +0,0 @@
-import { OperatorFunction, ObservableInput } from '../types';
-/**
- * Collects all observable inner sources from the source, once the source completes,
- * it will subscribe to all inner sources, combining their values by index and emitting
- * them.
- *
- * @see {@link zipWith}
- * @see {@link zip}
- */
-export declare function zipAll<T>(): OperatorFunction<ObservableInput<T>, T[]>;
-export declare function zipAll<T>(): OperatorFunction<any, T[]>;
-export declare function zipAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>;
-export declare function zipAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>;
-//# sourceMappingURL=zipAll.d.ts.map

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

@@ -1,26 +0,0 @@
-import { ObservableInputTuple, OperatorFunction, Cons } from '../types';
-/**
- * Subscribes to the source, and the observable inputs provided as arguments, and combines their values, by index, into arrays.
- *
- * What is meant by "combine by index": The first value from each will be made into a single array, then emitted,
- * then the second value from each will be combined into a single array and emitted, then the third value
- * from each will be combined into a single array and emitted, and so on.
- *
- * This will continue until it is no longer able to combine values of the same index into an array.
- *
- * After the last value from any one completed source is emitted in an array, the resulting observable will complete,
- * as there is no way to continue "zipping" values together by index.
- *
- * Use-cases for this operator are limited. There are memory concerns if one of the streams is emitting
- * values at a much faster rate than the others. Usage should likely be limited to streams that emit
- * at a similar pace, or finite streams of known length.
- *
- * In many cases, authors want `combineLatestWith` and not `zipWith`.
- *
- * @param otherInputs other observable inputs to collate values from.
- * @return A function that returns an Observable that emits items by index
- * combined from the source Observable and provided Observables, in form of an
- * array.
- */
-export declare function zipWith<T, A extends readonly unknown[]>(...otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
-//# sourceMappingURL=zipWith.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduled/scheduleArray.d.ts

@@ -1,4 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-export declare function scheduleArray<T>(input: ArrayLike<T>, scheduler: SchedulerLike): Observable<T>;
-//# sourceMappingURL=scheduleArray.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduled/scheduleAsyncIterable.d.ts

@@ -1,4 +0,0 @@
-import { SchedulerLike } from '../types';
-import { Observable } from '../Observable';
-export declare function scheduleAsyncIterable<T>(input: AsyncIterable<T>, scheduler: SchedulerLike): Observable<T>;
-//# sourceMappingURL=scheduleAsyncIterable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduled/scheduleIterable.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-/**
- * Used in {@link scheduled} to create an observable from an Iterable.
- * @param input The iterable to create an observable from
- * @param scheduler The scheduler to use
- */
-export declare function scheduleIterable<T>(input: Iterable<T>, scheduler: SchedulerLike): Observable<T>;
-//# sourceMappingURL=scheduleIterable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduled/scheduleObservable.d.ts

@@ -1,3 +0,0 @@
-import { InteropObservable, SchedulerLike } from '../types';
-export declare function scheduleObservable<T>(input: InteropObservable<T>, scheduler: SchedulerLike): import("../Observable").Observable<T>;
-//# sourceMappingURL=scheduleObservable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduled/schedulePromise.d.ts

@@ -1,3 +0,0 @@
-import { SchedulerLike } from '../types';
-export declare function schedulePromise<T>(input: PromiseLike<T>, scheduler: SchedulerLike): import("../Observable").Observable<T>;
-//# sourceMappingURL=schedulePromise.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduled/scheduleReadableStreamLike.d.ts

@@ -1,4 +0,0 @@
-import { SchedulerLike, ReadableStreamLike } from '../types';
-import { Observable } from '../Observable';
-export declare function scheduleReadableStreamLike<T>(input: ReadableStreamLike<T>, scheduler: SchedulerLike): Observable<T>;
-//# sourceMappingURL=scheduleReadableStreamLike.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduled/scheduled.d.ts

@@ -1,15 +0,0 @@
-import { ObservableInput, SchedulerLike } from '../types';
-import { Observable } from '../Observable';
-/**
- * Converts from a common {@link ObservableInput} type to an observable where subscription and emissions
- * are scheduled on the provided scheduler.
- *
- * @see {@link from}
- * @see {@link of}
- *
- * @param input The observable, array, promise, iterable, etc you would like to schedule
- * @param scheduler The scheduler to use to schedule the subscription and emissions from
- * the returned observable.
- */
-export declare function scheduled<T>(input: ObservableInput<T>, scheduler: SchedulerLike): Observable<T>;
-//# sourceMappingURL=scheduled.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/Action.d.ts

@@ -1,30 +0,0 @@
-import { Scheduler } from '../Scheduler';
-import { Subscription } from '../Subscription';
-import { SchedulerAction } from '../types';
-/**
- * A unit of work to be executed in a `scheduler`. An action is typically
- * created from within a {@link SchedulerLike} and an RxJS user does not need to concern
- * themselves about creating and manipulating an Action.
- *
- * ```ts
- * class Action<T> extends Subscription {
- *   new (scheduler: Scheduler, work: (state?: T) => void);
- *   schedule(state?: T, delay: number = 0): Subscription;
- * }
- * ```
- */
-export declare class Action<T> extends Subscription {
-    constructor(scheduler: Scheduler, work: (this: SchedulerAction<T>, state?: T) => void);
-    /**
-     * Schedules this action on its parent {@link SchedulerLike} for execution. May be passed
-     * some context object, `state`. May happen at some point in the future,
-     * according to the `delay` parameter, if specified.
-     * @param state Some contextual data that the `work` function uses when called by the
-     * Scheduler.
-     * @param delay Time to wait before executing the work, where the time unit is implicit
-     * and defined by the Scheduler.
-     * @return A subscription in order to be able to unsubscribe the scheduled work.
-     */
-    schedule(state?: T, delay?: number): Subscription;
-}
-//# sourceMappingURL=Action.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/AnimationFrameAction.d.ts

@@ -1,12 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AnimationFrameScheduler } from './AnimationFrameScheduler';
-import { SchedulerAction } from '../types';
-import { TimerHandle } from './timerHandle';
-export declare class AnimationFrameAction<T> extends AsyncAction<T> {
-    protected scheduler: AnimationFrameScheduler;
-    protected work: (this: SchedulerAction<T>, state?: T) => void;
-    constructor(scheduler: AnimationFrameScheduler, work: (this: SchedulerAction<T>, state?: T) => void);
-    protected requestAsyncId(scheduler: AnimationFrameScheduler, id?: TimerHandle, delay?: number): TimerHandle;
-    protected recycleAsyncId(scheduler: AnimationFrameScheduler, id?: TimerHandle, delay?: number): TimerHandle | undefined;
-}
-//# sourceMappingURL=AnimationFrameAction.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/AnimationFrameScheduler.d.ts

@@ -1,6 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsyncScheduler } from './AsyncScheduler';
-export declare class AnimationFrameScheduler extends AsyncScheduler {
-    flush(action?: AsyncAction<any>): void;
-}
-//# sourceMappingURL=AnimationFrameScheduler.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/AsapAction.d.ts

@@ -1,12 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsapScheduler } from './AsapScheduler';
-import { SchedulerAction } from '../types';
-import { TimerHandle } from './timerHandle';
-export declare class AsapAction<T> extends AsyncAction<T> {
-    protected scheduler: AsapScheduler;
-    protected work: (this: SchedulerAction<T>, state?: T) => void;
-    constructor(scheduler: AsapScheduler, work: (this: SchedulerAction<T>, state?: T) => void);
-    protected requestAsyncId(scheduler: AsapScheduler, id?: TimerHandle, delay?: number): TimerHandle;
-    protected recycleAsyncId(scheduler: AsapScheduler, id?: TimerHandle, delay?: number): TimerHandle | undefined;
-}
-//# sourceMappingURL=AsapAction.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/AsapScheduler.d.ts

@@ -1,6 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsyncScheduler } from './AsyncScheduler';
-export declare class AsapScheduler extends AsyncScheduler {
-    flush(action?: AsyncAction<any>): void;
-}
-//# sourceMappingURL=AsapScheduler.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/AsyncAction.d.ts

@@ -1,24 +0,0 @@
-import { Action } from './Action';
-import { SchedulerAction } from '../types';
-import { Subscription } from '../Subscription';
-import { AsyncScheduler } from './AsyncScheduler';
-import { TimerHandle } from './timerHandle';
-export declare class AsyncAction<T> extends Action<T> {
-    protected scheduler: AsyncScheduler;
-    protected work: (this: SchedulerAction<T>, state?: T) => void;
-    id: TimerHandle | undefined;
-    state?: T;
-    delay: number;
-    protected pending: boolean;
-    constructor(scheduler: AsyncScheduler, work: (this: SchedulerAction<T>, state?: T) => void);
-    schedule(state?: T, delay?: number): Subscription;
-    protected requestAsyncId(scheduler: AsyncScheduler, _id?: TimerHandle, delay?: number): TimerHandle;
-    protected recycleAsyncId(_scheduler: AsyncScheduler, id?: TimerHandle, delay?: number | null): TimerHandle | undefined;
-    /**
-     * Immediately executes this action and the `work` it contains.
-     */
-    execute(state: T, delay: number): any;
-    protected _execute(state: T, _delay: number): any;
-    unsubscribe(): void;
-}
-//# sourceMappingURL=AsyncAction.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/AsyncScheduler.d.ts

@@ -1,9 +0,0 @@
-import { Scheduler } from '../Scheduler';
-import { Action } from './Action';
-import { AsyncAction } from './AsyncAction';
-export declare class AsyncScheduler extends Scheduler {
-    actions: Array<AsyncAction<any>>;
-    constructor(SchedulerAction: typeof Action, now?: () => number);
-    flush(action: AsyncAction<any>): void;
-}
-//# sourceMappingURL=AsyncScheduler.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/QueueAction.d.ts

@@ -1,14 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { Subscription } from '../Subscription';
-import { QueueScheduler } from './QueueScheduler';
-import { SchedulerAction } from '../types';
-import { TimerHandle } from './timerHandle';
-export declare class QueueAction<T> extends AsyncAction<T> {
-    protected scheduler: QueueScheduler;
-    protected work: (this: SchedulerAction<T>, state?: T) => void;
-    constructor(scheduler: QueueScheduler, work: (this: SchedulerAction<T>, state?: T) => void);
-    schedule(state?: T, delay?: number): Subscription;
-    execute(state: T, delay: number): any;
-    protected requestAsyncId(scheduler: QueueScheduler, id?: TimerHandle, delay?: number): TimerHandle;
-}
-//# sourceMappingURL=QueueAction.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/QueueScheduler.d.ts

@@ -1,4 +0,0 @@
-import { AsyncScheduler } from './AsyncScheduler';
-export declare class QueueScheduler extends AsyncScheduler {
-}
-//# sourceMappingURL=QueueScheduler.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/VirtualTimeScheduler.d.ts

@@ -1,48 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { Subscription } from '../Subscription';
-import { AsyncScheduler } from './AsyncScheduler';
-import { SchedulerAction } from '../types';
-import { TimerHandle } from './timerHandle';
-export declare class VirtualTimeScheduler extends AsyncScheduler {
-    maxFrames: number;
-    /** @deprecated Not used in VirtualTimeScheduler directly. Will be removed in v8. */
-    static frameTimeFactor: number;
-    /**
-     * The current frame for the state of the virtual scheduler instance. The difference
-     * between two "frames" is synonymous with the passage of "virtual time units". So if
-     * you record `scheduler.frame` to be `1`, then later, observe `scheduler.frame` to be at `11`,
-     * that means `10` virtual time units have passed.
-     */
-    frame: number;
-    /**
-     * Used internally to examine the current virtual action index being processed.
-     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-     */
-    index: number;
-    /**
-     * This creates an instance of a `VirtualTimeScheduler`. Experts only. The signature of
-     * this constructor is likely to change in the long run.
-     *
-     * @param schedulerActionCtor The type of Action to initialize when initializing actions during scheduling.
-     * @param maxFrames The maximum number of frames to process before stopping. Used to prevent endless flush cycles.
-     */
-    constructor(schedulerActionCtor?: typeof AsyncAction, maxFrames?: number);
-    /**
-     * Prompt the Scheduler to execute all of its queued actions, therefore
-     * clearing its queue.
-     */
-    flush(): void;
-}
-export declare class VirtualAction<T> extends AsyncAction<T> {
-    protected scheduler: VirtualTimeScheduler;
-    protected work: (this: SchedulerAction<T>, state?: T) => void;
-    protected index: number;
-    protected active: boolean;
-    constructor(scheduler: VirtualTimeScheduler, work: (this: SchedulerAction<T>, state?: T) => void, index?: number);
-    schedule(state?: T, delay?: number): Subscription;
-    protected requestAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): TimerHandle;
-    protected recycleAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): TimerHandle | undefined;
-    protected _execute(state: T, delay: number): any;
-    private static sortActions;
-}
-//# sourceMappingURL=VirtualTimeScheduler.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/animationFrame.d.ts

@@ -1,38 +0,0 @@
-import { AnimationFrameScheduler } from './AnimationFrameScheduler';
-/**
- *
- * Animation Frame Scheduler
- *
- * <span class="informal">Perform task when `window.requestAnimationFrame` would fire</span>
- *
- * When `animationFrame` scheduler is used with delay, it will fall back to {@link asyncScheduler} scheduler
- * behaviour.
- *
- * Without delay, `animationFrame` scheduler can be used to create smooth browser animations.
- * It makes sure scheduled task will happen just before next browser content repaint,
- * thus performing animations as efficiently as possible.
- *
- * ## Example
- * Schedule div height animation
- * ```ts
- * // html: <div style="background: #0ff;"></div>
- * import { animationFrameScheduler } from '../..';
- *
- * const div = document.querySelector('div');
- *
- * animationFrameScheduler.schedule(function(height) {
- *   div.style.height = height + "px";
- *
- *   this.schedule(height + 1);  // `this` references currently executing Action,
- *                               // which we reschedule with new state
- * }, 0, 0);
- *
- * // You will see a div element growing in height
- * ```
- */
-export declare const animationFrameScheduler: AnimationFrameScheduler;
-/**
- * @deprecated Renamed to {@link animationFrameScheduler}. Will be removed in v8.
- */
-export declare const animationFrame: AnimationFrameScheduler;
-//# sourceMappingURL=animationFrame.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/animationFrameProvider.d.ts

@@ -1,13 +0,0 @@
-import { Subscription } from '../Subscription';
-interface AnimationFrameProvider {
-    schedule(callback: FrameRequestCallback): Subscription;
-    requestAnimationFrame: typeof requestAnimationFrame;
-    cancelAnimationFrame: typeof cancelAnimationFrame;
-    delegate: {
-        requestAnimationFrame: typeof requestAnimationFrame;
-        cancelAnimationFrame: typeof cancelAnimationFrame;
-    } | undefined;
-}
-export declare const animationFrameProvider: AnimationFrameProvider;
-export {};
-//# sourceMappingURL=animationFrameProvider.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/asap.d.ts

@@ -1,41 +0,0 @@
-import { AsapScheduler } from './AsapScheduler';
-/**
- *
- * Asap Scheduler
- *
- * <span class="informal">Perform task as fast as it can be performed asynchronously</span>
- *
- * `asap` scheduler behaves the same as {@link asyncScheduler} scheduler when you use it to delay task
- * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing
- * code to end and then it will try to execute given task as fast as possible.
- *
- * `asap` scheduler will do its best to minimize time between end of currently executing code
- * and start of scheduled task. This makes it best candidate for performing so called "deferring".
- * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves
- * some (although minimal) unwanted delay.
- *
- * Note that using `asap` scheduler does not necessarily mean that your task will be first to process
- * after currently executing code. In particular, if some task was also scheduled with `asap` before,
- * that task will execute first. That being said, if you need to schedule task asynchronously, but
- * as soon as possible, `asap` scheduler is your best bet.
- *
- * ## Example
- * Compare async and asap scheduler<
- * ```ts
- * import { asapScheduler, asyncScheduler } from '../..';
- *
- * asyncScheduler.schedule(() => console.log('async')); // scheduling 'async' first...
- * asapScheduler.schedule(() => console.log('asap'));
- *
- * // Logs:
- * // "asap"
- * // "async"
- * // ... but 'asap' goes first!
- * ```
- */
-export declare const asapScheduler: AsapScheduler;
-/**
- * @deprecated Renamed to {@link asapScheduler}. Will be removed in v8.
- */
-export declare const asap: AsapScheduler;
-//# sourceMappingURL=asap.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/async.d.ts

@@ -1,53 +0,0 @@
-import { AsyncScheduler } from './AsyncScheduler';
-/**
- *
- * Async Scheduler
- *
- * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span>
- *
- * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript
- * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating
- * in intervals.
- *
- * If you just want to "defer" task, that is to perform it right after currently
- * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),
- * better choice will be the {@link asapScheduler} scheduler.
- *
- * ## Examples
- * Use async scheduler to delay task
- * ```ts
- * import { asyncScheduler } from '../..';
- *
- * const task = () => console.log('it works!');
- *
- * asyncScheduler.schedule(task, 2000);
- *
- * // After 2 seconds logs:
- * // "it works!"
- * ```
- *
- * Use async scheduler to repeat task in intervals
- * ```ts
- * import { asyncScheduler } from '../..';
- *
- * function task(state) {
- *   console.log(state);
- *   this.schedule(state + 1, 1000); // `this` references currently executing Action,
- *                                   // which we reschedule with new state and delay
- * }
- *
- * asyncScheduler.schedule(task, 3000, 0);
- *
- * // Logs:
- * // 0 after 3s
- * // 1 after 4s
- * // 2 after 5s
- * // 3 after 6s
- * ```
- */
-export declare const asyncScheduler: AsyncScheduler;
-/**
- * @deprecated Renamed to {@link asyncScheduler}. Will be removed in v8.
- */
-export declare const async: AsyncScheduler;
-//# sourceMappingURL=async.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/dateTimestampProvider.d.ts

@@ -1,7 +0,0 @@
-import { TimestampProvider } from '../types';
-interface DateTimestampProvider extends TimestampProvider {
-    delegate: TimestampProvider | undefined;
-}
-export declare const dateTimestampProvider: DateTimestampProvider;
-export {};
-//# sourceMappingURL=dateTimestampProvider.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/immediateProvider.d.ts

@@ -1,14 +0,0 @@
-import type { TimerHandle } from './timerHandle';
-declare type SetImmediateFunction = (handler: () => void, ...args: any[]) => TimerHandle;
-declare type ClearImmediateFunction = (handle: TimerHandle) => void;
-interface ImmediateProvider {
-    setImmediate: SetImmediateFunction;
-    clearImmediate: ClearImmediateFunction;
-    delegate: {
-        setImmediate: SetImmediateFunction;
-        clearImmediate: ClearImmediateFunction;
-    } | undefined;
-}
-export declare const immediateProvider: ImmediateProvider;
-export {};
-//# sourceMappingURL=immediateProvider.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/intervalProvider.d.ts

@@ -1,14 +0,0 @@
-import type { TimerHandle } from './timerHandle';
-declare type SetIntervalFunction = (handler: () => void, timeout?: number, ...args: any[]) => TimerHandle;
-declare type ClearIntervalFunction = (handle: TimerHandle) => void;
-interface IntervalProvider {
-    setInterval: SetIntervalFunction;
-    clearInterval: ClearIntervalFunction;
-    delegate: {
-        setInterval: SetIntervalFunction;
-        clearInterval: ClearIntervalFunction;
-    } | undefined;
-}
-export declare const intervalProvider: IntervalProvider;
-export {};
-//# sourceMappingURL=intervalProvider.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/performanceTimestampProvider.d.ts

@@ -1,7 +0,0 @@
-import { TimestampProvider } from '../types';
-interface PerformanceTimestampProvider extends TimestampProvider {
-    delegate: TimestampProvider | undefined;
-}
-export declare const performanceTimestampProvider: PerformanceTimestampProvider;
-export {};
-//# sourceMappingURL=performanceTimestampProvider.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/queue.d.ts

@@ -1,69 +0,0 @@
-import { QueueScheduler } from './QueueScheduler';
-/**
- *
- * Queue Scheduler
- *
- * <span class="informal">Put every next task on a queue, instead of executing it immediately</span>
- *
- * `queue` scheduler, when used with delay, behaves the same as {@link asyncScheduler} scheduler.
- *
- * When used without delay, it schedules given task synchronously - executes it right when
- * it is scheduled. However when called recursively, that is when inside the scheduled task,
- * another task is scheduled with queue scheduler, instead of executing immediately as well,
- * that task will be put on a queue and wait for current one to finish.
- *
- * This means that when you execute task with `queue` scheduler, you are sure it will end
- * before any other task scheduled with that scheduler will start.
- *
- * ## Examples
- * Schedule recursively first, then do something
- * ```ts
- * import { queueScheduler } from '../..';
- *
- * queueScheduler.schedule(() => {
- *   queueScheduler.schedule(() => console.log('second')); // will not happen now, but will be put on a queue
- *
- *   console.log('first');
- * });
- *
- * // Logs:
- * // "first"
- * // "second"
- * ```
- *
- * Reschedule itself recursively
- * ```ts
- * import { queueScheduler } from '../..';
- *
- * queueScheduler.schedule(function(state) {
- *   if (state !== 0) {
- *     console.log('before', state);
- *     this.schedule(state - 1); // `this` references currently executing Action,
- *                               // which we reschedule with new state
- *     console.log('after', state);
- *   }
- * }, 0, 3);
- *
- * // In scheduler that runs recursively, you would expect:
- * // "before", 3
- * // "before", 2
- * // "before", 1
- * // "after", 1
- * // "after", 2
- * // "after", 3
- *
- * // But with queue it logs:
- * // "before", 3
- * // "after", 3
- * // "before", 2
- * // "after", 2
- * // "before", 1
- * // "after", 1
- * ```
- */
-export declare const queueScheduler: QueueScheduler;
-/**
- * @deprecated Renamed to {@link queueScheduler}. Will be removed in v8.
- */
-export declare const queue: QueueScheduler;
-//# sourceMappingURL=queue.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/timeoutProvider.d.ts

@@ -1,14 +0,0 @@
-import type { TimerHandle } from './timerHandle';
-declare type SetTimeoutFunction = (handler: () => void, timeout?: number, ...args: any[]) => TimerHandle;
-declare type ClearTimeoutFunction = (handle: TimerHandle) => void;
-interface TimeoutProvider {
-    setTimeout: SetTimeoutFunction;
-    clearTimeout: ClearTimeoutFunction;
-    delegate: {
-        setTimeout: SetTimeoutFunction;
-        clearTimeout: ClearTimeoutFunction;
-    } | undefined;
-}
-export declare const timeoutProvider: TimeoutProvider;
-export {};
-//# sourceMappingURL=timeoutProvider.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/scheduler/timerHandle.d.ts

@@ -1,2 +0,0 @@
-export declare type TimerHandle = number | ReturnType<typeof setTimeout>;
-//# sourceMappingURL=timerHandle.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/symbol/iterator.d.ts

@@ -1,3 +0,0 @@
-export declare function getSymbolIterator(): symbol;
-export declare const iterator: symbol;
-//# sourceMappingURL=iterator.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/symbol/observable.d.ts

@@ -1,8 +0,0 @@
-/**
- * Symbol.observable or a string "@@observable". Used for interop
- *
- * @deprecated We will no longer be exporting this symbol in upcoming versions of RxJS.
- * Instead polyfill and use Symbol.observable directly *or* use https://www.npmjs.com/package/symbol-observable
- */
-export declare const observable: string | symbol;
-//# sourceMappingURL=observable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/testing/ColdObservable.d.ts

@@ -1,16 +0,0 @@
-import { Observable } from '../Observable';
-import { Scheduler } from '../Scheduler';
-import { TestMessage } from './TestMessage';
-import { SubscriptionLog } from './SubscriptionLog';
-import { SubscriptionLoggable } from './SubscriptionLoggable';
-import { Subscriber } from '../Subscriber';
-export declare class ColdObservable<T> extends Observable<T> implements SubscriptionLoggable {
-    messages: TestMessage[];
-    subscriptions: SubscriptionLog[];
-    scheduler: Scheduler;
-    logSubscribedFrame: () => number;
-    logUnsubscribedFrame: (index: number) => void;
-    constructor(messages: TestMessage[], scheduler: Scheduler);
-    scheduleMessages(subscriber: Subscriber<any>): void;
-}
-//# sourceMappingURL=ColdObservable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/testing/HotObservable.d.ts

@@ -1,15 +0,0 @@
-import { Subject } from '../Subject';
-import { Scheduler } from '../Scheduler';
-import { TestMessage } from './TestMessage';
-import { SubscriptionLog } from './SubscriptionLog';
-import { SubscriptionLoggable } from './SubscriptionLoggable';
-export declare class HotObservable<T> extends Subject<T> implements SubscriptionLoggable {
-    messages: TestMessage[];
-    subscriptions: SubscriptionLog[];
-    scheduler: Scheduler;
-    logSubscribedFrame: () => number;
-    logUnsubscribedFrame: (index: number) => void;
-    constructor(messages: TestMessage[], scheduler: Scheduler);
-    setup(): void;
-}
-//# sourceMappingURL=HotObservable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/testing/SubscriptionLog.d.ts

@@ -1,6 +0,0 @@
-export declare class SubscriptionLog {
-    subscribedFrame: number;
-    unsubscribedFrame: number;
-    constructor(subscribedFrame: number, unsubscribedFrame?: number);
-}
-//# sourceMappingURL=SubscriptionLog.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/testing/SubscriptionLoggable.d.ts

@@ -1,9 +0,0 @@
-import { Scheduler } from '../Scheduler';
-import { SubscriptionLog } from './SubscriptionLog';
-export declare class SubscriptionLoggable {
-    subscriptions: SubscriptionLog[];
-    scheduler: Scheduler;
-    logSubscribedFrame(): number;
-    logUnsubscribedFrame(index: number): void;
-}
-//# sourceMappingURL=SubscriptionLoggable.d.ts.map