appiq-solution 1.0.0

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

@@ -0,0 +1,41 @@
+import { ObservableInput, OperatorFunction } from '../types';
+/**
+ * Buffers the source Observable values, using a factory function of closing
+ * Observables to determine when to close, emit, and reset the buffer.
+ *
+ * <span class="informal">Collects values from the past as an array. When it
+ * starts collecting values, it calls a function that returns an Observable that
+ * tells when to close the buffer and restart collecting.</span>
+ *
+ * ![](bufferWhen.svg)
+ *
+ * Opens a buffer immediately, then closes the buffer when the observable
+ * returned by calling `closingSelector` function emits a value. When it closes
+ * the buffer, it immediately opens a new buffer and repeats the process.
+ *
+ * ## Example
+ *
+ * Emit an array of the last clicks every [1-5] random seconds
+ *
+ * ```ts
+ * import { fromEvent, bufferWhen, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(
+ *   bufferWhen(() => interval(1000 + Math.random() * 4000))
+ * );
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link buffer}
+ * @see {@link bufferCount}
+ * @see {@link bufferTime}
+ * @see {@link bufferToggle}
+ * @see {@link windowWhen}
+ *
+ * @param closingSelector A function that takes no arguments and returns an
+ * Observable that signals buffer closure.
+ * @return A function that returns an Observable of arrays of buffered values.
+ */
+export declare function bufferWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferWhen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferWhen.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/bufferWhen.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAM7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC,GAAG,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAgDnG"}

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

@@ -0,0 +1,4 @@
+import { Observable } from '../Observable';
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+export declare function catchError<T, O extends ObservableInput<any>>(selector: (err: any, caught: Observable<T>) => O): OperatorFunction<T, T | ObservedValueOf<O>>;
+//# sourceMappingURL=catchError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catchError.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/catchError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAM9E,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAC1D,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,GAC/C,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,6 @@
+import { combineLatestAll } from './combineLatestAll';
+/**
+ * @deprecated Renamed to {@link combineLatestAll}. Will be removed in v8.
+ */
+export declare const combineAll: typeof combineLatestAll;
+//# sourceMappingURL=combineAll.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combineAll.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/combineAll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,UAAU,yBAAmB,CAAC"}

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

@@ -0,0 +1,10 @@
+import { ObservableInputTuple, OperatorFunction } from '../types';
+/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */
+export declare function combineLatest<T, A extends readonly unknown[], R>(sources: [...ObservableInputTuple<A>], project: (...values: [T, ...A]) => R): OperatorFunction<T, R>;
+/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */
+export declare function combineLatest<T, A extends readonly unknown[], R>(sources: [...ObservableInputTuple<A>]): OperatorFunction<T, [T, ...A]>;
+/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */
+export declare function combineLatest<T, A extends readonly unknown[], R>(...sourcesAndProject: [...ObservableInputTuple<A>, (...values: [T, ...A]) => R]): OperatorFunction<T, R>;
+/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */
+export declare function combineLatest<T, A extends readonly unknown[], R>(...sources: [...ObservableInputTuple<A>]): OperatorFunction<T, [T, ...A]>;
+//# sourceMappingURL=combineLatest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combineLatest.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/combineLatest.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAOnF,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,EAC9D,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,EACrC,OAAO,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,GACnC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1B,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AAEzI,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,EAC9D,GAAG,iBAAiB,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,GAC9E,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1B,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,6 @@
+import { OperatorFunction, ObservableInput } from '../types';
+export declare function combineLatestAll<T>(): OperatorFunction<ObservableInput<T>, T[]>;
+export declare function combineLatestAll<T>(): OperatorFunction<any, T[]>;
+export declare function combineLatestAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>;
+export declare function combineLatestAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>;
+//# sourceMappingURL=combineLatestAll.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combineLatestAll.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/combineLatestAll.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG7D,wBAAgB,gBAAgB,CAAC,CAAC,KAAK,gBAAgB,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AACjF,wBAAgB,gBAAgB,CAAC,CAAC,KAAK,gBAAgB,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAClE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAChH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,43 @@
+import { ObservableInputTuple, OperatorFunction, Cons } from '../types';
+/**
+ * Create an observable that combines the latest values from all passed observables and the source
+ * into arrays and emits them.
+ *
+ * Returns an observable, that when subscribed to, will subscribe to the source observable and all
+ * sources provided as arguments. Once all sources emit at least one value, all of the latest values
+ * will be emitted as an array. After that, every time any source emits a value, all of the latest values
+ * will be emitted as an array.
+ *
+ * This is a useful operator for eagerly calculating values based off of changed inputs.
+ *
+ * ## Example
+ *
+ * Simple concatenation of values from two inputs
+ *
+ * ```ts
+ * import { fromEvent, combineLatestWith, map } from 'rxjs';
+ *
+ * // Setup: Add two inputs to the page
+ * const input1 = document.createElement('input');
+ * document.body.appendChild(input1);
+ * const input2 = document.createElement('input');
+ * document.body.appendChild(input2);
+ *
+ * // Get streams of changes
+ * const input1Changes$ = fromEvent(input1, 'change');
+ * const input2Changes$ = fromEvent(input2, 'change');
+ *
+ * // Combine the changes by adding them together
+ * input1Changes$.pipe(
+ *   combineLatestWith(input2Changes$),
+ *   map(([e1, e2]) => (<HTMLInputElement>e1.target).value + ' - ' + (<HTMLInputElement>e2.target).value)
+ * )
+ * .subscribe(x => console.log(x));
+ * ```
+ *
+ * @param otherSources the other sources to subscribe to.
+ * @return A function that returns an Observable that emits the latest
+ * emissions from both source and provided Observables.
+ */
+export declare function combineLatestWith<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
+//# sourceMappingURL=combineLatestWith.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combineLatestWith.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/combineLatestWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAC/D,GAAG,YAAY,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAC5C,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAEjC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/concat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAMjF,2EAA2E;AAC3E,wBAAgB,MAAM,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;AACtI,2EAA2E;AAC3E,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACpD,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"}

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

@@ -0,0 +1,59 @@
+import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
+/**
+ * Converts a higher-order Observable into a first-order Observable by
+ * concatenating the inner Observables in order.
+ *
+ * <span class="informal">Flattens an Observable-of-Observables by putting one
+ * inner Observable after the other.</span>
+ *
+ * ![](concatAll.svg)
+ *
+ * Joins every Observable emitted by the source (a higher-order Observable), in
+ * a serial fashion. It subscribes to each inner Observable only after the
+ * previous inner Observable has completed, and merges all of their values into
+ * the returned observable.
+ *
+ * __Warning:__ If the source Observable emits Observables quickly and
+ * endlessly, and the inner Observables it emits generally complete slower than
+ * the source emits, you can run into memory issues as the incoming Observables
+ * collect in an unbounded buffer.
+ *
+ * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set
+ * to `1`.
+ *
+ * ## Example
+ *
+ * For each click event, tick every second from 0 to 3, with no concurrency
+ *
+ * ```ts
+ * import { fromEvent, map, interval, take, concatAll } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const higherOrder = clicks.pipe(
+ *   map(() => interval(1000).pipe(take(4)))
+ * );
+ * const firstOrder = higherOrder.pipe(concatAll());
+ * firstOrder.subscribe(x => console.log(x));
+ *
+ * // Results in the following:
+ * // (results are not concurrent)
+ * // For every click on the "document" it will emit values 0 to 3 spaced
+ * // on a 1000ms interval
+ * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3
+ * ```
+ *
+ * @see {@link combineLatestAll}
+ * @see {@link concat}
+ * @see {@link concatMap}
+ * @see {@link concatMapTo}
+ * @see {@link exhaustAll}
+ * @see {@link mergeAll}
+ * @see {@link switchAll}
+ * @see {@link switchMap}
+ * @see {@link zipAll}
+ *
+ * @return A function that returns an Observable emitting values from all the
+ * inner Observables concatenated.
+ */
+export declare function concatAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>>;
+//# sourceMappingURL=concatAll.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concatAll.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/concatAll.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,KAAK,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAEnG"}

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

@@ -0,0 +1,7 @@
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+export declare function concatMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): 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 concatMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): 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 concatMap<T, R, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
+//# sourceMappingURL=concatMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concatMap.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/concatMap.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI9E,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EACzD,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GACtC,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3C,0JAA0J;AAC1J,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EACzD,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EACvC,cAAc,EAAE,SAAS,GACxB,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3C,0JAA0J;AAC1J,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAC5D,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,GAC3G,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,8 @@
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+/** @deprecated Will be removed in v9. Use {@link concatMap} instead: `concatMap(() => result)` */
+export declare function concatMapTo<O extends ObservableInput<unknown>>(observable: O): 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 concatMapTo<O extends ObservableInput<unknown>>(observable: O, resultSelector: undefined): 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 concatMapTo<T, R, O extends ObservableInput<unknown>>(observable: O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
+//# sourceMappingURL=concatMapTo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concatMapTo.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/concatMapTo.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG9E,kGAAkG;AAClG,wBAAgB,WAAW,CAAC,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,gBAAgB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9H,0JAA0J;AAC1J,wBAAgB,WAAW,CAAC,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,EAC5D,UAAU,EAAE,CAAC,EACb,cAAc,EAAE,SAAS,GACxB,gBAAgB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,0JAA0J;AAC1J,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,EAClE,UAAU,EAAE,CAAC,EACb,cAAc,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC,GAC3G,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,43 @@
+import { ObservableInputTuple, OperatorFunction } from '../types';
+/**
+ * Emits all of the values from the source observable, then, once it completes, subscribes
+ * to each observable source provided, one at a time, emitting all of their values, and not subscribing
+ * to the next one until it completes.
+ *
+ * `concat(a$, b$, c$)` is the same as `a$.pipe(concatWith(b$, c$))`.
+ *
+ * ## Example
+ *
+ * Listen for one mouse click, then listen for all mouse moves.
+ *
+ * ```ts
+ * import { fromEvent, map, take, concatWith } from 'rxjs';
+ *
+ * const clicks$ = fromEvent(document, 'click');
+ * const moves$ = fromEvent(document, 'mousemove');
+ *
+ * clicks$.pipe(
+ *   map(() => 'click'),
+ *   take(1),
+ *   concatWith(
+ *     moves$.pipe(
+ *       map(() => 'move')
+ *     )
+ *   )
+ * )
+ * .subscribe(x => console.log(x));
+ *
+ * // 'click'
+ * // 'move'
+ * // 'move'
+ * // 'move'
+ * // ...
+ * ```
+ *
+ * @param otherSources Other observable sources to subscribe to, in sequence, after the original source is complete.
+ * @return A function that returns an Observable that concatenates
+ * subscriptions to the source and provided Observables subscribing to the next
+ * only once the current subscription completes.
+ */
+export declare function concatWith<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>;
+//# sourceMappingURL=concatWith.d.ts.map

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

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

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

@@ -0,0 +1,87 @@
+import { OperatorFunction, ObservableInput, ObservedValueOf, SubjectLike } from '../types';
+import { Observable } from '../Observable';
+/**
+ * An object used to configure {@link connect} operator.
+ */
+export interface ConnectConfig<T> {
+    /**
+     * A factory function used to create the Subject through which the source
+     * is multicast. By default, this creates a {@link Subject}.
+     */
+    connector: () => SubjectLike<T>;
+}
+/**
+ * Creates an observable by multicasting the source within a function that
+ * allows the developer to define the usage of the multicast prior to connection.
+ *
+ * This is particularly useful if the observable source you wish to multicast could
+ * be synchronous or asynchronous. This sets it apart from {@link share}, which, in the
+ * case of totally synchronous sources will fail to share a single subscription with
+ * multiple consumers, as by the time the subscription to the result of {@link share}
+ * has returned, if the source is synchronous its internal reference count will jump from
+ * 0 to 1 back to 0 and reset.
+ *
+ * To use `connect`, you provide a `selector` function that will give you
+ * a multicast observable that is not yet connected. You then use that multicast observable
+ * to create a resulting observable that, when subscribed, will set up your multicast. This is
+ * generally, but not always, accomplished with {@link merge}.
+ *
+ * Note that using a {@link takeUntil} inside of `connect`'s `selector` _might_ mean you were looking
+ * to use the {@link takeWhile} operator instead.
+ *
+ * When you subscribe to the result of `connect`, the `selector` function will be called. After
+ * the `selector` function returns, the observable it returns will be subscribed to, _then_ the
+ * multicast will be connected to the source.
+ *
+ * ## Example
+ *
+ * Sharing a totally synchronous observable
+ *
+ * ```ts
+ * import { of, tap, connect, merge, map, filter } from 'rxjs';
+ *
+ * const source$ = of(1, 2, 3, 4, 5).pipe(
+ *   tap({
+ *     subscribe: () => console.log('subscription started'),
+ *     next: n => console.log(`source emitted ${ n }`)
+ *   })
+ * );
+ *
+ * source$.pipe(
+ *   // Notice in here we're merging 3 subscriptions to `shared$`.
+ *   connect(shared$ => merge(
+ *     shared$.pipe(map(n => `all ${ n }`)),
+ *     shared$.pipe(filter(n => n % 2 === 0), map(n => `even ${ n }`)),
+ *     shared$.pipe(filter(n => n % 2 === 1), map(n => `odd ${ n }`))
+ *   ))
+ * )
+ * .subscribe(console.log);
+ *
+ * // Expected output: (notice only one subscription)
+ * 'subscription started'
+ * 'source emitted 1'
+ * 'all 1'
+ * 'odd 1'
+ * 'source emitted 2'
+ * 'all 2'
+ * 'even 2'
+ * 'source emitted 3'
+ * 'all 3'
+ * 'odd 3'
+ * 'source emitted 4'
+ * 'all 4'
+ * 'even 4'
+ * 'source emitted 5'
+ * 'all 5'
+ * 'odd 5'
+ * ```
+ *
+ * @param selector A function used to set up the multicast. Gives you a multicast observable
+ * that is not yet connected. With that, you're expected to create and return
+ * and Observable, that when subscribed to, will utilize the multicast observable.
+ * After this function is executed -- and its return value subscribed to -- the
+ * operator will subscribe to the source, and the connection will be made.
+ * @param config The configuration object for `connect`.
+ */
+export declare function connect<T, O extends ObservableInput<unknown>>(selector: (shared: Observable<T>) => O, config?: ConnectConfig<T>): OperatorFunction<T, ObservedValueOf<O>>;
+//# sourceMappingURL=connect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/connect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC3F,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAM3C;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B;;;OAGG;IACH,SAAS,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC;CACjC;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,EAC3D,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,EACtC,MAAM,GAAE,aAAa,CAAC,CAAC,CAAkB,GACxC,gBAAgB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAOzC"}

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

@@ -0,0 +1,58 @@
+import { OperatorFunction } from '../types';
+/**
+ * Counts the number of emissions on the source and emits that number when the
+ * source completes.
+ *
+ * <span class="informal">Tells how many values were emitted, when the source
+ * completes.</span>
+ *
+ * ![](count.png)
+ *
+ * `count` transforms an Observable that emits values into an Observable that
+ * emits a single value that represents the number of values emitted by the
+ * source Observable. If the source Observable terminates with an error, `count`
+ * will pass this error notification along without emitting a value first. If
+ * the source Observable does not terminate at all, `count` will neither emit
+ * a value nor terminate. This operator takes an optional `predicate` function
+ * as argument, in which case the output emission will represent the number of
+ * source values that matched `true` with the `predicate`.
+ *
+ * ## Examples
+ *
+ * Counts how many seconds have passed before the first click happened
+ *
+ * ```ts
+ * import { interval, fromEvent, takeUntil, count } from 'rxjs';
+ *
+ * const seconds = interval(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const secondsBeforeClick = seconds.pipe(takeUntil(clicks));
+ * const result = secondsBeforeClick.pipe(count());
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * Counts how many odd numbers are there between 1 and 7
+ *
+ * ```ts
+ * import { range, count } from 'rxjs';
+ *
+ * const numbers = range(1, 7);
+ * const result = numbers.pipe(count(i => i % 2 === 1));
+ * result.subscribe(x => console.log(x));
+ * // Results in:
+ * // 4
+ * ```
+ *
+ * @see {@link max}
+ * @see {@link min}
+ * @see {@link reduce}
+ *
+ * @param predicate A function that is used to analyze the value and the index and
+ * determine whether or not to increment the count. Return `true` to increment the count,
+ * and return `false` to keep the count the same.
+ * If the predicate is not provided, every value will be counted.
+ * @return A function that returns an Observable that emits one number that
+ * represents the count of emissions.
+ */
+export declare function count<T>(predicate?: (value: T, index: number) => boolean): OperatorFunction<T, number>;
+//# sourceMappingURL=count.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/count.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC,CAEtG"}

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

@@ -0,0 +1,61 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Emits a notification from the source Observable only after a particular time span
+ * determined by another Observable has passed without another source emission.
+ *
+ * <span class="informal">It's like {@link debounceTime}, but the time span of
+ * emission silence is determined by a second Observable.</span>
+ *
+ * ![](debounce.svg)
+ *
+ * `debounce` delays notifications emitted by the source Observable, but drops previous
+ * pending delayed emissions if a new notification arrives on the source Observable.
+ * This operator keeps track of the most recent notification from the source
+ * Observable, and spawns a duration Observable by calling the
+ * `durationSelector` function. The notification is emitted only when the duration
+ * Observable emits a next notification, and if no other notification was emitted on
+ * the source Observable since the duration Observable was spawned. If a new
+ * notification appears before the duration Observable emits, the previous notification will
+ * not be emitted and a new duration is scheduled from `durationSelector` is scheduled.
+ * If the completing event happens during the scheduled duration the last cached notification
+ * is emitted before the completion event is forwarded to the output observable.
+ * If the error event happens during the scheduled duration or after it only the error event is
+ * forwarded to the output observable. The cache notification is not emitted in this case.
+ *
+ * Like {@link debounceTime}, this is a rate-limiting operator, and also a
+ * delay-like operator since output emissions do not necessarily occur at the
+ * same time as they did on the source Observable.
+ *
+ * ## Example
+ *
+ * Emit the most recent click after a burst of clicks
+ *
+ * ```ts
+ * import { fromEvent, scan, debounce, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(
+ *   scan(i => ++i, 1),
+ *   debounce(i => interval(200 * i))
+ * );
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link audit}
+ * @see {@link auditTime}
+ * @see {@link debounceTime}
+ * @see {@link delay}
+ * @see {@link sample}
+ * @see {@link sampleTime}
+ * @see {@link throttle}
+ * @see {@link throttleTime}
+ *
+ * @param durationSelector A function
+ * that receives a value from the source Observable, for computing the timeout
+ * duration for each source value, returned as an Observable or a Promise.
+ * @return A function that returns an Observable that delays the emissions of
+ * the source Observable by the specified duration Observable returned by
+ * `durationSelector`, and may drop some values if they occur too frequently.
+ */
+export declare function debounce<T>(durationSelector: (value: T) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=debounce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/debounce.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAMrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,eAAe,CAAC,GAAG,CAAC,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAqD7G"}

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

@@ -0,0 +1,59 @@
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+/**
+ * Emits a notification from the source Observable only after a particular time span
+ * has passed without another source emission.
+ *
+ * <span class="informal">It's like {@link delay}, but passes only the most
+ * recent notification from each burst of emissions.</span>
+ *
+ * ![](debounceTime.png)
+ *
+ * `debounceTime` delays notifications emitted by the source Observable, but drops
+ * previous pending delayed emissions if a new notification arrives on the source
+ * Observable. This operator keeps track of the most recent notification from the
+ * source Observable, and emits that only when `dueTime` has passed
+ * without any other notification appearing on the source Observable. If a new value
+ * appears before `dueTime` silence occurs, the previous notification will be dropped
+ * and will not be emitted and a new `dueTime` is scheduled.
+ * If the completing event happens during `dueTime` the last cached notification
+ * is emitted before the completion event is forwarded to the output observable.
+ * If the error event happens during `dueTime` or after it only the error event is
+ * forwarded to the output observable. The cache notification is not emitted in this case.
+ *
+ * This is a rate-limiting operator, because it is impossible for more than one
+ * notification to be emitted in any time window of duration `dueTime`, but it is also
+ * a delay-like operator since output emissions do not occur at the same time as
+ * they did on the source Observable. Optionally takes a {@link SchedulerLike} for
+ * managing timers.
+ *
+ * ## Example
+ *
+ * Emit the most recent click after a burst of clicks
+ *
+ * ```ts
+ * import { fromEvent, debounceTime } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(debounceTime(1000));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link audit}
+ * @see {@link auditTime}
+ * @see {@link debounce}
+ * @see {@link sample}
+ * @see {@link sampleTime}
+ * @see {@link throttle}
+ * @see {@link throttleTime}
+ *
+ * @param dueTime The timeout duration in milliseconds (or the time unit determined
+ * internally by the optional `scheduler`) for the window of time required to wait
+ * for emission silence before emitting the most recent source value.
+ * @param scheduler The {@link SchedulerLike} to use for managing the timers that
+ * handle the timeout for each value.
+ * @return A function that returns an Observable that delays the emissions of
+ * the source Observable by the specified `dueTime`, and may drop some values
+ * if they occur too frequently.
+ */
+export declare function debounceTime<T>(dueTime: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=debounceTime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debounceTime.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/debounceTime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAmB,aAAa,EAAE,MAAM,UAAU,CAAC;AAIpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,aAA8B,GAAG,wBAAwB,CAAC,CAAC,CAAC,CA4DvH"}

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

@@ -0,0 +1,38 @@
+import { OperatorFunction } from '../types';
+/**
+ * Emits a given value if the source Observable completes without emitting any
+ * `next` value, otherwise mirrors the source Observable.
+ *
+ * <span class="informal">If the source Observable turns out to be empty, then
+ * this operator will emit a default value.</span>
+ *
+ * ![](defaultIfEmpty.png)
+ *
+ * `defaultIfEmpty` emits the values emitted by the source Observable or a
+ * specified default value if the source Observable is empty (completes without
+ * having emitted any `next` value).
+ *
+ * ## Example
+ *
+ * If no clicks happen in 5 seconds, then emit 'no clicks'
+ *
+ * ```ts
+ * import { fromEvent, takeUntil, interval, defaultIfEmpty } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const clicksBeforeFive = clicks.pipe(takeUntil(interval(5000)));
+ * const result = clicksBeforeFive.pipe(defaultIfEmpty('no clicks'));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link empty}
+ * @see {@link last}
+ *
+ * @param defaultValue The default value used if the source
+ * Observable is empty.
+ * @return A function that returns an Observable that emits either the
+ * specified `defaultValue` if the source Observable emits no items, or the
+ * values emitted by the source Observable.
+ */
+export declare function defaultIfEmpty<T, R>(defaultValue: R): OperatorFunction<T, T | R>;
+//# sourceMappingURL=defaultIfEmpty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultIfEmpty.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/defaultIfEmpty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAmBhF"}