lambda-live-debugger 1.12.2 → 1.12.4

package/node_modules/rxjs/src/internal/types.ts

@@ -1,371 +0,0 @@
-// https://github.com/microsoft/TypeScript/issues/40462#issuecomment-689879308
-/// <reference lib="esnext.asynciterable" />
-
-import { Observable } from './Observable';
-import { Subscription } from './Subscription';
-
-/**
- * Note: This will add Symbol.observable globally for all TypeScript users,
- * however, we are no longer polyfilling Symbol.observable
- */
-declare global {
-  interface SymbolConstructor {
-    readonly observable: symbol;
-  }
-}
-
-/* OPERATOR INTERFACES */
-
-/**
- * A function type interface that describes a function that accepts one parameter `T`
- * and returns another parameter `R`.
- *
- * Usually used to describe {@link OperatorFunction} - it always takes a single
- * parameter (the source Observable) and returns another Observable.
- */
-export interface UnaryFunction<T, R> {
-  (source: T): R;
-}
-
-export interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {}
-
-export type FactoryOrValue<T> = T | (() => T);
-
-/**
- * A function type interface that describes a function that accepts and returns a parameter of the same type.
- *
- * Used to describe {@link OperatorFunction} with the only one type: `OperatorFunction<T, T>`.
- *
- */
-export interface MonoTypeOperatorFunction<T> extends OperatorFunction<T, T> {}
-
-/**
- * A value and the time at which it was emitted.
- *
- * Emitted by the `timestamp` operator
- *
- * @see {@link timestamp}
- */
-export interface Timestamp<T> {
-  value: T;
-  /**
-   * The timestamp. By default, this is in epoch milliseconds.
-   * Could vary based on the timestamp provider passed to the operator.
-   */
-  timestamp: number;
-}
-
-/**
- * A value emitted and the amount of time since the last value was emitted.
- *
- * Emitted by the `timeInterval` operator.
- *
- * @see {@link timeInterval}
- */
-export interface TimeInterval<T> {
-  value: T;
-
-  /**
-   * The amount of time between this value's emission and the previous value's emission.
-   * If this is the first emitted value, then it will be the amount of time since subscription
-   * started.
-   */
-  interval: number;
-}
-
-/* SUBSCRIPTION INTERFACES */
-
-export interface Unsubscribable {
-  unsubscribe(): void;
-}
-
-export type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;
-
-export interface SubscriptionLike extends Unsubscribable {
-  unsubscribe(): void;
-  readonly closed: boolean;
-}
-
-/**
- * @deprecated Do not use. Most likely you want to use `ObservableInput`. Will be removed in v8.
- */
-export type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>;
-
-/** OBSERVABLE INTERFACES */
-
-export interface Subscribable<T> {
-  subscribe(observer: Partial<Observer<T>>): Unsubscribable;
-}
-
-/**
- * Valid types that can be converted to observables.
- */
-export type ObservableInput<T> =
-  | Observable<T>
-  | InteropObservable<T>
-  | AsyncIterable<T>
-  | PromiseLike<T>
-  | ArrayLike<T>
-  | Iterable<T>
-  | ReadableStreamLike<T>;
-
-/**
- * @deprecated Renamed to {@link InteropObservable }. Will be removed in v8.
- */
-export type ObservableLike<T> = InteropObservable<T>;
-
-/**
- * An object that implements the `Symbol.observable` interface.
- */
-export interface InteropObservable<T> {
-  [Symbol.observable]: () => Subscribable<T>;
-}
-
-/* NOTIFICATIONS */
-
-/**
- * A notification representing a "next" from an observable.
- * Can be used with {@link dematerialize}.
- */
-export interface NextNotification<T> {
-  /** The kind of notification. Always "N" */
-  kind: 'N';
-  /** The value of the notification. */
-  value: T;
-}
-
-/**
- * A notification representing an "error" from an observable.
- * Can be used with {@link dematerialize}.
- */
-export interface ErrorNotification {
-  /** The kind of notification. Always "E" */
-  kind: 'E';
-  error: any;
-}
-
-/**
- * A notification representing a "completion" from an observable.
- * Can be used with {@link dematerialize}.
- */
-export interface CompleteNotification {
-  kind: 'C';
-}
-
-/**
- * Valid observable notification types.
- */
-export type ObservableNotification<T> = NextNotification<T> | ErrorNotification | CompleteNotification;
-
-/* OBSERVER INTERFACES */
-
-export interface NextObserver<T> {
-  closed?: boolean;
-  next: (value: T) => void;
-  error?: (err: any) => void;
-  complete?: () => void;
-}
-
-export interface ErrorObserver<T> {
-  closed?: boolean;
-  next?: (value: T) => void;
-  error: (err: any) => void;
-  complete?: () => void;
-}
-
-export interface CompletionObserver<T> {
-  closed?: boolean;
-  next?: (value: T) => void;
-  error?: (err: any) => void;
-  complete: () => void;
-}
-
-export type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>;
-
-/**
- * An object interface that defines a set of callback functions a user can use to get
- * notified of any set of {@link Observable}
- * {@link guide/glossary-and-semantics#notification notification} events.
- *
- * For more info, please refer to {@link guide/observer this guide}.
- */
-export interface Observer<T> {
-  /**
-   * A callback function that gets called by the producer during the subscription when
-   * the producer "has" the `value`. It won't be called if `error` or `complete` callback
-   * functions have been called, nor after the consumer has unsubscribed.
-   *
-   * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
-   */
-  next: (value: T) => void;
-  /**
-   * A callback function that gets called by the producer if and when it encountered a
-   * problem of any kind. The errored value will be provided through the `err` parameter.
-   * This callback can't be called more than one time, it can't be called if the
-   * `complete` callback function have been called previously, nor it can't be called if
-   * the consumer has unsubscribed.
-   *
-   * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
-   */
-  error: (err: any) => void;
-  /**
-   * A callback function that gets called by the producer if and when it has no more
-   * values to provide (by calling `next` callback function). This means that no error
-   * has happened. This callback can't be called more than one time, it can't be called
-   * if the `error` callback function have been called previously, nor it can't be called
-   * if the consumer has unsubscribed.
-   *
-   * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
-   */
-  complete: () => void;
-}
-
-export interface SubjectLike<T> extends Observer<T>, Subscribable<T> {}
-
-/* SCHEDULER INTERFACES */
-
-export interface SchedulerLike extends TimestampProvider {
-  schedule<T>(work: (this: SchedulerAction<T>, state: T) => void, delay: number, state: T): Subscription;
-  schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay: number, state?: T): Subscription;
-  schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
-}
-
-export interface SchedulerAction<T> extends Subscription {
-  schedule(state?: T, delay?: number): Subscription;
-}
-
-/**
- * This is a type that provides a method to allow RxJS to create a numeric timestamp
- */
-export interface TimestampProvider {
-  /**
-   * Returns a timestamp as a number.
-   *
-   * This is used by types like `ReplaySubject` or operators like `timestamp` to calculate
-   * the amount of time passed between events.
-   */
-  now(): number;
-}
-
-/**
- * Extracts the type from an `ObservableInput<any>`. If you have
- * `O extends ObservableInput<any>` and you pass in `Observable<number>`, or
- * `Promise<number>`, etc, it will type as `number`.
- */
-export type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never;
-
-/**
- * Extracts a union of element types from an `ObservableInput<any>[]`.
- * If you have `O extends ObservableInput<any>[]` and you pass in
- * `Observable<string>[]` or `Promise<string>[]` you would get
- * back a type of `string`.
- * If you pass in `[Observable<string>, Observable<number>]` you would
- * get back a type of `string | number`.
- */
-export type ObservedValueUnionFromArray<X> = X extends Array<ObservableInput<infer T>> ? T : never;
-
-/**
- * @deprecated Renamed to {@link ObservedValueUnionFromArray}. Will be removed in v8.
- */
-export type ObservedValuesFromArray<X> = ObservedValueUnionFromArray<X>;
-
-/**
- * Extracts a tuple of element types from an `ObservableInput<any>[]`.
- * If you have `O extends ObservableInput<any>[]` and you pass in
- * `[Observable<string>, Observable<number>]` you would get back a type
- * of `[string, number]`.
- */
-export type ObservedValueTupleFromArray<X> = { [K in keyof X]: ObservedValueOf<X[K]> };
-
-/**
- * Used to infer types from arguments to functions like {@link forkJoin}.
- * So that you can have `forkJoin([Observable<A>, PromiseLike<B>]): Observable<[A, B]>`
- * et al.
- */
-export type ObservableInputTuple<T> = {
-  [K in keyof T]: ObservableInput<T[K]>;
-};
-
-/**
- * Constructs a new tuple with the specified type at the head.
- * If you declare `Cons<A, [B, C]>` you will get back `[A, B, C]`.
- */
-export type Cons<X, Y extends readonly any[]> = ((arg: X, ...rest: Y) => any) extends (...args: infer U) => any ? U : never;
-
-/**
- * Extracts the head of a tuple.
- * If you declare `Head<[A, B, C]>` you will get back `A`.
- */
-export type Head<X extends readonly any[]> = ((...args: X) => any) extends (arg: infer U, ...rest: any[]) => any ? U : never;
-
-/**
- * Extracts the tail of a tuple.
- * If you declare `Tail<[A, B, C]>` you will get back `[B, C]`.
- */
-export type Tail<X extends readonly any[]> = ((...args: X) => any) extends (arg: any, ...rest: infer U) => any ? U : never;
-
-/**
- * Extracts the generic value from an Array type.
- * If you have `T extends Array<any>`, and pass a `string[]` to it,
- * `ValueFromArray<T>` will return the actual type of `string`.
- */
-export type ValueFromArray<A extends readonly unknown[]> = A extends Array<infer T> ? T : never;
-
-/**
- * Gets the value type from an {@link ObservableNotification}, if possible.
- */
-export type ValueFromNotification<T> = T extends { kind: 'N' | 'E' | 'C' }
-  ? T extends NextNotification<any>
-    ? T extends { value: infer V }
-      ? V
-      : undefined
-    : never
-  : never;
-
-/**
- * A simple type to represent a gamut of "falsy" values... with a notable exception:
- * `NaN` is "falsy" however, it is not and cannot be typed via TypeScript. See
- * comments here: https://github.com/microsoft/TypeScript/issues/28682#issuecomment-707142417
- */
-export type Falsy = null | undefined | false | 0 | -0 | 0n | '';
-
-export type TruthyTypesOf<T> = T extends Falsy ? never : T;
-
-// We shouldn't rely on this type definition being available globally yet since it's
-// not necessarily available in every TS environment.
-interface ReadableStreamDefaultReaderLike<T> {
-  // HACK: As of TS 4.2.2, The provided types for the iterator results of a `ReadableStreamDefaultReader`
-  // are significantly different enough from `IteratorResult` as to cause compilation errors.
-  // The type at the time is `ReadableStreamDefaultReadResult`.
-  read(): PromiseLike<
-    | {
-        done: false;
-        value: T;
-      }
-    | { done: true; value?: undefined }
-  >;
-  releaseLock(): void;
-}
-
-/**
- * The base signature RxJS will look for to identify and use
- * a [ReadableStream](https://streams.spec.whatwg.org/#rs-class)
- * as an {@link ObservableInput} source.
- */
-export interface ReadableStreamLike<T> {
-  getReader(): ReadableStreamDefaultReaderLike<T>;
-}
-
-/**
- * An observable with a `connect` method that is used to create a subscription
- * to an underlying source, connecting it with all consumers via a multicast.
- */
-export interface Connectable<T> extends Observable<T> {
-  /**
-   * (Idempotent) Calling this method will connect the underlying source observable to all subscribed consumers
-   * through an underlying {@link Subject}.
-   * @returns A subscription, that when unsubscribed, will "disconnect" the source from the connector subject,
-   * severing notifications to all consumers.
-   */
-  connect(): Subscription;
-}

package/node_modules/rxjs/src/internal/umd.ts

@@ -1,26 +0,0 @@
-/*
-  NOTE: This is the global export file for rxjs v6 and higher.
- */
-
-/* rxjs */
-export * from '../index';
-
-/* rxjs.operators */
-import * as _operators from '../operators/index';
-export const operators = _operators;
-
-/* rxjs.testing */
-import * as _testing from '../testing/index';
-export const testing = _testing;
-
-/* rxjs.ajax */
-import * as _ajax from '../ajax/index';
-export const ajax = _ajax;
-
-/* rxjs.webSocket */
-import * as _webSocket from '../webSocket/index';
-export const webSocket = _webSocket;
-
-/* rxjs.fetch */
-import * as _fetch from '../fetch/index';
-export const fetch = _fetch;

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

@@ -1,28 +0,0 @@
-import { createErrorClass } from './createErrorClass';
-
-export interface ArgumentOutOfRangeError extends Error {}
-
-export interface ArgumentOutOfRangeErrorCtor {
-  /**
-   * @deprecated Internal implementation detail. Do not construct error instances.
-   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-   */
-  new (): ArgumentOutOfRangeError;
-}
-
-/**
- * An error thrown when an element was queried at a certain index of an
- * Observable, but no such index or position exists in that sequence.
- *
- * @see {@link elementAt}
- * @see {@link take}
- * @see {@link takeLast}
- */
-export const ArgumentOutOfRangeError: ArgumentOutOfRangeErrorCtor = createErrorClass(
-  (_super) =>
-    function ArgumentOutOfRangeErrorImpl(this: any) {
-      _super(this);
-      this.name = 'ArgumentOutOfRangeError';
-      this.message = 'argument out of range';
-    }
-);

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

@@ -1,30 +0,0 @@
-import { createErrorClass } from './createErrorClass';
-
-export interface EmptyError extends Error {}
-
-export interface EmptyErrorCtor {
-  /**
-   * @deprecated Internal implementation detail. Do not construct error instances.
-   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-   */
-  new (): EmptyError;
-}
-
-/**
- * An error thrown when an Observable or a sequence was queried but has no
- * elements.
- *
- * @see {@link first}
- * @see {@link last}
- * @see {@link single}
- * @see {@link firstValueFrom}
- * @see {@link lastValueFrom}
- */
-export const EmptyError: EmptyErrorCtor = createErrorClass(
-  (_super) =>
-    function EmptyErrorImpl(this: any) {
-      _super(this);
-      this.name = 'EmptyError';
-      this.message = 'no elements in sequence';
-    }
-);

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

@@ -1,45 +0,0 @@
-let nextHandle = 1;
-// The promise needs to be created lazily otherwise it won't be patched by Zones
-let resolved: Promise<any>;
-const activeHandles: { [key: number]: any } = {};
-
-/**
- * Finds the handle in the list of active handles, and removes it.
- * Returns `true` if found, `false` otherwise. Used both to clear
- * Immediate scheduled tasks, and to identify if a task should be scheduled.
- */
-function findAndClearHandle(handle: number): boolean {
-  if (handle in activeHandles) {
-    delete activeHandles[handle];
-    return true;
-  }
-  return false;
-}
-
-/**
- * Helper functions to schedule and unschedule microtasks.
- */
-export const Immediate = {
-  setImmediate(cb: () => void): number {
-    const handle = nextHandle++;
-    activeHandles[handle] = true;
-    if (!resolved) {
-      resolved = Promise.resolve();
-    }
-    resolved.then(() => findAndClearHandle(handle) && cb());
-    return handle;
-  },
-
-  clearImmediate(handle: number): void {
-    findAndClearHandle(handle);
-  },
-};
-
-/**
- * Used for internal testing purposes only. Do not export from library.
- */
-export const TestTools = {
-  pending() {
-    return Object.keys(activeHandles).length;
-  }
-};

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

@@ -1,26 +0,0 @@
-import { createErrorClass } from './createErrorClass';
-
-export interface NotFoundError extends Error {}
-
-export interface NotFoundErrorCtor {
-  /**
-   * @deprecated Internal implementation detail. Do not construct error instances.
-   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-   */
-  new (message: string): NotFoundError;
-}
-
-/**
- * An error thrown when a value or values are missing from an
- * observable sequence.
- *
- * @see {@link operators/single}
- */
-export const NotFoundError: NotFoundErrorCtor = createErrorClass(
-  (_super) =>
-    function NotFoundErrorImpl(this: any, message: string) {
-      _super(this);
-      this.name = 'NotFoundError';
-      this.message = message;
-    }
-);

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

@@ -1,29 +0,0 @@
-import { createErrorClass } from './createErrorClass';
-
-export interface ObjectUnsubscribedError extends Error {}
-
-export interface ObjectUnsubscribedErrorCtor {
-  /**
-   * @deprecated Internal implementation detail. Do not construct error instances.
-   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-   */
-  new (): ObjectUnsubscribedError;
-}
-
-/**
- * An error thrown when an action is invalid because the object has been
- * unsubscribed.
- *
- * @see {@link Subject}
- * @see {@link BehaviorSubject}
- *
- * @class ObjectUnsubscribedError
- */
-export const ObjectUnsubscribedError: ObjectUnsubscribedErrorCtor = createErrorClass(
-  (_super) =>
-    function ObjectUnsubscribedErrorImpl(this: any) {
-      _super(this);
-      this.name = 'ObjectUnsubscribedError';
-      this.message = 'object unsubscribed';
-    }
-);

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

@@ -1,26 +0,0 @@
-import { createErrorClass } from './createErrorClass';
-
-export interface SequenceError extends Error {}
-
-export interface SequenceErrorCtor {
-  /**
-   * @deprecated Internal implementation detail. Do not construct error instances.
-   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-   */
-  new (message: string): SequenceError;
-}
-
-/**
- * An error thrown when something is wrong with the sequence of
- * values arriving on the observable.
- *
- * @see {@link operators/single}
- */
-export const SequenceError: SequenceErrorCtor = createErrorClass(
-  (_super) =>
-    function SequenceErrorImpl(this: any, message: string) {
-      _super(this);
-      this.name = 'SequenceError';
-      this.message = message;
-    }
-);

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

@@ -1,30 +0,0 @@
-import { createErrorClass } from './createErrorClass';
-
-export interface UnsubscriptionError extends Error {
-  readonly errors: any[];
-}
-
-export interface UnsubscriptionErrorCtor {
-  /**
-   * @deprecated Internal implementation detail. Do not construct error instances.
-   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-   */
-  new (errors: any[]): UnsubscriptionError;
-}
-
-/**
- * An error thrown when one or more errors have occurred during the
- * `unsubscribe` of a {@link Subscription}.
- */
-export const UnsubscriptionError: UnsubscriptionErrorCtor = createErrorClass(
-  (_super) =>
-    function UnsubscriptionErrorImpl(this: any, errors: (Error | string)[]) {
-      _super(this);
-      this.message = errors
-        ? `${errors.length} errors occurred during unsubscription:
-${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}`
-        : '';
-      this.name = 'UnsubscriptionError';
-      this.errors = errors;
-    }
-);

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

@@ -1,10 +0,0 @@
-export function applyMixins(derivedCtor: any, baseCtors: any[]) {
-  for (let i = 0, len = baseCtors.length; i < len; i++) {
-    const baseCtor = baseCtors[i];
-    const propertyKeys = Object.getOwnPropertyNames(baseCtor.prototype);
-    for (let j = 0, len2 = propertyKeys.length; j < len2; j++) {
-      const name = propertyKeys[j];
-      derivedCtor.prototype[name] = baseCtor.prototype[name];
-    }
-  }
-}

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

@@ -1,19 +0,0 @@
-import { SchedulerLike } from '../types';
-import { isFunction } from './isFunction';
-import { isScheduler } from './isScheduler';
-
-function last<T>(arr: T[]): T | undefined {
-  return arr[arr.length - 1];
-}
-
-export function popResultSelector(args: any[]): ((...args: unknown[]) => unknown) | undefined {
-  return isFunction(last(args)) ? args.pop() : undefined;
-}
-
-export function popScheduler(args: any[]): SchedulerLike | undefined {
-  return isScheduler(last(args)) ? args.pop() : undefined;
-}
-
-export function popNumber(args: any[], defaultValue: number): number {
-  return typeof last(args) === 'number' ? args.pop()! : defaultValue;
-}

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

@@ -1,30 +0,0 @@
-const { isArray } = Array;
-const { getPrototypeOf, prototype: objectProto, keys: getKeys } = Object;
-
-/**
- * Used in functions where either a list of arguments, a single array of arguments, or a
- * dictionary of arguments can be returned. Returns an object with an `args` property with
- * the arguments in an array, if it is a dictionary, it will also return the `keys` in another
- * property.
- */
-export function argsArgArrayOrObject<T, O extends Record<string, T>>(args: T[] | [O] | [T[]]): { args: T[]; keys: string[] | null } {
-  if (args.length === 1) {
-    const first = args[0];
-    if (isArray(first)) {
-      return { args: first, keys: null };
-    }
-    if (isPOJO(first)) {
-      const keys = getKeys(first);
-      return {
-        args: keys.map((key) => first[key]),
-        keys,
-      };
-    }
-  }
-
-  return { args: args as T[], keys: null };
-}
-
-function isPOJO(obj: any): obj is object {
-  return obj && typeof obj === 'object' && getPrototypeOf(obj) === objectProto;
-}

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

@@ -1,9 +0,0 @@
-const { isArray } = Array;
-
-/**
- * Used in operators and functions that accept either a list of arguments, or an array of arguments
- * as a single argument.
- */
-export function argsOrArgArray<T>(args: (T | T[])[]): T[] {
-  return args.length === 1 && isArray(args[0]) ? args[0] : (args as T[]);
-}