ngxsmk-datepicker 1.2.9 → 1.3.0

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/windowToggle.d.ts

@@ -1,49 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInput, OperatorFunction } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable starting from
- * an emission from `openings` and ending when the output of `closingSelector`
- * emits.
- *
- * <span class="informal">It's like {@link bufferToggle}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowToggle.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits windows that contain those items
- * emitted by the source Observable between the time when the `openings`
- * Observable emits an item and when the Observable returned by
- * `closingSelector` emits an item.
- *
- * ## Example
- *
- * Every other second, emit the click events from the next 500ms
- *
- * ```ts
- * import { fromEvent, interval, windowToggle, EMPTY, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const openings = interval(1000);
- * const result = clicks.pipe(
- *   windowToggle(openings, i => i % 2 ? interval(500) : EMPTY),
- *   mergeAll()
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowWhen}
- * @see {@link bufferToggle}
- *
- * @param openings An observable of notifications to start new windows.
- * @param closingSelector A function that takes the value emitted by the
- * `openings` observable and returns an Observable, which, when it emits a next
- * notification, signals that the associated window should complete.
- * @return A function that returns an Observable of windows, which in turn are
- * Observables.
- */
-export declare function windowToggle<T, O>(openings: ObservableInput<O>, closingSelector: (openValue: O) => ObservableInput<any>): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowToggle.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/windowWhen.d.ts

@@ -1,49 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInput, OperatorFunction } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable using a
- * factory function of closing Observables to determine when to start a new
- * window.
- *
- * <span class="informal">It's like {@link bufferWhen}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowWhen.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits connected, non-overlapping windows.
- * It emits the current window and opens a new one whenever the Observable
- * produced by the specified `closingSelector` function emits an item. The first
- * window is opened immediately when subscribing to the output Observable.
- *
- * ## Example
- *
- * Emit only the first two clicks events in every window of [1-5] random seconds
- *
- * ```ts
- * import { fromEvent, windowWhen, interval, map, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowWhen(() => interval(1000 + Math.random() * 4000)),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link bufferWhen}
- *
- * @param closingSelector A function that takes no arguments and returns an
- * {@link ObservableInput} (that gets converted to Observable) that signals
- * (on either `next` or `complete`) when to close the previous window and
- * start a new one.
- * @return A function that returns an Observable of windows, which in turn are
- * Observables.
- */
-export declare function windowWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowWhen.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/withLatestFrom.d.ts

@@ -1,4 +0,0 @@
-import { OperatorFunction, ObservableInputTuple } from '../types';
-export declare function withLatestFrom<T, O extends unknown[]>(...inputs: [...ObservableInputTuple<O>]): OperatorFunction<T, [T, ...O]>;
-export declare function withLatestFrom<T, O extends unknown[], R>(...inputs: [...ObservableInputTuple<O>, (...value: [T, ...O]) => R]): OperatorFunction<T, R>;
-//# sourceMappingURL=withLatestFrom.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/internal/operators/zip.d.ts

@@ -1,10 +0,0 @@
-import { ObservableInputTuple, OperatorFunction, Cons } from '../types';
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[]>(otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[], R>(otherInputsAndProject: [...ObservableInputTuple<A>], project: (...values: Cons<T, A>) => R): OperatorFunction<T, R>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[]>(...otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[], R>(...otherInputsAndProject: [...ObservableInputTuple<A>, (...values: Cons<T, A>) => R]): OperatorFunction<T, R>;
-//# sourceMappingURL=zip.d.ts.map

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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 'rxjs';
- *
- * 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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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 'rxjs';
- *
- * 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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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 'rxjs';
- *
- * 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 'rxjs';
- *
- * 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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/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