lambda-live-debugger 1.12.3 → 1.12.4

package/node_modules/rxjs/src/internal/util/arrRemove.ts

@@ -1,11 +0,0 @@
-/**
- * Removes an item from an array, mutating it.
- * @param arr The array to remove the item from
- * @param item The item to remove
- */
-export function arrRemove<T>(arr: T[] | undefined | null, item: T) {
-  if (arr) {
-    const index = arr.indexOf(item);
-    0 <= index && arr.splice(index, 1);
-  }
-}

package/node_modules/rxjs/src/internal/util/createErrorClass.ts

@@ -1,20 +0,0 @@
-/**
- * Used to create Error subclasses until the community moves away from ES5.
- *
- * This is because compiling from TypeScript down to ES5 has issues with subclassing Errors
- * as well as other built-in types: https://github.com/Microsoft/TypeScript/issues/12123
- *
- * @param createImpl A factory function to create the actual constructor implementation. The returned
- * function should be a named function that calls `_super` internally.
- */
-export function createErrorClass<T>(createImpl: (_super: any) => any): T {
-  const _super = (instance: any) => {
-    Error.call(instance);
-    instance.stack = new Error().stack;
-  };
-
-  const ctorFunc = createImpl(_super);
-  ctorFunc.prototype = Object.create(Error.prototype);
-  ctorFunc.prototype.constructor = ctorFunc;
-  return ctorFunc;
-}

package/node_modules/rxjs/src/internal/util/createObject.ts

@@ -1,3 +0,0 @@
-export function createObject(keys: string[], values: any[]) {
-  return keys.reduce((result, key, i) => ((result[key] = values[i]), result), {} as any);
-}

package/node_modules/rxjs/src/internal/util/errorContext.ts

@@ -1,42 +0,0 @@
-import { config } from '../config';
-
-let context: { errorThrown: boolean; error: any } | null = null;
-
-/**
- * Handles dealing with errors for super-gross mode. Creates a context, in which
- * any synchronously thrown errors will be passed to {@link captureError}. Which
- * will record the error such that it will be rethrown after the call back is complete.
- * TODO: Remove in v8
- * @param cb An immediately executed function.
- */
-export function errorContext(cb: () => void) {
-  if (config.useDeprecatedSynchronousErrorHandling) {
-    const isRoot = !context;
-    if (isRoot) {
-      context = { errorThrown: false, error: null };
-    }
-    cb();
-    if (isRoot) {
-      const { errorThrown, error } = context!;
-      context = null;
-      if (errorThrown) {
-        throw error;
-      }
-    }
-  } else {
-    // This is the general non-deprecated path for everyone that
-    // isn't crazy enough to use super-gross mode (useDeprecatedSynchronousErrorHandling)
-    cb();
-  }
-}
-
-/**
- * Captures errors only in super-gross mode.
- * @param err the error to capture
- */
-export function captureError(err: any) {
-  if (config.useDeprecatedSynchronousErrorHandling && context) {
-    context.errorThrown = true;
-    context.error = err;
-  }
-}

package/node_modules/rxjs/src/internal/util/executeSchedule.ts

@@ -1,44 +0,0 @@
-import { Subscription } from '../Subscription';
-import { SchedulerAction, SchedulerLike } from '../types';
-
-export function executeSchedule(
-  parentSubscription: Subscription,
-  scheduler: SchedulerLike,
-  work: () => void,
-  delay: number,
-  repeat: true
-): void;
-export function executeSchedule(
-  parentSubscription: Subscription,
-  scheduler: SchedulerLike,
-  work: () => void,
-  delay?: number,
-  repeat?: false
-): Subscription;
-
-export function executeSchedule(
-  parentSubscription: Subscription,
-  scheduler: SchedulerLike,
-  work: () => void,
-  delay = 0,
-  repeat = false
-): Subscription | void {
-  const scheduleSubscription = scheduler.schedule(function (this: SchedulerAction<any>) {
-    work();
-    if (repeat) {
-      parentSubscription.add(this.schedule(null, delay));
-    } else {
-      this.unsubscribe();
-    }
-  }, delay);
-
-  parentSubscription.add(scheduleSubscription);
-
-  if (!repeat) {
-    // Because user-land scheduler implementations are unlikely to properly reuse
-    // Actions for repeat scheduling, we can't trust that the returned subscription
-    // will control repeat subscription scenarios. So we're trying to avoid using them
-    // incorrectly within this library.
-    return scheduleSubscription;
-  }
-}

package/node_modules/rxjs/src/internal/util/identity.ts

@@ -1,45 +0,0 @@
-/**
- * This function takes one parameter and just returns it. Simply put,
- * this is like `<T>(x: T): T => x`.
- *
- * ## Examples
- *
- * This is useful in some cases when using things like `mergeMap`
- *
- * ```ts
- * import { interval, take, map, range, mergeMap, identity } from 'rxjs';
- *
- * const source$ = interval(1000).pipe(take(5));
- *
- * const result$ = source$.pipe(
- *   map(i => range(i)),
- *   mergeMap(identity) // same as mergeMap(x => x)
- * );
- *
- * result$.subscribe({
- *   next: console.log
- * });
- * ```
- *
- * Or when you want to selectively apply an operator
- *
- * ```ts
- * import { interval, take, identity } from 'rxjs';
- *
- * const shouldLimit = () => Math.random() < 0.5;
- *
- * const source$ = interval(1000);
- *
- * const result$ = source$.pipe(shouldLimit() ? take(5) : identity);
- *
- * result$.subscribe({
- *   next: console.log
- * });
- * ```
- *
- * @param x Any value that is returned by this function
- * @returns The value passed as the first parameter to this function
- */
-export function identity<T>(x: T): T {
-  return x;
-}

package/node_modules/rxjs/src/internal/util/isArrayLike.ts

@@ -1 +0,0 @@
-export const isArrayLike = (<T>(x: any): x is ArrayLike<T> => x && typeof x.length === 'number' && typeof x !== 'function');

package/node_modules/rxjs/src/internal/util/isAsyncIterable.ts

@@ -1,5 +0,0 @@
-import { isFunction } from './isFunction';
-
-export function isAsyncIterable<T>(obj: any): obj is AsyncIterable<T> {
-  return Symbol.asyncIterator && isFunction(obj?.[Symbol.asyncIterator]);
-}

package/node_modules/rxjs/src/internal/util/isDate.ts

@@ -1,10 +0,0 @@
-/**
- * Checks to see if a value is not only a `Date` object,
- * but a *valid* `Date` object that can be converted to a
- * number. For example, `new Date('blah')` is indeed an
- * `instanceof Date`, however it cannot be converted to a
- * number.
- */
-export function isValidDate(value: any): value is Date {
-  return value instanceof Date && !isNaN(value as any);
-}

package/node_modules/rxjs/src/internal/util/isFunction.ts

@@ -1,7 +0,0 @@
-/**
- * Returns true if the object is a function.
- * @param value The value to check
- */
-export function isFunction(value: any): value is (...args: any[]) => any {
-  return typeof value === 'function';
-}

package/node_modules/rxjs/src/internal/util/isInteropObservable.ts

@@ -1,8 +0,0 @@
-import { InteropObservable } from '../types';
-import { observable as Symbol_observable } from '../symbol/observable';
-import { isFunction } from './isFunction';
-
-/** Identifies an input as being Observable (but not necessary an Rx Observable) */
-export function isInteropObservable(input: any): input is InteropObservable<any> {
-  return isFunction(input[Symbol_observable]);
-}

package/node_modules/rxjs/src/internal/util/isIterable.ts

@@ -1,7 +0,0 @@
-import { iterator as Symbol_iterator } from '../symbol/iterator';
-import { isFunction } from './isFunction';
-
-/** Identifies an input as being an Iterable */
-export function isIterable(input: any): input is Iterable<any> {
-  return isFunction(input?.[Symbol_iterator]);
-}

package/node_modules/rxjs/src/internal/util/isObservable.ts

@@ -1,13 +0,0 @@
-/** prettier */
-import { Observable } from '../Observable';
-import { isFunction } from './isFunction';
-
-/**
- * Tests to see if the object is an RxJS {@link Observable}
- * @param obj the object to test
- */
-export function isObservable(obj: any): obj is Observable<unknown> {
-  // The !! is to ensure that this publicly exposed function returns
-  // `false` if something like `null` or `0` is passed.
-  return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe)));
-}

package/node_modules/rxjs/src/internal/util/isPromise.ts

@@ -1,9 +0,0 @@
-import { isFunction } from "./isFunction";
-
-/**
- * Tests to see if the object is "thennable".
- * @param value the object to test
- */
-export function isPromise(value: any): value is PromiseLike<any> {
-  return isFunction(value?.then);
-}

package/node_modules/rxjs/src/internal/util/isReadableStreamLike.ts

@@ -1,23 +0,0 @@
-import { ReadableStreamLike } from '../types';
-import { isFunction } from './isFunction';
-
-export async function* readableStreamLikeToAsyncGenerator<T>(readableStream: ReadableStreamLike<T>): AsyncGenerator<T> {
-  const reader = readableStream.getReader();
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) {
-        return;
-      }
-      yield value!;
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-export function isReadableStreamLike<T>(obj: any): obj is ReadableStreamLike<T> {
-  // We don't want to use instanceof checks because they would return
-  // false for instances from another Realm, like an <iframe>.
-  return isFunction(obj?.getReader);
-}

package/node_modules/rxjs/src/internal/util/isScheduler.ts

@@ -1,6 +0,0 @@
-import { SchedulerLike } from '../types';
-import { isFunction } from './isFunction';
-
-export function isScheduler(value: any): value is SchedulerLike {
-  return value && isFunction(value.schedule);
-}

package/node_modules/rxjs/src/internal/util/lift.ts

@@ -1,32 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { OperatorFunction } from '../types';
-import { isFunction } from './isFunction';
-
-/**
- * Used to determine if an object is an Observable with a lift function.
- */
-export function hasLift(source: any): source is { lift: InstanceType<typeof Observable>['lift'] } {
-  return isFunction(source?.lift);
-}
-
-/**
- * Creates an `OperatorFunction`. Used to define operators throughout the library in a concise way.
- * @param init The logic to connect the liftedSource to the subscriber at the moment of subscription.
- */
-export function operate<T, R>(
-  init: (liftedSource: Observable<T>, subscriber: Subscriber<R>) => (() => void) | void
-): OperatorFunction<T, R> {
-  return (source: Observable<T>) => {
-    if (hasLift(source)) {
-      return source.lift(function (this: Subscriber<R>, liftedSource: Observable<T>) {
-        try {
-          return init(liftedSource, this);
-        } catch (err) {
-          this.error(err);
-        }
-      });
-    }
-    throw new TypeError('Unable to lift unknown Observable type');
-  };
-}

package/node_modules/rxjs/src/internal/util/mapOneOrManyArgs.ts

@@ -1,16 +0,0 @@
-import { OperatorFunction } from "../types";
-import { map } from "../operators/map";
-
-const { isArray } = Array;
-
-function callOrApply<T, R>(fn: ((...values: T[]) => R), args: T|T[]): R {
-    return isArray(args) ? fn(...args) : fn(args);
-}
-
-/**
- * Used in several -- mostly deprecated -- situations where we need to 
- * apply a list of arguments or a single argument to a result selector.
- */
-export function mapOneOrManyArgs<T, R>(fn: ((...values: T[]) => R)): OperatorFunction<T|T[], R> {
-    return map(args => callOrApply(fn, args))
-}

package/node_modules/rxjs/src/internal/util/noop.ts

@@ -1,2 +0,0 @@
-/* tslint:disable:no-empty */
-export function noop() { }

package/node_modules/rxjs/src/internal/util/not.ts

@@ -1,3 +0,0 @@
-export function not<T>(pred: (value: T, index: number) => boolean, thisArg: any): (value: T, index: number) => boolean {
-  return (value: T, index: number) => !pred.call(thisArg, value, index); 
-}

package/node_modules/rxjs/src/internal/util/pipe.ts

@@ -1,95 +0,0 @@
-import { identity } from './identity';
-import { UnaryFunction } from '../types';
-
-export function pipe(): typeof identity;
-export function pipe<T, A>(fn1: UnaryFunction<T, A>): UnaryFunction<T, A>;
-export function pipe<T, A, B>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>): UnaryFunction<T, B>;
-export function pipe<T, A, B, C>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>): UnaryFunction<T, C>;
-export function pipe<T, A, B, C, D>(
-  fn1: UnaryFunction<T, A>,
-  fn2: UnaryFunction<A, B>,
-  fn3: UnaryFunction<B, C>,
-  fn4: UnaryFunction<C, D>
-): UnaryFunction<T, D>;
-export function pipe<T, A, B, C, D, E>(
-  fn1: UnaryFunction<T, A>,
-  fn2: UnaryFunction<A, B>,
-  fn3: UnaryFunction<B, C>,
-  fn4: UnaryFunction<C, D>,
-  fn5: UnaryFunction<D, E>
-): UnaryFunction<T, E>;
-export function pipe<T, A, B, C, D, E, F>(
-  fn1: UnaryFunction<T, A>,
-  fn2: UnaryFunction<A, B>,
-  fn3: UnaryFunction<B, C>,
-  fn4: UnaryFunction<C, D>,
-  fn5: UnaryFunction<D, E>,
-  fn6: UnaryFunction<E, F>
-): UnaryFunction<T, F>;
-export function pipe<T, A, B, C, D, E, F, G>(
-  fn1: UnaryFunction<T, A>,
-  fn2: UnaryFunction<A, B>,
-  fn3: UnaryFunction<B, C>,
-  fn4: UnaryFunction<C, D>,
-  fn5: UnaryFunction<D, E>,
-  fn6: UnaryFunction<E, F>,
-  fn7: UnaryFunction<F, G>
-): UnaryFunction<T, G>;
-export function pipe<T, A, B, C, D, E, F, G, H>(
-  fn1: UnaryFunction<T, A>,
-  fn2: UnaryFunction<A, B>,
-  fn3: UnaryFunction<B, C>,
-  fn4: UnaryFunction<C, D>,
-  fn5: UnaryFunction<D, E>,
-  fn6: UnaryFunction<E, F>,
-  fn7: UnaryFunction<F, G>,
-  fn8: UnaryFunction<G, H>
-): UnaryFunction<T, H>;
-export function pipe<T, A, B, C, D, E, F, G, H, I>(
-  fn1: UnaryFunction<T, A>,
-  fn2: UnaryFunction<A, B>,
-  fn3: UnaryFunction<B, C>,
-  fn4: UnaryFunction<C, D>,
-  fn5: UnaryFunction<D, E>,
-  fn6: UnaryFunction<E, F>,
-  fn7: UnaryFunction<F, G>,
-  fn8: UnaryFunction<G, H>,
-  fn9: UnaryFunction<H, I>
-): UnaryFunction<T, I>;
-export function pipe<T, A, B, C, D, E, F, G, H, I>(
-  fn1: UnaryFunction<T, A>,
-  fn2: UnaryFunction<A, B>,
-  fn3: UnaryFunction<B, C>,
-  fn4: UnaryFunction<C, D>,
-  fn5: UnaryFunction<D, E>,
-  fn6: UnaryFunction<E, F>,
-  fn7: UnaryFunction<F, G>,
-  fn8: UnaryFunction<G, H>,
-  fn9: UnaryFunction<H, I>,
-  ...fns: UnaryFunction<any, any>[]
-): UnaryFunction<T, unknown>;
-
-/**
- * pipe() can be called on one or more functions, each of which can take one argument ("UnaryFunction")
- * and uses it to return a value.
- * It returns a function that takes one argument, passes it to the first UnaryFunction, and then
- * passes the result to the next one, passes that result to the next one, and so on.  
- */
-export function pipe(...fns: Array<UnaryFunction<any, any>>): UnaryFunction<any, any> {
-  return pipeFromArray(fns);
-}
-
-/** @internal */
-export function pipeFromArray<T, R>(fns: Array<UnaryFunction<T, R>>): UnaryFunction<T, R> {
-  if (fns.length === 0) {
-    return identity as UnaryFunction<any, any>;
-  }
-
-  if (fns.length === 1) {
-    return fns[0];
-  }
-
-  return function piped(input: T): R {
-    return fns.reduce((prev: any, fn: UnaryFunction<T, R>) => fn(prev), input as any);
-  };
-}

package/node_modules/rxjs/src/internal/util/reportUnhandledError.ts

@@ -1,24 +0,0 @@
-import { config } from '../config';
-import { timeoutProvider } from '../scheduler/timeoutProvider';
-
-/**
- * Handles an error on another job either with the user-configured {@link onUnhandledError},
- * or by throwing it on that new job so it can be picked up by `window.onerror`, `process.on('error')`, etc.
- *
- * This should be called whenever there is an error that is out-of-band with the subscription
- * or when an error hits a terminal boundary of the subscription and no error handler was provided.
- *
- * @param err the error to report
- */
-export function reportUnhandledError(err: any) {
-  timeoutProvider.setTimeout(() => {
-    const { onUnhandledError } = config;
-    if (onUnhandledError) {
-      // Execute the user-configured error handler.
-      onUnhandledError(err);
-    } else {
-      // Throw so it is picked up by the runtime's uncaught error mechanism.
-      throw err;
-    }
-  });
-}

package/node_modules/rxjs/src/internal/util/subscribeToArray.ts

@@ -1,12 +0,0 @@
-import { Subscriber } from '../Subscriber';
-
-/**
- * Subscribes to an ArrayLike with a subscriber
- * @param array The array or array-like to subscribe to
- */
-export const subscribeToArray = <T>(array: ArrayLike<T>) => (subscriber: Subscriber<T>) => {
-  for (let i = 0, len = array.length; i < len && !subscriber.closed; i++) {
-    subscriber.next(array[i]);
-  }
-  subscriber.complete();
-};

package/node_modules/rxjs/src/internal/util/throwUnobservableError.ts

@@ -1,12 +0,0 @@
-/**
- * Creates the TypeError to throw if an invalid object is passed to `from` or `scheduled`.
- * @param input The object that was passed.
- */
-export function createInvalidObservableTypeError(input: any) {
-  // TODO: We should create error codes that can be looked up, so this can be less verbose.
-  return new TypeError(
-    `You provided ${
-      input !== null && typeof input === 'object' ? 'an invalid object' : `'${input}'`
-    } where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`
-  );
-}

package/node_modules/rxjs/src/internal/util/workarounds.ts

@@ -1,7 +0,0 @@
-// Instead of using any - or another less-than-ideal type - to workaround a
-// TypeScript problem or bug, create a type alias and use that instead.
-// Wherever possible, use a TypeScript issue number in the type - something
-// like TS_18757 - or use a descriptive name and leave a detailed comment
-// alongside the type alias.
-
-export {}

package/node_modules/rxjs/src/operators/index.ts

@@ -1,114 +0,0 @@
-/* Operator exports */
-export { audit } from '../internal/operators/audit';
-export { auditTime } from '../internal/operators/auditTime';
-export { buffer } from '../internal/operators/buffer';
-export { bufferCount } from '../internal/operators/bufferCount';
-export { bufferTime } from '../internal/operators/bufferTime';
-export { bufferToggle } from '../internal/operators/bufferToggle';
-export { bufferWhen } from '../internal/operators/bufferWhen';
-export { catchError } from '../internal/operators/catchError';
-export { combineAll } from '../internal/operators/combineAll';
-export { combineLatestAll } from '../internal/operators/combineLatestAll';
-export { combineLatest } from '../internal/operators/combineLatest';
-export { combineLatestWith } from '../internal/operators/combineLatestWith';
-export { concat } from '../internal/operators/concat';
-export { concatAll } from '../internal/operators/concatAll';
-export { concatMap } from '../internal/operators/concatMap';
-export { concatMapTo } from '../internal/operators/concatMapTo';
-export { concatWith } from '../internal/operators/concatWith';
-export { connect, ConnectConfig } from '../internal/operators/connect';
-export { count } from '../internal/operators/count';
-export { debounce } from '../internal/operators/debounce';
-export { debounceTime } from '../internal/operators/debounceTime';
-export { defaultIfEmpty } from '../internal/operators/defaultIfEmpty';
-export { delay } from '../internal/operators/delay';
-export { delayWhen } from '../internal/operators/delayWhen';
-export { dematerialize } from '../internal/operators/dematerialize';
-export { distinct } from '../internal/operators/distinct';
-export { distinctUntilChanged } from '../internal/operators/distinctUntilChanged';
-export { distinctUntilKeyChanged } from '../internal/operators/distinctUntilKeyChanged';
-export { elementAt } from '../internal/operators/elementAt';
-export { endWith } from '../internal/operators/endWith';
-export { every } from '../internal/operators/every';
-export { exhaust } from '../internal/operators/exhaust';
-export { exhaustAll } from '../internal/operators/exhaustAll';
-export { exhaustMap } from '../internal/operators/exhaustMap';
-export { expand } from '../internal/operators/expand';
-export { filter } from '../internal/operators/filter';
-export { finalize } from '../internal/operators/finalize';
-export { find } from '../internal/operators/find';
-export { findIndex } from '../internal/operators/findIndex';
-export { first } from '../internal/operators/first';
-export { groupBy, BasicGroupByOptions, GroupByOptionsWithElement } from '../internal/operators/groupBy';
-export { ignoreElements } from '../internal/operators/ignoreElements';
-export { isEmpty } from '../internal/operators/isEmpty';
-export { last } from '../internal/operators/last';
-export { map } from '../internal/operators/map';
-export { mapTo } from '../internal/operators/mapTo';
-export { materialize } from '../internal/operators/materialize';
-export { max } from '../internal/operators/max';
-export { merge } from '../internal/operators/merge';
-export { mergeAll } from '../internal/operators/mergeAll';
-export { flatMap } from '../internal/operators/flatMap';
-export { mergeMap } from '../internal/operators/mergeMap';
-export { mergeMapTo } from '../internal/operators/mergeMapTo';
-export { mergeScan } from '../internal/operators/mergeScan';
-export { mergeWith } from '../internal/operators/mergeWith';
-export { min } from '../internal/operators/min';
-export { multicast } from '../internal/operators/multicast';
-export { observeOn } from '../internal/operators/observeOn';
-export { onErrorResumeNext } from '../internal/operators/onErrorResumeNextWith';
-export { pairwise } from '../internal/operators/pairwise';
-export { partition } from '../internal/operators/partition';
-export { pluck } from '../internal/operators/pluck';
-export { publish } from '../internal/operators/publish';
-export { publishBehavior } from '../internal/operators/publishBehavior';
-export { publishLast } from '../internal/operators/publishLast';
-export { publishReplay } from '../internal/operators/publishReplay';
-export { race } from '../internal/operators/race';
-export { raceWith } from '../internal/operators/raceWith';
-export { reduce } from '../internal/operators/reduce';
-export { repeat, RepeatConfig } from '../internal/operators/repeat';
-export { repeatWhen } from '../internal/operators/repeatWhen';
-export { retry, RetryConfig } from '../internal/operators/retry';
-export { retryWhen } from '../internal/operators/retryWhen';
-export { refCount } from '../internal/operators/refCount';
-export { sample } from '../internal/operators/sample';
-export { sampleTime } from '../internal/operators/sampleTime';
-export { scan } from '../internal/operators/scan';
-export { sequenceEqual } from '../internal/operators/sequenceEqual';
-export { share, ShareConfig } from '../internal/operators/share';
-export { shareReplay, ShareReplayConfig } from '../internal/operators/shareReplay';
-export { single } from '../internal/operators/single';
-export { skip } from '../internal/operators/skip';
-export { skipLast } from '../internal/operators/skipLast';
-export { skipUntil } from '../internal/operators/skipUntil';
-export { skipWhile } from '../internal/operators/skipWhile';
-export { startWith } from '../internal/operators/startWith';
-export { subscribeOn } from '../internal/operators/subscribeOn';
-export { switchAll } from '../internal/operators/switchAll';
-export { switchMap } from '../internal/operators/switchMap';
-export { switchMapTo } from '../internal/operators/switchMapTo';
-export { switchScan } from '../internal/operators/switchScan';
-export { take } from '../internal/operators/take';
-export { takeLast } from '../internal/operators/takeLast';
-export { takeUntil } from '../internal/operators/takeUntil';
-export { takeWhile } from '../internal/operators/takeWhile';
-export { tap, TapObserver } from '../internal/operators/tap';
-export { throttle, ThrottleConfig } from '../internal/operators/throttle';
-export { throttleTime } from '../internal/operators/throttleTime';
-export { throwIfEmpty } from '../internal/operators/throwIfEmpty';
-export { timeInterval } from '../internal/operators/timeInterval';
-export { timeout, TimeoutConfig, TimeoutInfo } from '../internal/operators/timeout';
-export { timeoutWith } from '../internal/operators/timeoutWith';
-export { timestamp } from '../internal/operators/timestamp';
-export { toArray } from '../internal/operators/toArray';
-export { window } from '../internal/operators/window';
-export { windowCount } from '../internal/operators/windowCount';
-export { windowTime } from '../internal/operators/windowTime';
-export { windowToggle } from '../internal/operators/windowToggle';
-export { windowWhen } from '../internal/operators/windowWhen';
-export { withLatestFrom } from '../internal/operators/withLatestFrom';
-export { zip } from '../internal/operators/zip';
-export { zipAll } from '../internal/operators/zipAll';
-export { zipWith } from '../internal/operators/zipWith';

package/node_modules/rxjs/src/testing/index.ts

@@ -1 +0,0 @@
-export { TestScheduler, RunHelpers } from '../internal/testing/TestScheduler';

package/node_modules/rxjs/src/tsconfig.base.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false,
-    "baseUrl": ".",
-    "paths": {
-      "rxjs": ["./"],
-      "rxjs/*": ["./*"]
-    }
-  },
-  "include": ["./**/*.ts"]
-}

package/node_modules/rxjs/src/tsconfig.cjs.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "es5",
-    "downlevelIteration": true,
-    "outDir": "../dist/cjs"
-  },
-  "exclude": ["./internal/umd.ts"]
-}

package/node_modules/rxjs/src/tsconfig.cjs.spec.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.cjs.json",
-  /**
-   * this is pseudo config for test case's relative path resolution to `../src`, runs
-   * cjs config once more instead of manual copying to utilize incremental build.
-   */
-  "compilerOptions": {
-    "outDir": "../dist/src"
-  }
-}