strict-ts-lib-v5.0 0.4.0

package/libs/es2016/array-include/index.d.ts

@@ -0,0 +1,115 @@
+/// <reference no-default-lib="true"/>
+
+interface Array<T> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: T | (import('ts-type-forge').WidenLiteral<T> & {}),
+    fromIndex?: number,
+  ): searchElement is T;
+}
+
+interface ReadonlyArray<T> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: T | (import('ts-type-forge').WidenLiteral<T> & {}),
+    fromIndex?: number,
+  ): searchElement is T;
+}
+
+interface Int8Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Int8,
+    fromIndex?: number,
+  ): boolean;
+}
+
+interface Uint8Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Uint8,
+    fromIndex?: number,
+  ): boolean;
+}
+
+interface Uint8ClampedArray {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Uint8,
+    fromIndex?: number,
+  ): boolean;
+}
+
+interface Int16Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(searchElement: number, fromIndex?: number): boolean;
+}
+
+interface Uint16Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(searchElement: number, fromIndex?: number): boolean;
+}
+
+interface Int32Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(searchElement: number, fromIndex?: number): boolean;
+}
+
+interface Uint32Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(searchElement: number, fromIndex?: number): boolean;
+}
+
+interface Float32Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(searchElement: number, fromIndex?: number): boolean;
+}
+
+interface Float64Array {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(searchElement: number, fromIndex?: number): boolean;
+}

package/libs/es2016/full/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2016" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />

package/libs/es2016/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015" />
+/// <reference lib="es2016.array.include" />

package/libs/es2017/full/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2017" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />

package/libs/es2017/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2016" />
+/// <reference lib="es2017.object" />
+/// <reference lib="es2017.sharedmemory" />
+/// <reference lib="es2017.string" />
+/// <reference lib="es2017.intl" />
+/// <reference lib="es2017.typedarrays" />

package/libs/es2017/intl/index.d.ts

@@ -0,0 +1,28 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  interface DateTimeFormatPartTypesRegistry {
+    readonly day: unknown;
+    readonly dayPeriod: unknown;
+    readonly era: unknown;
+    readonly hour: unknown;
+    readonly literal: unknown;
+    readonly minute: unknown;
+    readonly month: unknown;
+    readonly second: unknown;
+    readonly timeZoneName: unknown;
+    readonly weekday: unknown;
+    readonly year: unknown;
+  }
+
+  type DateTimeFormatPartTypes = keyof DateTimeFormatPartTypesRegistry;
+
+  interface DateTimeFormatPart {
+    readonly type: DateTimeFormatPartTypes;
+    readonly value: string;
+  }
+
+  interface DateTimeFormat {
+    formatToParts(date?: Date | number): DateTimeFormatPart[];
+  }
+}

package/libs/es2017/object/index.d.ts

@@ -0,0 +1,115 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace StrictLibInternals {
+  /**
+   * Opens a union of string literals so that it still accepts — and
+   * completes to — the literals, without rejecting the excess keys a
+   * wider object may carry.
+   *
+   * Adds nothing when `K` already contains `string`: `string | (string & {})`
+   * *is* `string`, so the arm would only leave a confusing artifact in
+   * every type computed from it.
+   *
+   * @internal
+   */
+  type WithOpenString<K> = string extends K ? K : K | (string & {});
+
+  /** @internal */
+  type ToObjectKeys<R extends import('ts-type-forge').UnknownRecord> =
+    WithOpenString<ToStr<keyof R>>;
+
+  /** @internal */
+  type ToStr<A> = A extends string ? A : A extends number ? `${A}` : never;
+
+  /** @internal */
+  type PickByValue<R, V> = Pick<
+    R,
+    {
+      [K in keyof R]: R[K] extends V ? K : never;
+    }[keyof R]
+  >;
+
+  /** @internal */
+  type ToObjectEntries<R extends import('ts-type-forge').UnknownRecord> =
+    R extends R
+      ? (
+          | (string extends ToStr<keyof R>
+              ? never
+              : readonly [
+                  string & {},
+                  import('ts-type-forge').WidenLiteral<
+                    import('ts-type-forge').ValueOf<R>
+                  >,
+                ])
+          | {
+              [K in keyof R]: readonly [
+                ToStr<keyof PickByValue<R, R[K]>>,
+                R[K],
+              ];
+              // eslint-disable-next-line @typescript-eslint/no-restricted-types
+            }[import('ts-type-forge').RelaxedExclude<keyof R, symbol>]
+        )[]
+      : never;
+}
+
+interface ObjectConstructor {
+  /**
+   * Returns an array of values of the enumerable properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  values<T>(o: { readonly [s: string]: T } | ArrayLike<T>): T[];
+
+  /**
+   * Returns an array of values of the enumerable properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  values(o: {}): unknown[];
+
+  /**
+   * Returns an array of key/values of the enumerable properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   *
+   * ```ts
+   * const obj = {
+   *   x: 1,
+   *   y: 2,
+   *   z: 2,
+   *   3: 4,
+   * } as const;
+   *
+   * const entries = Object.entries(obj); // (['3', 4] | ['x', 1] | ['y' | 'z', 2] | [string, unknown])[]
+   * ```
+   *
+   */
+  entries<const R extends import('ts-type-forge').UnknownRecord>(
+    object: R,
+  ): StrictLibInternals.ToObjectEntries<R>;
+
+  /**
+   * Returns an array of key/values of the enumerable own properties of an
+   * object
+   *
+   * @param o Object that contains the properties and methods. This can be an
+   *   object that you created or an existing Document Object Model (DOM)
+   *   object.
+   */
+  entries<T>(
+    o: { readonly [s: string]: T } | ArrayLike<T>,
+  ): (readonly [string, T])[];
+
+  /**
+   * Returns an array of key/values of the enumerable properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  entries(o: {}): (readonly [string, unknown])[];
+
+  /**
+   * Returns an object containing all own property descriptors of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  getOwnPropertyDescriptors<T>(o: T): {
+    [P in keyof T]: TypedPropertyDescriptor<T[P]>;
+  } & {
+    [x: string]: PropertyDescriptor;
+  };
+}

package/libs/es2017/sharedmemory/index.d.ts

@@ -0,0 +1,244 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.symbol" />
+/// <reference lib="es2015.symbol.wellknown" />
+
+interface SharedArrayBuffer {
+  /**
+   * Read-only. The length of the ArrayBuffer (in bytes).
+   */
+  readonly byteLength: number;
+
+  /**
+   * Returns a section of an SharedArrayBuffer.
+   */
+  slice(begin: number, end?: number): SharedArrayBuffer;
+  readonly [Symbol.species]: SharedArrayBuffer;
+  readonly [Symbol.toStringTag]: 'SharedArrayBuffer';
+}
+
+interface SharedArrayBufferConstructor {
+  readonly prototype: SharedArrayBuffer;
+  new (byteLength: number): SharedArrayBuffer;
+}
+declare const SharedArrayBuffer: SharedArrayBufferConstructor;
+
+interface ArrayBufferTypes {
+  readonly SharedArrayBuffer: SharedArrayBuffer;
+}
+
+interface Atomics {
+  /**
+   * Adds a value to the value at the given position in the array, returning the original value.
+   * Until this atomic operation completes, any other read or write operation against the array
+   * will block.
+   */
+  add(
+    typedArray: Int8Array,
+    index: number,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  add(
+    typedArray: Uint8Array,
+    index: number,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  add(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    value: number,
+  ): number;
+
+  /**
+   * Stores the bitwise AND of a value with the value at the given position in the array,
+   * returning the original value. Until this atomic operation completes, any other read or
+   * write operation against the array will block.
+   */
+  and(
+    typedArray: Int8Array,
+    index: number,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  and(
+    typedArray: Uint8Array,
+    index: number,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  and(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    value: number,
+  ): number;
+
+  /**
+   * Replaces the value at the given position in the array if the original value equals the given
+   * expected value, returning the original value. Until this atomic operation completes, any
+   * other read or write operation against the array will block.
+   */
+  compareExchange(
+    typedArray: Int8Array,
+    index: number,
+    expectedValue: import('ts-type-forge').Int8,
+    replacementValue: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  compareExchange(
+    typedArray: Uint8Array,
+    index: number,
+    expectedValue: import('ts-type-forge').Uint8,
+    replacementValue: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  compareExchange(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    expectedValue: number,
+    replacementValue: number,
+  ): number;
+
+  /**
+   * Replaces the value at the given position in the array, returning the original value. Until
+   * this atomic operation completes, any other read or write operation against the array will
+   * block.
+   */
+  exchange(
+    typedArray: Int8Array,
+    index: number,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  exchange(
+    typedArray: Uint8Array,
+    index: number,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  exchange(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    value: number,
+  ): number;
+
+  /**
+   * Returns a value indicating whether high-performance algorithms can use atomic operations
+   * (`true`) or must use locks (`false`) for the given number of bytes-per-element of a typed
+   * array.
+   */
+  isLockFree(size: number): boolean;
+
+  /**
+   * Returns the value at the given position in the array. Until this atomic operation completes,
+   * any other read or write operation against the array will block.
+   */
+  load(typedArray: Int8Array, index: number): import('ts-type-forge').Int8;
+  load(typedArray: Uint8Array, index: number): import('ts-type-forge').Uint8;
+  load(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+  ): number;
+
+  /**
+   * Stores the bitwise OR of a value with the value at the given position in the array,
+   * returning the original value. Until this atomic operation completes, any other read or write
+   * operation against the array will block.
+   */
+  or(
+    typedArray: Int8Array,
+    index: number,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  or(
+    typedArray: Uint8Array,
+    index: number,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  or(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    value: number,
+  ): number;
+
+  /**
+   * Stores a value at the given position in the array, returning the new value. Until this
+   * atomic operation completes, any other read or write operation against the array will block.
+   */
+  store(
+    typedArray: Int8Array,
+    index: number,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  store(
+    typedArray: Uint8Array,
+    index: number,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  store(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    value: number,
+  ): number;
+
+  /**
+   * Subtracts a value from the value at the given position in the array, returning the original
+   * value. Until this atomic operation completes, any other read or write operation against the
+   * array will block.
+   */
+  sub(
+    typedArray: Int8Array,
+    index: number,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  sub(
+    typedArray: Uint8Array,
+    index: number,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  sub(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    value: number,
+  ): number;
+
+  /**
+   * If the value at the given position in the array is equal to the provided value, the current
+   * agent is put to sleep causing execution to suspend until the timeout expires (returning
+   * `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns
+   * `"not-equal"`.
+   */
+  wait(
+    typedArray: Int32Array,
+    index: number,
+    value: number,
+    timeout?: number,
+  ): 'ok' | 'not-equal' | 'timed-out';
+
+  /**
+   * Wakes up sleeping agents that are waiting on the given index of the array, returning the
+   * number of agents that were awoken.
+   * @param typedArray A shared Int32Array.
+   * @param index The position in the typedArray to wake up on.
+   * @param count The number of sleeping agents to notify. Defaults to +Infinity.
+   */
+  notify(typedArray: Int32Array, index: number, count?: number): number;
+
+  /**
+   * Stores the bitwise XOR of a value with the value at the given position in the array,
+   * returning the original value. Until this atomic operation completes, any other read or write
+   * operation against the array will block.
+   */
+  xor(
+    typedArray: Int8Array,
+    index: number,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  xor(
+    typedArray: Uint8Array,
+    index: number,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  xor(
+    typedArray: Int16Array | Uint16Array | Int32Array | Uint32Array,
+    index: number,
+    value: number,
+  ): number;
+
+  readonly [Symbol.toStringTag]: 'Atomics';
+}
+
+declare const Atomics: Atomics;

package/libs/es2017/string/index.d.ts

@@ -0,0 +1,29 @@
+/// <reference no-default-lib="true"/>
+
+interface String {
+  /**
+   * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
+   * The padding is applied from the start (left) of the current string.
+   *
+   * @param maxLength The length of the resulting string once the current string has been padded.
+   *        If this parameter is smaller than the current string's length, the current string will be returned as it is.
+   *
+   * @param fillString The string to pad the current string with.
+   *        If this string is too long, it will be truncated and the left-most part will be applied.
+   *        The default value for this parameter is " " (U+0020).
+   */
+  padStart(maxLength: number, fillString?: string): string;
+
+  /**
+   * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
+   * The padding is applied from the end (right) of the current string.
+   *
+   * @param maxLength The length of the resulting string once the current string has been padded.
+   *        If this parameter is smaller than the current string's length, the current string will be returned as it is.
+   *
+   * @param fillString The string to pad the current string with.
+   *        If this string is too long, it will be truncated and the left-most part will be applied.
+   *        The default value for this parameter is " " (U+0020).
+   */
+  padEnd(maxLength: number, fillString?: string): string;
+}

package/libs/es2017/typedarrays/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference no-default-lib="true"/>
+
+interface Int8ArrayConstructor {
+  new (): Int8Array;
+}
+
+interface Uint8ArrayConstructor {
+  new (): Uint8Array;
+}
+
+interface Uint8ClampedArrayConstructor {
+  new (): Uint8ClampedArray;
+}
+
+interface Int16ArrayConstructor {
+  new (): Int16Array;
+}
+
+interface Uint16ArrayConstructor {
+  new (): Uint16Array;
+}
+
+interface Int32ArrayConstructor {
+  new (): Int32Array;
+}
+
+interface Uint32ArrayConstructor {
+  new (): Uint32Array;
+}
+
+interface Float32ArrayConstructor {
+  new (): Float32Array;
+}
+
+interface Float64ArrayConstructor {
+  new (): Float64Array;
+}

package/libs/es2018/asyncgenerator/index.d.ts

@@ -0,0 +1,69 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2018.asynciterable" />
+
+interface AsyncGenerator<
+  T = unknown,
+  TReturn = any,
+  TNext = unknown,
+> extends AsyncIterator<T, TReturn, TNext> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(
+    ...args: readonly [] | readonly [TNext]
+  ): Promise<IteratorResult<T, TReturn>>;
+  return(
+    value: TReturn | PromiseLike<TReturn>,
+  ): Promise<IteratorResult<T, TReturn>>;
+  throw(e: unknown): Promise<IteratorResult<T, TReturn>>;
+  [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+}
+
+interface AsyncGeneratorFunction {
+  /**
+   * Creates a new AsyncGenerator object.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly unknown[]): AsyncGenerator;
+  /**
+   * Creates a new AsyncGenerator object.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly unknown[]): AsyncGenerator;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: number;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: AsyncGenerator;
+}
+
+interface AsyncGeneratorFunctionConstructor {
+  /**
+   * Creates a new AsyncGenerator function.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly string[]): AsyncGeneratorFunction;
+  /**
+   * Creates a new AsyncGenerator function.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly string[]): AsyncGeneratorFunction;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: number;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: AsyncGeneratorFunction;
+}