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

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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,14 @@
+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

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

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,9 @@
+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