ngxsmk-datepicker 1.2.9 → 1.3.1

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

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

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

@@ -1,62 +0,0 @@
-import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-/**
- * Converts a higher-order Observable into a first-order Observable which
- * concurrently delivers all values that are emitted on the inner Observables.
- *
- * <span class="informal">Flattens an Observable-of-Observables.</span>
- *
- * ![](mergeAll.png)
- *
- * `mergeAll` subscribes to an Observable that emits Observables, also known as
- * a higher-order Observable. Each time it observes one of these emitted inner
- * Observables, it subscribes to that and delivers all the values from the
- * inner Observable on the output Observable. The output Observable only
- * completes once all inner Observables have completed. Any error delivered by
- * a inner Observable will be immediately emitted on the output Observable.
- *
- * ## Examples
- *
- * Spawn a new interval Observable for each click event, and blend their outputs as one Observable
- *
- * ```ts
- * import { fromEvent, map, interval, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const higherOrder = clicks.pipe(map(() => interval(1000)));
- * const firstOrder = higherOrder.pipe(mergeAll());
- *
- * firstOrder.subscribe(x => console.log(x));
- * ```
- *
- * Count from 0 to 9 every second for each click, but only allow 2 concurrent timers
- *
- * ```ts
- * import { fromEvent, map, interval, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const higherOrder = clicks.pipe(
- *   map(() => interval(1000).pipe(take(10)))
- * );
- * const firstOrder = higherOrder.pipe(mergeAll(2));
- *
- * firstOrder.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link combineLatestAll}
- * @see {@link concatAll}
- * @see {@link exhaustAll}
- * @see {@link merge}
- * @see {@link mergeMap}
- * @see {@link mergeMapTo}
- * @see {@link mergeScan}
- * @see {@link switchAll}
- * @see {@link switchMap}
- * @see {@link zipAll}
- *
- * @param concurrent Maximum number of inner Observables being subscribed to
- * concurrently.
- * @return A function that returns an Observable that emits values coming from
- * all the inner Observables emitted by the source Observable.
- */
-export declare function mergeAll<O extends ObservableInput<any>>(concurrent?: number): OperatorFunction<O, ObservedValueOf<O>>;
-//# sourceMappingURL=mergeAll.d.ts.map

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

@@ -1,18 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { ObservableInput, SchedulerLike } from '../types';
-/**
- * A process embodying the general "merge" strategy. This is used in
- * `mergeMap` and `mergeScan` because the logic is otherwise nearly identical.
- * @param source The original source observable
- * @param subscriber The consumer subscriber
- * @param project The projection function to get our inner sources
- * @param concurrent The number of concurrent inner subscriptions
- * @param onBeforeNext Additional logic to apply before nexting to our consumer
- * @param expand If `true` this will perform an "expand" strategy, which differs only
- * in that it recurses, and the inner subscription must be schedule-able.
- * @param innerSubScheduler A scheduler to use to schedule inner subscriptions,
- * this is to support the expand strategy, mostly, and should be deprecated
- */
-export declare function mergeInternals<T, R>(source: Observable<T>, subscriber: Subscriber<R>, project: (value: T, index: number) => ObservableInput<R>, concurrent: number, onBeforeNext?: (innerValue: R) => void, expand?: boolean, innerSubScheduler?: SchedulerLike, additionalFinalizer?: () => void): () => void;
-//# sourceMappingURL=mergeInternals.d.ts.map

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

@@ -1,7 +0,0 @@
-import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
-export declare function mergeMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, concurrent?: number): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export declare function mergeMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined, concurrent?: number): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export declare function mergeMap<T, R, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R, concurrent?: number): OperatorFunction<T, R>;
-//# sourceMappingURL=mergeMap.d.ts.map

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

@@ -1,9 +0,0 @@
-import { OperatorFunction, ObservedValueOf, ObservableInput } from '../types';
-/** @deprecated Will be removed in v9. Use {@link mergeMap} instead: `mergeMap(() => result)` */
-export declare function mergeMapTo<O extends ObservableInput<unknown>>(innerObservable: O, concurrent?: number): OperatorFunction<unknown, ObservedValueOf<O>>;
-/**
- * @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead.
- * Details: https://rxjs.dev/deprecations/resultSelector
- */
-export declare function mergeMapTo<T, R, O extends ObservableInput<unknown>>(innerObservable: O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R, concurrent?: number): OperatorFunction<T, R>;
-//# sourceMappingURL=mergeMapTo.d.ts.map

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

@@ -1,68 +0,0 @@
-import { ObservableInput, OperatorFunction } from '../types';
-/**
- * Applies an accumulator function over the source Observable where the
- * accumulator function itself returns an Observable, then each intermediate
- * Observable returned is merged into the output Observable.
- *
- * <span class="informal">It's like {@link scan}, but the Observables returned
- * by the accumulator are merged into the outer Observable.</span>
- *
- * The first parameter of the `mergeScan` is an `accumulator` function which is
- * being called every time the source Observable emits a value. `mergeScan` will
- * subscribe to the value returned by the `accumulator` function and will emit
- * values to the subscriber emitted by inner Observable.
- *
- * The `accumulator` function is being called with three parameters passed to it:
- * `acc`, `value` and `index`. The `acc` parameter is used as the state parameter
- * whose value is initially set to the `seed` parameter (the second parameter
- * passed to the `mergeScan` operator).
- *
- * `mergeScan` internally keeps the value of the `acc` parameter: as long as the
- * source Observable emits without inner Observable emitting, the `acc` will be
- * set to `seed`. The next time the inner Observable emits a value, `mergeScan`
- * will internally remember it and it will be passed to the `accumulator`
- * function as `acc` parameter the next time source emits.
- *
- * The `value` parameter of the `accumulator` function is the value emitted by the
- * source Observable, while the `index` is a number which represent the order of the
- * current emission by the source Observable. It starts with 0.
- *
- * The last parameter to the `mergeScan` is the `concurrent` value which defaults
- * to Infinity. It represents the maximum number of inner Observable subscriptions
- * at a time.
- *
- * ## Example
- *
- * Count the number of click events
- *
- * ```ts
- * import { fromEvent, map, mergeScan, of } from 'rxjs';
- *
- * const click$ = fromEvent(document, 'click');
- * const one$ = click$.pipe(map(() => 1));
- * const seed = 0;
- * const count$ = one$.pipe(
- *   mergeScan((acc, one) => of(acc + one), seed)
- * );
- *
- * count$.subscribe(x => console.log(x));
- *
- * // Results:
- * // 1
- * // 2
- * // 3
- * // 4
- * // ...and so on for each click
- * ```
- *
- * @see {@link scan}
- * @see {@link switchScan}
- *
- * @param accumulator The accumulator function called on each source value.
- * @param seed The initial accumulation value.
- * @param concurrent Maximum number of input Observables being subscribed to
- * concurrently.
- * @return A function that returns an Observable of the accumulated values.
- */
-export declare function mergeScan<T, R>(accumulator: (acc: R, value: T, index: number) => ObservableInput<R>, seed: R, concurrent?: number): OperatorFunction<T, R>;
-//# sourceMappingURL=mergeScan.d.ts.map

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

@@ -1,44 +0,0 @@
-import { ObservableInputTuple, OperatorFunction } from '../types';
-/**
- * Merge the values from all observables to a single observable result.
- *
- * Creates an observable, that when subscribed to, subscribes to the source
- * observable, and all other sources provided as arguments. All values from
- * every source are emitted from the resulting subscription.
- *
- * When all sources complete, the resulting observable will complete.
- *
- * When any source errors, the resulting observable will error.
- *
- * ## Example
- *
- * Joining all outputs from multiple user input event streams
- *
- * ```ts
- * import { fromEvent, map, mergeWith } from 'rxjs';
- *
- * const clicks$ = fromEvent(document, 'click').pipe(map(() => 'click'));
- * const mousemoves$ = fromEvent(document, 'mousemove').pipe(map(() => 'mousemove'));
- * const dblclicks$ = fromEvent(document, 'dblclick').pipe(map(() => 'dblclick'));
- *
- * mousemoves$
- *   .pipe(mergeWith(clicks$, dblclicks$))
- *   .subscribe(x => console.log(x));
- *
- * // result (assuming user interactions)
- * // 'mousemove'
- * // 'mousemove'
- * // 'mousemove'
- * // 'click'
- * // 'click'
- * // 'dblclick'
- * ```
- *
- * @see {@link merge}
- *
- * @param otherSources the sources to combine the current source with.
- * @return A function that returns an Observable that merges the values from
- * all given Observables.
- */
-export declare function mergeWith<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-//# sourceMappingURL=mergeWith.d.ts.map

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

@@ -1,50 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * The `min` operator operates on an Observable that emits numbers (or items that
- * can be compared with a provided function), and when source Observable completes
- * it emits a single item: the item with the smallest value.
- *
- * ![](min.png)
- *
- * ## Examples
- *
- * Get the minimal value of a series of numbers
- *
- * ```ts
- * import { of, min } from 'rxjs';
- *
- * of(5, 4, 7, 2, 8)
- *   .pipe(min())
- *   .subscribe(x => console.log(x));
- *
- * // Outputs
- * // 2
- * ```
- *
- * Use a comparer function to get the minimal item
- *
- * ```ts
- * import { of, min } from 'rxjs';
- *
- * of(
- *   { age: 7, name: 'Foo' },
- *   { age: 5, name: 'Bar' },
- *   { age: 9, name: 'Beer' }
- * ).pipe(
- *   min((a, b) => a.age < b.age ? -1 : 1)
- * )
- * .subscribe(x => console.log(x.name));
- *
- * // Outputs
- * // 'Bar'
- * ```
- *
- * @see {@link max}
- *
- * @param comparer Optional comparer function that it will use instead of its
- * default to compare the value of two items.
- * @return A function that returns an Observable that emits item with the
- * smallest value.
- */
-export declare function min<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=min.d.ts.map

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

@@ -1,63 +0,0 @@
-import { Subject } from '../Subject';
-import { Observable } from '../Observable';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { OperatorFunction, UnaryFunction, ObservedValueOf, ObservableInput } from '../types';
-/**
- * An operator that creates a {@link ConnectableObservable}, that when connected,
- * with the `connect` method, will use the provided subject to multicast the values
- * from the source to all consumers.
- *
- * @param subject The subject to multicast through.
- * @return A function that returns a {@link ConnectableObservable}
- * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
- * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead.
- * `multicast(subject), refCount()` is equivalent to
- * `share({ connector: () => subject, resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function multicast<T>(subject: Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-/**
- * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented,
- * rather than duplicate the effort of documenting the same behavior, please see documentation for the
- * {@link connect} operator.
- *
- * @param subject The subject used to multicast.
- * @param selector A setup function to setup the multicast
- * @return A function that returns an observable that mirrors the observable returned by the selector.
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `multicast(subject, selector)` is equivalent to
- * `connect(selector, { connector: () => subject })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function multicast<T, O extends ObservableInput<any>>(subject: Subject<T>, selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;
-/**
- * An operator that creates a {@link ConnectableObservable}, that when connected,
- * with the `connect` method, will use the provided subject to multicast the values
- * from the source to all consumers.
- *
- * @param subjectFactory A factory that will be called to create the subject. Passing a function here
- * will cause the underlying subject to be "reset" on error, completion, or refCounted unsubscription of
- * the source.
- * @return A function that returns a {@link ConnectableObservable}
- * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
- * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead.
- * `multicast(() => new BehaviorSubject('test')), refCount()` is equivalent to
- * `share({ connector: () => new BehaviorSubject('test') })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function multicast<T>(subjectFactory: () => Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-/**
- * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented,
- * rather than duplicate the effort of documenting the same behavior, please see documentation for the
- * {@link connect} operator.
- *
- * @param subjectFactory A factory that creates the subject used to multicast.
- * @param selector A function to setup the multicast and select the output.
- * @return A function that returns an observable that mirrors the observable returned by the selector.
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `multicast(subjectFactory, selector)` is equivalent to
- * `connect(selector, { connector: subjectFactory })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function multicast<T, O extends ObservableInput<any>>(subjectFactory: () => Subject<T>, selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;
-//# sourceMappingURL=multicast.d.ts.map

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

@@ -1,56 +0,0 @@
-/** @prettier */
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-/**
- * Re-emits all notifications from source Observable with specified scheduler.
- *
- * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span>
- *
- * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule
- * notifications emitted by the source Observable. It might be useful, if you do not have control over
- * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.
- *
- * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,
- * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal
- * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits
- * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.
- * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split
- * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source
- * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a
- * little bit more, to ensure that they are emitted at expected moments.
- *
- * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications
- * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`
- * will delay all notifications - including error notifications - while `delay` will pass through error
- * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator
- * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used
- * for notification emissions in general.
- *
- * ## Example
- *
- * Ensure values in subscribe are called just before browser repaint
- *
- * ```ts
- * import { interval, observeOn, animationFrameScheduler } from 'rxjs';
- *
- * const someDiv = document.createElement('div');
- * someDiv.style.cssText = 'width: 200px;background: #09c';
- * document.body.appendChild(someDiv);
- * const intervals = interval(10);      // Intervals are scheduled
- *                                      // with async scheduler by default...
- * intervals.pipe(
- *   observeOn(animationFrameScheduler) // ...but we will observe on animationFrame
- * )                                    // scheduler to ensure smooth animation.
- * .subscribe(val => {
- *   someDiv.style.height = val + 'px';
- * });
- * ```
- *
- * @see {@link delay}
- *
- * @param scheduler Scheduler that will be used to reschedule notifications from source Observable.
- * @param delay Number of milliseconds that states with what delay every notification should be rescheduled.
- * @return A function that returns an Observable that emits the same
- * notifications as the source Observable, but with provided scheduler.
- */
-export declare function observeOn<T>(scheduler: SchedulerLike, delay?: number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=observeOn.d.ts.map

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

@@ -1,8 +0,0 @@
-import { ObservableInputTuple, OperatorFunction } from '../types';
-export declare function onErrorResumeNextWith<T, A extends readonly unknown[]>(sources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-export declare function onErrorResumeNextWith<T, A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-/**
- * @deprecated Renamed. Use {@link onErrorResumeNextWith} instead. Will be removed in v8.
- */
-export declare const onErrorResumeNext: typeof onErrorResumeNextWith;
-//# sourceMappingURL=onErrorResumeNextWith.d.ts.map

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

@@ -1,46 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Groups pairs of consecutive emissions together and emits them as an array of
- * two values.
- *
- * <span class="informal">Puts the current value and previous value together as
- * an array, and emits that.</span>
- *
- * ![](pairwise.png)
- *
- * The Nth emission from the source Observable will cause the output Observable
- * to emit an array [(N-1)th, Nth] of the previous and the current value, as a
- * pair. For this reason, `pairwise` emits on the second and subsequent
- * emissions from the source Observable, but not on the first emission, because
- * there is no previous value in that case.
- *
- * ## Example
- *
- * On every click (starting from the second), emit the relative distance to the previous click
- *
- * ```ts
- * import { fromEvent, pairwise, map } from 'rxjs';
- *
- * const clicks = fromEvent<PointerEvent>(document, 'click');
- * const pairs = clicks.pipe(pairwise());
- * const distance = pairs.pipe(
- *   map(([first, second]) => {
- *     const x0 = first.clientX;
- *     const y0 = first.clientY;
- *     const x1 = second.clientX;
- *     const y1 = second.clientY;
- *     return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
- *   })
- * );
- *
- * distance.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link buffer}
- * @see {@link bufferCount}
- *
- * @return A function that returns an Observable of pairs (as arrays) of
- * consecutive values from the source Observable.
- */
-export declare function pairwise<T>(): OperatorFunction<T, [T, T]>;
-//# sourceMappingURL=pairwise.d.ts.map

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

@@ -1,54 +0,0 @@
-import { Observable } from '../Observable';
-import { UnaryFunction } from '../types';
-/**
- * Splits the source Observable into two, one with values that satisfy a
- * predicate, and another with values that don't satisfy the predicate.
- *
- * <span class="informal">It's like {@link filter}, but returns two Observables:
- * one like the output of {@link filter}, and the other with values that did not
- * pass the condition.</span>
- *
- * ![](partition.png)
- *
- * `partition` outputs an array with two Observables that partition the values
- * from the source Observable through the given `predicate` function. The first
- * Observable in that array emits source values for which the predicate argument
- * returns true. The second Observable emits source values for which the
- * predicate returns false. The first behaves like {@link filter} and the second
- * behaves like {@link filter} with the predicate negated.
- *
- * ## Example
- *
- * Partition click events into those on DIV elements and those elsewhere
- *
- * ```ts
- * import { fromEvent } from 'rxjs';
- * import { partition } from 'rxjs/operators';
- *
- * const div = document.createElement('div');
- * div.style.cssText = 'width: 200px; height: 200px; background: #09c;';
- * document.body.appendChild(div);
- *
- * const clicks = fromEvent(document, 'click');
- * const [clicksOnDivs, clicksElsewhere] = clicks.pipe(partition(ev => (<HTMLElement>ev.target).tagName === 'DIV'));
- *
- * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));
- * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));
- * ```
- *
- * @see {@link filter}
- *
- * @param predicate A function that evaluates each value emitted by the source
- * Observable. If it returns `true`, the value is emitted on the first Observable
- * in the returned array, if `false` the value is emitted on the second Observable
- * in the array. The `index` parameter is the number `i` for the i-th source
- * emission that has happened since the subscription, starting from the number `0`.
- * @param thisArg An optional argument to determine the value of `this` in the
- * `predicate` function.
- * @return A function that returns an array with two Observables: one with
- * values that passed the predicate, and another with values that did not pass
- * the predicate.
- * @deprecated Replaced with the {@link partition} static creation function. Will be removed in v8.
- */
-export declare function partition<T>(predicate: (value: T, index: number) => boolean, thisArg?: any): UnaryFunction<Observable<T>, [Observable<T>, Observable<T>]>;
-//# sourceMappingURL=partition.d.ts.map

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

@@ -1,18 +0,0 @@
-import { OperatorFunction } from '../types';
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T, K1 extends keyof T>(k1: K1): OperatorFunction<T, T[K1]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T, K1 extends keyof T, K2 extends keyof T[K1]>(k1: K1, k2: K2): OperatorFunction<T, T[K1][K2]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(k1: K1, k2: K2, k3: K3): OperatorFunction<T, T[K1][K2][K3]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(k1: K1, k2: K2, k3: K3, k4: K4): OperatorFunction<T, T[K1][K2][K3][K4]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): OperatorFunction<T, T[K1][K2][K3][K4][K5]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4], K6 extends keyof T[K1][K2][K3][K4][K5]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): OperatorFunction<T, T[K1][K2][K3][K4][K5][K6]>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4], K6 extends keyof T[K1][K2][K3][K4][K5]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, ...rest: string[]): OperatorFunction<T, unknown>;
-/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
-export declare function pluck<T>(...properties: string[]): OperatorFunction<T, unknown>;
-//# sourceMappingURL=pluck.d.ts.map

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

@@ -1,30 +0,0 @@
-import { Observable } from '../Observable';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { OperatorFunction, UnaryFunction, ObservableInput, ObservedValueOf } from '../types';
-/**
- * Returns a connectable observable that, when connected, will multicast
- * all values through a single underlying {@link Subject} instance.
- *
- * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
- * `source.pipe(publish())` is equivalent to
- * `connectable(source, { connector: () => new Subject(), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publish`, use {@link share} operator instead.
- * `source.pipe(publish(), refCount())` is equivalent to
- * `source.pipe(share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publish<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-/**
- * Returns an observable, that when subscribed to, creates an underlying {@link Subject},
- * provides an observable view of it to a `selector` function, takes the observable result of
- * that selector function and subscribes to it, sending its values to the consumer, _then_ connects
- * the subject to the original source.
- *
- * @param selector A function used to setup multicasting prior to automatic connection.
- *
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `publish(selector)` is equivalent to `connect(selector)`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publish<T, O extends ObservableInput<any>>(selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;
-//# sourceMappingURL=publish.d.ts.map

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

@@ -1,19 +0,0 @@
-import { Observable } from '../Observable';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction } from '../types';
-/**
- * Creates a {@link ConnectableObservable} that utilizes a {@link BehaviorSubject}.
- *
- * @param initialValue The initial value passed to the {@link BehaviorSubject}.
- * @return A function that returns a {@link ConnectableObservable}
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link BehaviorSubject} under the hood, use {@link connectable}.
- * `source.pipe(publishBehavior(initValue))` is equivalent to
- * `connectable(source, { connector: () => new BehaviorSubject(initValue), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishBehavior`, use the {@link share} operator instead.
- * `source.pipe(publishBehavior(initValue), refCount())` is equivalent to
- * `source.pipe(share({ connector: () => new BehaviorSubject(initValue), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false  }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishBehavior<T>(initialValue: T): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-//# sourceMappingURL=publishBehavior.d.ts.map