appiq-solution 1.0.0

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/throwError.d.ts

@@ -0,0 +1,115 @@
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+/**
+ * Creates an observable that will create an error instance and push it to the consumer as an error
+ * immediately upon subscription.
+ *
+ * <span class="informal">Just errors and does nothing else</span>
+ *
+ * ![](throw.png)
+ *
+ * This creation function is useful for creating an observable that will create an error and error every
+ * time it is subscribed to. Generally, inside of most operators when you might want to return an errored
+ * observable, this is unnecessary. In most cases, such as in the inner return of {@link concatMap},
+ * {@link mergeMap}, {@link defer}, and many others, you can simply throw the error, and RxJS will pick
+ * that up and notify the consumer of the error.
+ *
+ * ## Example
+ *
+ * Create a simple observable that will create a new error with a timestamp and log it
+ * and the message every time you subscribe to it
+ *
+ * ```ts
+ * import { throwError } from 'rxjs';
+ *
+ * let errorCount = 0;
+ *
+ * const errorWithTimestamp$ = throwError(() => {
+ *   const error: any = new Error(`This is error number ${ ++errorCount }`);
+ *   error.timestamp = Date.now();
+ *   return error;
+ * });
+ *
+ * errorWithTimestamp$.subscribe({
+ *   error: err => console.log(err.timestamp, err.message)
+ * });
+ *
+ * errorWithTimestamp$.subscribe({
+ *   error: err => console.log(err.timestamp, err.message)
+ * });
+ *
+ * // Logs the timestamp and a new error message for each subscription
+ * ```
+ *
+ * ### Unnecessary usage
+ *
+ * Using `throwError` inside of an operator or creation function
+ * with a callback, is usually not necessary
+ *
+ * ```ts
+ * import { of, concatMap, timer, throwError } from 'rxjs';
+ *
+ * const delays$ = of(1000, 2000, Infinity, 3000);
+ *
+ * delays$.pipe(
+ *   concatMap(ms => {
+ *     if (ms < 10000) {
+ *       return timer(ms);
+ *     } else {
+ *       // This is probably overkill.
+ *       return throwError(() => new Error(`Invalid time ${ ms }`));
+ *     }
+ *   })
+ * )
+ * .subscribe({
+ *   next: console.log,
+ *   error: console.error
+ * });
+ * ```
+ *
+ * You can just throw the error instead
+ *
+ * ```ts
+ * import { of, concatMap, timer } from 'rxjs';
+ *
+ * const delays$ = of(1000, 2000, Infinity, 3000);
+ *
+ * delays$.pipe(
+ *   concatMap(ms => {
+ *     if (ms < 10000) {
+ *       return timer(ms);
+ *     } else {
+ *       // Cleaner and easier to read for most folks.
+ *       throw new Error(`Invalid time ${ ms }`);
+ *     }
+ *   })
+ * )
+ * .subscribe({
+ *   next: console.log,
+ *   error: console.error
+ * });
+ * ```
+ *
+ * @param errorFactory A factory function that will create the error instance that is pushed.
+ */
+export declare function throwError(errorFactory: () => any): Observable<never>;
+/**
+ * Returns an observable that will error with the specified error immediately upon subscription.
+ *
+ * @param error The error instance to emit
+ * @deprecated Support for passing an error value will be removed in v8. Instead, pass a factory function to `throwError(() => new Error('test'))`. This is
+ * because it will create the error at the moment it should be created and capture a more appropriate stack trace. If
+ * for some reason you need to create the error ahead of time, you can still do that: `const err = new Error('test'); throwError(() => err);`.
+ */
+export declare function throwError(error: any): Observable<never>;
+/**
+ * Notifies the consumer of an error using a given scheduler by scheduling it at delay `0` upon subscription.
+ *
+ * @param errorOrErrorFactory An error instance or error factory
+ * @param scheduler A scheduler to use to schedule the error notification
+ * @deprecated The `scheduler` parameter will be removed in v8.
+ * Use `throwError` in combination with {@link observeOn}: `throwError(() => new Error('test')).pipe(observeOn(scheduler));`.
+ * Details: https://rxjs.dev/deprecations/scheduler-argument
+ */
+export declare function throwError(errorOrErrorFactory: any, scheduler: SchedulerLike): Observable<never>;
+//# sourceMappingURL=throwError.d.ts.map

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/throwError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throwError.d.ts","sourceRoot":"","sources":["../../../../src/internal/observable/throwError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,wBAAgB,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;AAEvE;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,mBAAmB,EAAE,GAAG,EAAE,SAAS,EAAE,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC"}

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/timer.d.ts

@@ -0,0 +1,126 @@
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+/**
+ * Creates an observable that will wait for a specified time period, or exact date, before
+ * emitting the number 0.
+ *
+ * <span class="informal">Used to emit a notification after a delay.</span>
+ *
+ * This observable is useful for creating delays in code, or racing against other values
+ * for ad-hoc timeouts.
+ *
+ * The `delay` is specified by default in milliseconds, however providing a custom scheduler could
+ * create a different behavior.
+ *
+ * ## Examples
+ *
+ * Wait 3 seconds and start another observable
+ *
+ * You might want to use `timer` to delay subscription to an
+ * observable by a set amount of time. Here we use a timer with
+ * {@link concatMapTo} or {@link concatMap} in order to wait
+ * a few seconds and start a subscription to a source.
+ *
+ * ```ts
+ * import { of, timer, concatMap } from 'rxjs';
+ *
+ * // This could be any observable
+ * const source = of(1, 2, 3);
+ *
+ * timer(3000)
+ *   .pipe(concatMap(() => source))
+ *   .subscribe(console.log);
+ * ```
+ *
+ * Take all values until the start of the next minute
+ *
+ * Using a `Date` as the trigger for the first emission, you can
+ * do things like wait until midnight to fire an event, or in this case,
+ * wait until a new minute starts (chosen so the example wouldn't take
+ * too long to run) in order to stop watching a stream. Leveraging
+ * {@link takeUntil}.
+ *
+ * ```ts
+ * import { interval, takeUntil, timer } from 'rxjs';
+ *
+ * // Build a Date object that marks the
+ * // next minute.
+ * const currentDate = new Date();
+ * const startOfNextMinute = new Date(
+ *   currentDate.getFullYear(),
+ *   currentDate.getMonth(),
+ *   currentDate.getDate(),
+ *   currentDate.getHours(),
+ *   currentDate.getMinutes() + 1
+ * );
+ *
+ * // This could be any observable stream
+ * const source = interval(1000);
+ *
+ * const result = source.pipe(
+ *   takeUntil(timer(startOfNextMinute))
+ * );
+ *
+ * result.subscribe(console.log);
+ * ```
+ *
+ * ### Known Limitations
+ *
+ * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled.
+ *
+ * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and
+ * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission
+ * should occur will be incorrect. In this case, it would be best to do your own calculations
+ * ahead of time, and pass a `number` in as the `dueTime`.
+ *
+ * @param due If a `number`, the amount of time in milliseconds to wait before emitting.
+ * If a `Date`, the exact time at which to emit.
+ * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}.
+ */
+export declare function timer(due: number | Date, scheduler?: SchedulerLike): Observable<0>;
+/**
+ * Creates an observable that starts an interval after a specified delay, emitting incrementing numbers -- starting at `0` --
+ * on each interval after words.
+ *
+ * The `delay` and `intervalDuration` are specified by default in milliseconds, however providing a custom scheduler could
+ * create a different behavior.
+ *
+ * ## Example
+ *
+ * ### Start an interval that starts right away
+ *
+ * Since {@link interval} waits for the passed delay before starting,
+ * sometimes that's not ideal. You may want to start an interval immediately.
+ * `timer` works well for this. Here we have both side-by-side so you can
+ * see them in comparison.
+ *
+ * Note that this observable will never complete.
+ *
+ * ```ts
+ * import { timer, interval } from 'rxjs';
+ *
+ * timer(0, 1000).subscribe(n => console.log('timer', n));
+ * interval(1000).subscribe(n => console.log('interval', n));
+ * ```
+ *
+ * ### Known Limitations
+ *
+ * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled.
+ *
+ * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and
+ * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission
+ * should occur will be incorrect. In this case, it would be best to do your own calculations
+ * ahead of time, and pass a `number` in as the `startDue`.
+ * @param startDue If a `number`, is the time to wait before starting the interval.
+ * If a `Date`, is the exact time at which to start the interval.
+ * @param intervalDuration The delay between each value emitted in the interval. Passing a
+ * negative number here will result in immediate completion after the first value is emitted, as though
+ * no `intervalDuration` was passed at all.
+ * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}.
+ */
+export declare function timer(startDue: number | Date, intervalDuration: number, scheduler?: SchedulerLike): Observable<number>;
+/**
+ * @deprecated The signature allowing `undefined` to be passed for `intervalDuration` will be removed in v8. Use the `timer(dueTime, scheduler?)` signature instead.
+ */
+export declare function timer(dueTime: number | Date, unused: undefined, scheduler?: SchedulerLike): Observable<0>;
+//# sourceMappingURL=timer.d.ts.map

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../../../src/internal/observable/timer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAKzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;AAExH;;GAEG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC"}

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/using.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from '../Observable';
+import { Unsubscribable, ObservableInput, ObservedValueOf } from '../types';
+/**
+ * Creates an Observable that uses a resource which will be disposed at the same time as the Observable.
+ *
+ * <span class="informal">Use it when you catch yourself cleaning up after an Observable.</span>
+ *
+ * `using` is a factory operator, which accepts two functions. First function returns a disposable resource.
+ * It can be an arbitrary object that implements `unsubscribe` method. Second function will be injected with
+ * that object and should return an Observable. That Observable can use resource object during its execution.
+ * Both functions passed to `using` will be called every time someone subscribes - neither an Observable nor
+ * resource object will be shared in any way between subscriptions.
+ *
+ * When Observable returned by `using` is subscribed, Observable returned from the second function will be subscribed
+ * as well. All its notifications (nexted values, completion and error events) will be emitted unchanged by the output
+ * Observable. If however someone unsubscribes from the Observable or source Observable completes or errors by itself,
+ * the `unsubscribe` method on resource object will be called. This can be used to do any necessary clean up, which
+ * otherwise would have to be handled by hand. Note that complete or error notifications are not emitted when someone
+ * cancels subscription to an Observable via `unsubscribe`, so `using` can be used as a hook, allowing you to make
+ * sure that all resources which need to exist during an Observable execution will be disposed at appropriate time.
+ *
+ * @see {@link defer}
+ *
+ * @param resourceFactory A function which creates any resource object that implements `unsubscribe` method.
+ * @param observableFactory A function which creates an Observable, that can use injected resource object.
+ * @return An Observable that behaves the same as Observable returned by `observableFactory`, but
+ * which - when completed, errored or unsubscribed - will also call `unsubscribe` on created resource object.
+ */
+export declare function using<T extends ObservableInput<any>>(resourceFactory: () => Unsubscribable | void, observableFactory: (resource: Unsubscribable | void) => T | void): Observable<ObservedValueOf<T>>;
+//# sourceMappingURL=using.d.ts.map

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/using.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"using.d.ts","sourceRoot":"","sources":["../../../../src/internal/observable/using.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI5E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,eAAe,CAAC,GAAG,CAAC,EAClD,eAAe,EAAE,MAAM,cAAc,GAAG,IAAI,EAC5C,iBAAiB,EAAE,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI,GAC/D,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAchC"}

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/zip.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from '../Observable';
+import { ObservableInputTuple } from '../types';
+export declare function zip<A extends readonly unknown[]>(sources: [...ObservableInputTuple<A>]): Observable<A>;
+export declare function zip<A extends readonly unknown[], R>(sources: [...ObservableInputTuple<A>], resultSelector: (...values: A) => R): Observable<R>;
+export declare function zip<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;
+export declare function zip<A extends readonly unknown[], R>(...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R]): Observable<R>;
+//# sourceMappingURL=zip.d.ts.map

package/tools/installer/node_modules/rxjs/dist/types/internal/observable/zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../../src/internal/observable/zip.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAOhD,wBAAgB,GAAG,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AACxG,wBAAgB,GAAG,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,EACjD,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,EACrC,cAAc,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,GAClC,UAAU,CAAC,CAAC,CAAC,CAAC;AACjB,wBAAgB,GAAG,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAC3G,wBAAgB,GAAG,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,EACjD,GAAG,wBAAwB,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,GAC7E,UAAU,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,41 @@
+import { Subscriber } from '../Subscriber';
+/**
+ * Creates an instance of an `OperatorSubscriber`.
+ * @param destination The downstream subscriber.
+ * @param onNext Handles next values, only called if this subscriber is not stopped or closed. Any
+ * error that occurs in this function is caught and sent to the `error` method of this subscriber.
+ * @param onError Handles errors from the subscription, any errors that occur in this handler are caught
+ * and send to the `destination` error handler.
+ * @param onComplete Handles completion notification from the subscription. Any errors that occur in
+ * this handler are sent to the `destination` error handler.
+ * @param onFinalize Additional teardown logic here. This will only be called on teardown if the
+ * subscriber itself is not already closed. This is called after all other teardown logic is executed.
+ */
+export declare function createOperatorSubscriber<T>(destination: Subscriber<any>, onNext?: (value: T) => void, onComplete?: () => void, onError?: (err: any) => void, onFinalize?: () => void): Subscriber<T>;
+/**
+ * A generic helper for allowing operators to be created with a Subscriber and
+ * use closures to capture necessary state from the operator function itself.
+ */
+export declare class OperatorSubscriber<T> extends Subscriber<T> {
+    private onFinalize?;
+    private shouldUnsubscribe?;
+    /**
+     * Creates an instance of an `OperatorSubscriber`.
+     * @param destination The downstream subscriber.
+     * @param onNext Handles next values, only called if this subscriber is not stopped or closed. Any
+     * error that occurs in this function is caught and sent to the `error` method of this subscriber.
+     * @param onError Handles errors from the subscription, any errors that occur in this handler are caught
+     * and send to the `destination` error handler.
+     * @param onComplete Handles completion notification from the subscription. Any errors that occur in
+     * this handler are sent to the `destination` error handler.
+     * @param onFinalize Additional finalization logic here. This will only be called on finalization if the
+     * subscriber itself is not already closed. This is called after all other finalization logic is executed.
+     * @param shouldUnsubscribe An optional check to see if an unsubscribe call should truly unsubscribe.
+     * NOTE: This currently **ONLY** exists to support the strange behavior of {@link groupBy}, where unsubscription
+     * to the resulting observable does not actually disconnect from the source if there are active subscriptions
+     * to any grouped observable. (DO NOT EXPOSE OR USE EXTERNALLY!!!)
+     */
+    constructor(destination: Subscriber<any>, onNext?: (value: T) => void, onComplete?: () => void, onError?: (err: any) => void, onFinalize?: (() => void) | undefined, shouldUnsubscribe?: (() => boolean) | undefined);
+    unsubscribe(): void;
+}
+//# sourceMappingURL=OperatorSubscriber.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OperatorSubscriber.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/OperatorSubscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,WAAW,EAAE,UAAU,CAAC,GAAG,CAAC,EAC5B,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC3B,UAAU,CAAC,EAAE,MAAM,IAAI,EACvB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAC5B,UAAU,CAAC,EAAE,MAAM,IAAI,GACtB,UAAU,CAAC,CAAC,CAAC,CAEf;AAED;;;GAGG;AACH,qBAAa,kBAAkB,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IAsBpD,OAAO,CAAC,UAAU,CAAC;IACnB,OAAO,CAAC,iBAAiB,CAAC;IAtB5B;;;;;;;;;;;;;;;OAeG;gBAED,WAAW,EAAE,UAAU,CAAC,GAAG,CAAC,EAC5B,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC3B,UAAU,CAAC,EAAE,MAAM,IAAI,EACvB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EACpB,UAAU,CAAC,SAAQ,IAAI,aAAA,EACvB,iBAAiB,CAAC,SAAQ,OAAO,aAAA;IAoD3C,WAAW;CAQZ"}

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

@@ -0,0 +1,48 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Ignores source values for a duration determined by another Observable, then
+ * emits the most recent value from the source Observable, then repeats this
+ * process.
+ *
+ * <span class="informal">It's like {@link auditTime}, but the silencing
+ * duration is determined by a second Observable.</span>
+ *
+ * ![](audit.svg)
+ *
+ * `audit` is similar to `throttle`, but emits the last value from the silenced
+ * time window, instead of the first value. `audit` emits the most recent value
+ * from the source Observable on the output Observable as soon as its internal
+ * timer becomes disabled, and ignores source values while the timer is enabled.
+ * Initially, the timer is disabled. As soon as the first source value arrives,
+ * the timer is enabled by calling the `durationSelector` function with the
+ * source value, which returns the "duration" Observable. When the duration
+ * Observable emits a value, the timer is disabled, then the most
+ * recent source value is emitted on the output Observable, and this process
+ * repeats for the next source value.
+ *
+ * ## Example
+ *
+ * Emit clicks at a rate of at most one click per second
+ *
+ * ```ts
+ * import { fromEvent, audit, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(audit(ev => interval(1000)));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link auditTime}
+ * @see {@link debounce}
+ * @see {@link delayWhen}
+ * @see {@link sample}
+ * @see {@link throttle}
+ *
+ * @param durationSelector A function
+ * that receives a value from the source Observable, for computing the silencing
+ * duration, returned as an Observable or a Promise.
+ * @return A function that returns an Observable that performs rate-limiting of
+ * emissions from the source Observable.
+ */
+export declare function audit<T>(durationSelector: (value: T) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=audit.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+/**
+ * Ignores source values for `duration` milliseconds, then emits the most recent
+ * value from the source Observable, then repeats this process.
+ *
+ * <span class="informal">When it sees a source value, it ignores that plus
+ * the next ones for `duration` milliseconds, and then it emits the most recent
+ * value from the source.</span>
+ *
+ * ![](auditTime.png)
+ *
+ * `auditTime` is similar to `throttleTime`, but emits the last value from the
+ * silenced time window, instead of the first value. `auditTime` emits the most
+ * recent value from the source Observable on the output Observable as soon as
+ * its internal timer becomes disabled, and ignores source values while the
+ * timer is enabled. Initially, the timer is disabled. As soon as the first
+ * source value arrives, the timer is enabled. After `duration` milliseconds (or
+ * the time unit determined internally by the optional `scheduler`) has passed,
+ * the timer is disabled, then the most recent source value is emitted on the
+ * output Observable, and this process repeats for the next source value.
+ * Optionally takes a {@link SchedulerLike} for managing timers.
+ *
+ * ## Example
+ *
+ * Emit clicks at a rate of at most one click per second
+ *
+ * ```ts
+ * import { fromEvent, auditTime } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(auditTime(1000));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link audit}
+ * @see {@link debounceTime}
+ * @see {@link delay}
+ * @see {@link sampleTime}
+ * @see {@link throttleTime}
+ *
+ * @param duration Time to wait before emitting the most recent source value,
+ * measured in milliseconds or the time unit determined internally by the
+ * optional `scheduler`.
+ * @param scheduler The {@link SchedulerLike} to use for managing the timers
+ * that handle the rate-limiting behavior.
+ * @return A function that returns an Observable that performs rate-limiting of
+ * emissions from the source Observable.
+ */
+export declare function auditTime<T>(duration: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=auditTime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auditTime.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/auditTime.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAE,aAA8B,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAErH"}

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

@@ -0,0 +1,41 @@
+import { OperatorFunction, ObservableInput } from '../types';
+/**
+ * Buffers the source Observable values until `closingNotifier` emits.
+ *
+ * <span class="informal">Collects values from the past as an array, and emits
+ * that array only when another Observable emits.</span>
+ *
+ * ![](buffer.png)
+ *
+ * Buffers the incoming Observable values until the given `closingNotifier`
+ * `ObservableInput` (that internally gets converted to an Observable)
+ * emits a value, at which point it emits the buffer on the output
+ * Observable and starts a new buffer internally, awaiting the next time
+ * `closingNotifier` emits.
+ *
+ * ## Example
+ *
+ * On every click, emit array of most recent interval events
+ *
+ * ```ts
+ * import { fromEvent, interval, buffer } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const intervalEvents = interval(1000);
+ * const buffered = intervalEvents.pipe(buffer(clicks));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link bufferCount}
+ * @see {@link bufferTime}
+ * @see {@link bufferToggle}
+ * @see {@link bufferWhen}
+ * @see {@link window}
+ *
+ * @param closingNotifier An `ObservableInput` that signals the
+ * buffer to be emitted on the output Observable.
+ * @return A function that returns an Observable of buffers, which are arrays
+ * of values.
+ */
+export declare function buffer<T>(closingNotifier: ObservableInput<any>): OperatorFunction<T, T[]>;
+//# sourceMappingURL=buffer.d.ts.map

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

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

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

@@ -0,0 +1,54 @@
+import { OperatorFunction } from '../types';
+/**
+ * Buffers the source Observable values until the size hits the maximum
+ * `bufferSize` given.
+ *
+ * <span class="informal">Collects values from the past as an array, and emits
+ * that array only when its size reaches `bufferSize`.</span>
+ *
+ * ![](bufferCount.png)
+ *
+ * Buffers a number of values from the source Observable by `bufferSize` then
+ * emits the buffer and clears it, and starts a new buffer each
+ * `startBufferEvery` values. If `startBufferEvery` is not provided or is
+ * `null`, then new buffers are started immediately at the start of the source
+ * and when each buffer closes and is emitted.
+ *
+ * ## Examples
+ *
+ * Emit the last two click events as an array
+ *
+ * ```ts
+ * import { fromEvent, bufferCount } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferCount(2));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * On every click, emit the last two click events as an array
+ *
+ * ```ts
+ * import { fromEvent, bufferCount } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferCount(2, 1));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link buffer}
+ * @see {@link bufferTime}
+ * @see {@link bufferToggle}
+ * @see {@link bufferWhen}
+ * @see {@link pairwise}
+ * @see {@link windowCount}
+ *
+ * @param bufferSize The maximum size of the buffer emitted.
+ * @param startBufferEvery Interval at which to start a new buffer.
+ * For example if `startBufferEvery` is `2`, then a new buffer will be started
+ * on every other value from the source. A new buffer is started at the
+ * beginning of the source by default.
+ * @return A function that returns an Observable of arrays of buffered values.
+ */
+export declare function bufferCount<T>(bufferSize: number, startBufferEvery?: number | null): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferCount.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferCount.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/bufferCount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAM,GAAG,IAAW,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CA+DnH"}

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

@@ -0,0 +1,5 @@
+import { OperatorFunction, SchedulerLike } from '../types';
+export declare function bufferTime<T>(bufferTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
+export declare function bufferTime<T>(bufferTimeSpan: number, bufferCreationInterval: number | null | undefined, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
+export declare function bufferTime<T>(bufferTimeSpan: number, bufferCreationInterval: number | null | undefined, maxBufferSize: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferTime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferTime.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/bufferTime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAQ3D,wBAAgB,UAAU,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAC3G,wBAAgB,UAAU,CAAC,CAAC,EAC1B,cAAc,EAAE,MAAM,EACtB,sBAAsB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,SAAS,CAAC,EAAE,aAAa,GACxB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAC5B,wBAAgB,UAAU,CAAC,CAAC,EAC1B,cAAc,EAAE,MAAM,EACtB,sBAAsB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,aAAa,EAAE,MAAM,EACrB,SAAS,CAAC,EAAE,aAAa,GACxB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,46 @@
+import { OperatorFunction, ObservableInput } from '../types';
+/**
+ * Buffers the source Observable values starting from an emission from
+ * `openings` and ending when the output of `closingSelector` emits.
+ *
+ * <span class="informal">Collects values from the past as an array. Starts
+ * collecting only when `opening` emits, and calls the `closingSelector`
+ * function to get an Observable that tells when to close the buffer.</span>
+ *
+ * ![](bufferToggle.png)
+ *
+ * Buffers values from the source by opening the buffer via signals from an
+ * Observable provided to `openings`, and closing and sending the buffers when
+ * a Subscribable or Promise returned by the `closingSelector` function emits.
+ *
+ * ## Example
+ *
+ * Every other second, emit the click events from the next 500ms
+ *
+ * ```ts
+ * import { fromEvent, interval, bufferToggle, EMPTY } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const openings = interval(1000);
+ * const buffered = clicks.pipe(bufferToggle(openings, i =>
+ *   i % 2 ? interval(500) : EMPTY
+ * ));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link buffer}
+ * @see {@link bufferCount}
+ * @see {@link bufferTime}
+ * @see {@link bufferWhen}
+ * @see {@link windowToggle}
+ *
+ * @param openings A Subscribable or Promise of notifications to start new
+ * buffers.
+ * @param closingSelector A function that takes
+ * the value emitted by the `openings` observable and returns a Subscribable or Promise,
+ * which, when it emits, signals that the associated buffer should be emitted
+ * and cleared.
+ * @return A function that returns an Observable of arrays of buffered values.
+ */
+export declare function bufferToggle<T, O>(openings: ObservableInput<O>, closingSelector: (value: O) => ObservableInput<any>): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferToggle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferToggle.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/bufferToggle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAO7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,EAC5B,eAAe,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,eAAe,CAAC,GAAG,CAAC,GAClD,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CA+C1B"}