lambda-live-debugger 1.12.2 → 1.12.4

package/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/node_modules/rxjs/dist/types/internal/operators/mergeWith.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mergeWith.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/mergeWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACvD,GAAG,YAAY,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAC5C,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAEpC"}

package/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/node_modules/rxjs/dist/types/internal/operators/min.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"min.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/min.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAErF"}

package/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/node_modules/rxjs/dist/types/internal/operators/multicast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multicast.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/multicast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI7F;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1G;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EACzD,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,GACrC,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;AAEvH;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EACzD,cAAc,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAChC,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,GACrC,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/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/node_modules/rxjs/dist/types/internal/operators/observeOn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observeOn.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/observeOn.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,OAAO,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAKnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,SAAI,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAW7F"}

package/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/node_modules/rxjs/dist/types/internal/operators/onErrorResumeNextWith.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onErrorResumeNextWith.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/onErrorResumeNextWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIlE,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACnE,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GACpC,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACtC,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACnE,GAAG,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GACvC,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAsFtC;;GAEG;AACH,eAAO,MAAM,iBAAiB,8BAAwB,CAAC"}

package/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/node_modules/rxjs/dist/types/internal/operators/pairwise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pairwise.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/pairwise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,QAAQ,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAazD"}

package/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/node_modules/rxjs/dist/types/internal/operators/partition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/partition.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EAC/C,OAAO,CAAC,EAAE,GAAG,GACZ,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAG9D"}

package/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/node_modules/rxjs/dist/types/internal/operators/pluck.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pluck.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/pluck.ts"],"names":[],"mappings":"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"}

package/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/node_modules/rxjs/dist/types/internal/operators/publish.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAA4B,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGvH;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,KAAK,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;AAErF;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/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

package/node_modules/rxjs/dist/types/internal/operators/publishBehavior.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"publishBehavior.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/publishBehavior.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAM1G"}

package/node_modules/rxjs/dist/types/internal/operators/publishLast.d.ts

@@ -1,69 +0,0 @@
-import { Observable } from '../Observable';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction } from '../types';
-/**
- * Returns a connectable observable sequence that shares a single subscription to the
- * underlying sequence containing only the last notification.
- *
- * ![](publishLast.png)
- *
- * Similar to {@link publish}, but it waits until the source observable completes and stores
- * the last emitted value.
- * Similarly to {@link publishReplay} and {@link publishBehavior}, this keeps storing the last
- * value even if it has no more subscribers. If subsequent subscriptions happen, they will
- * immediately get that last stored value and complete.
- *
- * ## Example
- *
- * ```ts
- * import { ConnectableObservable, interval, publishLast, tap, take } from 'rxjs';
- *
- * const connectable = <ConnectableObservable<number>>interval(1000)
- *   .pipe(
- *     tap(x => console.log('side effect', x)),
- *     take(3),
- *     publishLast()
- *   );
- *
- * connectable.subscribe({
- *   next: x => console.log('Sub. A', x),
- *   error: err => console.log('Sub. A Error', err),
- *   complete: () => console.log('Sub. A Complete')
- * });
- *
- * connectable.subscribe({
- *   next: x => console.log('Sub. B', x),
- *   error: err => console.log('Sub. B Error', err),
- *   complete: () => console.log('Sub. B Complete')
- * });
- *
- * connectable.connect();
- *
- * // Results:
- * // 'side effect 0'   - after one second
- * // 'side effect 1'   - after two seconds
- * // 'side effect 2'   - after three seconds
- * // 'Sub. A 2'        - immediately after 'side effect 2'
- * // 'Sub. B 2'
- * // 'Sub. A Complete'
- * // 'Sub. B Complete'
- * ```
- *
- * @see {@link ConnectableObservable}
- * @see {@link publish}
- * @see {@link publishReplay}
- * @see {@link publishBehavior}
- *
- * @return A function that returns an Observable that emits elements of a
- * sequence produced by multicasting the source sequence.
- * @deprecated Will be removed in v8. To create a connectable observable with an
- * {@link AsyncSubject} under the hood, use {@link connectable}.
- * `source.pipe(publishLast())` is equivalent to
- * `connectable(source, { connector: () => new AsyncSubject(), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishLast`, use the {@link share} operator instead.
- * `source.pipe(publishLast(), refCount())` is equivalent to
- * `source.pipe(share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishLast<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-//# sourceMappingURL=publishLast.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/publishLast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"publishLast.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/publishLast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,WAAW,CAAC,CAAC,KAAK,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAMvF"}

package/node_modules/rxjs/dist/types/internal/operators/publishReplay.d.ts

@@ -1,56 +0,0 @@
-import { Observable } from '../Observable';
-import { MonoTypeOperatorFunction, OperatorFunction, TimestampProvider, ObservableInput, ObservedValueOf } from '../types';
-/**
- * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
- * internally.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link ReplaySubject} under the hood, use {@link connectable}.
- * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
- * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
- * `publishReplay(size, time, scheduler), refCount()` is equivalent to
- * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishReplay<T>(bufferSize?: number, windowTime?: number, timestampProvider?: TimestampProvider): MonoTypeOperatorFunction<T>;
-/**
- * Creates an observable, that when subscribed to, will create a {@link ReplaySubject},
- * and pass an observable from it (using [asObservable](api/index/class/Subject#asObservable)) to
- * the `selector` function, which then returns an observable that is subscribed to before
- * "connecting" the source to the internal `ReplaySubject`.
- *
- * Since this is deprecated, for additional details see the documentation for {@link connect}.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param selector A function used to setup the multicast.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
- * `source.pipe(publishReplay(size, window, selector, scheduler))` is equivalent to
- * `source.pipe(connect(selector, { connector: () => new ReplaySubject(size, window, scheduler) }))`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishReplay<T, O extends ObservableInput<any>>(bufferSize: number | undefined, windowTime: number | undefined, selector: (shared: Observable<T>) => O, timestampProvider?: TimestampProvider): OperatorFunction<T, ObservedValueOf<O>>;
-/**
- * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject}
- * internally.
- *
- * @param bufferSize The buffer size for the underlying {@link ReplaySubject}.
- * @param windowTime The window time for the underlying {@link ReplaySubject}.
- * @param selector Passing `undefined` here determines that this operator will return a {@link ConnectableObservable}.
- * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}.
- * @deprecated Will be removed in v8. To create a connectable observable that uses a
- * {@link ReplaySubject} under the hood, use {@link connectable}.
- * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to
- * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`.
- * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead.
- * `publishReplay(size, time, scheduler), refCount()` is equivalent to
- * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function publishReplay<T, O extends ObservableInput<any>>(bufferSize: number | undefined, windowTime: number | undefined, selector: undefined, timestampProvider: TimestampProvider): OperatorFunction<T, ObservedValueOf<O>>;
-//# sourceMappingURL=publishReplay.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/publishReplay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"publishReplay.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/publishReplay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3H;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAE/B;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAC7D,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,EACtC,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAC7D,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,SAAS,EACnB,iBAAiB,EAAE,iBAAiB,GACnC,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/node_modules/rxjs/dist/types/internal/operators/race.d.ts

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

package/node_modules/rxjs/dist/types/internal/operators/race.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"race.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/race.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIlE,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,YAAY,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACtI,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,YAAY,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/node_modules/rxjs/dist/types/internal/operators/raceWith.d.ts

@@ -1,29 +0,0 @@
-import { OperatorFunction, ObservableInputTuple } from '../types';
-/**
- * Creates an Observable that mirrors the first source Observable to emit a next,
- * error or complete notification from the combination of the Observable to which
- * the operator is applied and supplied Observables.
- *
- * ## Example
- *
- * ```ts
- * import { interval, map, raceWith } from 'rxjs';
- *
- * const obs1 = interval(7000).pipe(map(() => 'slow one'));
- * const obs2 = interval(3000).pipe(map(() => 'fast one'));
- * const obs3 = interval(5000).pipe(map(() => 'medium one'));
- *
- * obs1
- *   .pipe(raceWith(obs2, obs3))
- *   .subscribe(winner => console.log(winner));
- *
- * // Outputs
- * // a series of 'fast one'
- * ```
- *
- * @param otherSources Sources used to race for which Observable emits first.
- * @return A function that returns an Observable that mirrors the output of the
- * first Observable to emit an item.
- */
-export declare function raceWith<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
-//# sourceMappingURL=raceWith.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/raceWith.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"raceWith.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/raceWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAKlE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACtD,GAAG,YAAY,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAC5C,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAMpC"}