strict-ts-lib-v5.6-branded 0.4.0

package/libs/es2015/generator/index.d.ts

@@ -0,0 +1,65 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.iterable" />
+
+interface Generator<
+  T = unknown,
+  TReturn = any,
+  TNext = unknown,
+> extends IteratorObject<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]): IteratorResult<T, TReturn>;
+  return(value: TReturn): IteratorResult<T, TReturn>;
+  throw(e: unknown): IteratorResult<T, TReturn>;
+  [Symbol.iterator](): Generator<T, TReturn, TNext>;
+}
+
+interface GeneratorFunction {
+  /**
+   * Creates a new Generator object.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly unknown[]): Generator;
+  /**
+   * Creates a new Generator object.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly unknown[]): Generator;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: NumberType.ArraySize;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: Generator;
+}
+
+interface GeneratorFunctionConstructor {
+  /**
+   * Creates a new Generator function.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly string[]): GeneratorFunction;
+  /**
+   * Creates a new Generator function.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly string[]): GeneratorFunction;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: NumberType.ArraySize;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: GeneratorFunction;
+}

package/libs/es2015/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es5" />
+/// <reference lib="es2015.core" />
+/// <reference lib="es2015.collection" />
+/// <reference lib="es2015.iterable" />
+/// <reference lib="es2015.generator" />
+/// <reference lib="es2015.promise" />
+/// <reference lib="es2015.proxy" />
+/// <reference lib="es2015.reflect" />
+/// <reference lib="es2015.symbol" />
+/// <reference lib="es2015.symbol.wellknown" />

package/libs/es2015/iterable/index.d.ts

@@ -0,0 +1,625 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.symbol" />
+
+interface SymbolConstructor {
+  /**
+   * A method that returns the default iterator for an object. Called by the semantics of the
+   * for-of statement.
+   */
+  readonly iterator: unique symbol;
+}
+
+interface IteratorYieldResult<TYield> {
+  readonly done?: false;
+  readonly value: TYield;
+}
+
+interface IteratorReturnResult<TReturn> {
+  readonly done: true;
+  readonly value: TReturn;
+}
+
+type IteratorResult<T, TReturn = any> =
+  | IteratorYieldResult<T>
+  | IteratorReturnResult<TReturn>;
+
+interface Iterator<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]: [] | [TNext]): IteratorResult<T, TReturn>;
+  return?(value?: TReturn): IteratorResult<T, TReturn>;
+  throw?(e?: unknown): IteratorResult<T, TReturn>;
+}
+
+interface Iterable<T, TReturn = any, TNext = unknown> {
+  [Symbol.iterator](): Iterator<T, TReturn, TNext>;
+}
+
+/**
+ * Describes a user-defined {@link Iterator} that is also iterable.
+ */
+interface IterableIterator<T, TReturn = any, TNext = unknown> extends Iterator<
+  T,
+  TReturn,
+  TNext
+> {
+  [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
+}
+
+/**
+ * Describes an {@link Iterator} produced by the runtime that inherits from the intrinsic `Iterator.prototype`.
+ */
+interface IteratorObject<T, TReturn = any, TNext = unknown> extends Iterator<
+  T,
+  TReturn,
+  TNext
+> {
+  [Symbol.iterator](): IteratorObject<T, TReturn, TNext>;
+}
+
+/**
+ * Defines the `TReturn` type used for built-in iterators produced by `Array`, `Map`, `Set`, and others.
+ * This is `undefined` when `strictBuiltInIteratorReturn` is `true`; otherwise, this is `any`.
+ */
+type BuiltinIteratorReturn = intrinsic;
+
+interface ArrayIterator<T> extends IteratorObject<
+  T,
+  BuiltinIteratorReturn,
+  unknown
+> {
+  [Symbol.iterator](): ArrayIterator<T>;
+}
+
+interface Array<T> {
+  /** Iterator */
+  [Symbol.iterator](): ArrayIterator<T>;
+
+  /**
+   * Returns an iterable of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<readonly [NumberType.ArraySize, T]>;
+
+  /**
+   * Returns an iterable of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.ArraySize>;
+
+  /**
+   * Returns an iterable of values in the array
+   */
+  values(): ArrayIterator<T>;
+}
+
+interface ArrayConstructor {
+  /**
+   * Creates an array from an iterable object.
+   * @param iterable An iterable object to convert to an array.
+   */
+  from<T>(iterable: Iterable<T> | ArrayLike<T>): readonly T[];
+
+  /**
+   * Creates an array from an iterable object.
+   * @param iterable An iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T, U>(
+    iterable: Iterable<T> | ArrayLike<T>,
+    mapfn: (v: T, k: NumberType.ArraySize) => U,
+    thisArg?: unknown,
+  ): readonly U[];
+}
+
+interface ReadonlyArray<T> {
+  /** Iterator of values in the array. */
+  [Symbol.iterator](): ArrayIterator<T>;
+
+  /**
+   * Returns an iterable of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<readonly [NumberType.ArraySize, T]>;
+
+  /**
+   * Returns an iterable of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.ArraySize>;
+
+  /**
+   * Returns an iterable of values in the array
+   */
+  values(): ArrayIterator<T>;
+}
+
+interface IArguments {
+  /** Iterator */
+  [Symbol.iterator](): ArrayIterator<unknown>;
+}
+
+interface MapIterator<T> extends IteratorObject<
+  T,
+  BuiltinIteratorReturn,
+  unknown
+> {
+  [Symbol.iterator](): MapIterator<T>;
+}
+
+interface Map<K, V> {
+  /** Returns an iterable of entries in the map. */
+  [Symbol.iterator](): MapIterator<readonly [K, V]>;
+
+  /**
+   * Returns an iterable of key, value pairs for every entry in the map.
+   */
+  entries(): MapIterator<readonly [K, V]>;
+
+  /**
+   * Returns an iterable of keys in the map
+   */
+  keys(): MapIterator<K>;
+
+  /**
+   * Returns an iterable of values in the map
+   */
+  values(): MapIterator<V>;
+}
+
+interface ReadonlyMap<K, V> {
+  /** Returns an iterable of entries in the map. */
+  [Symbol.iterator](): MapIterator<readonly [K, V]>;
+
+  /**
+   * Returns an iterable of key, value pairs for every entry in the map.
+   */
+  entries(): MapIterator<readonly [K, V]>;
+
+  /**
+   * Returns an iterable of keys in the map
+   */
+  keys(): MapIterator<K>;
+
+  /**
+   * Returns an iterable of values in the map
+   */
+  values(): MapIterator<V>;
+}
+
+interface MapConstructor {
+  new (): Map<never, never>;
+  new <K, V>(iterable?: Iterable<readonly [K, V]>): Map<K, V>;
+}
+
+interface WeakMap<K extends WeakKey, V> {}
+
+interface WeakMapConstructor {
+  new <K extends WeakKey, V>(
+    iterable: Iterable<readonly [K, V]>,
+  ): WeakMap<K, V>;
+}
+
+interface SetIterator<T> extends IteratorObject<
+  T,
+  BuiltinIteratorReturn,
+  unknown
+> {
+  [Symbol.iterator](): SetIterator<T>;
+}
+
+interface Set<T> {
+  /** Iterates over values in the set. */
+  [Symbol.iterator](): SetIterator<T>;
+  /**
+   * Returns an iterable of [v,v] pairs for every value `v` in the set.
+   */
+  entries(): SetIterator<readonly [T, T]>;
+  /**
+   * Despite its name, returns an iterable of the values in the set.
+   */
+  keys(): SetIterator<T>;
+
+  /**
+   * Returns an iterable of values in the set.
+   */
+  values(): SetIterator<T>;
+}
+
+interface ReadonlySet<T> {
+  /** Iterates over values in the set. */
+  [Symbol.iterator](): SetIterator<T>;
+
+  /**
+   * Returns an iterable of [v,v] pairs for every value `v` in the set.
+   */
+  entries(): SetIterator<readonly [T, T]>;
+
+  /**
+   * Despite its name, returns an iterable of the values in the set.
+   */
+  keys(): SetIterator<T>;
+
+  /**
+   * Returns an iterable of values in the set.
+   */
+  values(): SetIterator<T>;
+}
+
+interface SetConstructor {
+  new (): Set<never>;
+  new <T>(iterable?: Iterable<T>): Set<T>;
+}
+
+interface WeakSet<T extends WeakKey> {}
+
+interface WeakSetConstructor {
+  new <T extends WeakKey = WeakKey>(iterable: Iterable<T>): WeakSet<T>;
+}
+
+interface Promise<T> {}
+
+interface PromiseConstructor {
+  /**
+   * Creates a Promise that is resolved with an array of results when all of the provided Promises
+   * resolve, or rejected when any Promise is rejected.
+   * @param values An iterable of Promises.
+   * @returns A new Promise.
+   */
+  all<T>(values: Iterable<T | PromiseLike<T>>): Promise<readonly Awaited<T>[]>;
+
+  /**
+   * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+   * or rejected.
+   * @param values An iterable of Promises.
+   * @returns A new Promise.
+   */
+  race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+}
+
+interface StringIterator<T> extends IteratorObject<
+  T,
+  BuiltinIteratorReturn,
+  unknown
+> {
+  [Symbol.iterator](): StringIterator<T>;
+}
+
+interface String {
+  /** Iterator */
+  [Symbol.iterator](): StringIterator<string>;
+}
+
+interface Int8Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Int8>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Int8]
+  >;
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Int8>;
+}
+
+interface Int8ArrayConstructor {
+  new (elements: Iterable<number>): Int8Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Int8,
+    thisArg?: unknown,
+  ): Int8Array;
+}
+
+interface Uint8Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Uint8>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Uint8]
+  >;
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Uint8>;
+}
+
+interface Uint8ArrayConstructor {
+  new (elements: Iterable<number>): Uint8Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Uint8,
+    thisArg?: unknown,
+  ): Uint8Array;
+}
+
+interface Uint8ClampedArray {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Uint8>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Uint8]
+  >;
+
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Uint8>;
+}
+
+interface Uint8ClampedArrayConstructor {
+  new (elements: Iterable<number>): Uint8ClampedArray;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Uint8,
+    thisArg?: unknown,
+  ): Uint8ClampedArray;
+}
+
+interface Int16Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Int16>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Int16]
+  >;
+
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Int16>;
+}
+
+interface Int16ArrayConstructor {
+  new (elements: Iterable<number>): Int16Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Int16,
+    thisArg?: unknown,
+  ): Int16Array;
+}
+
+interface Uint16Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Uint16>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Uint16]
+  >;
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Uint16>;
+}
+
+interface Uint16ArrayConstructor {
+  new (elements: Iterable<number>): Uint16Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Uint16,
+    thisArg?: unknown,
+  ): Uint16Array;
+}
+
+interface Int32Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Int32>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Int32]
+  >;
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Int32>;
+}
+
+interface Int32ArrayConstructor {
+  new (elements: Iterable<number>): Int32Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Int32,
+    thisArg?: unknown,
+  ): Int32Array;
+}
+
+interface Uint32Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Uint32>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Uint32]
+  >;
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Uint32>;
+}
+
+interface Uint32ArrayConstructor {
+  new (elements: Iterable<number>): Uint32Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Uint32,
+    thisArg?: unknown,
+  ): Uint32Array;
+}
+
+interface Float32Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Float32>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Float32]
+  >;
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Float32>;
+}
+
+interface Float32ArrayConstructor {
+  new (elements: Iterable<number>): Float32Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Float32,
+    thisArg?: unknown,
+  ): Float32Array;
+}
+
+interface Float64Array {
+  [Symbol.iterator](): ArrayIterator<import('ts-type-forge').Float64>;
+  /**
+   * Returns an array of key, value pairs for every entry in the array
+   */
+  entries(): ArrayIterator<
+    readonly [NumberType.TypedArraySize, import('ts-type-forge').Float64]
+  >;
+  /**
+   * Returns an list of keys in the array
+   */
+  keys(): ArrayIterator<NumberType.TypedArraySize>;
+  /**
+   * Returns an list of values in the array
+   */
+  values(): ArrayIterator<import('ts-type-forge').Float64>;
+}
+
+interface Float64ArrayConstructor {
+  new (elements: Iterable<number>): Float64Array;
+
+  /**
+   * Creates an array from an array-like or iterable object.
+   * @param arrayLike An array-like or iterable object to convert to an array.
+   * @param mapfn A mapping function to call on every element of the array.
+   * @param thisArg Value of 'this' used to invoke the mapfn.
+   */
+  from<T extends number>(
+    arrayLike: Iterable<T>,
+    mapfn?: (
+      v: T,
+      k: NumberType.TypedArraySize,
+    ) => import('ts-type-forge').Float64,
+    thisArg?: unknown,
+  ): Float64Array;
+}