appiq-solution 1.0.0

package/tools/installer/node_modules/rxjs/src/internal/Observable.ts

@@ -0,0 +1,487 @@
+import { Operator } from './Operator';
+import { SafeSubscriber, Subscriber } from './Subscriber';
+import { isSubscription, Subscription } from './Subscription';
+import { TeardownLogic, OperatorFunction, Subscribable, Observer } from './types';
+import { observable as Symbol_observable } from './symbol/observable';
+import { pipeFromArray } from './util/pipe';
+import { config } from './config';
+import { isFunction } from './util/isFunction';
+import { errorContext } from './util/errorContext';
+
+/**
+ * A representation of any set of values over any amount of time. This is the most basic building block
+ * of RxJS.
+ */
+export class Observable<T> implements Subscribable<T> {
+  /**
+   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+   */
+  source: Observable<any> | undefined;
+
+  /**
+   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+   */
+  operator: Operator<any, T> | undefined;
+
+  /**
+   * @param subscribe The function that is called when the Observable is
+   * initially subscribed to. This function is given a Subscriber, to which new values
+   * can be `next`ed, or an `error` method can be called to raise an error, or
+   * `complete` can be called to notify of a successful completion.
+   */
+  constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+
+  // HACK: Since TypeScript inherits static properties too, we have to
+  // fight against TypeScript here so Subject can have a different static create signature
+  /**
+   * Creates a new Observable by calling the Observable constructor
+   * @param subscribe the subscriber function to be passed to the Observable constructor
+   * @return A new observable.
+   * @deprecated Use `new Observable()` instead. Will be removed in v8.
+   */
+  static create: (...args: any[]) => any = <T>(subscribe?: (subscriber: Subscriber<T>) => TeardownLogic) => {
+    return new Observable<T>(subscribe);
+  };
+
+  /**
+   * Creates a new Observable, with this Observable instance as the source, and the passed
+   * operator defined as the new observable's operator.
+   * @param operator the operator defining the operation to take on the observable
+   * @return A new observable with the Operator applied.
+   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+   * If you have implemented an operator using `lift`, it is recommended that you create an
+   * operator by simply returning `new Observable()` directly. See "Creating new operators from
+   * scratch" section here: https://rxjs.dev/guide/operators
+   */
+  lift<R>(operator?: Operator<T, R>): Observable<R> {
+    const observable = new Observable<R>();
+    observable.source = this;
+    observable.operator = operator;
+    return observable;
+  }
+
+  subscribe(observerOrNext?: Partial<Observer<T>> | ((value: T) => void)): Subscription;
+  /** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
+  subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
+  /**
+   * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.
+   *
+   * <span class="informal">Use it when you have all these Observables, but still nothing is happening.</span>
+   *
+   * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It
+   * might be for example a function that you passed to Observable's constructor, but most of the time it is
+   * a library implementation, which defines what will be emitted by an Observable, and when it be will emitted. This means
+   * that calling `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often
+   * the thought.
+   *
+   * Apart from starting the execution of an Observable, this method allows you to listen for values
+   * that an Observable emits, as well as for when it completes or errors. You can achieve this in two
+   * of the following ways.
+   *
+   * The first way is creating an object that implements {@link Observer} interface. It should have methods
+   * defined by that interface, but note that it should be just a regular JavaScript object, which you can create
+   * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular, do
+   * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also
+   * that your object does not have to implement all methods. If you find yourself creating a method that doesn't
+   * do anything, you can simply omit it. Note however, if the `error` method is not provided and an error happens,
+   * it will be thrown asynchronously. Errors thrown asynchronously cannot be caught using `try`/`catch`. Instead,
+   * use the {@link onUnhandledError} configuration option or use a runtime handler (like `window.onerror` or
+   * `process.on('error)`) to be notified of unhandled errors. Because of this, it's recommended that you provide
+   * an `error` method to avoid missing thrown errors.
+   *
+   * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.
+   * This means you can provide three functions as arguments to `subscribe`, where the first function is equivalent
+   * of a `next` method, the second of an `error` method and the third of a `complete` method. Just as in case of an Observer,
+   * if you do not need to listen for something, you can omit a function by passing `undefined` or `null`,
+   * since `subscribe` recognizes these functions by where they were placed in function call. When it comes
+   * to the `error` function, as with an Observer, if not provided, errors emitted by an Observable will be thrown asynchronously.
+   *
+   * You can, however, subscribe with no parameters at all. This may be the case where you're not interested in terminal events
+   * and you also handled emissions internally by using operators (e.g. using `tap`).
+   *
+   * Whichever style of calling `subscribe` you use, in both cases it returns a Subscription object.
+   * This object allows you to call `unsubscribe` on it, which in turn will stop the work that an Observable does and will clean
+   * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback
+   * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.
+   *
+   * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.
+   * It is an Observable itself that decides when these functions will be called. For example {@link of}
+   * by default emits all its values synchronously. Always check documentation for how given Observable
+   * will behave when subscribed and if its default behavior can be modified with a `scheduler`.
+   *
+   * #### Examples
+   *
+   * Subscribe with an {@link guide/observer Observer}
+   *
+   * ```ts
+   * import { of } from 'rxjs';
+   *
+   * const sumObserver = {
+   *   sum: 0,
+   *   next(value) {
+   *     console.log('Adding: ' + value);
+   *     this.sum = this.sum + value;
+   *   },
+   *   error() {
+   *     // We actually could just remove this method,
+   *     // since we do not really care about errors right now.
+   *   },
+   *   complete() {
+   *     console.log('Sum equals: ' + this.sum);
+   *   }
+   * };
+   *
+   * of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.
+   *   .subscribe(sumObserver);
+   *
+   * // Logs:
+   * // 'Adding: 1'
+   * // 'Adding: 2'
+   * // 'Adding: 3'
+   * // 'Sum equals: 6'
+   * ```
+   *
+   * Subscribe with functions ({@link deprecations/subscribe-arguments deprecated})
+   *
+   * ```ts
+   * import { of } from 'rxjs'
+   *
+   * let sum = 0;
+   *
+   * of(1, 2, 3).subscribe(
+   *   value => {
+   *     console.log('Adding: ' + value);
+   *     sum = sum + value;
+   *   },
+   *   undefined,
+   *   () => console.log('Sum equals: ' + sum)
+   * );
+   *
+   * // Logs:
+   * // 'Adding: 1'
+   * // 'Adding: 2'
+   * // 'Adding: 3'
+   * // 'Sum equals: 6'
+   * ```
+   *
+   * Cancel a subscription
+   *
+   * ```ts
+   * import { interval } from 'rxjs';
+   *
+   * const subscription = interval(1000).subscribe({
+   *   next(num) {
+   *     console.log(num)
+   *   },
+   *   complete() {
+   *     // Will not be called, even when cancelling subscription.
+   *     console.log('completed!');
+   *   }
+   * });
+   *
+   * setTimeout(() => {
+   *   subscription.unsubscribe();
+   *   console.log('unsubscribed!');
+   * }, 2500);
+   *
+   * // Logs:
+   * // 0 after 1s
+   * // 1 after 2s
+   * // 'unsubscribed!' after 2.5s
+   * ```
+   *
+   * @param observerOrNext Either an {@link Observer} with some or all callback methods,
+   * or the `next` handler that is called for each value emitted from the subscribed Observable.
+   * @param error A handler for a terminal event resulting from an error. If no error handler is provided,
+   * the error will be thrown asynchronously as unhandled.
+   * @param complete A handler for a terminal event resulting from successful completion.
+   * @return A subscription reference to the registered handlers.
+   */
+  subscribe(
+    observerOrNext?: Partial<Observer<T>> | ((value: T) => void) | null,
+    error?: ((error: any) => void) | null,
+    complete?: (() => void) | null
+  ): Subscription {
+    const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+
+    errorContext(() => {
+      const { operator, source } = this;
+      subscriber.add(
+        operator
+          ? // We're dealing with a subscription in the
+            // operator chain to one of our lifted operators.
+            operator.call(subscriber, source)
+          : source
+          ? // If `source` has a value, but `operator` does not, something that
+            // had intimate knowledge of our API, like our `Subject`, must have
+            // set it. We're going to just call `_subscribe` directly.
+            this._subscribe(subscriber)
+          : // In all other cases, we're likely wrapping a user-provided initializer
+            // function, so we need to catch errors and handle them appropriately.
+            this._trySubscribe(subscriber)
+      );
+    });
+
+    return subscriber;
+  }
+
+  /** @internal */
+  protected _trySubscribe(sink: Subscriber<T>): TeardownLogic {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      // We don't need to return anything in this case,
+      // because it's just going to try to `add()` to a subscription
+      // above.
+      sink.error(err);
+    }
+  }
+
+  /**
+   * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
+   * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
+   *
+   * **WARNING**: Only use this with observables you *know* will complete. If the source
+   * observable does not complete, you will end up with a promise that is hung up, and
+   * potentially all of the state of an async function hanging out in memory. To avoid
+   * this situation, look into adding something like {@link timeout}, {@link take},
+   * {@link takeWhile}, or {@link takeUntil} amongst others.
+   *
+   * #### Example
+   *
+   * ```ts
+   * import { interval, take } from 'rxjs';
+   *
+   * const source$ = interval(1000).pipe(take(4));
+   *
+   * async function getTotal() {
+   *   let total = 0;
+   *
+   *   await source$.forEach(value => {
+   *     total += value;
+   *     console.log('observable -> ' + value);
+   *   });
+   *
+   *   return total;
+   * }
+   *
+   * getTotal().then(
+   *   total => console.log('Total: ' + total)
+   * );
+   *
+   * // Expected:
+   * // 'observable -> 0'
+   * // 'observable -> 1'
+   * // 'observable -> 2'
+   * // 'observable -> 3'
+   * // 'Total: 6'
+   * ```
+   *
+   * @param next A handler for each value emitted by the observable.
+   * @return A promise that either resolves on observable completion or
+   * rejects with the handled error.
+   */
+  forEach(next: (value: T) => void): Promise<void>;
+
+  /**
+   * @param next a handler for each value emitted by the observable
+   * @param promiseCtor a constructor function used to instantiate the Promise
+   * @return a promise that either resolves on observable completion or
+   *  rejects with the handled error
+   * @deprecated Passing a Promise constructor will no longer be available
+   * in upcoming versions of RxJS. This is because it adds weight to the library, for very
+   * little benefit. If you need this functionality, it is recommended that you either
+   * polyfill Promise, or you create an adapter to convert the returned native promise
+   * to whatever promise implementation you wanted. Will be removed in v8.
+   */
+  forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
+
+  forEach(next: (value: T) => void, promiseCtor?: PromiseConstructorLike): Promise<void> {
+    promiseCtor = getPromiseCtor(promiseCtor);
+
+    return new promiseCtor<void>((resolve, reject) => {
+      const subscriber = new SafeSubscriber<T>({
+        next: (value) => {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve,
+      });
+      this.subscribe(subscriber);
+    }) as Promise<void>;
+  }
+
+  /** @internal */
+  protected _subscribe(subscriber: Subscriber<any>): TeardownLogic {
+    return this.source?.subscribe(subscriber);
+  }
+
+  /**
+   * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
+   * @return This instance of the observable.
+   */
+  [Symbol_observable]() {
+    return this;
+  }
+
+  /* tslint:disable:max-line-length */
+  pipe(): Observable<T>;
+  pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
+  pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
+  pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
+  pipe<A, B, C, D>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>
+  ): Observable<D>;
+  pipe<A, B, C, D, E>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>
+  ): Observable<E>;
+  pipe<A, B, C, D, E, F>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>
+  ): Observable<F>;
+  pipe<A, B, C, D, E, F, G>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>
+  ): Observable<G>;
+  pipe<A, B, C, D, E, F, G, H>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>,
+    op8: OperatorFunction<G, H>
+  ): Observable<H>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>,
+    op8: OperatorFunction<G, H>,
+    op9: OperatorFunction<H, I>
+  ): Observable<I>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>,
+    op8: OperatorFunction<G, H>,
+    op9: OperatorFunction<H, I>,
+    ...operations: OperatorFunction<any, any>[]
+  ): Observable<unknown>;
+  /* tslint:enable:max-line-length */
+
+  /**
+   * Used to stitch together functional operators into a chain.
+   *
+   * ## Example
+   *
+   * ```ts
+   * import { interval, filter, map, scan } from 'rxjs';
+   *
+   * interval(1000)
+   *   .pipe(
+   *     filter(x => x % 2 === 0),
+   *     map(x => x + x),
+   *     scan((acc, x) => acc + x)
+   *   )
+   *   .subscribe(x => console.log(x));
+   * ```
+   *
+   * @return The Observable result of all the operators having been called
+   * in the order they were passed in.
+   */
+  pipe(...operations: OperatorFunction<any, any>[]): Observable<any> {
+    return pipeFromArray(operations)(this);
+  }
+
+  /* tslint:disable:max-line-length */
+  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+  toPromise(): Promise<T | undefined>;
+  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+  toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
+  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+  toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
+  /* tslint:enable:max-line-length */
+
+  /**
+   * Subscribe to this Observable and get a Promise resolving on
+   * `complete` with the last emission (if any).
+   *
+   * **WARNING**: Only use this with observables you *know* will complete. If the source
+   * observable does not complete, you will end up with a promise that is hung up, and
+   * potentially all of the state of an async function hanging out in memory. To avoid
+   * this situation, look into adding something like {@link timeout}, {@link take},
+   * {@link takeWhile}, or {@link takeUntil} amongst others.
+   *
+   * @param [promiseCtor] a constructor function used to instantiate
+   * the Promise
+   * @return A Promise that resolves with the last value emit, or
+   * rejects on an error. If there were no emissions, Promise
+   * resolves with undefined.
+   * @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise
+   */
+  toPromise(promiseCtor?: PromiseConstructorLike): Promise<T | undefined> {
+    promiseCtor = getPromiseCtor(promiseCtor);
+
+    return new promiseCtor((resolve, reject) => {
+      let value: T | undefined;
+      this.subscribe(
+        (x: T) => (value = x),
+        (err: any) => reject(err),
+        () => resolve(value)
+      );
+    }) as Promise<T | undefined>;
+  }
+}
+
+/**
+ * Decides between a passed promise constructor from consuming code,
+ * A default configured promise constructor, and the native promise
+ * constructor and returns it. If nothing can be found, it will throw
+ * an error.
+ * @param promiseCtor The optional promise constructor to passed by consuming code
+ */
+function getPromiseCtor(promiseCtor: PromiseConstructorLike | undefined) {
+  return promiseCtor ?? config.Promise ?? Promise;
+}
+
+function isObserver<T>(value: any): value is Observer<T> {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+
+function isSubscriber<T>(value: any): value is Subscriber<T> {
+  return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+}

package/tools/installer/node_modules/rxjs/src/internal/Operator.ts

@@ -0,0 +1,9 @@
+import { Subscriber } from './Subscriber';
+import { TeardownLogic } from './types';
+
+/***
+ * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+ */
+export interface Operator<T, R> {
+  call(subscriber: Subscriber<R>, source: any): TeardownLogic;
+}

package/tools/installer/node_modules/rxjs/src/internal/ReplaySubject.ts

@@ -0,0 +1,110 @@
+import { Subject } from './Subject';
+import { TimestampProvider } from './types';
+import { Subscriber } from './Subscriber';
+import { Subscription } from './Subscription';
+import { dateTimestampProvider } from './scheduler/dateTimestampProvider';
+
+/**
+ * A variant of {@link Subject} that "replays" old values to new subscribers by emitting them when they first subscribe.
+ *
+ * `ReplaySubject` has an internal buffer that will store a specified number of values that it has observed. Like `Subject`,
+ * `ReplaySubject` "observes" values by having them passed to its `next` method. When it observes a value, it will store that
+ * value for a time determined by the configuration of the `ReplaySubject`, as passed to its constructor.
+ *
+ * When a new subscriber subscribes to the `ReplaySubject` instance, it will synchronously emit all values in its buffer in
+ * a First-In-First-Out (FIFO) manner. The `ReplaySubject` will also complete, if it has observed completion; and it will
+ * error if it has observed an error.
+ *
+ * There are two main configuration items to be concerned with:
+ *
+ * 1. `bufferSize` - This will determine how many items are stored in the buffer, defaults to infinite.
+ * 2. `windowTime` - The amount of time to hold a value in the buffer before removing it from the buffer.
+ *
+ * Both configurations may exist simultaneously. So if you would like to buffer a maximum of 3 values, as long as the values
+ * are less than 2 seconds old, you could do so with a `new ReplaySubject(3, 2000)`.
+ *
+ * ### Differences with BehaviorSubject
+ *
+ * `BehaviorSubject` is similar to `new ReplaySubject(1)`, with a couple of exceptions:
+ *
+ * 1. `BehaviorSubject` comes "primed" with a single value upon construction.
+ * 2. `ReplaySubject` will replay values, even after observing an error, where `BehaviorSubject` will not.
+ *
+ * @see {@link Subject}
+ * @see {@link BehaviorSubject}
+ * @see {@link shareReplay}
+ */
+export class ReplaySubject<T> extends Subject<T> {
+  private _buffer: (T | number)[] = [];
+  private _infiniteTimeWindow = true;
+
+  /**
+   * @param _bufferSize The size of the buffer to replay on subscription
+   * @param _windowTime The amount of time the buffered items will stay buffered
+   * @param _timestampProvider An object with a `now()` method that provides the current timestamp. This is used to
+   * calculate the amount of time something has been buffered.
+   */
+  constructor(
+    private _bufferSize = Infinity,
+    private _windowTime = Infinity,
+    private _timestampProvider: TimestampProvider = dateTimestampProvider
+  ) {
+    super();
+    this._infiniteTimeWindow = _windowTime === Infinity;
+    this._bufferSize = Math.max(1, _bufferSize);
+    this._windowTime = Math.max(1, _windowTime);
+  }
+
+  next(value: T): void {
+    const { isStopped, _buffer, _infiniteTimeWindow, _timestampProvider, _windowTime } = this;
+    if (!isStopped) {
+      _buffer.push(value);
+      !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+    }
+    this._trimBuffer();
+    super.next(value);
+  }
+
+  /** @internal */
+  protected _subscribe(subscriber: Subscriber<T>): Subscription {
+    this._throwIfClosed();
+    this._trimBuffer();
+
+    const subscription = this._innerSubscribe(subscriber);
+
+    const { _infiniteTimeWindow, _buffer } = this;
+    // We use a copy here, so reentrant code does not mutate our array while we're
+    // emitting it to a new subscriber.
+    const copy = _buffer.slice();
+    for (let i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+      subscriber.next(copy[i] as T);
+    }
+
+    this._checkFinalizedStatuses(subscriber);
+
+    return subscription;
+  }
+
+  private _trimBuffer() {
+    const { _bufferSize, _timestampProvider, _buffer, _infiniteTimeWindow } = this;
+    // If we don't have an infinite buffer size, and we're over the length,
+    // use splice to truncate the old buffer values off. Note that we have to
+    // double the size for instances where we're not using an infinite time window
+    // because we're storing the values and the timestamps in the same array.
+    const adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+    _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+
+    // Now, if we're not in an infinite time window, remove all values where the time is
+    // older than what is allowed.
+    if (!_infiniteTimeWindow) {
+      const now = _timestampProvider.now();
+      let last = 0;
+      // Search the array for the first timestamp that isn't expired and
+      // truncate the buffer up to that point.
+      for (let i = 1; i < _buffer.length && (_buffer[i] as number) <= now; i += 2) {
+        last = i;
+      }
+      last && _buffer.splice(0, last + 1);
+    }
+  }
+}

package/tools/installer/node_modules/rxjs/src/internal/Scheduler.ts

@@ -0,0 +1,60 @@
+import { Action } from './scheduler/Action';
+import { Subscription } from './Subscription';
+import { SchedulerLike, SchedulerAction } from './types';
+import { dateTimestampProvider } from './scheduler/dateTimestampProvider';
+
+/**
+ * An execution context and a data structure to order tasks and schedule their
+ * execution. Provides a notion of (potentially virtual) time, through the
+ * `now()` getter method.
+ *
+ * Each unit of work in a Scheduler is called an `Action`.
+ *
+ * ```ts
+ * class Scheduler {
+ *   now(): number;
+ *   schedule(work, delay?, state?): Subscription;
+ * }
+ * ```
+ *
+ * @deprecated Scheduler is an internal implementation detail of RxJS, and
+ * should not be used directly. Rather, create your own class and implement
+ * {@link SchedulerLike}. Will be made internal in v8.
+ */
+export class Scheduler implements SchedulerLike {
+  public static now: () => number = dateTimestampProvider.now;
+
+  constructor(private schedulerActionCtor: typeof Action, now: () => number = Scheduler.now) {
+    this.now = now;
+  }
+
+  /**
+   * A getter method that returns a number representing the current time
+   * (at the time this function was called) according to the scheduler's own
+   * internal clock.
+   * @return A number that represents the current time. May or may not
+   * have a relation to wall-clock time. May or may not refer to a time unit
+   * (e.g. milliseconds).
+   */
+  public now: () => number;
+
+  /**
+   * Schedules a function, `work`, for execution. May happen at some point in
+   * the future, according to the `delay` parameter, if specified. May be passed
+   * some context object, `state`, which will be passed to the `work` function.
+   *
+   * The given arguments will be processed an stored as an Action object in a
+   * queue of actions.
+   *
+   * @param work A function representing a task, or some unit of work to be
+   * executed by the Scheduler.
+   * @param delay Time to wait before executing the work, where the time unit is
+   * implicit and defined by the Scheduler itself.
+   * @param state Some contextual data that the `work` function uses when called
+   * by the Scheduler.
+   * @return A subscription in order to be able to unsubscribe the scheduled work.
+   */
+  public schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay: number = 0, state?: T): Subscription {
+    return new this.schedulerActionCtor<T>(this, work).schedule(state, delay);
+  }
+}