strict-ts-lib-v5.7 0.4.0

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

@@ -0,0 +1,248 @@
+/// <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<ArrayBufferLike>,
+    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<ArrayBufferLike>.
+   * @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<ArrayBufferLike>,
+    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<ArrayBuffer>;
+}
+
+interface Uint8ArrayConstructor {
+  new (): Uint8Array<ArrayBuffer>;
+}
+
+interface Uint8ClampedArrayConstructor {
+  new (): Uint8ClampedArray<ArrayBuffer>;
+}
+
+interface Int16ArrayConstructor {
+  new (): Int16Array<ArrayBuffer>;
+}
+
+interface Uint16ArrayConstructor {
+  new (): Uint16Array<ArrayBuffer>;
+}
+
+interface Int32ArrayConstructor {
+  new (): Int32Array<ArrayBuffer>;
+}
+
+interface Uint32ArrayConstructor {
+  new (): Uint32Array<ArrayBuffer>;
+}
+
+interface Float32ArrayConstructor {
+  new (): Float32Array<ArrayBuffer>;
+}
+
+interface Float64ArrayConstructor {
+  new (): Float64Array<ArrayBuffer>;
+}

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 AsyncIteratorObject<T, TReturn, TNext> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(
+    ...[value]: 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;
+}

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

@@ -0,0 +1,49 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.symbol" />
+/// <reference lib="es2015.iterable" />
+
+interface SymbolConstructor {
+  /**
+   * A method that returns the default async iterator for an object. Called by the semantics of
+   * the for-await-of statement.
+   */
+  readonly asyncIterator: unique symbol;
+}
+
+interface AsyncIterator<T, TReturn = any, TNext = unknown> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(
+    ...[value]: readonly [] | readonly [TNext]
+  ): Promise<IteratorResult<T, TReturn>>;
+  return?(
+    value?: TReturn | PromiseLike<TReturn>,
+  ): Promise<IteratorResult<T, TReturn>>;
+  throw?(e?: unknown): Promise<IteratorResult<T, TReturn>>;
+}
+
+interface AsyncIterable<T, TReturn = any, TNext = unknown> {
+  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>;
+}
+
+/**
+ * Describes a user-defined {@link AsyncIterator} that is also async iterable.
+ */
+interface AsyncIterableIterator<
+  T,
+  TReturn = any,
+  TNext = unknown,
+> extends AsyncIterator<T, TReturn, TNext> {
+  [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
+}
+
+/**
+ * Describes an {@link AsyncIterator} produced by the runtime that inherits from the intrinsic `AsyncIterator.prototype`.
+ */
+interface AsyncIteratorObject<
+  T,
+  TReturn = any,
+  TNext = unknown,
+> extends AsyncIterator<T, TReturn, TNext> {
+  [Symbol.asyncIterator](): AsyncIteratorObject<T, TReturn, TNext>;
+}

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

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

package/libs/es2018/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2017" />
+/// <reference lib="es2018.asynciterable" />
+/// <reference lib="es2018.asyncgenerator" />
+/// <reference lib="es2018.promise" />
+/// <reference lib="es2018.regexp" />
+/// <reference lib="es2018.intl" />

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

@@ -0,0 +1,92 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  // http://cldr.unicode.org/index/cldr-spec/plural-rules#TOC-Determining-Plural-Categories
+  type LDMLPluralRule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+  type PluralRuleType = 'cardinal' | 'ordinal';
+
+  interface PluralRulesOptions {
+    readonly localeMatcher?: 'lookup' | 'best fit' | undefined;
+    readonly type?: PluralRuleType | undefined;
+    readonly minimumIntegerDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+    readonly minimumFractionDigits?:
+      | import('ts-type-forge').UintRange<0, 21>
+      | undefined;
+    readonly maximumFractionDigits?:
+      | import('ts-type-forge').UintRange<0, 21>
+      | undefined;
+    readonly minimumSignificantDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+    readonly maximumSignificantDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+  }
+
+  interface ResolvedPluralRulesOptions {
+    readonly locale: string;
+    readonly pluralCategories: readonly LDMLPluralRule[];
+    readonly type: PluralRuleType;
+    readonly minimumIntegerDigits: import('ts-type-forge').UintRange<1, 22>;
+    readonly minimumFractionDigits: import('ts-type-forge').UintRange<0, 21>;
+    readonly maximumFractionDigits: import('ts-type-forge').UintRange<0, 21>;
+    readonly minimumSignificantDigits?: import('ts-type-forge').UintRange<
+      1,
+      22
+    >;
+    readonly maximumSignificantDigits?: import('ts-type-forge').UintRange<
+      1,
+      22
+    >;
+  }
+
+  interface PluralRules {
+    resolvedOptions(): ResolvedPluralRulesOptions;
+    select(n: number): LDMLPluralRule;
+  }
+
+  interface PluralRulesConstructor {
+    new (
+      locales?: string | readonly string[],
+      options?: PluralRulesOptions,
+    ): PluralRules;
+    (
+      locales?: string | readonly string[],
+      options?: PluralRulesOptions,
+    ): PluralRules;
+    supportedLocalesOf(
+      locales: string | readonly string[],
+      options?: { readonly localeMatcher?: 'lookup' | 'best fit' },
+    ): string[];
+  }
+
+  const PluralRules: PluralRulesConstructor;
+
+  interface NumberFormatPartTypeRegistry {
+    readonly literal: never;
+    readonly nan: never;
+    readonly infinity: never;
+    readonly percent: never;
+    readonly integer: never;
+    readonly group: never;
+    readonly decimal: never;
+    readonly fraction: never;
+    readonly plusSign: never;
+    readonly minusSign: never;
+    readonly percentSign: never;
+    readonly currency: never;
+  }
+
+  type NumberFormatPartTypes = keyof NumberFormatPartTypeRegistry;
+
+  interface NumberFormatPart {
+    readonly type: NumberFormatPartTypes;
+    readonly value: string;
+  }
+
+  interface NumberFormat {
+    formatToParts(number?: number | bigint): NumberFormatPart[];
+  }
+}

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

@@ -0,0 +1,14 @@
+/// <reference no-default-lib="true"/>
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}

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

@@ -0,0 +1,21 @@
+/// <reference no-default-lib="true"/>
+
+interface RegExpMatchArray {
+  readonly groups?: {
+    readonly [key: string]: string;
+  };
+}
+
+interface RegExpExecArray {
+  readonly groups?: {
+    readonly [key: string]: string;
+  };
+}
+
+interface RegExp {
+  /**
+   * Returns a Boolean value indicating the state of the dotAll flag (s) used with a regular expression.
+   * Default is false. Read-only.
+   */
+  readonly dotAll: boolean;
+}

package/libs/es2019/array/index.d.ts

@@ -0,0 +1,94 @@
+/// <reference no-default-lib="true"/>
+
+type FlatArray<Arr, Depth extends number> = {
+  readonly done: Arr;
+  readonly recur: Arr extends ReadonlyArray<infer InnerArr>
+    ? FlatArray<
+        InnerArr,
+        (readonly [
+          -1,
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17,
+          18,
+          19,
+          20,
+        ])[Depth]
+      >
+    : Arr;
+}[Depth extends -1 ? 'done' : 'recur'];
+
+interface ReadonlyArray<T> {
+  /**
+   * Calls a defined callback function on each element of an array. Then, flattens the result into
+   * a new array.
+   * This is identical to a map followed by flat with depth 1.
+   *
+   * @param callback A function that accepts up to three arguments. The flatMap method calls the
+   * callback function one time for each element in the array.
+   * @param thisArg An object to which the this keyword can refer in the callback function. If
+   * thisArg is omitted, undefined is used as the this value.
+   */
+  flatMap<U, This = undefined>(
+    callback: (
+      this: This,
+      value: T,
+      index: number,
+      array: readonly T[],
+    ) => U | ReadonlyArray<U>,
+    thisArg?: This,
+  ): U[];
+
+  /**
+   * Returns a new array with all sub-array elements concatenated into it recursively up to the
+   * specified depth.
+   *
+   * @param depth The maximum recursion depth
+   */
+  flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
+}
+
+interface Array<T> {
+  /**
+   * Calls a defined callback function on each element of an array. Then, flattens the result into
+   * a new array.
+   * This is identical to a map followed by flat with depth 1.
+   *
+   * @param callback A function that accepts up to three arguments. The flatMap method calls the
+   * callback function one time for each element in the array.
+   * @param thisArg An object to which the this keyword can refer in the callback function. If
+   * thisArg is omitted, undefined is used as the this value.
+   */
+  flatMap<U, This = undefined>(
+    callback: (
+      this: This,
+      value: T,
+      index: number,
+      array: readonly T[],
+    ) => U | ReadonlyArray<U>,
+    thisArg?: This,
+  ): U[];
+
+  /**
+   * Returns a new array with all sub-array elements concatenated into it recursively up to the
+   * specified depth.
+   *
+   * @param depth The maximum recursion depth
+   */
+  flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
+}

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

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