lambda-live-debugger 1.12.2 → 1.12.4

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

@@ -1,115 +0,0 @@
-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/node_modules/rxjs/dist/types/internal/observable/throwError.d.ts.map

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

@@ -1,126 +0,0 @@
-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/node_modules/rxjs/dist/types/internal/observable/timer.d.ts.map

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

@@ -1,30 +0,0 @@
-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/node_modules/rxjs/dist/types/internal/observable/using.d.ts.map

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

@@ -1,7 +0,0 @@
-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/node_modules/rxjs/dist/types/internal/observable/zip.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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