taskninja 1.1.5 → 1.1.6

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

@@ -1 +0,0 @@
-{"version":3,"file":"raceWith.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/raceWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAKlE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EACtD,GAAG,YAAY,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAC5C,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAMpC"}

package/src/node_modules/rxjs/dist/types/internal/operators/reduce.d.ts

@@ -1,5 +0,0 @@
-import { OperatorFunction } from '../../../../src/internal/types';
-export declare function reduce<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
-export declare function reduce<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
-export declare function reduce<V, A, S = A>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
-//# sourceMappingURL=reduce.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reduce.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/reduce.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5C,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AACtH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACnH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/src/node_modules/rxjs/dist/types/internal/operators/refCount.d.ts

@@ -1,61 +0,0 @@
-import { MonoTypeOperatorFunction } from '../../../../src/internal/types';
-/**
- * Make a {@link ConnectableObservable} behave like a ordinary observable and automates the way
- * you can connect to it.
- *
- * Internally it counts the subscriptions to the observable and subscribes (only once) to the source if
- * the number of subscriptions is larger than 0. If the number of subscriptions is smaller than 1, it
- * unsubscribes from the source. This way you can make sure that everything before the *published*
- * refCount has only a single subscription independently of the number of subscribers to the target
- * observable.
- *
- * Note that using the {@link share} operator is exactly the same as using the `multicast(() => new Subject())` operator
- * (making the observable hot) and the *refCount* operator in a sequence.
- *
- * ![](refCount.png)
- *
- * ## Example
- *
- * In the following example there are two intervals turned into connectable observables
- * by using the *publish* operator. The first one uses the *refCount* operator, the
- * second one does not use it. You will notice that a connectable observable does nothing
- * until you call its connect function.
- *
- * ```ts
- * import { interval, tap, publish, refCount } from 'rxjs';
- *
- * // Turn the interval observable into a ConnectableObservable (hot)
- * const refCountInterval = interval(400).pipe(
- *   tap(num => console.log(`refCount ${ num }`)),
- *   publish(),
- *   refCount()
- * );
- *
- * const publishedInterval = interval(400).pipe(
- *   tap(num => console.log(`publish ${ num }`)),
- *   publish()
- * );
- *
- * refCountInterval.subscribe();
- * refCountInterval.subscribe();
- * // 'refCount 0' -----> 'refCount 1' -----> etc
- * // All subscriptions will receive the same value and the tap (and
- * // every other operator) before the `publish` operator will be executed
- * // only once per event independently of the number of subscriptions.
- *
- * publishedInterval.subscribe();
- * // Nothing happens until you call .connect() on the observable.
- * ```
- *
- * @return A function that returns an Observable that automates the connection
- * to ConnectableObservable.
- * @see {@link ConnectableObservable}
- * @see {@link share}
- * @see {@link publish}
- * @deprecated Replaced with the {@link share} operator. How `share` is used
- * will depend on the connectable observable you created just prior to the
- * `refCount` operator.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export declare function refCount<T>(): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=refCount.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"refCount.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/refCount.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAIpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,QAAQ,CAAC,CAAC,KAAK,wBAAwB,CAAC,CAAC,CAAC,CAsDzD"}

package/src/node_modules/rxjs/dist/types/internal/operators/repeat.d.ts

@@ -1,108 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../../../../src/internal/types';
-export interface RepeatConfig {
-    /**
-     * The number of times to repeat the source. Defaults to `Infinity`.
-     */
-    count?: number;
-    /**
-     * If a `number`, will delay the repeat of the source by that number of milliseconds.
-     * If a function, it will provide the number of times the source has been subscribed to,
-     * and the return value should be a valid observable input that will notify when the source
-     * should be repeated. If the notifier observable is empty, the result will complete.
-     */
-    delay?: number | ((count: number) => ObservableInput<any>);
-}
-/**
- * Returns an Observable that will resubscribe to the source stream when the source stream completes.
- *
- * <span class="informal">Repeats all values emitted on the source. It's like {@link retry}, but for non error cases.</span>
- *
- * ![](repeat.png)
- *
- * Repeat will output values from a source until the source completes, then it will resubscribe to the
- * source a specified number of times, with a specified delay. Repeat can be particularly useful in
- * combination with closing operators like {@link take}, {@link takeUntil}, {@link first}, or {@link takeWhile},
- * as it can be used to restart a source again from scratch.
- *
- * Repeat is very similar to {@link retry}, where {@link retry} will resubscribe to the source in the error case, but
- * `repeat` will resubscribe if the source completes.
- *
- * Note that `repeat` will _not_ catch errors. Use {@link retry} for that.
- *
- * - `repeat(0)` returns an empty observable
- * - `repeat()` will repeat forever
- * - `repeat({ delay: 200 })` will repeat forever, with a delay of 200ms between repetitions.
- * - `repeat({ count: 2, delay: 400 })` will repeat twice, with a delay of 400ms between repetitions.
- * - `repeat({ delay: (count) => timer(count * 1000) })` will repeat forever, but will have a delay that grows by one second for each repetition.
- *
- * ## Example
- *
- * Repeat a message stream
- *
- * ```ts
- * import { of, repeat } from 'rxjs';
- *
- * const source = of('Repeat message');
- * const result = source.pipe(repeat(3));
- *
- * result.subscribe(x => console.log(x));
- *
- * // Results
- * // 'Repeat message'
- * // 'Repeat message'
- * // 'Repeat message'
- * ```
- *
- * Repeat 3 values, 2 times
- *
- * ```ts
- * import { interval, take, repeat } from 'rxjs';
- *
- * const source = interval(1000);
- * const result = source.pipe(take(3), repeat(2));
- *
- * result.subscribe(x => console.log(x));
- *
- * // Results every second
- * // 0
- * // 1
- * // 2
- * // 0
- * // 1
- * // 2
- * ```
- *
- * Defining two complex repeats with delays on the same source.
- * Note that the second repeat cannot be called until the first
- * repeat as exhausted it's count.
- *
- * ```ts
- * import { defer, of, repeat } from 'rxjs';
- *
- * const source = defer(() => {
- *    return of(`Hello, it is ${new Date()}`)
- * });
- *
- * source.pipe(
- *    // Repeat 3 times with a delay of 1 second between repetitions
- *    repeat({
- *      count: 3,
- *      delay: 1000,
- *    }),
- *
- *    // *Then* repeat forever, but with an exponential step-back
- *    // maxing out at 1 minute.
- *    repeat({
- *      delay: (count) => timer(Math.min(60000, 2 ^ count * 1000))
- *    })
- * )
- * ```
- *
- * @see {@link repeatWhen}
- * @see {@link retry}
- *
- * @param countOrConfig Either the number of times the source Observable items are repeated
- * (a count of 0 will yield an empty Observable) or a {@link RepeatConfig} object.
- */
-export declare function repeat<T>(countOrConfig?: number | RepeatConfig): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=repeat.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/repeat.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAKrE,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;CAC5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAwD5F"}

package/src/node_modules/rxjs/dist/types/internal/operators/repeatWhen.d.ts

@@ -1,38 +0,0 @@
-import { Observable } from '../../../../src/internal/Observable';
-import { MonoTypeOperatorFunction, ObservableInput } from '../../../../src/internal/types';
-/**
- * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source
- * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable
- * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise
- * this method will resubscribe to the source Observable.
- *
- * ![](repeatWhen.png)
- *
- * ## Example
- *
- * Repeat a message stream on click
- *
- * ```ts
- * import { of, fromEvent, repeatWhen } from 'rxjs';
- *
- * const source = of('Repeat message');
- * const documentClick$ = fromEvent(document, 'click');
- *
- * const result = source.pipe(repeatWhen(() => documentClick$));
- *
- * result.subscribe(data => console.log(data))
- * ```
- *
- * @see {@link repeat}
- * @see {@link retry}
- * @see {@link retryWhen}
- *
- * @param notifier Function that receives an Observable of notifications with
- * which a user can `complete` or `error`, aborting the repetition.
- * @return A function that returns an Observable that mirrors the source
- * Observable with the exception of a `complete`.
- * @deprecated Will be removed in v9 or v10. Use {@link repeat}'s {@link RepeatConfig#delay delay} option instead.
- * Instead of `repeatWhen(() => notify$)`, use: `repeat({ delay: () => notify$ })`.
- */
-export declare function repeatWhen<T>(notifier: (notifications: Observable<void>) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=repeatWhen.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"repeatWhen.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/repeatWhen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,aAAa,EAAE,UAAU,CAAC,IAAI,CAAC,KAAK,eAAe,CAAC,GAAG,CAAC,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAiF9H"}

package/src/node_modules/rxjs/dist/types/internal/operators/retry.d.ts

@@ -1,28 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../../../../src/internal/types';
-/**
- * The {@link retry} operator configuration object. `retry` either accepts a `number`
- * or an object described by this interface.
- */
-export interface RetryConfig {
-    /**
-     * The maximum number of times to retry. If `count` is omitted, `retry` will try to
-     * resubscribe on errors infinite number of times.
-     */
-    count?: number;
-    /**
-     * The number of milliseconds to delay before retrying, OR a function to
-     * return a notifier for delaying. If a function is given, that function should
-     * return a notifier that, when it emits will retry the source. If the notifier
-     * completes _without_ emitting, the resulting observable will complete without error,
-     * if the notifier errors, the error will be pushed to the result.
-     */
-    delay?: number | ((error: any, retryCount: number) => ObservableInput<any>);
-    /**
-     * Whether or not to reset the retry counter when the retried subscription
-     * emits its first value.
-     */
-    resetOnSuccess?: boolean;
-}
-export declare function retry<T>(count?: number): MonoTypeOperatorFunction<T>;
-export declare function retry<T>(config: RetryConfig): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=retry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/retry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAQrE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,KAAK,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5E;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC;AACtE,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

package/src/node_modules/rxjs/dist/types/internal/operators/retryWhen.d.ts

@@ -1,61 +0,0 @@
-import { Observable } from '../../../../src/internal/Observable';
-import { MonoTypeOperatorFunction, ObservableInput } from '../../../../src/internal/types';
-/**
- * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
- * calls `error`, this method will emit the Throwable that caused the error to the `ObservableInput` returned from `notifier`.
- * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
- * subscription. Otherwise this method will resubscribe to the source Observable.
- *
- * ![](retryWhen.png)
- *
- * Retry an observable sequence on error based on custom criteria.
- *
- * ## Example
- *
- * ```ts
- * import { interval, map, retryWhen, tap, delayWhen, timer } from 'rxjs';
- *
- * const source = interval(1000);
- * const result = source.pipe(
- *   map(value => {
- *     if (value > 5) {
- *       // error will be picked up by retryWhen
- *       throw value;
- *     }
- *     return value;
- *   }),
- *   retryWhen(errors =>
- *     errors.pipe(
- *       // log error message
- *       tap(value => console.log(`Value ${ value } was too high!`)),
- *       // restart in 5 seconds
- *       delayWhen(value => timer(value * 1000))
- *     )
- *   )
- * );
- *
- * result.subscribe(value => console.log(value));
- *
- * // results:
- * // 0
- * // 1
- * // 2
- * // 3
- * // 4
- * // 5
- * // 'Value 6 was too high!'
- * // - Wait 5 seconds then repeat
- * ```
- *
- * @see {@link retry}
- *
- * @param notifier Function that receives an Observable of notifications with which a
- * user can `complete` or `error`, aborting the retry.
- * @return A function that returns an Observable that mirrors the source
- * Observable with the exception of an `error`.
- * @deprecated Will be removed in v9 or v10, use {@link retry}'s `delay` option instead.
- * Will be removed in v9 or v10. Use {@link retry}'s {@link RetryConfig#delay delay} option instead.
- * Instead of `retryWhen(() => notify$)`, use: `retry({ delay: () => notify$ })`.
- */
-export declare function retryWhen<T>(notifier: (errors: Observable<any>) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=retryWhen.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"retryWhen.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/retryWhen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,KAAK,eAAe,CAAC,GAAG,CAAC,GAAG,wBAAwB,CAAC,CAAC,CAAC,CA8CrH"}

package/src/node_modules/rxjs/dist/types/internal/operators/sample.d.ts

@@ -1,43 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../../../../src/internal/types';
-/**
- * Emits the most recently emitted value from the source Observable whenever
- * another Observable, the `notifier`, emits.
- *
- * <span class="informal">It's like {@link sampleTime}, but samples whenever
- * the `notifier` `ObservableInput` emits something.</span>
- *
- * ![](sample.png)
- *
- * Whenever the `notifier` `ObservableInput` emits a value, `sample`
- * looks at the source Observable and emits whichever value it has most recently
- * emitted since the previous sampling, unless the source has not emitted
- * anything since the previous sampling. The `notifier` is subscribed to as soon
- * as the output Observable is subscribed.
- *
- * ## Example
- *
- * On every click, sample the most recent `seconds` timer
- *
- * ```ts
- * import { fromEvent, interval, sample } from 'rxjs';
- *
- * const seconds = interval(1000);
- * const clicks = fromEvent(document, 'click');
- * const result = seconds.pipe(sample(clicks));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link audit}
- * @see {@link debounce}
- * @see {@link sampleTime}
- * @see {@link throttle}
- *
- * @param notifier The `ObservableInput` to use for sampling the
- * source Observable.
- * @return A function that returns an Observable that emits the results of
- * sampling the values emitted by the source Observable whenever the notifier
- * Observable emits value or completes.
- */
-export declare function sample<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=sample.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/sample.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAKrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe,CAAC,GAAG,CAAC,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAyBrF"}

package/src/node_modules/rxjs/dist/types/internal/operators/sampleTime.d.ts

@@ -1,46 +0,0 @@
-import { MonoTypeOperatorFunction, SchedulerLike } from '../../../../src/internal/types';
-/**
- * Emits the most recently emitted value from the source Observable within
- * periodic time intervals.
- *
- * <span class="informal">Samples the source Observable at periodic time
- * intervals, emitting what it samples.</span>
- *
- * ![](sampleTime.png)
- *
- * `sampleTime` periodically looks at the source Observable and emits whichever
- * value it has most recently emitted since the previous sampling, unless the
- * source has not emitted anything since the previous sampling. The sampling
- * happens periodically in time every `period` milliseconds (or the time unit
- * defined by the optional `scheduler` argument). The sampling starts as soon as
- * the output Observable is subscribed.
- *
- * ## Example
- *
- * Every second, emit the most recent click at most once
- *
- * ```ts
- * import { fromEvent, sampleTime } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(sampleTime(1000));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link auditTime}
- * @see {@link debounceTime}
- * @see {@link delay}
- * @see {@link sample}
- * @see {@link throttleTime}
- *
- * @param period The sampling period expressed 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 sampling.
- * @return A function that returns an Observable that emits the results of
- * sampling the values emitted by the source Observable at the specified time
- * interval.
- */
-export declare function sampleTime<T>(period: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=sampleTime.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sampleTime.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/sampleTime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAInE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAE,aAA8B,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAEpH"}

package/src/node_modules/rxjs/dist/types/internal/operators/scan.d.ts

@@ -1,5 +0,0 @@
-import { OperatorFunction } from '../../../../src/internal/types';
-export declare function scan<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
-export declare function scan<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
-export declare function scan<V, A, S>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
-//# sourceMappingURL=scan.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/scan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAI5C,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AACpH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACjH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/src/node_modules/rxjs/dist/types/internal/operators/scanInternals.d.ts

@@ -1,12 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-/**
- * A basic scan operation. This is used for `scan` and `reduce`.
- * @param accumulator The accumulator to use
- * @param seed The seed value for the state to accumulate
- * @param hasSeed Whether or not a seed was provided
- * @param emitOnNext Whether or not to emit the state on next
- * @param emitBeforeComplete Whether or not to emit the before completion
- */
-export declare function scanInternals<V, A, S>(accumulator: (acc: V | A | S, value: V, index: number) => A, seed: S, hasSeed: boolean, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<V>, subscriber: Subscriber<any>) => void;
-//# sourceMappingURL=scanInternals.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"scanInternals.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/scanInternals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C;;;;;;;GAOG;AAEH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACnC,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAC3D,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,OAAO,EACnB,kBAAkB,CAAC,EAAE,SAAS,GAAG,IAAI,YAErB,WAAW,CAAC,CAAC,cAAc,WAAW,GAAG,CAAC,UAyC3D"}

package/src/node_modules/rxjs/dist/types/internal/operators/sequenceEqual.d.ts

@@ -1,60 +0,0 @@
-import { OperatorFunction, ObservableInput } from '../../../../src/internal/types';
-/**
- * Compares all values of two observables in sequence using an optional comparator function
- * and returns an observable of a single boolean value representing whether or not the two sequences
- * are equal.
- *
- * <span class="informal">Checks to see of all values emitted by both observables are equal, in order.</span>
- *
- * ![](sequenceEqual.png)
- *
- * `sequenceEqual` subscribes to source observable and `compareTo` `ObservableInput` (that internally
- * gets converted to an observable) and buffers incoming values from each observable. Whenever either
- * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom
- * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the
- * observables completes, the operator will wait for the other observable to complete; If the other
- * observable emits before completing, the returned observable will emit `false` and complete. If one observable never
- * completes or emits after the other completes, the returned observable will never complete.
- *
- * ## Example
- *
- * Figure out if the Konami code matches
- *
- * ```ts
- * import { from, fromEvent, map, bufferCount, mergeMap, sequenceEqual } from 'rxjs';
- *
- * const codes = from([
- *   'ArrowUp',
- *   'ArrowUp',
- *   'ArrowDown',
- *   'ArrowDown',
- *   'ArrowLeft',
- *   'ArrowRight',
- *   'ArrowLeft',
- *   'ArrowRight',
- *   'KeyB',
- *   'KeyA',
- *   'Enter', // no start key, clearly.
- * ]);
- *
- * const keys = fromEvent<KeyboardEvent>(document, 'keyup').pipe(map(e => e.code));
- * const matches = keys.pipe(
- *   bufferCount(11, 1),
- *   mergeMap(last11 => from(last11).pipe(sequenceEqual(codes)))
- * );
- * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched));
- * ```
- *
- * @see {@link combineLatest}
- * @see {@link zip}
- * @see {@link withLatestFrom}
- *
- * @param compareTo The `ObservableInput` sequence to compare the source sequence to.
- * @param comparator An optional function to compare each value pair.
- *
- * @return A function that returns an Observable that emits a single boolean
- * value representing whether or not the values emitted by the source
- * Observable and provided `ObservableInput` were equal in sequence.
- */
-export declare function sequenceEqual<T>(compareTo: ObservableInput<T>, comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean>;
-//# sourceMappingURL=sequenceEqual.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sequenceEqual.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/sequenceEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,EAC7B,UAAU,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAA2B,GACtD,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CA2D9B"}

package/src/node_modules/rxjs/dist/types/internal/operators/share.d.ts

@@ -1,43 +0,0 @@
-import { MonoTypeOperatorFunction, SubjectLike, ObservableInput } from '../../../../src/internal/types';
-export interface ShareConfig<T> {
-    /**
-     * The factory used to create the subject that will connect the source observable to
-     * multicast consumers.
-     */
-    connector?: () => SubjectLike<T>;
-    /**
-     * If `true`, the resulting observable will reset internal state on error from source and return to a "cold" state. This
-     * allows the resulting observable to be "retried" in the event of an error.
-     * If `false`, when an error comes from the source it will push the error into the connecting subject, and the subject
-     * will remain the connecting subject, meaning the resulting observable will not go "cold" again, and subsequent retries
-     * or resubscriptions will resubscribe to that same subject. In all cases, RxJS subjects will emit the same error again, however
-     * {@link ReplaySubject} will also push its buffered values before pushing the error.
-     * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
-     * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
-     */
-    resetOnError?: boolean | ((error: any) => ObservableInput<any>);
-    /**
-     * If `true`, the resulting observable will reset internal state on completion from source and return to a "cold" state. This
-     * allows the resulting observable to be "repeated" after it is done.
-     * If `false`, when the source completes, it will push the completion through the connecting subject, and the subject
-     * will remain the connecting subject, meaning the resulting observable will not go "cold" again, and subsequent repeats
-     * or resubscriptions will resubscribe to that same subject.
-     * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
-     * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
-     */
-    resetOnComplete?: boolean | (() => ObservableInput<any>);
-    /**
-     * If `true`, when the number of subscribers to the resulting observable reaches zero due to those subscribers unsubscribing, the
-     * internal state will be reset and the resulting observable will return to a "cold" state. This means that the next
-     * time the resulting observable is subscribed to, a new subject will be created and the source will be subscribed to
-     * again.
-     * If `false`, when the number of subscribers to the resulting observable reaches zero due to unsubscription, the subject
-     * will remain connected to the source, and new subscriptions to the result will be connected through that same subject.
-     * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained
-     * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets.
-     */
-    resetOnRefCountZero?: boolean | (() => ObservableInput<any>);
-}
-export declare function share<T>(): MonoTypeOperatorFunction<T>;
-export declare function share<T>(options: ShareConfig<T>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=share.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"share.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/share.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGlF,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC;IACjC;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;IAChE;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;IACzD;;;;;;;;;OASG;IACH,mBAAmB,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;CAC9D;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAK,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAExD,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

package/src/node_modules/rxjs/dist/types/internal/operators/shareReplay.d.ts

@@ -1,10 +0,0 @@
-import { MonoTypeOperatorFunction, SchedulerLike } from '../../../../src/internal/types';
-export interface ShareReplayConfig {
-    bufferSize?: number;
-    windowTime?: number;
-    refCount: boolean;
-    scheduler?: SchedulerLike;
-}
-export declare function shareReplay<T>(config: ShareReplayConfig): MonoTypeOperatorFunction<T>;
-export declare function shareReplay<T>(bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=shareReplay.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"shareReplay.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/shareReplay.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGnE,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,iBAAiB,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC;AACvF,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

package/src/node_modules/rxjs/dist/types/internal/operators/single.d.ts

@@ -1,5 +0,0 @@
-import { Observable } from '../../../../src/internal/Observable';
-import { MonoTypeOperatorFunction, OperatorFunction, TruthyTypesOf } from '../../../../src/internal/types';
-export declare function single<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
-export declare function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=single.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"single.d.ts","sourceRoot":"","sources":["../../../../src/internal/operators/single.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAMrF,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAChG,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

package/src/node_modules/rxjs/dist/types/internal/operators/skip.d.ts

@@ -1,36 +0,0 @@
-import { MonoTypeOperatorFunction } from '../../../../src/internal/types';
-/**
- * Returns an Observable that skips the first `count` items emitted by the source Observable.
- *
- * ![](skip.png)
- *
- * Skips the values until the sent notifications are equal or less than provided skip count. It raises
- * an error if skip count is equal or more than the actual number of emits and source raises an error.
- *
- * ## Example
- *
- * Skip the values before the emission
- *
- * ```ts
- * import { interval, skip } from 'rxjs';
- *
- * // emit every half second
- * const source = interval(500);
- * // skip the first 10 emitted values
- * const result = source.pipe(skip(10));
- *
- * result.subscribe(value => console.log(value));
- * // output: 10...11...12...13...
- * ```
- *
- * @see {@link last}
- * @see {@link skipWhile}
- * @see {@link skipUntil}
- * @see {@link skipLast}
- *
- * @param count The number of times, items emitted by source Observable should be skipped.
- * @return A function that returns an Observable that skips the first `count`
- * values emitted by the source Observable.
- */
-export declare function skip<T>(count: number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=skip.d.ts.map