appiq-solution 1.0.0

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

@@ -0,0 +1,119 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/groupBy.d.ts.map

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

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

@@ -0,0 +1,38 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/ignoreElements.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/isEmpty.d.ts

@@ -0,0 +1,64 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/isEmpty.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/joinAllInternals.d.ts

@@ -0,0 +1,14 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/joinAllInternals.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/last.d.ts

@@ -0,0 +1,8 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/last.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/map.d.ts

@@ -0,0 +1,5 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/map.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mapTo.d.ts

@@ -0,0 +1,10 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mapTo.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/materialize.d.ts

@@ -0,0 +1,52 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/materialize.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/max.d.ts

@@ -0,0 +1,50 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/max.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/merge.d.ts

@@ -0,0 +1,10 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/merge.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeAll.d.ts

@@ -0,0 +1,62 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeAll.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeInternals.d.ts

@@ -0,0 +1,18 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeInternals.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeMap.d.ts

@@ -0,0 +1,7 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeMap.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeMapTo.d.ts

@@ -0,0 +1,9 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeMapTo.d.ts.map

@@ -0,0 +1 @@
+{"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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeScan.d.ts

@@ -0,0 +1,68 @@
+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/tools/installer/node_modules/rxjs/dist/types/internal/operators/mergeScan.d.ts.map

@@ -0,0 +1 @@
+{"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"}