ngxsmk-datepicker 1.2.9 → 1.3.1

package/projects/ngxsmk-datepicker/node_modules/rxjs/dist/types/index.d.ts

@@ -1,173 +0,0 @@
-/// <reference path="operators/index.d.ts" />
-/// <reference path="testing/index.d.ts" />
-export { Observable } from './internal/Observable';
-export { ConnectableObservable } from './internal/observable/ConnectableObservable';
-export { GroupedObservable } from './internal/operators/groupBy';
-export { Operator } from './internal/Operator';
-export { observable } from './internal/symbol/observable';
-export { animationFrames } from './internal/observable/dom/animationFrames';
-export { Subject } from './internal/Subject';
-export { BehaviorSubject } from './internal/BehaviorSubject';
-export { ReplaySubject } from './internal/ReplaySubject';
-export { AsyncSubject } from './internal/AsyncSubject';
-export { asap, asapScheduler } from './internal/scheduler/asap';
-export { async, asyncScheduler } from './internal/scheduler/async';
-export { queue, queueScheduler } from './internal/scheduler/queue';
-export { animationFrame, animationFrameScheduler } from './internal/scheduler/animationFrame';
-export { VirtualTimeScheduler, VirtualAction } from './internal/scheduler/VirtualTimeScheduler';
-export { Scheduler } from './internal/Scheduler';
-export { Subscription } from './internal/Subscription';
-export { Subscriber } from './internal/Subscriber';
-export { Notification, NotificationKind } from './internal/Notification';
-export { pipe } from './internal/util/pipe';
-export { noop } from './internal/util/noop';
-export { identity } from './internal/util/identity';
-export { isObservable } from './internal/util/isObservable';
-export { lastValueFrom } from './internal/lastValueFrom';
-export { firstValueFrom } from './internal/firstValueFrom';
-export { ArgumentOutOfRangeError } from './internal/util/ArgumentOutOfRangeError';
-export { EmptyError } from './internal/util/EmptyError';
-export { NotFoundError } from './internal/util/NotFoundError';
-export { ObjectUnsubscribedError } from './internal/util/ObjectUnsubscribedError';
-export { SequenceError } from './internal/util/SequenceError';
-export { TimeoutError } from './internal/operators/timeout';
-export { UnsubscriptionError } from './internal/util/UnsubscriptionError';
-export { bindCallback } from './internal/observable/bindCallback';
-export { bindNodeCallback } from './internal/observable/bindNodeCallback';
-export { combineLatest } from './internal/observable/combineLatest';
-export { concat } from './internal/observable/concat';
-export { connectable } from './internal/observable/connectable';
-export { defer } from './internal/observable/defer';
-export { empty } from './internal/observable/empty';
-export { forkJoin } from './internal/observable/forkJoin';
-export { from } from './internal/observable/from';
-export { fromEvent } from './internal/observable/fromEvent';
-export { fromEventPattern } from './internal/observable/fromEventPattern';
-export { generate } from './internal/observable/generate';
-export { iif } from './internal/observable/iif';
-export { interval } from './internal/observable/interval';
-export { merge } from './internal/observable/merge';
-export { never } from './internal/observable/never';
-export { of } from './internal/observable/of';
-export { onErrorResumeNext } from './internal/observable/onErrorResumeNext';
-export { pairs } from './internal/observable/pairs';
-export { partition } from './internal/observable/partition';
-export { race } from './internal/observable/race';
-export { range } from './internal/observable/range';
-export { throwError } from './internal/observable/throwError';
-export { timer } from './internal/observable/timer';
-export { using } from './internal/observable/using';
-export { zip } from './internal/observable/zip';
-export { scheduled } from './internal/scheduled/scheduled';
-export { EMPTY } from './internal/observable/empty';
-export { NEVER } from './internal/observable/never';
-export * from './internal/types';
-export { config, GlobalConfig } from './internal/config';
-export { audit } from './internal/operators/audit';
-export { auditTime } from './internal/operators/auditTime';
-export { buffer } from './internal/operators/buffer';
-export { bufferCount } from './internal/operators/bufferCount';
-export { bufferTime } from './internal/operators/bufferTime';
-export { bufferToggle } from './internal/operators/bufferToggle';
-export { bufferWhen } from './internal/operators/bufferWhen';
-export { catchError } from './internal/operators/catchError';
-export { combineAll } from './internal/operators/combineAll';
-export { combineLatestAll } from './internal/operators/combineLatestAll';
-export { combineLatestWith } from './internal/operators/combineLatestWith';
-export { concatAll } from './internal/operators/concatAll';
-export { concatMap } from './internal/operators/concatMap';
-export { concatMapTo } from './internal/operators/concatMapTo';
-export { concatWith } from './internal/operators/concatWith';
-export { connect, ConnectConfig } from './internal/operators/connect';
-export { count } from './internal/operators/count';
-export { debounce } from './internal/operators/debounce';
-export { debounceTime } from './internal/operators/debounceTime';
-export { defaultIfEmpty } from './internal/operators/defaultIfEmpty';
-export { delay } from './internal/operators/delay';
-export { delayWhen } from './internal/operators/delayWhen';
-export { dematerialize } from './internal/operators/dematerialize';
-export { distinct } from './internal/operators/distinct';
-export { distinctUntilChanged } from './internal/operators/distinctUntilChanged';
-export { distinctUntilKeyChanged } from './internal/operators/distinctUntilKeyChanged';
-export { elementAt } from './internal/operators/elementAt';
-export { endWith } from './internal/operators/endWith';
-export { every } from './internal/operators/every';
-export { exhaust } from './internal/operators/exhaust';
-export { exhaustAll } from './internal/operators/exhaustAll';
-export { exhaustMap } from './internal/operators/exhaustMap';
-export { expand } from './internal/operators/expand';
-export { filter } from './internal/operators/filter';
-export { finalize } from './internal/operators/finalize';
-export { find } from './internal/operators/find';
-export { findIndex } from './internal/operators/findIndex';
-export { first } from './internal/operators/first';
-export { groupBy, BasicGroupByOptions, GroupByOptionsWithElement } from './internal/operators/groupBy';
-export { ignoreElements } from './internal/operators/ignoreElements';
-export { isEmpty } from './internal/operators/isEmpty';
-export { last } from './internal/operators/last';
-export { map } from './internal/operators/map';
-export { mapTo } from './internal/operators/mapTo';
-export { materialize } from './internal/operators/materialize';
-export { max } from './internal/operators/max';
-export { mergeAll } from './internal/operators/mergeAll';
-export { flatMap } from './internal/operators/flatMap';
-export { mergeMap } from './internal/operators/mergeMap';
-export { mergeMapTo } from './internal/operators/mergeMapTo';
-export { mergeScan } from './internal/operators/mergeScan';
-export { mergeWith } from './internal/operators/mergeWith';
-export { min } from './internal/operators/min';
-export { multicast } from './internal/operators/multicast';
-export { observeOn } from './internal/operators/observeOn';
-export { onErrorResumeNextWith } from './internal/operators/onErrorResumeNextWith';
-export { pairwise } from './internal/operators/pairwise';
-export { pluck } from './internal/operators/pluck';
-export { publish } from './internal/operators/publish';
-export { publishBehavior } from './internal/operators/publishBehavior';
-export { publishLast } from './internal/operators/publishLast';
-export { publishReplay } from './internal/operators/publishReplay';
-export { raceWith } from './internal/operators/raceWith';
-export { reduce } from './internal/operators/reduce';
-export { repeat, RepeatConfig } from './internal/operators/repeat';
-export { repeatWhen } from './internal/operators/repeatWhen';
-export { retry, RetryConfig } from './internal/operators/retry';
-export { retryWhen } from './internal/operators/retryWhen';
-export { refCount } from './internal/operators/refCount';
-export { sample } from './internal/operators/sample';
-export { sampleTime } from './internal/operators/sampleTime';
-export { scan } from './internal/operators/scan';
-export { sequenceEqual } from './internal/operators/sequenceEqual';
-export { share, ShareConfig } from './internal/operators/share';
-export { shareReplay, ShareReplayConfig } from './internal/operators/shareReplay';
-export { single } from './internal/operators/single';
-export { skip } from './internal/operators/skip';
-export { skipLast } from './internal/operators/skipLast';
-export { skipUntil } from './internal/operators/skipUntil';
-export { skipWhile } from './internal/operators/skipWhile';
-export { startWith } from './internal/operators/startWith';
-export { subscribeOn } from './internal/operators/subscribeOn';
-export { switchAll } from './internal/operators/switchAll';
-export { switchMap } from './internal/operators/switchMap';
-export { switchMapTo } from './internal/operators/switchMapTo';
-export { switchScan } from './internal/operators/switchScan';
-export { take } from './internal/operators/take';
-export { takeLast } from './internal/operators/takeLast';
-export { takeUntil } from './internal/operators/takeUntil';
-export { takeWhile } from './internal/operators/takeWhile';
-export { tap, TapObserver } from './internal/operators/tap';
-export { throttle, ThrottleConfig } from './internal/operators/throttle';
-export { throttleTime } from './internal/operators/throttleTime';
-export { throwIfEmpty } from './internal/operators/throwIfEmpty';
-export { timeInterval } from './internal/operators/timeInterval';
-export { timeout, TimeoutConfig, TimeoutInfo } from './internal/operators/timeout';
-export { timeoutWith } from './internal/operators/timeoutWith';
-export { timestamp } from './internal/operators/timestamp';
-export { toArray } from './internal/operators/toArray';
-export { window } from './internal/operators/window';
-export { windowCount } from './internal/operators/windowCount';
-export { windowTime } from './internal/operators/windowTime';
-export { windowToggle } from './internal/operators/windowToggle';
-export { windowWhen } from './internal/operators/windowWhen';
-export { withLatestFrom } from './internal/operators/withLatestFrom';
-export { zipAll } from './internal/operators/zipAll';
-export { zipWith } from './internal/operators/zipWith';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +0,0 @@
-declare const anyCatcherSymbol: unique symbol;
-/**
- * This is just a type that we're using to identify `any` being passed to
- * function overloads. This is used because of situations like {@link forkJoin},
- * where it could return an `Observable<T[]>` or an `Observable<{ [key: K]: T }>`,
- * so `forkJoin(any)` would mean we need to return `Observable<unknown>`.
- */
-export declare type AnyCatcher = typeof anyCatcherSymbol;
-export {};
-//# sourceMappingURL=AnyCatcher.d.ts.map

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

@@ -1,13 +0,0 @@
-import { Subject } from './Subject';
-/**
- * A variant of Subject that only emits a value when it completes. It will emit
- * its latest value to all its observers on completion.
- */
-export declare class AsyncSubject<T> extends Subject<T> {
-    private _value;
-    private _hasValue;
-    private _isComplete;
-    next(value: T): void;
-    complete(): void;
-}
-//# sourceMappingURL=AsyncSubject.d.ts.map

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

@@ -1,13 +0,0 @@
-import { Subject } from './Subject';
-/**
- * A variant of Subject that requires an initial value and emits its current
- * value whenever it is subscribed to.
- */
-export declare class BehaviorSubject<T> extends Subject<T> {
-    private _value;
-    constructor(_value: T);
-    get value(): T;
-    getValue(): T;
-    next(value: T): void;
-}
-//# sourceMappingURL=BehaviorSubject.d.ts.map

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

@@ -1,175 +0,0 @@
-import { PartialObserver, ObservableNotification, CompleteNotification, NextNotification, ErrorNotification } from './types';
-import { Observable } from './Observable';
-/**
- * @deprecated Use a string literal instead. `NotificationKind` will be replaced with a type alias in v8.
- * It will not be replaced with a const enum as those are not compatible with isolated modules.
- */
-export declare enum NotificationKind {
-    NEXT = "N",
-    ERROR = "E",
-    COMPLETE = "C"
-}
-/**
- * Represents a push-based event or value that an {@link Observable} can emit.
- * This class is particularly useful for operators that manage notifications,
- * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and
- * others. Besides wrapping the actual delivered value, it also annotates it
- * with metadata of, for instance, what type of push message it is (`next`,
- * `error`, or `complete`).
- *
- * @see {@link materialize}
- * @see {@link dematerialize}
- * @see {@link observeOn}
- * @deprecated It is NOT recommended to create instances of `Notification` directly.
- * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
- * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
- * Will be removed in v8.
- */
-export declare class Notification<T> {
-    readonly kind: 'N' | 'E' | 'C';
-    readonly value?: T | undefined;
-    readonly error?: any;
-    /**
-     * A value signifying that the notification will "next" if observed. In truth,
-     * This is really synonymous with just checking `kind === "N"`.
-     * @deprecated Will be removed in v8. Instead, just check to see if the value of `kind` is `"N"`.
-     */
-    readonly hasValue: boolean;
-    /**
-     * Creates a "Next" notification object.
-     * @param kind Always `'N'`
-     * @param value The value to notify with if observed.
-     * @deprecated Internal implementation detail. Use {@link Notification#createNext createNext} instead.
-     */
-    constructor(kind: 'N', value?: T);
-    /**
-     * Creates an "Error" notification object.
-     * @param kind Always `'E'`
-     * @param value Always `undefined`
-     * @param error The error to notify with if observed.
-     * @deprecated Internal implementation detail. Use {@link Notification#createError createError} instead.
-     */
-    constructor(kind: 'E', value: undefined, error: any);
-    /**
-     * Creates a "completion" notification object.
-     * @param kind Always `'C'`
-     * @deprecated Internal implementation detail. Use {@link Notification#createComplete createComplete} instead.
-     */
-    constructor(kind: 'C');
-    /**
-     * Executes the appropriate handler on a passed `observer` given the `kind` of notification.
-     * If the handler is missing it will do nothing. Even if the notification is an error, if
-     * there is no error handler on the observer, an error will not be thrown, it will noop.
-     * @param observer The observer to notify.
-     */
-    observe(observer: PartialObserver<T>): void;
-    /**
-     * Executes a notification on the appropriate handler from a list provided.
-     * If a handler is missing for the kind of notification, nothing is called
-     * and no error is thrown, it will be a noop.
-     * @param next A next handler
-     * @param error An error handler
-     * @param complete A complete handler
-     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
-     */
-    do(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;
-    /**
-     * Executes a notification on the appropriate handler from a list provided.
-     * If a handler is missing for the kind of notification, nothing is called
-     * and no error is thrown, it will be a noop.
-     * @param next A next handler
-     * @param error An error handler
-     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
-     */
-    do(next: (value: T) => void, error: (err: any) => void): void;
-    /**
-     * Executes the next handler if the Notification is of `kind` `"N"`. Otherwise
-     * this will not error, and it will be a noop.
-     * @param next The next handler
-     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
-     */
-    do(next: (value: T) => void): void;
-    /**
-     * Executes a notification on the appropriate handler from a list provided.
-     * If a handler is missing for the kind of notification, nothing is called
-     * and no error is thrown, it will be a noop.
-     * @param next A next handler
-     * @param error An error handler
-     * @param complete A complete handler
-     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
-     */
-    accept(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;
-    /**
-     * Executes a notification on the appropriate handler from a list provided.
-     * If a handler is missing for the kind of notification, nothing is called
-     * and no error is thrown, it will be a noop.
-     * @param next A next handler
-     * @param error An error handler
-     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
-     */
-    accept(next: (value: T) => void, error: (err: any) => void): void;
-    /**
-     * Executes the next handler if the Notification is of `kind` `"N"`. Otherwise
-     * this will not error, and it will be a noop.
-     * @param next The next handler
-     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
-     */
-    accept(next: (value: T) => void): void;
-    /**
-     * Executes the appropriate handler on a passed `observer` given the `kind` of notification.
-     * If the handler is missing it will do nothing. Even if the notification is an error, if
-     * there is no error handler on the observer, an error will not be thrown, it will noop.
-     * @param observer The observer to notify.
-     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
-     */
-    accept(observer: PartialObserver<T>): void;
-    /**
-     * Returns a simple Observable that just delivers the notification represented
-     * by this Notification instance.
-     *
-     * @deprecated Will be removed in v8. To convert a `Notification` to an {@link Observable},
-     * use {@link of} and {@link dematerialize}: `of(notification).pipe(dematerialize())`.
-     */
-    toObservable(): Observable<T>;
-    private static completeNotification;
-    /**
-     * A shortcut to create a Notification instance of the type `next` from a
-     * given value.
-     * @param value The `next` value.
-     * @return The "next" Notification representing the argument.
-     * @deprecated It is NOT recommended to create instances of `Notification` directly.
-     * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
-     * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
-     * Will be removed in v8.
-     */
-    static createNext<T>(value: T): Notification<T> & NextNotification<T>;
-    /**
-     * A shortcut to create a Notification instance of the type `error` from a
-     * given error.
-     * @param err The `error` error.
-     * @return The "error" Notification representing the argument.
-     * @deprecated It is NOT recommended to create instances of `Notification` directly.
-     * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
-     * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
-     * Will be removed in v8.
-     */
-    static createError(err?: any): Notification<never> & ErrorNotification;
-    /**
-     * A shortcut to create a Notification instance of the type `complete`.
-     * @return The valueless "complete" Notification.
-     * @deprecated It is NOT recommended to create instances of `Notification` directly.
-     * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
-     * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
-     * Will be removed in v8.
-     */
-    static createComplete(): Notification<never> & CompleteNotification;
-}
-/**
- * Executes the appropriate handler on a passed `observer` given the `kind` of notification.
- * If the handler is missing it will do nothing. Even if the notification is an error, if
- * there is no error handler on the observer, an error will not be thrown, it will noop.
- * @param notification The notification object to observe.
- * @param observer The observer to notify.
- */
-export declare function observeNotification<T>(notification: ObservableNotification<T>, observer: PartialObserver<T>): void;
-//# sourceMappingURL=Notification.d.ts.map

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=NotificationFactories.d.ts.map

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

@@ -1,121 +0,0 @@
-import { Operator } from './Operator';
-import { Subscriber } from './Subscriber';
-import { Subscription } from './Subscription';
-import { TeardownLogic, OperatorFunction, Subscribable, Observer } from './types';
-/**
- * A representation of any set of values over any amount of time. This is the most basic building block
- * of RxJS.
- */
-export declare class Observable<T> implements Subscribable<T> {
-    /**
-     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-     */
-    source: Observable<any> | undefined;
-    /**
-     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-     */
-    operator: Operator<any, T> | undefined;
-    /**
-     * @param subscribe The function that is called when the Observable is
-     * initially subscribed to. This function is given a Subscriber, to which new values
-     * can be `next`ed, or an `error` method can be called to raise an error, or
-     * `complete` can be called to notify of a successful completion.
-     */
-    constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
-    /**
-     * Creates a new Observable by calling the Observable constructor
-     * @param subscribe the subscriber function to be passed to the Observable constructor
-     * @return A new observable.
-     * @deprecated Use `new Observable()` instead. Will be removed in v8.
-     */
-    static create: (...args: any[]) => any;
-    /**
-     * Creates a new Observable, with this Observable instance as the source, and the passed
-     * operator defined as the new observable's operator.
-     * @param operator the operator defining the operation to take on the observable
-     * @return A new observable with the Operator applied.
-     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-     * If you have implemented an operator using `lift`, it is recommended that you create an
-     * operator by simply returning `new Observable()` directly. See "Creating new operators from
-     * scratch" section here: https://rxjs.dev/guide/operators
-     */
-    lift<R>(operator?: Operator<T, R>): Observable<R>;
-    subscribe(observerOrNext?: Partial<Observer<T>> | ((value: T) => void)): Subscription;
-    /** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
-    subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
-    /**
-     * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
-     * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
-     *
-     * **WARNING**: Only use this with observables you *know* will complete. If the source
-     * observable does not complete, you will end up with a promise that is hung up, and
-     * potentially all of the state of an async function hanging out in memory. To avoid
-     * this situation, look into adding something like {@link timeout}, {@link take},
-     * {@link takeWhile}, or {@link takeUntil} amongst others.
-     *
-     * #### Example
-     *
-     * ```ts
-     * import { interval, take } from 'rxjs';
-     *
-     * const source$ = interval(1000).pipe(take(4));
-     *
-     * async function getTotal() {
-     *   let total = 0;
-     *
-     *   await source$.forEach(value => {
-     *     total += value;
-     *     console.log('observable -> ' + value);
-     *   });
-     *
-     *   return total;
-     * }
-     *
-     * getTotal().then(
-     *   total => console.log('Total: ' + total)
-     * );
-     *
-     * // Expected:
-     * // 'observable -> 0'
-     * // 'observable -> 1'
-     * // 'observable -> 2'
-     * // 'observable -> 3'
-     * // 'Total: 6'
-     * ```
-     *
-     * @param next A handler for each value emitted by the observable.
-     * @return A promise that either resolves on observable completion or
-     * rejects with the handled error.
-     */
-    forEach(next: (value: T) => void): Promise<void>;
-    /**
-     * @param next a handler for each value emitted by the observable
-     * @param promiseCtor a constructor function used to instantiate the Promise
-     * @return a promise that either resolves on observable completion or
-     *  rejects with the handled error
-     * @deprecated Passing a Promise constructor will no longer be available
-     * in upcoming versions of RxJS. This is because it adds weight to the library, for very
-     * little benefit. If you need this functionality, it is recommended that you either
-     * polyfill Promise, or you create an adapter to convert the returned native promise
-     * to whatever promise implementation you wanted. Will be removed in v8.
-     */
-    forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
-    pipe(): Observable<T>;
-    pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
-    pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
-    pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
-    pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
-    pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
-    pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
-    pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
-    pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
-    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
-    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;
-    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-    toPromise(): Promise<T | undefined>;
-    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-    toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
-    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-    toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
-}
-//# sourceMappingURL=Observable.d.ts.map

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

@@ -1,9 +0,0 @@
-import { Subscriber } from './Subscriber';
-import { TeardownLogic } from './types';
-/***
- * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
- */
-export interface Operator<T, R> {
-    call(subscriber: Subscriber<R>, source: any): TeardownLogic;
-}
-//# sourceMappingURL=Operator.d.ts.map

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

@@ -1,49 +0,0 @@
-import { Subject } from './Subject';
-import { TimestampProvider } from './types';
-/**
- * A variant of {@link Subject} that "replays" old values to new subscribers by emitting them when they first subscribe.
- *
- * `ReplaySubject` has an internal buffer that will store a specified number of values that it has observed. Like `Subject`,
- * `ReplaySubject` "observes" values by having them passed to its `next` method. When it observes a value, it will store that
- * value for a time determined by the configuration of the `ReplaySubject`, as passed to its constructor.
- *
- * When a new subscriber subscribes to the `ReplaySubject` instance, it will synchronously emit all values in its buffer in
- * a First-In-First-Out (FIFO) manner. The `ReplaySubject` will also complete, if it has observed completion; and it will
- * error if it has observed an error.
- *
- * There are two main configuration items to be concerned with:
- *
- * 1. `bufferSize` - This will determine how many items are stored in the buffer, defaults to infinite.
- * 2. `windowTime` - The amount of time to hold a value in the buffer before removing it from the buffer.
- *
- * Both configurations may exist simultaneously. So if you would like to buffer a maximum of 3 values, as long as the values
- * are less than 2 seconds old, you could do so with a `new ReplaySubject(3, 2000)`.
- *
- * ### Differences with BehaviorSubject
- *
- * `BehaviorSubject` is similar to `new ReplaySubject(1)`, with a couple of exceptions:
- *
- * 1. `BehaviorSubject` comes "primed" with a single value upon construction.
- * 2. `ReplaySubject` will replay values, even after observing an error, where `BehaviorSubject` will not.
- *
- * @see {@link Subject}
- * @see {@link BehaviorSubject}
- * @see {@link shareReplay}
- */
-export declare class ReplaySubject<T> extends Subject<T> {
-    private _bufferSize;
-    private _windowTime;
-    private _timestampProvider;
-    private _buffer;
-    private _infiniteTimeWindow;
-    /**
-     * @param _bufferSize The size of the buffer to replay on subscription
-     * @param _windowTime The amount of time the buffered items will stay buffered
-     * @param _timestampProvider An object with a `now()` method that provides the current timestamp. This is used to
-     * calculate the amount of time something has been buffered.
-     */
-    constructor(_bufferSize?: number, _windowTime?: number, _timestampProvider?: TimestampProvider);
-    next(value: T): void;
-    private _trimBuffer;
-}
-//# sourceMappingURL=ReplaySubject.d.ts.map

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

@@ -1,53 +0,0 @@
-import { Action } from './scheduler/Action';
-import { Subscription } from './Subscription';
-import { SchedulerLike, SchedulerAction } from './types';
-/**
- * An execution context and a data structure to order tasks and schedule their
- * execution. Provides a notion of (potentially virtual) time, through the
- * `now()` getter method.
- *
- * Each unit of work in a Scheduler is called an `Action`.
- *
- * ```ts
- * class Scheduler {
- *   now(): number;
- *   schedule(work, delay?, state?): Subscription;
- * }
- * ```
- *
- * @deprecated Scheduler is an internal implementation detail of RxJS, and
- * should not be used directly. Rather, create your own class and implement
- * {@link SchedulerLike}. Will be made internal in v8.
- */
-export declare class Scheduler implements SchedulerLike {
-    private schedulerActionCtor;
-    static now: () => number;
-    constructor(schedulerActionCtor: typeof Action, now?: () => number);
-    /**
-     * A getter method that returns a number representing the current time
-     * (at the time this function was called) according to the scheduler's own
-     * internal clock.
-     * @return A number that represents the current time. May or may not
-     * have a relation to wall-clock time. May or may not refer to a time unit
-     * (e.g. milliseconds).
-     */
-    now: () => number;
-    /**
-     * Schedules a function, `work`, for execution. May happen at some point in
-     * the future, according to the `delay` parameter, if specified. May be passed
-     * some context object, `state`, which will be passed to the `work` function.
-     *
-     * The given arguments will be processed an stored as an Action object in a
-     * queue of actions.
-     *
-     * @param work A function representing a task, or some unit of work to be
-     * executed by the Scheduler.
-     * @param delay Time to wait before executing the work, where the time unit is
-     * implicit and defined by the Scheduler itself.
-     * @param state Some contextual data that the `work` function uses when called
-     * by the Scheduler.
-     * @return A subscription in order to be able to unsubscribe the scheduled work.
-     */
-    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
-}
-//# sourceMappingURL=Scheduler.d.ts.map