appiq-solution 1.0.9 → 1.2.0

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

@@ -1,41 +0,0 @@
-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

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

@@ -1,4 +0,0 @@
-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

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

@@ -1,6 +0,0 @@
-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

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

@@ -1,10 +0,0 @@
-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

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

@@ -1,6 +0,0 @@
-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

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

@@ -1,43 +0,0 @@
-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

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

@@ -1,6 +0,0 @@
-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

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

@@ -1,59 +0,0 @@
-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

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

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

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

@@ -1,8 +0,0 @@
-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

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

@@ -1,43 +0,0 @@
-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

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

@@ -1,87 +0,0 @@
-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

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

@@ -1,58 +0,0 @@
-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

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

@@ -1,61 +0,0 @@
-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

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

@@ -1,59 +0,0 @@
-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

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

@@ -1,38 +0,0 @@
-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

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