lambda-live-debugger 1.12.3 → 1.12.4

package/node_modules/rxjs/dist/types/internal/operators/throttleTime.d.ts

@@ -1,53 +0,0 @@
-import { ThrottleConfig } from './throttle';
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-/**
- * Emits a value from the source Observable, then ignores subsequent source
- * values for `duration` milliseconds, then repeats this process.
- *
- * <span class="informal">Lets a value pass, then ignores source values for the
- * next `duration` milliseconds.</span>
- *
- * ![](throttleTime.png)
- *
- * `throttleTime` emits the source Observable values on the output Observable
- * when its internal timer is disabled, and ignores source values when the timer
- * is enabled. Initially, the timer is disabled. As soon as the first source
- * value arrives, it is forwarded to the output Observable, and then the timer
- * is enabled. After `duration` milliseconds (or the time unit determined
- * internally by the optional `scheduler`) has passed, the timer is disabled,
- * and this process repeats for the next source value. Optionally takes a
- * {@link SchedulerLike} for managing timers.
- *
- * ## Examples
- *
- * ### Limit click rate
- *
- * Emit clicks at a rate of at most one click per second
- *
- * ```ts
- * import { fromEvent, throttleTime } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(throttleTime(1000));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link auditTime}
- * @see {@link debounceTime}
- * @see {@link delay}
- * @see {@link sampleTime}
- * @see {@link throttle}
- *
- * @param duration Time to wait before emitting another value after
- * emitting the last 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 throttling. Defaults to {@link asyncScheduler}.
- * @param config A configuration object to define `leading` and
- * `trailing` behavior. Defaults to `{ leading: true, trailing: false }`.
- * @return A function that returns an Observable that performs the throttle
- * operation to limit the rate of emissions from the source.
- */
-export declare function throttleTime<T>(duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=throttleTime.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/throttleTime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttleTime.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/throttleTime.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,cAAc,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,aAA8B,EACzC,MAAM,CAAC,EAAE,cAAc,GACtB,wBAAwB,CAAC,CAAC,CAAC,CAG7B"}

package/node_modules/rxjs/dist/types/internal/operators/throwIfEmpty.d.ts

@@ -1,39 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * If the source observable completes without emitting a value, it will emit
- * an error. The error will be created at that time by the optional
- * `errorFactory` argument, otherwise, the error will be {@link EmptyError}.
- *
- * ![](throwIfEmpty.png)
- *
- * ## Example
- *
- * Throw an error if the document wasn't clicked within 1 second
- *
- * ```ts
- * import { fromEvent, takeUntil, timer, throwIfEmpty } from 'rxjs';
- *
- * const click$ = fromEvent(document, 'click');
- *
- * click$.pipe(
- *   takeUntil(timer(1000)),
- *   throwIfEmpty(() => new Error('The document was not clicked within 1 second'))
- * )
- * .subscribe({
- *   next() {
- *    console.log('The document was clicked');
- *   },
- *   error(err) {
- *     console.error(err.message);
- *   }
- * });
- * ```
- *
- * @param errorFactory A factory function called to produce the
- * error to be thrown when the source observable completes without emitting a
- * value.
- * @return A function that returns an Observable that throws an error if the
- * source Observable completed without emitting.
- */
-export declare function throwIfEmpty<T>(errorFactory?: () => any): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=throwIfEmpty.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/throwIfEmpty.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throwIfEmpty.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/throwIfEmpty.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAIpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,GAAE,MAAM,GAAyB,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAc1G"}

package/node_modules/rxjs/dist/types/internal/operators/timeInterval.d.ts

@@ -1,50 +0,0 @@
-import { SchedulerLike, OperatorFunction } from '../types';
-/**
- * Emits an object containing the current value, and the time that has
- * passed between emitting the current value and the previous value, which is
- * calculated by using the provided `scheduler`'s `now()` method to retrieve
- * the current time at each emission, then calculating the difference. The `scheduler`
- * defaults to {@link asyncScheduler}, so by default, the `interval` will be in
- * milliseconds.
- *
- * <span class="informal">Convert an Observable that emits items into one that
- * emits indications of the amount of time elapsed between those emissions.</span>
- *
- * ![](timeInterval.png)
- *
- * ## Example
- *
- * Emit interval between current value with the last value
- *
- * ```ts
- * import { interval, timeInterval } from 'rxjs';
- *
- * const seconds = interval(1000);
- *
- * seconds
- *   .pipe(timeInterval())
- *   .subscribe(value => console.log(value));
- *
- * // NOTE: The values will never be this precise,
- * // intervals created with `interval` or `setInterval`
- * // are non-deterministic.
- *
- * // { value: 0, interval: 1000 }
- * // { value: 1, interval: 1000 }
- * // { value: 2, interval: 1000 }
- * ```
- *
- * @param scheduler Scheduler used to get the current time.
- * @return A function that returns an Observable that emits information about
- * value and interval.
- */
-export declare function timeInterval<T>(scheduler?: SchedulerLike): OperatorFunction<T, TimeInterval<T>>;
-export declare class TimeInterval<T> {
-    value: T;
-    interval: number;
-    /**
-     * @deprecated Internal implementation detail, do not construct directly. Will be made an interface in v8.
-     */
-    constructor(value: T, interval: number);
-}
-//# sourceMappingURL=timeInterval.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/timeInterval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeInterval.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/timeInterval.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAE,aAA8B,GAAG,gBAAgB,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAY/G;AAKD,qBAAa,YAAY,CAAC,CAAC;IAIN,KAAK,EAAE,CAAC;IAAS,QAAQ,EAAE,MAAM;IAHpD;;OAEG;gBACgB,KAAK,EAAE,CAAC,EAAS,QAAQ,EAAE,MAAM;CACrD"}

package/node_modules/rxjs/dist/types/internal/operators/timeout.d.ts

@@ -1,255 +0,0 @@
-import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-export interface TimeoutConfig<T, O extends ObservableInput<unknown> = ObservableInput<T>, M = unknown> {
-    /**
-     * The time allowed between values from the source before timeout is triggered.
-     */
-    each?: number;
-    /**
-     * The relative time as a `number` in milliseconds, or a specific time as a `Date` object,
-     * by which the first value must arrive from the source before timeout is triggered.
-     */
-    first?: number | Date;
-    /**
-     * The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler}
-     */
-    scheduler?: SchedulerLike;
-    /**
-     * A factory used to create observable to switch to when timeout occurs. Provides
-     * a {@link TimeoutInfo} about the source observable's emissions and what delay or
-     * exact time triggered the timeout.
-     */
-    with?: (info: TimeoutInfo<T, M>) => O;
-    /**
-     * Optional additional metadata you can provide to code that handles
-     * the timeout, will be provided through the {@link TimeoutError}.
-     * This can be used to help identify the source of a timeout or pass along
-     * other information related to the timeout.
-     */
-    meta?: M;
-}
-export interface TimeoutInfo<T, M = unknown> {
-    /** Optional metadata that was provided to the timeout configuration. */
-    readonly meta: M;
-    /** The number of messages seen before the timeout */
-    readonly seen: number;
-    /** The last message seen */
-    readonly lastValue: T | null;
-}
-/**
- * An error emitted when a timeout occurs.
- */
-export interface TimeoutError<T = unknown, M = unknown> extends Error {
-    /**
-     * The information provided to the error by the timeout
-     * operation that created the error. Will be `null` if
-     * used directly in non-RxJS code with an empty constructor.
-     * (Note that using this constructor directly is not recommended,
-     * you should create your own errors)
-     */
-    info: TimeoutInfo<T, M> | null;
-}
-export interface TimeoutErrorCtor {
-    /**
-     * @deprecated Internal implementation detail. Do not construct error instances.
-     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-     */
-    new <T = unknown, M = unknown>(info?: TimeoutInfo<T, M>): TimeoutError<T, M>;
-}
-/**
- * An error thrown by the {@link timeout} operator.
- *
- * Provided so users can use as a type and do quality comparisons.
- * We recommend you do not subclass this or create instances of this class directly.
- * If you have need of a error representing a timeout, you should
- * create your own error class and use that.
- *
- * @see {@link timeout}
- */
-export declare const TimeoutError: TimeoutErrorCtor;
-/**
- * If `with` is provided, this will return an observable that will switch to a different observable if the source
- * does not push values within the specified time parameters.
- *
- * <span class="informal">The most flexible option for creating a timeout behavior.</span>
- *
- * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
- * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
- * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
- * the settings in `first` and `each`.
- *
- * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
- * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
- * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
- * against the time period provided by `each`, if it was provided.
- *
- * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
- * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
- * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
- * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
- *
- * ## Examples
- *
- * Emit a custom error if there is too much time between values
- *
- * ```ts
- * import { interval, timeout, throwError } from 'rxjs';
- *
- * class CustomTimeoutError extends Error {
- *   constructor() {
- *     super('It was too slow');
- *     this.name = 'CustomTimeoutError';
- *   }
- * }
- *
- * const slow$ = interval(900);
- *
- * slow$.pipe(
- *   timeout({
- *     each: 1000,
- *     with: () => throwError(() => new CustomTimeoutError())
- *   })
- * )
- * .subscribe({
- *   error: console.error
- * });
- * ```
- *
- * Switch to a faster observable if your source is slow.
- *
- * ```ts
- * import { interval, timeout } from 'rxjs';
- *
- * const slow$ = interval(900);
- * const fast$ = interval(500);
- *
- * slow$.pipe(
- *   timeout({
- *     each: 1000,
- *     with: () => fast$,
- *   })
- * )
- * .subscribe(console.log);
- * ```
- * @param config The configuration for the timeout.
- */
-export declare function timeout<T, O extends ObservableInput<unknown>, M = unknown>(config: TimeoutConfig<T, O, M> & {
-    with: (info: TimeoutInfo<T, M>) => O;
-}): OperatorFunction<T, T | ObservedValueOf<O>>;
-/**
- * Returns an observable that will error or switch to a different observable if the source does not push values
- * within the specified time parameters.
- *
- * <span class="informal">The most flexible option for creating a timeout behavior.</span>
- *
- * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
- * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
- * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
- * the settings in `first` and `each`.
- *
- * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
- * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
- * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
- * against the time period provided by `each`, if it was provided.
- *
- * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
- * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
- * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
- * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
- *
- * ### Handling TimeoutErrors
- *
- * If no `with` property was provided, subscriptions to the resulting observable may emit an error of {@link TimeoutError}.
- * The timeout error provides useful information you can examine when you're handling the error. The most common way to handle
- * the error would be with {@link catchError}, although you could use {@link tap} or just the error handler in your `subscribe` call
- * directly, if your error handling is only a side effect (such as notifying the user, or logging).
- *
- * In this case, you would check the error for `instanceof TimeoutError` to validate that the error was indeed from `timeout`, and
- * not from some other source. If it's not from `timeout`, you should probably rethrow it if you're in a `catchError`.
- *
- * ## Examples
- *
- * Emit a {@link TimeoutError} if the first value, and _only_ the first value, does not arrive within 5 seconds
- *
- * ```ts
- * import { interval, timeout } from 'rxjs';
- *
- * // A random interval that lasts between 0 and 10 seconds per tick
- * const source$ = interval(Math.round(Math.random() * 10_000));
- *
- * source$.pipe(
- *   timeout({ first: 5_000 })
- * )
- * .subscribe({
- *   next: console.log,
- *   error: console.error
- * });
- * ```
- *
- * Emit a {@link TimeoutError} if the source waits longer than 5 seconds between any two values or the first value
- * and subscription.
- *
- * ```ts
- * import { timer, timeout, expand } from 'rxjs';
- *
- * const getRandomTime = () => Math.round(Math.random() * 10_000);
- *
- * // An observable that waits a random amount of time between each delivered value
- * const source$ = timer(getRandomTime())
- *   .pipe(expand(() => timer(getRandomTime())));
- *
- * source$
- *   .pipe(timeout({ each: 5_000 }))
- *   .subscribe({
- *     next: console.log,
- *     error: console.error
- *   });
- * ```
- *
- * Emit a {@link TimeoutError} if the source does not emit before 7 seconds, _or_ if the source waits longer than
- * 5 seconds between any two values after the first.
- *
- * ```ts
- * import { timer, timeout, expand } from 'rxjs';
- *
- * const getRandomTime = () => Math.round(Math.random() * 10_000);
- *
- * // An observable that waits a random amount of time between each delivered value
- * const source$ = timer(getRandomTime())
- *   .pipe(expand(() => timer(getRandomTime())));
- *
- * source$
- *   .pipe(timeout({ first: 7_000, each: 5_000 }))
- *   .subscribe({
- *     next: console.log,
- *     error: console.error
- *   });
- * ```
- */
-export declare function timeout<T, M = unknown>(config: Omit<TimeoutConfig<T, any, M>, 'with'>): OperatorFunction<T, T>;
-/**
- * Returns an observable that will error if the source does not push its first value before the specified time passed as a `Date`.
- * This is functionally the same as `timeout({ first: someDate })`.
- *
- * <span class="informal">Errors if the first value doesn't show up before the given date and time</span>
- *
- * ![](timeout.png)
- *
- * @param first The date to at which the resulting observable will timeout if the source observable
- * does not emit at least one value.
- * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
- */
-export declare function timeout<T>(first: Date, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-/**
- * Returns an observable that will error if the source does not push a value within the specified time in milliseconds.
- * This is functionally the same as `timeout({ each: milliseconds })`.
- *
- * <span class="informal">Errors if it waits too long between any value</span>
- *
- * ![](timeout.png)
- *
- * @param each The time allowed between each pushed value from the source before the resulting observable
- * will timeout.
- * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
- */
-export declare function timeout<T>(each: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=timeout.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/timeout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/timeout.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAUvH,MAAM,WAAW,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO;IACpG;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtB;;OAEG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC;IAE1B;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;IAEtC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CAAC,CAAC;CACV;AAED,MAAM,WAAW,WAAW,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO;IACzC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4BAA4B;IAC5B,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,CAAE,SAAQ,KAAK;IACnE;;;;;;OAMG;IACH,IAAI,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,KAAK,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC9E;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,gBAQ1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,EACxE,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAA;CAAE,GACxE,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEhH;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAEhG;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

package/node_modules/rxjs/dist/types/internal/operators/timeoutWith.d.ts

@@ -1,8 +0,0 @@
-import { ObservableInput, OperatorFunction, SchedulerLike } from '../types';
-/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(someDate, a$, scheduler)`, use the configuration object
- * `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8. */
-export declare function timeoutWith<T, R>(dueBy: Date, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
-/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use the configuration object
- *  `timeout({ each: 100, with: () => a$, scheduler })`. Will be removed in v8. */
-export declare function timeoutWith<T, R>(waitFor: number, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
-//# sourceMappingURL=timeoutWith.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/timeoutWith.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeoutWith.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/timeoutWith.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG5E;uFACuF;AACvF,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AACpI;kFACkF;AAClF,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC"}

package/node_modules/rxjs/dist/types/internal/operators/timestamp.d.ts

@@ -1,35 +0,0 @@
-import { OperatorFunction, TimestampProvider, Timestamp } from '../types';
-/**
- * Attaches a timestamp to each item emitted by an observable indicating when it was emitted
- *
- * The `timestamp` operator maps the *source* observable stream to an object of type
- * `{value: T, timestamp: R}`. The properties are generically typed. The `value` property contains the value
- * and type of the *source* observable. The `timestamp` is generated by the schedulers `now` function. By
- * default, it uses the `asyncScheduler` which simply returns `Date.now()` (milliseconds since 1970/01/01
- * 00:00:00:000) and therefore is of type `number`.
- *
- * ![](timestamp.png)
- *
- * ## Example
- *
- * In this example there is a timestamp attached to the document's click events
- *
- * ```ts
- * import { fromEvent, timestamp } from 'rxjs';
- *
- * const clickWithTimestamp = fromEvent(document, 'click').pipe(
- *   timestamp()
- * );
- *
- * // Emits data of type { value: PointerEvent, timestamp: number }
- * clickWithTimestamp.subscribe(data => {
- *   console.log(data);
- * });
- * ```
- *
- * @param timestampProvider An object with a `now()` method used to get the current timestamp.
- * @return A function that returns an Observable that attaches a timestamp to
- * each item emitted by the source Observable indicating when it was emitted.
- */
-export declare function timestamp<T>(timestampProvider?: TimestampProvider): OperatorFunction<T, Timestamp<T>>;
-//# sourceMappingURL=timestamp.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/timestamp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timestamp.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/timestamp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAI1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,iBAAiB,GAAE,iBAAyC,GAAG,gBAAgB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAE5H"}

package/node_modules/rxjs/dist/types/internal/operators/toArray.d.ts

@@ -1,33 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Collects all source emissions and emits them as an array when the source completes.
- *
- * <span class="informal">Get all values inside an array when the source completes</span>
- *
- * ![](toArray.png)
- *
- * `toArray` will wait until the source Observable completes before emitting
- * the array containing all emissions. When the source Observable errors no
- * array will be emitted.
- *
- * ## Example
- *
- * ```ts
- * import { interval, take, toArray } from 'rxjs';
- *
- * const source = interval(1000);
- * const example = source.pipe(
- *   take(10),
- *   toArray()
- * );
- *
- * example.subscribe(value => console.log(value));
- *
- * // output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- * ```
- *
- * @return A function that returns an Observable that emits an array of items
- * emitted by the source Observable when source completes.
- */
-export declare function toArray<T>(): OperatorFunction<T, T[]>;
-//# sourceMappingURL=toArray.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/toArray.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toArray.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/toArray.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,OAAO,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAOrD"}

package/node_modules/rxjs/dist/types/internal/operators/window.d.ts

@@ -1,48 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, ObservableInput } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable whenever
- * `windowBoundaries` emits.
- *
- * <span class="informal">It's like {@link buffer}, but emits a nested Observable
- * instead of an array.</span>
- *
- * ![](window.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits connected, non-overlapping
- * windows. It emits the current window and opens a new one whenever the
- * `windowBoundaries` emits an item. `windowBoundaries` can be any type that
- * `ObservableInput` accepts. It internally gets converted to an Observable.
- * Because each window is an Observable, the output is a higher-order Observable.
- *
- * ## Example
- *
- * In every window of 1 second each, emit at most 2 click events
- *
- * ```ts
- * import { fromEvent, interval, window, map, take, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const sec = interval(1000);
- * const result = clicks.pipe(
- *   window(sec),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link windowWhen}
- * @see {@link buffer}
- *
- * @param windowBoundaries An `ObservableInput` that completes the
- * previous window and starts a new window.
- * @return A function that returns an Observable of windows, which are
- * Observables emitting values of the source Observable.
- */
-export declare function window<T>(windowBoundaries: ObservableInput<any>): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=window.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/window.d.ts.map

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

package/node_modules/rxjs/dist/types/internal/operators/windowCount.d.ts

@@ -1,65 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable with each
- * nested Observable emitting at most `windowSize` values.
- *
- * <span class="informal">It's like {@link bufferCount}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowCount.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits windows every `startWindowEvery`
- * items, each containing no more than `windowSize` items. When the source
- * Observable completes or encounters an error, the output Observable emits
- * the current window and propagates the notification from the source
- * Observable. If `startWindowEvery` is not provided, then new windows are
- * started immediately at the start of the source and when each window completes
- * with size `windowSize`.
- *
- * ## Examples
- *
- * Ignore every 3rd click event, starting from the first one
- *
- * ```ts
- * import { fromEvent, windowCount, map, skip, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowCount(3),
- *   map(win => win.pipe(skip(1))), // skip first of every 3 clicks
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * Ignore every 3rd click event, starting from the third one
- *
- * ```ts
- * import { fromEvent, windowCount, mergeAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowCount(2, 3),
- *   mergeAll() // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link windowWhen}
- * @see {@link bufferCount}
- *
- * @param windowSize The maximum number of values emitted by each window.
- * @param startWindowEvery Interval at which to start a new window. For example
- * if `startWindowEvery` is `2`, then a new window will be started on every
- * other value from the source. A new window is started at the beginning of the
- * source by default.
- * @return A function that returns an Observable of windows, which in turn are
- * Observable of values.
- */
-export declare function windowCount<T>(windowSize: number, startWindowEvery?: number): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowCount.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/windowCount.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"windowCount.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/windowCount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAU,GAAG,gBAAgB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CA6DnH"}

package/node_modules/rxjs/dist/types/internal/operators/windowTime.d.ts

@@ -1,6 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, SchedulerLike } from '../types';
-export declare function windowTime<T>(windowTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;
-export declare function windowTime<T>(windowTimeSpan: number, windowCreationInterval: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;
-export declare function windowTime<T>(windowTimeSpan: number, windowCreationInterval: number | null | void, maxWindowSize: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowTime.d.ts.map

package/node_modules/rxjs/dist/types/internal/operators/windowTime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"windowTime.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/windowTime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAY,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAOrE,wBAAgB,UAAU,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AACrH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,cAAc,EAAE,MAAM,EACtB,sBAAsB,EAAE,MAAM,EAC9B,SAAS,CAAC,EAAE,aAAa,GACxB,gBAAgB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,wBAAgB,UAAU,CAAC,CAAC,EAC1B,cAAc,EAAE,MAAM,EACtB,sBAAsB,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,EAC5C,aAAa,EAAE,MAAM,EACrB,SAAS,CAAC,EAAE,aAAa,GACxB,gBAAgB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC"}