lambda-live-debugger 1.12.2 → 1.12.4

package/node_modules/rxjs/src/internal/observable/throwError.ts

@@ -1,125 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { SchedulerLike } from '../types';
-import { isFunction } from '../util/isFunction';
-
-/**
- * Creates an observable that will create an error instance and push it to the consumer as an error
- * immediately upon subscription.
- *
- * <span class="informal">Just errors and does nothing else</span>
- *
- * ![](throw.png)
- *
- * This creation function is useful for creating an observable that will create an error and error every
- * time it is subscribed to. Generally, inside of most operators when you might want to return an errored
- * observable, this is unnecessary. In most cases, such as in the inner return of {@link concatMap},
- * {@link mergeMap}, {@link defer}, and many others, you can simply throw the error, and RxJS will pick
- * that up and notify the consumer of the error.
- *
- * ## Example
- *
- * Create a simple observable that will create a new error with a timestamp and log it
- * and the message every time you subscribe to it
- *
- * ```ts
- * import { throwError } from 'rxjs';
- *
- * let errorCount = 0;
- *
- * const errorWithTimestamp$ = throwError(() => {
- *   const error: any = new Error(`This is error number ${ ++errorCount }`);
- *   error.timestamp = Date.now();
- *   return error;
- * });
- *
- * errorWithTimestamp$.subscribe({
- *   error: err => console.log(err.timestamp, err.message)
- * });
- *
- * errorWithTimestamp$.subscribe({
- *   error: err => console.log(err.timestamp, err.message)
- * });
- *
- * // Logs the timestamp and a new error message for each subscription
- * ```
- *
- * ### Unnecessary usage
- *
- * Using `throwError` inside of an operator or creation function
- * with a callback, is usually not necessary
- *
- * ```ts
- * import { of, concatMap, timer, throwError } from 'rxjs';
- *
- * const delays$ = of(1000, 2000, Infinity, 3000);
- *
- * delays$.pipe(
- *   concatMap(ms => {
- *     if (ms < 10000) {
- *       return timer(ms);
- *     } else {
- *       // This is probably overkill.
- *       return throwError(() => new Error(`Invalid time ${ ms }`));
- *     }
- *   })
- * )
- * .subscribe({
- *   next: console.log,
- *   error: console.error
- * });
- * ```
- *
- * You can just throw the error instead
- *
- * ```ts
- * import { of, concatMap, timer } from 'rxjs';
- *
- * const delays$ = of(1000, 2000, Infinity, 3000);
- *
- * delays$.pipe(
- *   concatMap(ms => {
- *     if (ms < 10000) {
- *       return timer(ms);
- *     } else {
- *       // Cleaner and easier to read for most folks.
- *       throw new Error(`Invalid time ${ ms }`);
- *     }
- *   })
- * )
- * .subscribe({
- *   next: console.log,
- *   error: console.error
- * });
- * ```
- *
- * @param errorFactory A factory function that will create the error instance that is pushed.
- */
-export function throwError(errorFactory: () => any): Observable<never>;
-
-/**
- * Returns an observable that will error with the specified error immediately upon subscription.
- *
- * @param error The error instance to emit
- * @deprecated Support for passing an error value will be removed in v8. Instead, pass a factory function to `throwError(() => new Error('test'))`. This is
- * because it will create the error at the moment it should be created and capture a more appropriate stack trace. If
- * for some reason you need to create the error ahead of time, you can still do that: `const err = new Error('test'); throwError(() => err);`.
- */
-export function throwError(error: any): Observable<never>;
-
-/**
- * Notifies the consumer of an error using a given scheduler by scheduling it at delay `0` upon subscription.
- *
- * @param errorOrErrorFactory An error instance or error factory
- * @param scheduler A scheduler to use to schedule the error notification
- * @deprecated The `scheduler` parameter will be removed in v8.
- * Use `throwError` in combination with {@link observeOn}: `throwError(() => new Error('test')).pipe(observeOn(scheduler));`.
- * Details: https://rxjs.dev/deprecations/scheduler-argument
- */
-export function throwError(errorOrErrorFactory: any, scheduler: SchedulerLike): Observable<never>;
-
-export function throwError(errorOrErrorFactory: any, scheduler?: SchedulerLike): Observable<never> {
-  const errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : () => errorOrErrorFactory;
-  const init = (subscriber: Subscriber<never>) => subscriber.error(errorFactory());
-  return new Observable(scheduler ? (subscriber) => scheduler.schedule(init as any, 0, subscriber) : init);
-}

package/node_modules/rxjs/src/internal/observable/timer.ts

@@ -1,186 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-import { async as asyncScheduler } from '../scheduler/async';
-import { isScheduler } from '../util/isScheduler';
-import { isValidDate } from '../util/isDate';
-
-/**
- * Creates an observable that will wait for a specified time period, or exact date, before
- * emitting the number 0.
- *
- * <span class="informal">Used to emit a notification after a delay.</span>
- *
- * This observable is useful for creating delays in code, or racing against other values
- * for ad-hoc timeouts.
- *
- * The `delay` is specified by default in milliseconds, however providing a custom scheduler could
- * create a different behavior.
- *
- * ## Examples
- *
- * Wait 3 seconds and start another observable
- *
- * You might want to use `timer` to delay subscription to an
- * observable by a set amount of time. Here we use a timer with
- * {@link concatMapTo} or {@link concatMap} in order to wait
- * a few seconds and start a subscription to a source.
- *
- * ```ts
- * import { of, timer, concatMap } from 'rxjs';
- *
- * // This could be any observable
- * const source = of(1, 2, 3);
- *
- * timer(3000)
- *   .pipe(concatMap(() => source))
- *   .subscribe(console.log);
- * ```
- *
- * Take all values until the start of the next minute
- *
- * Using a `Date` as the trigger for the first emission, you can
- * do things like wait until midnight to fire an event, or in this case,
- * wait until a new minute starts (chosen so the example wouldn't take
- * too long to run) in order to stop watching a stream. Leveraging
- * {@link takeUntil}.
- *
- * ```ts
- * import { interval, takeUntil, timer } from 'rxjs';
- *
- * // Build a Date object that marks the
- * // next minute.
- * const currentDate = new Date();
- * const startOfNextMinute = new Date(
- *   currentDate.getFullYear(),
- *   currentDate.getMonth(),
- *   currentDate.getDate(),
- *   currentDate.getHours(),
- *   currentDate.getMinutes() + 1
- * );
- *
- * // This could be any observable stream
- * const source = interval(1000);
- *
- * const result = source.pipe(
- *   takeUntil(timer(startOfNextMinute))
- * );
- *
- * result.subscribe(console.log);
- * ```
- *
- * ### Known Limitations
- *
- * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled.
- *
- * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and
- * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission
- * should occur will be incorrect. In this case, it would be best to do your own calculations
- * ahead of time, and pass a `number` in as the `dueTime`.
- *
- * @param due If a `number`, the amount of time in milliseconds to wait before emitting.
- * If a `Date`, the exact time at which to emit.
- * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}.
- */
-export function timer(due: number | Date, scheduler?: SchedulerLike): Observable<0>;
-
-/**
- * Creates an observable that starts an interval after a specified delay, emitting incrementing numbers -- starting at `0` --
- * on each interval after words.
- *
- * The `delay` and `intervalDuration` are specified by default in milliseconds, however providing a custom scheduler could
- * create a different behavior.
- *
- * ## Example
- *
- * ### Start an interval that starts right away
- *
- * Since {@link interval} waits for the passed delay before starting,
- * sometimes that's not ideal. You may want to start an interval immediately.
- * `timer` works well for this. Here we have both side-by-side so you can
- * see them in comparison.
- *
- * Note that this observable will never complete.
- *
- * ```ts
- * import { timer, interval } from 'rxjs';
- *
- * timer(0, 1000).subscribe(n => console.log('timer', n));
- * interval(1000).subscribe(n => console.log('interval', n));
- * ```
- *
- * ### Known Limitations
- *
- * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled.
- *
- * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and
- * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission
- * should occur will be incorrect. In this case, it would be best to do your own calculations
- * ahead of time, and pass a `number` in as the `startDue`.
- * @param startDue If a `number`, is the time to wait before starting the interval.
- * If a `Date`, is the exact time at which to start the interval.
- * @param intervalDuration The delay between each value emitted in the interval. Passing a
- * negative number here will result in immediate completion after the first value is emitted, as though
- * no `intervalDuration` was passed at all.
- * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}.
- */
-export function timer(startDue: number | Date, intervalDuration: number, scheduler?: SchedulerLike): Observable<number>;
-
-/**
- * @deprecated The signature allowing `undefined` to be passed for `intervalDuration` will be removed in v8. Use the `timer(dueTime, scheduler?)` signature instead.
- */
-export function timer(dueTime: number | Date, unused: undefined, scheduler?: SchedulerLike): Observable<0>;
-
-export function timer(
-  dueTime: number | Date = 0,
-  intervalOrScheduler?: number | SchedulerLike,
-  scheduler: SchedulerLike = asyncScheduler
-): Observable<number> {
-  // Since negative intervalDuration is treated as though no
-  // interval was specified at all, we start with a negative number.
-  let intervalDuration = -1;
-
-  if (intervalOrScheduler != null) {
-    // If we have a second argument, and it's a scheduler,
-    // override the scheduler we had defaulted. Otherwise,
-    // it must be an interval.
-    if (isScheduler(intervalOrScheduler)) {
-      scheduler = intervalOrScheduler;
-    } else {
-      // Note that this *could* be negative, in which case
-      // it's like not passing an intervalDuration at all.
-      intervalDuration = intervalOrScheduler;
-    }
-  }
-
-  return new Observable((subscriber) => {
-    // If a valid date is passed, calculate how long to wait before
-    // executing the first value... otherwise, if it's a number just schedule
-    // that many milliseconds (or scheduler-specified unit size) in the future.
-    let due = isValidDate(dueTime) ? +dueTime - scheduler!.now() : dueTime;
-
-    if (due < 0) {
-      // Ensure we don't schedule in the future.
-      due = 0;
-    }
-
-    // The incrementing value we emit.
-    let n = 0;
-
-    // Start the timer.
-    return scheduler.schedule(function () {
-      if (!subscriber.closed) {
-        // Emit the next value and increment.
-        subscriber.next(n++);
-
-        if (0 <= intervalDuration) {
-          // If we have a interval after the initial timer,
-          // reschedule with the period.
-          this.schedule(undefined, intervalDuration);
-        } else {
-          // We didn't have an interval. So just complete.
-          subscriber.complete();
-        }
-      }
-    }, due);
-  });
-}

package/node_modules/rxjs/src/internal/observable/using.ts

@@ -1,49 +0,0 @@
-import { Observable } from '../Observable';
-import { Unsubscribable, ObservableInput, ObservedValueOf } from '../types';
-import { innerFrom } from './innerFrom';
-import { EMPTY } from './empty';
-
-/**
- * Creates an Observable that uses a resource which will be disposed at the same time as the Observable.
- *
- * <span class="informal">Use it when you catch yourself cleaning up after an Observable.</span>
- *
- * `using` is a factory operator, which accepts two functions. First function returns a disposable resource.
- * It can be an arbitrary object that implements `unsubscribe` method. Second function will be injected with
- * that object and should return an Observable. That Observable can use resource object during its execution.
- * Both functions passed to `using` will be called every time someone subscribes - neither an Observable nor
- * resource object will be shared in any way between subscriptions.
- *
- * When Observable returned by `using` is subscribed, Observable returned from the second function will be subscribed
- * as well. All its notifications (nexted values, completion and error events) will be emitted unchanged by the output
- * Observable. If however someone unsubscribes from the Observable or source Observable completes or errors by itself,
- * the `unsubscribe` method on resource object will be called. This can be used to do any necessary clean up, which
- * otherwise would have to be handled by hand. Note that complete or error notifications are not emitted when someone
- * cancels subscription to an Observable via `unsubscribe`, so `using` can be used as a hook, allowing you to make
- * sure that all resources which need to exist during an Observable execution will be disposed at appropriate time.
- *
- * @see {@link defer}
- *
- * @param resourceFactory A function which creates any resource object that implements `unsubscribe` method.
- * @param observableFactory A function which creates an Observable, that can use injected resource object.
- * @return An Observable that behaves the same as Observable returned by `observableFactory`, but
- * which - when completed, errored or unsubscribed - will also call `unsubscribe` on created resource object.
- */
-export function using<T extends ObservableInput<any>>(
-  resourceFactory: () => Unsubscribable | void,
-  observableFactory: (resource: Unsubscribable | void) => T | void
-): Observable<ObservedValueOf<T>> {
-  return new Observable<ObservedValueOf<T>>((subscriber) => {
-    const resource = resourceFactory();
-    const result = observableFactory(resource);
-    const source = result ? innerFrom(result) : EMPTY;
-    source.subscribe(subscriber);
-    return () => {
-      // NOTE: Optional chaining did not work here.
-      // Related TS Issue: https://github.com/microsoft/TypeScript/issues/40818
-      if (resource) {
-        resource.unsubscribe();
-      }
-    };
-  });
-}

package/node_modules/rxjs/src/internal/observable/zip.ts

@@ -1,117 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInputTuple } from '../types';
-import { innerFrom } from './innerFrom';
-import { argsOrArgArray } from '../util/argsOrArgArray';
-import { EMPTY } from './empty';
-import { createOperatorSubscriber } from '../operators/OperatorSubscriber';
-import { popResultSelector } from '../util/args';
-
-export function zip<A extends readonly unknown[]>(sources: [...ObservableInputTuple<A>]): Observable<A>;
-export function zip<A extends readonly unknown[], R>(
-  sources: [...ObservableInputTuple<A>],
-  resultSelector: (...values: A) => R
-): Observable<R>;
-export function zip<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;
-export function zip<A extends readonly unknown[], R>(
-  ...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R]
-): Observable<R>;
-
-/**
- * Combines multiple Observables to create an Observable whose values are calculated from the values, in order, of each
- * of its input Observables.
- *
- * If the last parameter is a function, this function is used to compute the created value from the input values.
- * Otherwise, an array of the input values is returned.
- *
- * ## Example
- *
- * Combine age and name from different sources
- *
- * ```ts
- * import { of, zip, map } from 'rxjs';
- *
- * const age$ = of(27, 25, 29);
- * const name$ = of('Foo', 'Bar', 'Beer');
- * const isDev$ = of(true, true, false);
- *
- * zip(age$, name$, isDev$).pipe(
- *   map(([age, name, isDev]) => ({ age, name, isDev }))
- * )
- * .subscribe(x => console.log(x));
- *
- * // Outputs
- * // { age: 27, name: 'Foo', isDev: true }
- * // { age: 25, name: 'Bar', isDev: true }
- * // { age: 29, name: 'Beer', isDev: false }
- * ```
- *
- * @param args Any number of `ObservableInput`s provided either as an array or as an object
- * to combine with each other.
- * @return An Observable of array values of the values emitted at the same index from each
- * individual `ObservableInput`.
- */
-export function zip(...args: unknown[]): Observable<unknown> {
-  const resultSelector = popResultSelector(args);
-
-  const sources = argsOrArgArray(args) as Observable<unknown>[];
-
-  return sources.length
-    ? new Observable<unknown[]>((subscriber) => {
-        // A collection of buffers of values from each source.
-        // Keyed by the same index with which the sources were passed in.
-        let buffers: unknown[][] = sources.map(() => []);
-
-        // An array of flags of whether or not the sources have completed.
-        // This is used to check to see if we should complete the result.
-        // Keyed by the same index with which the sources were passed in.
-        let completed = sources.map(() => false);
-
-        // When everything is done, release the arrays above.
-        subscriber.add(() => {
-          buffers = completed = null!;
-        });
-
-        // Loop over our sources and subscribe to each one. The index `i` is
-        // especially important here, because we use it in closures below to
-        // access the related buffers and completion properties
-        for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
-          innerFrom(sources[sourceIndex]).subscribe(
-            createOperatorSubscriber(
-              subscriber,
-              (value) => {
-                buffers[sourceIndex].push(value);
-                // if every buffer has at least one value in it, then we
-                // can shift out the oldest value from each buffer and emit
-                // them as an array.
-                if (buffers.every((buffer) => buffer.length)) {
-                  const result: any = buffers.map((buffer) => buffer.shift()!);
-                  // Emit the array. If theres' a result selector, use that.
-                  subscriber.next(resultSelector ? resultSelector(...result) : result);
-                  // If any one of the sources is both complete and has an empty buffer
-                  // then we complete the result. This is because we cannot possibly have
-                  // any more values to zip together.
-                  if (buffers.some((buffer, i) => !buffer.length && completed[i])) {
-                    subscriber.complete();
-                  }
-                }
-              },
-              () => {
-                // This source completed. Mark it as complete so we can check it later
-                // if we have to.
-                completed[sourceIndex] = true;
-                // But, if this complete source has nothing in its buffer, then we
-                // can complete the result, because we can't possibly have any more
-                // values from this to zip together with the other values.
-                !buffers[sourceIndex].length && subscriber.complete();
-              }
-            )
-          );
-        }
-
-        // When everything is done, release the arrays above.
-        return () => {
-          buffers = completed = null!;
-        };
-      })
-    : EMPTY;
-}

package/node_modules/rxjs/src/internal/operators/OperatorSubscriber.ts

@@ -1,112 +0,0 @@
-import { Subscriber } from '../Subscriber';
-
-/**
- * Creates an instance of an `OperatorSubscriber`.
- * @param destination The downstream subscriber.
- * @param onNext Handles next values, only called if this subscriber is not stopped or closed. Any
- * error that occurs in this function is caught and sent to the `error` method of this subscriber.
- * @param onError Handles errors from the subscription, any errors that occur in this handler are caught
- * and send to the `destination` error handler.
- * @param onComplete Handles completion notification from the subscription. Any errors that occur in
- * this handler are sent to the `destination` error handler.
- * @param onFinalize Additional teardown logic here. This will only be called on teardown if the
- * subscriber itself is not already closed. This is called after all other teardown logic is executed.
- */
-export function createOperatorSubscriber<T>(
-  destination: Subscriber<any>,
-  onNext?: (value: T) => void,
-  onComplete?: () => void,
-  onError?: (err: any) => void,
-  onFinalize?: () => void
-): Subscriber<T> {
-  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
-}
-
-/**
- * A generic helper for allowing operators to be created with a Subscriber and
- * use closures to capture necessary state from the operator function itself.
- */
-export class OperatorSubscriber<T> extends Subscriber<T> {
-  /**
-   * Creates an instance of an `OperatorSubscriber`.
-   * @param destination The downstream subscriber.
-   * @param onNext Handles next values, only called if this subscriber is not stopped or closed. Any
-   * error that occurs in this function is caught and sent to the `error` method of this subscriber.
-   * @param onError Handles errors from the subscription, any errors that occur in this handler are caught
-   * and send to the `destination` error handler.
-   * @param onComplete Handles completion notification from the subscription. Any errors that occur in
-   * this handler are sent to the `destination` error handler.
-   * @param onFinalize Additional finalization logic here. This will only be called on finalization if the
-   * subscriber itself is not already closed. This is called after all other finalization logic is executed.
-   * @param shouldUnsubscribe An optional check to see if an unsubscribe call should truly unsubscribe.
-   * NOTE: This currently **ONLY** exists to support the strange behavior of {@link groupBy}, where unsubscription
-   * to the resulting observable does not actually disconnect from the source if there are active subscriptions
-   * to any grouped observable. (DO NOT EXPOSE OR USE EXTERNALLY!!!)
-   */
-  constructor(
-    destination: Subscriber<any>,
-    onNext?: (value: T) => void,
-    onComplete?: () => void,
-    onError?: (err: any) => void,
-    private onFinalize?: () => void,
-    private shouldUnsubscribe?: () => boolean
-  ) {
-    // It's important - for performance reasons - that all of this class's
-    // members are initialized and that they are always initialized in the same
-    // order. This will ensure that all OperatorSubscriber instances have the
-    // same hidden class in V8. This, in turn, will help keep the number of
-    // hidden classes involved in property accesses within the base class as
-    // low as possible. If the number of hidden classes involved exceeds four,
-    // the property accesses will become megamorphic and performance penalties
-    // will be incurred - i.e. inline caches won't be used.
-    //
-    // The reasons for ensuring all instances have the same hidden class are
-    // further discussed in this blog post from Benedikt Meurer:
-    // https://benediktmeurer.de/2018/03/23/impact-of-polymorphism-on-component-based-frameworks-like-react/
-    super(destination);
-    this._next = onNext
-      ? function (this: OperatorSubscriber<T>, value: T) {
-          try {
-            onNext(value);
-          } catch (err) {
-            destination.error(err);
-          }
-        }
-      : super._next;
-    this._error = onError
-      ? function (this: OperatorSubscriber<T>, err: any) {
-          try {
-            onError(err);
-          } catch (err) {
-            // Send any errors that occur down stream.
-            destination.error(err);
-          } finally {
-            // Ensure finalization.
-            this.unsubscribe();
-          }
-        }
-      : super._error;
-    this._complete = onComplete
-      ? function (this: OperatorSubscriber<T>) {
-          try {
-            onComplete();
-          } catch (err) {
-            // Send any errors that occur down stream.
-            destination.error(err);
-          } finally {
-            // Ensure finalization.
-            this.unsubscribe();
-          }
-        }
-      : super._complete;
-  }
-
-  unsubscribe() {
-    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
-      const { closed } = this;
-      super.unsubscribe();
-      // Execute additional teardown if we have any and we didn't already do so.
-      !closed && this.onFinalize?.();
-    }
-  }
-}

package/node_modules/rxjs/src/internal/operators/audit.ts

@@ -1,96 +0,0 @@
-import { Subscriber } from '../Subscriber';
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-
-import { operate } from '../util/lift';
-import { innerFrom } from '../observable/innerFrom';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Ignores source values for a duration determined by another Observable, then
- * emits the most recent value from the source Observable, then repeats this
- * process.
- *
- * <span class="informal">It's like {@link auditTime}, but the silencing
- * duration is determined by a second Observable.</span>
- *
- * ![](audit.svg)
- *
- * `audit` is similar to `throttle`, but emits the last value from the silenced
- * time window, instead of the first value. `audit` emits the most recent value
- * from the source Observable on the output Observable as soon as its internal
- * timer becomes disabled, and ignores source values while the timer is enabled.
- * Initially, the timer is disabled. As soon as the first source value arrives,
- * the timer is enabled by calling the `durationSelector` function with the
- * source value, which returns the "duration" Observable. When the duration
- * Observable emits a value, the timer is disabled, then the most
- * recent source value is emitted on the output Observable, and this process
- * repeats for the next source value.
- *
- * ## Example
- *
- * Emit clicks at a rate of at most one click per second
- *
- * ```ts
- * import { fromEvent, audit, interval } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(audit(ev => interval(1000)));
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link auditTime}
- * @see {@link debounce}
- * @see {@link delayWhen}
- * @see {@link sample}
- * @see {@link throttle}
- *
- * @param durationSelector A function
- * that receives a value from the source Observable, for computing the silencing
- * duration, returned as an Observable or a Promise.
- * @return A function that returns an Observable that performs rate-limiting of
- * emissions from the source Observable.
- */
-export function audit<T>(durationSelector: (value: T) => ObservableInput<any>): MonoTypeOperatorFunction<T> {
-  return operate((source, subscriber) => {
-    let hasValue = false;
-    let lastValue: T | null = null;
-    let durationSubscriber: Subscriber<any> | null = null;
-    let isComplete = false;
-
-    const endDuration = () => {
-      durationSubscriber?.unsubscribe();
-      durationSubscriber = null;
-      if (hasValue) {
-        hasValue = false;
-        const value = lastValue!;
-        lastValue = null;
-        subscriber.next(value);
-      }
-      isComplete && subscriber.complete();
-    };
-
-    const cleanupDuration = () => {
-      durationSubscriber = null;
-      isComplete && subscriber.complete();
-    };
-
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => {
-          hasValue = true;
-          lastValue = value;
-          if (!durationSubscriber) {
-            innerFrom(durationSelector(value)).subscribe(
-              (durationSubscriber = createOperatorSubscriber(subscriber, endDuration, cleanupDuration))
-            );
-          }
-        },
-        () => {
-          isComplete = true;
-          (!hasValue || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
-        }
-      )
-    );
-  });
-}