hyperp 1.0.0

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

@@ -0,0 +1,11 @@
+/**
+ * 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/cli/node_modules/rxjs/src/internal/util/createErrorClass.ts

@@ -0,0 +1,20 @@
+/**
+ * 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/cli/node_modules/rxjs/src/internal/util/createObject.ts

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

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

@@ -0,0 +1,42 @@
+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/cli/node_modules/rxjs/src/internal/util/executeSchedule.ts

@@ -0,0 +1,44 @@
+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/cli/node_modules/rxjs/src/internal/util/identity.ts

@@ -0,0 +1,45 @@
+/**
+ * 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/cli/node_modules/rxjs/src/internal/util/isArrayLike.ts

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

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * 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/cli/node_modules/rxjs/src/internal/util/isFunction.ts

@@ -0,0 +1,7 @@
+/**
+ * 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/cli/node_modules/rxjs/src/internal/util/isInteropObservable.ts

@@ -0,0 +1,8 @@
+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/cli/node_modules/rxjs/src/internal/util/isIterable.ts

@@ -0,0 +1,7 @@
+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/cli/node_modules/rxjs/src/internal/util/isObservable.ts

@@ -0,0 +1,13 @@
+/** 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/cli/node_modules/rxjs/src/internal/util/isPromise.ts

@@ -0,0 +1,9 @@
+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/cli/node_modules/rxjs/src/internal/util/isReadableStreamLike.ts

@@ -0,0 +1,23 @@
+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/cli/node_modules/rxjs/src/internal/util/isScheduler.ts

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

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

@@ -0,0 +1,32 @@
+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/cli/node_modules/rxjs/src/internal/util/mapOneOrManyArgs.ts

@@ -0,0 +1,16 @@
+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/cli/node_modules/rxjs/src/internal/util/noop.ts

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

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

@@ -0,0 +1,3 @@
+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/cli/node_modules/rxjs/src/internal/util/pipe.ts

@@ -0,0 +1,95 @@
+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/cli/node_modules/rxjs/src/internal/util/reportUnhandledError.ts

@@ -0,0 +1,24 @@
+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/cli/node_modules/rxjs/src/internal/util/subscribeToArray.ts

@@ -0,0 +1,12 @@
+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/cli/node_modules/rxjs/src/internal/util/throwUnobservableError.ts

@@ -0,0 +1,12 @@
+/**
+ * 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/cli/node_modules/rxjs/src/internal/util/workarounds.ts

@@ -0,0 +1,7 @@
+// 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/cli/node_modules/rxjs/src/operators/index.ts

@@ -0,0 +1,114 @@
+/* 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/cli/node_modules/rxjs/src/testing/index.ts

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

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

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

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

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

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

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