lambda-live-debugger 1.12.2 → 1.12.4

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

@@ -1,119 +0,0 @@
-import { Observable } from '../Observable';
-import { Subject } from '../Subject';
-import { ObservableInput, OperatorFunction, SubjectLike } from '../types';
-export interface BasicGroupByOptions<K, T> {
-    element?: undefined;
-    duration?: (grouped: GroupedObservable<K, T>) => ObservableInput<any>;
-    connector?: () => SubjectLike<T>;
-}
-export interface GroupByOptionsWithElement<K, E, T> {
-    element: (value: T) => E;
-    duration?: (grouped: GroupedObservable<K, E>) => ObservableInput<any>;
-    connector?: () => SubjectLike<E>;
-}
-export declare function groupBy<T, K>(key: (value: T) => K, options: BasicGroupByOptions<K, T>): OperatorFunction<T, GroupedObservable<K, T>>;
-export declare function groupBy<T, K, E>(key: (value: T) => K, options: GroupByOptionsWithElement<K, E, T>): OperatorFunction<T, GroupedObservable<K, E>>;
-export declare function groupBy<T, K extends T>(key: (value: T) => value is K): OperatorFunction<T, GroupedObservable<true, K> | GroupedObservable<false, Exclude<T, K>>>;
-export declare function groupBy<T, K>(key: (value: T) => K): OperatorFunction<T, GroupedObservable<K, T>>;
-/**
- * @deprecated use the options parameter instead.
- */
-export declare function groupBy<T, K>(key: (value: T) => K, element: void, duration: (grouped: GroupedObservable<K, T>) => Observable<any>): OperatorFunction<T, GroupedObservable<K, T>>;
-/**
- * @deprecated use the options parameter instead.
- */
-export declare function groupBy<T, K, R>(key: (value: T) => K, element?: (value: T) => R, duration?: (grouped: GroupedObservable<K, R>) => Observable<any>): OperatorFunction<T, GroupedObservable<K, R>>;
-/**
- * Groups the items emitted by an Observable according to a specified criterion,
- * and emits these grouped items as `GroupedObservables`, one
- * {@link GroupedObservable} per group.
- *
- * ![](groupBy.png)
- *
- * When the Observable emits an item, a key is computed for this item with the key function.
- *
- * If a {@link GroupedObservable} for this key exists, this {@link GroupedObservable} emits. Otherwise, a new
- * {@link GroupedObservable} for this key is created and emits.
- *
- * A {@link GroupedObservable} represents values belonging to the same group represented by a common key. The common
- * key is available as the `key` field of a {@link GroupedObservable} instance.
- *
- * The elements emitted by {@link GroupedObservable}s are by default the items emitted by the Observable, or elements
- * returned by the element function.
- *
- * ## Examples
- *
- * Group objects by `id` and return as array
- *
- * ```ts
- * import { of, groupBy, mergeMap, reduce } from 'rxjs';
- *
- * of(
- *   { id: 1, name: 'JavaScript' },
- *   { id: 2, name: 'Parcel' },
- *   { id: 2, name: 'webpack' },
- *   { id: 1, name: 'TypeScript' },
- *   { id: 3, name: 'TSLint' }
- * ).pipe(
- *   groupBy(p => p.id),
- *   mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], [])))
- * )
- * .subscribe(p => console.log(p));
- *
- * // displays:
- * // [{ id: 1, name: 'JavaScript' }, { id: 1, name: 'TypeScript'}]
- * // [{ id: 2, name: 'Parcel' }, { id: 2, name: 'webpack'}]
- * // [{ id: 3, name: 'TSLint' }]
- * ```
- *
- * Pivot data on the `id` field
- *
- * ```ts
- * import { of, groupBy, mergeMap, reduce, map } from 'rxjs';
- *
- * of(
- *   { id: 1, name: 'JavaScript' },
- *   { id: 2, name: 'Parcel' },
- *   { id: 2, name: 'webpack' },
- *   { id: 1, name: 'TypeScript' },
- *   { id: 3, name: 'TSLint' }
- * ).pipe(
- *   groupBy(p => p.id, { element: p => p.name }),
- *   mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], [`${ group$.key }`]))),
- *   map(arr => ({ id: parseInt(arr[0], 10), values: arr.slice(1) }))
- * )
- * .subscribe(p => console.log(p));
- *
- * // displays:
- * // { id: 1, values: [ 'JavaScript', 'TypeScript' ] }
- * // { id: 2, values: [ 'Parcel', 'webpack' ] }
- * // { id: 3, values: [ 'TSLint' ] }
- * ```
- *
- * @param key A function that extracts the key
- * for each item.
- * @param element A function that extracts the
- * return element for each item.
- * @param duration
- * A function that returns an Observable to determine how long each group should
- * exist.
- * @param connector Factory function to create an
- * intermediate Subject through which grouped elements are emitted.
- * @return A function that returns an Observable that emits GroupedObservables,
- * each of which corresponds to a unique key value and each of which emits
- * those items from the source Observable that share that key value.
- *
- * @deprecated Use the options parameter instead.
- */
-export declare function groupBy<T, K, R>(key: (value: T) => K, element?: (value: T) => R, duration?: (grouped: GroupedObservable<K, R>) => Observable<any>, connector?: () => Subject<R>): OperatorFunction<T, GroupedObservable<K, R>>;
-/**
- * An observable of values that is the emitted by the result of a {@link groupBy} operator,
- * contains a `key` property for the grouping.
- */
-export interface GroupedObservable<K, T> extends Observable<T> {
-    /**
-     * The key value for the grouped notifications.
-     */
-    readonly key: K;
-}
-//# sourceMappingURL=groupBy.d.ts.map

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

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

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

@@ -1,38 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.
- *
- * ![](ignoreElements.png)
- *
- * The `ignoreElements` operator suppresses all items emitted by the source Observable,
- * but allows its termination notification (either `error` or `complete`) to pass through unchanged.
- *
- * If you do not care about the items being emitted by an Observable, but you do want to be notified
- * when it completes or when it terminates with an error, you can apply the `ignoreElements` operator
- * to the Observable, which will ensure that it will never call its observers’ `next` handlers.
- *
- * ## Example
- *
- * Ignore all `next` emissions from the source
- *
- * ```ts
- * import { of, ignoreElements } from 'rxjs';
- *
- * of('you', 'talking', 'to', 'me')
- *   .pipe(ignoreElements())
- *   .subscribe({
- *     next: word => console.log(word),
- *     error: err => console.log('error:', err),
- *     complete: () => console.log('the end'),
- *   });
- *
- * // result:
- * // 'the end'
- * ```
- *
- * @return A function that returns an empty Observable that only calls
- * `complete` or `error`, based on which one is called by the source
- * Observable.
- */
-export declare function ignoreElements(): OperatorFunction<unknown, never>;
-//# sourceMappingURL=ignoreElements.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ignoreElements.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/ignoreElements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,cAAc,IAAI,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAIjE"}

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

@@ -1,64 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Emits `false` if the input Observable emits any values, or emits `true` if the
- * input Observable completes without emitting any values.
- *
- * <span class="informal">Tells whether any values are emitted by an Observable.</span>
- *
- * ![](isEmpty.png)
- *
- * `isEmpty` transforms an Observable that emits values into an Observable that
- * emits a single boolean value representing whether or not any values were
- * emitted by the source Observable. As soon as the source Observable emits a
- * value, `isEmpty` will emit a `false` and complete.  If the source Observable
- * completes having not emitted anything, `isEmpty` will emit a `true` and
- * complete.
- *
- * A similar effect could be achieved with {@link count}, but `isEmpty` can emit
- * a `false` value sooner.
- *
- * ## Examples
- *
- * Emit `false` for a non-empty Observable
- *
- * ```ts
- * import { Subject, isEmpty } from 'rxjs';
- *
- * const source = new Subject<string>();
- * const result = source.pipe(isEmpty());
- *
- * source.subscribe(x => console.log(x));
- * result.subscribe(x => console.log(x));
- *
- * source.next('a');
- * source.next('b');
- * source.next('c');
- * source.complete();
- *
- * // Outputs
- * // 'a'
- * // false
- * // 'b'
- * // 'c'
- * ```
- *
- * Emit `true` for an empty Observable
- *
- * ```ts
- * import { EMPTY, isEmpty } from 'rxjs';
- *
- * const result = EMPTY.pipe(isEmpty());
- * result.subscribe(x => console.log(x));
- *
- * // Outputs
- * // true
- * ```
- *
- * @see {@link count}
- * @see {@link EMPTY}
- *
- * @return A function that returns an Observable that emits boolean value
- * indicating whether the source Observable was empty or not.
- */
-export declare function isEmpty<T>(): OperatorFunction<T, boolean>;
-//# sourceMappingURL=isEmpty.d.ts.map

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

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

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

@@ -1,14 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInput } from '../types';
-/**
- * Collects all of the inner sources from source observable. Then, once the
- * source completes, joins the values using the given static.
- *
- * This is used for {@link combineLatestAll} and {@link zipAll} which both have the
- * same behavior of collecting all inner observables, then operating on them.
- *
- * @param joinFn The type of static join to apply to the sources collected
- * @param project The projection function to apply to the values, if any
- */
-export declare function joinAllInternals<T, R>(joinFn: (sources: ObservableInput<T>[]) => Observable<T>, project?: (...args: any[]) => R): import("../types").UnaryFunction<Observable<ObservableInput<T>>, unknown>;
-//# sourceMappingURL=joinAllInternals.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"joinAllInternals.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/joinAllInternals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAoB,MAAM,UAAU,CAAC;AAO7D;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,6EAU/H"}

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

@@ -1,8 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, TruthyTypesOf } from '../types';
-export declare function last<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
-export declare function last<T, D>(predicate: BooleanConstructor, defaultValue: D): OperatorFunction<T, TruthyTypesOf<T> | D>;
-export declare function last<T, D = T>(predicate?: null, defaultValue?: D): OperatorFunction<T, T | D>;
-export declare function last<T, S extends T>(predicate: (value: T, index: number, source: Observable<T>) => value is S, defaultValue?: S): OperatorFunction<T, S>;
-export declare function last<T, D = T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: D): OperatorFunction<T, T | D>;
-//# sourceMappingURL=last.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"last.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/last.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAO3D,wBAAgB,IAAI,CAAC,CAAC,EAAE,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9F,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,kBAAkB,EAAE,YAAY,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACtH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/F,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACjC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,EACzE,YAAY,CAAC,EAAE,CAAC,GACf,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1B,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAC3B,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,OAAO,EACtE,YAAY,CAAC,EAAE,CAAC,GACf,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC"}

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

@@ -1,5 +0,0 @@
-import { OperatorFunction } from '../types';
-export declare function map<T, R>(project: (value: T, index: number) => R): OperatorFunction<T, R>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export declare function map<T, R, A>(project: (this: A, value: T, index: number) => R, thisArg: A): OperatorFunction<T, R>;
-//# sourceMappingURL=map.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI5C,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC3F,gHAAgH;AAChH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -1,10 +0,0 @@
-import { OperatorFunction } from '../types';
-/** @deprecated To be removed in v9. Use {@link map} instead: `map(() => value)`. */
-export declare function mapTo<R>(value: R): OperatorFunction<unknown, R>;
-/**
- * @deprecated Do not specify explicit type parameters. Signatures with type parameters
- * that cannot be inferred will be removed in v8. `mapTo` itself will be removed in v9,
- * use {@link map} instead: `map(() => value)`.
- * */
-export declare function mapTo<T, R>(value: R): OperatorFunction<T, R>;
-//# sourceMappingURL=mapTo.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mapTo.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/mapTo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5C,oFAAoF;AACpF,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;AACjE;;;;KAIK;AACL,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -1,52 +0,0 @@
-import { Notification } from '../Notification';
-import { OperatorFunction, ObservableNotification } from '../types';
-/**
- * Represents all of the notifications from the source Observable as `next`
- * emissions marked with their original types within {@link Notification}
- * objects.
- *
- * <span class="informal">Wraps `next`, `error` and `complete` emissions in
- * {@link Notification} objects, emitted as `next` on the output Observable.
- * </span>
- *
- * ![](materialize.png)
- *
- * `materialize` returns an Observable that emits a `next` notification for each
- * `next`, `error`, or `complete` emission of the source Observable. When the
- * source Observable emits `complete`, the output Observable will emit `next` as
- * a Notification of type "complete", and then it will emit `complete` as well.
- * When the source Observable emits `error`, the output will emit `next` as a
- * Notification of type "error", and then `complete`.
- *
- * This operator is useful for producing metadata of the source Observable, to
- * be consumed as `next` emissions. Use it in conjunction with
- * {@link dematerialize}.
- *
- * ## Example
- *
- * Convert a faulty Observable to an Observable of Notifications
- *
- * ```ts
- * import { of, materialize, map } from 'rxjs';
- *
- * const letters = of('a', 'b', 13, 'd');
- * const upperCase = letters.pipe(map((x: any) => x.toUpperCase()));
- * const materialized = upperCase.pipe(materialize());
- *
- * materialized.subscribe(x => console.log(x));
- *
- * // Results in the following:
- * // - Notification { kind: 'N', value: 'A', error: undefined, hasValue: true }
- * // - Notification { kind: 'N', value: 'B', error: undefined, hasValue: true }
- * // - Notification { kind: 'E', value: undefined, error: TypeError { message: x.toUpperCase is not a function }, hasValue: false }
- * ```
- *
- * @see {@link Notification}
- * @see {@link dematerialize}
- *
- * @return A function that returns an Observable that emits
- * {@link Notification} objects that wrap the original emissions from the
- * source Observable with metadata.
- */
-export declare function materialize<T>(): OperatorFunction<T, Notification<T> & ObservableNotification<T>>;
-//# sourceMappingURL=materialize.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"materialize.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/materialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAIpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,WAAW,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAmBjG"}

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

@@ -1,50 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * The `max` 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 largest value.
- *
- * ![](max.png)
- *
- * ## Examples
- *
- * Get the maximal value of a series of numbers
- *
- * ```ts
- * import { of, max } from 'rxjs';
- *
- * of(5, 4, 7, 2, 8)
- *   .pipe(max())
- *   .subscribe(x => console.log(x));
- *
- * // Outputs
- * // 8
- * ```
- *
- * Use a comparer function to get the maximal item
- *
- * ```ts
- * import { of, max } from 'rxjs';
- *
- * of(
- *   { age: 7, name: 'Foo' },
- *   { age: 5, name: 'Bar' },
- *   { age: 9, name: 'Beer' }
- * ).pipe(
- *   max((a, b) => a.age < b.age ? -1 : 1)
- * )
- * .subscribe(x => console.log(x.name));
- *
- * // Outputs
- * // 'Beer'
- * ```
- *
- * @see {@link min}
- *
- * @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
- * largest value.
- */
-export declare function max<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=max.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"max.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/max.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/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/node_modules/rxjs/dist/types/internal/operators/merge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,oBAAoB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAMlG,0EAA0E;AAC1E,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACrI,0EAA0E;AAC1E,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACnD,GAAG,qBAAqB,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GAC7D,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACtC,0EAA0E;AAC1E,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACnD,GAAG,mBAAmB,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,GAClE,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACtC,0EAA0E;AAC1E,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACnD,GAAG,iCAAiC,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,GACxF,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"mergeAll.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/mergeAll.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAAE,UAAU,GAAE,MAAiB,GAAG,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAE/H"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"mergeInternals.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/mergeInternals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAI1D;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EACjC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EACrB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,eAAe,CAAC,CAAC,CAAC,EACxD,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,KAAK,IAAI,EACtC,MAAM,CAAC,EAAE,OAAO,EAChB,iBAAiB,CAAC,EAAE,aAAa,EACjC,mBAAmB,CAAC,EAAE,MAAM,IAAI,cAwHjC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"mergeMap.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/mergeMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAQ9E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EACxD,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EACvC,UAAU,CAAC,EAAE,MAAM,GAClB,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3C,0JAA0J;AAC1J,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EACxD,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EACvC,cAAc,EAAE,SAAS,EACzB,UAAU,CAAC,EAAE,MAAM,GAClB,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3C,0JAA0J;AAC1J,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAC3D,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EACvC,cAAc,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC,EAC5G,UAAU,CAAC,EAAE,MAAM,GAClB,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"mergeMapTo.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/mergeMapTo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI9E,gGAAgG;AAChG,wBAAgB,UAAU,CAAC,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,EAC3D,eAAe,EAAE,CAAC,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,gBAAgB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,EACjE,eAAe,EAAE,CAAC,EAClB,cAAc,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC,EAC5G,UAAU,CAAC,EAAE,MAAM,GAClB,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"mergeScan.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/mergeScan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,eAAe,CAAC,CAAC,CAAC,EACpE,IAAI,EAAE,CAAC,EACP,UAAU,SAAW,GACpB,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAkBxB"}