strict-ts-lib-v6.0 0.2.0

package/libs/es2023/collection/index.d.ts

@@ -0,0 +1,3 @@
+interface WeakKeyTypes {
+  readonly symbol: symbol;
+}

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

@@ -0,0 +1,6 @@
+/// <reference lib="es2023" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />
+/// <reference lib="dom.asynciterable" />

package/libs/es2023/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference lib="es2022" />
+/// <reference lib="es2023.array" />
+/// <reference lib="es2023.collection" />
+/// <reference lib="es2023.intl" />

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

@@ -0,0 +1,112 @@
+declare namespace Intl {
+  interface NumberFormatOptionsUseGroupingRegistry {
+    readonly min2: never;
+    readonly auto: never;
+    readonly always: never;
+  }
+
+  interface NumberFormatOptionsSignDisplayRegistry {
+    readonly negative: never;
+  }
+
+  interface NumberFormatRangePartTypeRegistry extends NumberFormatPartTypeRegistry {
+    readonly approximatelySign: never;
+  }
+
+  type NumberFormatRangePartTypes = keyof NumberFormatRangePartTypeRegistry;
+
+  interface NumberFormatOptions {
+    readonly roundingPriority?:
+      | 'auto'
+      | 'morePrecision'
+      | 'lessPrecision'
+      | undefined;
+    readonly roundingIncrement?:
+      | 1
+      | 2
+      | 5
+      | 10
+      | 20
+      | 25
+      | 50
+      | 100
+      | 200
+      | 250
+      | 500
+      | 1000
+      | 2000
+      | 2500
+      | 5000
+      | undefined;
+    readonly roundingMode?:
+      | 'ceil'
+      | 'floor'
+      | 'expand'
+      | 'trunc'
+      | 'halfCeil'
+      | 'halfFloor'
+      | 'halfExpand'
+      | 'halfTrunc'
+      | 'halfEven'
+      | undefined;
+    readonly trailingZeroDisplay?: 'auto' | 'stripIfInteger' | undefined;
+  }
+
+  interface ResolvedNumberFormatOptions {
+    readonly roundingPriority: 'auto' | 'morePrecision' | 'lessPrecision';
+    readonly roundingMode:
+      | 'ceil'
+      | 'floor'
+      | 'expand'
+      | 'trunc'
+      | 'halfCeil'
+      | 'halfFloor'
+      | 'halfExpand'
+      | 'halfTrunc'
+      | 'halfEven';
+    readonly roundingIncrement:
+      | 1
+      | 2
+      | 5
+      | 10
+      | 20
+      | 25
+      | 50
+      | 100
+      | 200
+      | 250
+      | 500
+      | 1000
+      | 2000
+      | 2500
+      | 5000;
+    readonly trailingZeroDisplay: 'auto' | 'stripIfInteger';
+  }
+
+  interface NumberRangeFormatPart {
+    readonly type: NumberFormatRangePartTypes;
+    readonly value: string;
+    readonly source: 'startRange' | 'endRange' | 'shared';
+  }
+
+  type StringNumericLiteral =
+    | `${number}`
+    | 'Infinity'
+    | '-Infinity'
+    | '+Infinity';
+
+  interface NumberFormat {
+    format(value: number | bigint | StringNumericLiteral): string;
+    formatToParts(
+      value: number | bigint | StringNumericLiteral,
+    ): NumberFormatPart[];
+    formatRange(
+      start: number | bigint | StringNumericLiteral,
+      end: number | bigint | StringNumericLiteral,
+    ): string;
+    formatRangeToParts(
+      start: number | bigint | StringNumericLiteral,
+      end: number | bigint | StringNumericLiteral,
+    ): NumberRangeFormatPart[];
+  }
+}

package/libs/es2024/arraybuffer/index.d.ts

@@ -0,0 +1,50 @@
+interface ArrayBuffer {
+  /**
+   * If this ArrayBuffer is resizable, returns the maximum byte length given during construction; returns the byte length if not.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/maxByteLength)
+   */
+  get maxByteLength(): number;
+
+  /**
+   * Returns true if this ArrayBuffer can be resized.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/resizable)
+   */
+  get resizable(): boolean;
+
+  /**
+   * Resizes the ArrayBuffer to the specified size (in bytes).
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/resize)
+   */
+  resize(newByteLength?: number): void;
+
+  /**
+   * Returns a boolean indicating whether or not this buffer has been detached (transferred).
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/detached)
+   */
+  get detached(): boolean;
+
+  /**
+   * Creates a new ArrayBuffer with the same byte content as this buffer, then detaches this buffer.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transfer)
+   */
+  transfer(newByteLength?: number): ArrayBuffer;
+
+  /**
+   * Creates a new non-resizable ArrayBuffer with the same byte content as this buffer, then detaches this buffer.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transferToFixedLength)
+   */
+  transferToFixedLength(newByteLength?: number): ArrayBuffer;
+}
+
+interface ArrayBufferConstructor {
+  new (
+    byteLength: number,
+    options?: { readonly maxByteLength?: number },
+  ): ArrayBuffer;
+}

package/libs/es2024/collection/index.d.ts

@@ -0,0 +1,11 @@
+interface MapConstructor {
+  /**
+   * Groups members of an iterable according to the return value of the passed callback.
+   * @param items An iterable.
+   * @param keySelector A callback which will be invoked for each item in items.
+   */
+  groupBy<K, T>(
+    items: Iterable<T>,
+    keySelector: (item: T, index: number) => K,
+  ): Map<K, T[]>;
+}

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

@@ -0,0 +1,6 @@
+/// <reference lib="es2024" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />
+/// <reference lib="dom.asynciterable" />

package/libs/es2024/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference lib="es2023" />
+/// <reference lib="es2024.arraybuffer" />
+/// <reference lib="es2024.collection" />
+/// <reference lib="es2024.object" />
+/// <reference lib="es2024.promise" />
+/// <reference lib="es2024.regexp" />
+/// <reference lib="es2024.sharedmemory" />
+/// <reference lib="es2024.string" />

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

@@ -0,0 +1,11 @@
+interface ObjectConstructor {
+  /**
+   * Groups members of an iterable according to the return value of the passed callback.
+   * @param items An iterable.
+   * @param keySelector A callback which will be invoked for each item in items.
+   */
+  groupBy<K extends PropertyKey, T>(
+    items: Iterable<T>,
+    keySelector: (item: T, index: number) => K,
+  ): Partial<import('ts-type-forge').MutableRecord<K, T[]>>;
+}

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

@@ -0,0 +1,17 @@
+interface PromiseWithResolvers<T> {
+  readonly promise: Promise<T>;
+  readonly resolve: (value: T | PromiseLike<T>) => void;
+  readonly reject: (reason?: unknown) => void;
+}
+
+interface PromiseConstructor {
+  /**
+   * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
+   * @returns An object with the properties `promise`, `resolve`, and `reject`.
+   *
+   * ```ts
+   * const { promise, resolve, reject } = Promise.withResolvers<T>();
+   * ```
+   */
+  withResolvers<T>(): PromiseWithResolvers<T>;
+}

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

@@ -0,0 +1,7 @@
+interface RegExp {
+  /**
+   * Returns a Boolean value indicating the state of the unicodeSets flag (v) used with a regular expression.
+   * Default is false. Read-only.
+   */
+  readonly unicodeSets: boolean;
+}

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

@@ -0,0 +1,67 @@
+/// <reference lib="es2020.bigint" />
+
+interface Atomics {
+  /**
+   * A non-blocking, asynchronous version of wait which is usable on the main thread.
+   * Waits asynchronously on a shared memory location and returns a Promise
+   * @param typedArray A shared Int32Array or BigInt64Array.
+   * @param index The position in the typedArray to wait on.
+   * @param value The expected value to test.
+   * @param [timeout] The expected value to test.
+   */
+  waitAsync(
+    typedArray: Int32Array,
+    index: number,
+    value: number,
+    timeout?: number,
+  ):
+    | { readonly async: false; readonly value: 'not-equal' | 'timed-out' }
+    | { readonly async: true; readonly value: Promise<'ok' | 'timed-out'> };
+
+  /**
+   * A non-blocking, asynchronous version of wait which is usable on the main thread.
+   * Waits asynchronously on a shared memory location and returns a Promise
+   * @param typedArray A shared Int32Array or BigInt64Array.
+   * @param index The position in the typedArray to wait on.
+   * @param value The expected value to test.
+   * @param [timeout] The expected value to test.
+   */
+  waitAsync(
+    typedArray: BigInt64Array,
+    index: number,
+    value: bigint,
+    timeout?: number,
+  ):
+    | { readonly async: false; readonly value: 'not-equal' | 'timed-out' }
+    | { readonly async: true; readonly value: Promise<'ok' | 'timed-out'> };
+}
+
+interface SharedArrayBuffer {
+  /**
+   * Returns true if this SharedArrayBuffer can be grown.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/growable)
+   */
+  get growable(): boolean;
+
+  /**
+   * If this SharedArrayBuffer is growable, returns the maximum byte length given during construction; returns the byte length if not.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/maxByteLength)
+   */
+  get maxByteLength(): number;
+
+  /**
+   * Grows the SharedArrayBuffer to the specified size (in bytes).
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/grow)
+   */
+  grow(newByteLength?: number): void;
+}
+
+interface SharedArrayBufferConstructor {
+  new (
+    byteLength: number,
+    options?: { readonly maxByteLength?: number },
+  ): SharedArrayBuffer;
+}

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

@@ -0,0 +1,11 @@
+interface String {
+  /**
+   * Returns true if all leading surrogates and trailing surrogates appear paired and in order.
+   */
+  isWellFormed(): boolean;
+
+  /**
+   * Returns a string where all lone or out-of-order surrogates have been replaced by the Unicode replacement character (U+FFFD).
+   */
+  toWellFormed(): string;
+}

package/libs/es2025/collection/index.d.ts

@@ -0,0 +1,78 @@
+/// <reference lib="es2024.collection" />
+
+interface ReadonlySetLike<T> {
+  /**
+   * Despite its name, returns an iterator of the values in the set-like.
+   */
+  keys(): Iterator<T>;
+  /**
+   * @returns a boolean indicating whether an element with the specified value exists in the set-like or not.
+   */
+  has(value: T): boolean;
+  /**
+   * @returns the number of (unique) elements in the set-like.
+   */
+  readonly size: number;
+}
+
+interface Set<T> {
+  /**
+   * @returns a new Set containing all the elements in this Set and also all the elements in the argument.
+   */
+  union<U>(other: ReadonlySetLike<U>): ReadonlySet<T | U>;
+  /**
+   * @returns a new Set containing all the elements which are both in this Set and in the argument.
+   */
+  intersection<U>(other: ReadonlySetLike<U>): ReadonlySet<T & U>;
+  /**
+   * @returns a new Set containing all the elements in this Set which are not also in the argument.
+   */
+  difference<U>(other: ReadonlySetLike<U>): ReadonlySet<T>;
+  /**
+   * @returns a new Set containing all the elements which are in either this Set or in the argument, but not in both.
+   */
+  symmetricDifference<U>(other: ReadonlySetLike<U>): ReadonlySet<T | U>;
+  /**
+   * @returns a boolean indicating whether all the elements in this Set are also in the argument.
+   */
+  isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+  /**
+   * @returns a boolean indicating whether all the elements in the argument are also in this Set.
+   */
+  isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+  /**
+   * @returns a boolean indicating whether this Set has no elements in common with the argument.
+   */
+  isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
+}
+
+interface ReadonlySet<T> {
+  /**
+   * @returns a new Set containing all the elements in this Set and also all the elements in the argument.
+   */
+  union<U>(other: ReadonlySetLike<U>): ReadonlySet<T | U>;
+  /**
+   * @returns a new Set containing all the elements which are both in this Set and in the argument.
+   */
+  intersection<U>(other: ReadonlySetLike<U>): ReadonlySet<T & U>;
+  /**
+   * @returns a new Set containing all the elements in this Set which are not also in the argument.
+   */
+  difference<U>(other: ReadonlySetLike<U>): ReadonlySet<T>;
+  /**
+   * @returns a new Set containing all the elements which are in either this Set or in the argument, but not in both.
+   */
+  symmetricDifference<U>(other: ReadonlySetLike<U>): ReadonlySet<T | U>;
+  /**
+   * @returns a boolean indicating whether all the elements in this Set are also in the argument.
+   */
+  isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+  /**
+   * @returns a boolean indicating whether all the elements in the argument are also in this Set.
+   */
+  isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+  /**
+   * @returns a boolean indicating whether this Set has no elements in common with the argument.
+   */
+  isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
+}