strict-ts-lib-v5.7 0.4.0

package/libs/es2015/symbol-wellknown/index.d.ts

@@ -0,0 +1,331 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.symbol" />
+
+interface SymbolConstructor {
+  /**
+   * A method that determines if a constructor object recognizes an object as one of the
+   * constructor’s instances. Called by the semantics of the instanceof operator.
+   */
+  readonly hasInstance: unique symbol;
+
+  /**
+   * A Boolean value that if true indicates that an object should flatten to its array elements
+   * by Array.prototype.concat.
+   */
+  readonly isConcatSpreadable: unique symbol;
+
+  /**
+   * A regular expression method that matches the regular expression against a string. Called
+   * by the String.prototype.match method.
+   */
+  readonly match: unique symbol;
+
+  /**
+   * A regular expression method that replaces matched substrings of a string. Called by the
+   * String.prototype.replace method.
+   */
+  readonly replace: unique symbol;
+
+  /**
+   * A regular expression method that returns the index within a string that matches the
+   * regular expression. Called by the String.prototype.search method.
+   */
+  readonly search: unique symbol;
+
+  /**
+   * A function valued property that is the constructor function that is used to create
+   * derived objects.
+   */
+  readonly species: unique symbol;
+
+  /**
+   * A regular expression method that splits a string at the indices that match the regular
+   * expression. Called by the String.prototype.split method.
+   */
+  readonly split: unique symbol;
+
+  /**
+   * A method that converts an object to a corresponding primitive value.
+   * Called by the ToPrimitive abstract operation.
+   */
+  readonly toPrimitive: unique symbol;
+
+  /**
+   * A String value that is used in the creation of the default string description of an object.
+   * Called by the built-in method Object.prototype.toString.
+   */
+  readonly toStringTag: unique symbol;
+
+  /**
+   * An Object whose truthy properties are properties that are excluded from the 'with'
+   * environment bindings of the associated objects.
+   */
+  readonly unscopables: unique symbol;
+}
+
+interface Symbol {
+  /**
+   * Converts a Symbol object to a symbol.
+   */
+  [Symbol.toPrimitive](hint: string): symbol;
+
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface Array<T> {
+  /**
+   * Is an object whose properties have the value 'true'
+   * when they will be absent when used in a 'with' statement.
+   */
+  readonly [Symbol.unscopables]: {
+    readonly [K in keyof (readonly any[])]?: boolean;
+  };
+}
+
+interface ReadonlyArray<T> {
+  /**
+   * Is an object whose properties have the value 'true'
+   * when they will be absent when used in a 'with' statement.
+   */
+  readonly [Symbol.unscopables]: {
+    readonly [K in keyof (readonly any[])]?: boolean;
+  };
+}
+
+interface Date {
+  /**
+   * Converts a Date object to a string.
+   */
+  [Symbol.toPrimitive](hint: 'default'): string;
+  /**
+   * Converts a Date object to a string.
+   */
+  [Symbol.toPrimitive](hint: 'string'): string;
+  /**
+   * Converts a Date object to a number.
+   */
+  [Symbol.toPrimitive](hint: 'number'): number;
+  /**
+   * Converts a Date object to a string or number.
+   *
+   * @param hint The strings "number", "string", or "default" to specify what primitive to return.
+   *
+   * @throws {TypeError} If 'hint' was given something other than "number", "string", or "default".
+   * @returns A number if 'hint' was "number", a string if 'hint' was "string" or "default".
+   */
+  [Symbol.toPrimitive](hint: string): string | number;
+}
+
+interface Map<K, V> {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface WeakMap<K extends WeakKey, V> {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface Set<T> {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface WeakSet<T extends WeakKey> {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface JSON {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface Function {
+  /**
+   * Determines whether the given value inherits from this function if this function was used
+   * as a constructor function.
+   *
+   * A constructor function can control which objects are recognized as its instances by
+   * 'instanceof' by overriding this method.
+   */
+  [Symbol.hasInstance](value: unknown): boolean;
+}
+
+interface GeneratorFunction {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface Math {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface Promise<T> {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface PromiseConstructor {
+  readonly [Symbol.species]: PromiseConstructor;
+}
+
+interface RegExp {
+  /**
+   * Matches a string with this regular expression, and returns an array containing the results of
+   * that search.
+   * @param string A string to search within.
+   */
+  [Symbol.match](string: string): RegExpMatchArray | null;
+
+  /**
+   * Replaces text in a string, using this regular expression.
+   * @param string A String object or string literal whose contents matching against
+   *               this regular expression will be replaced
+   * @param replaceValue A String object or string literal containing the text to replace for every
+   *                     successful match of this regular expression.
+   */
+  [Symbol.replace](string: string, replaceValue: string): string;
+
+  /**
+   * Replaces text in a string, using this regular expression.
+   * @param string A String object or string literal whose contents matching against
+   *               this regular expression will be replaced
+   * @param replacer A function that returns the replacement text.
+   */
+  [Symbol.replace](
+    string: string,
+    replacer: (substring: string, ...args: readonly unknown[]) => string,
+  ): string;
+
+  /**
+   * Finds the position beginning first substring match in a regular expression search
+   * using this regular expression.
+   *
+   * @param string The string to search within.
+   */
+  [Symbol.search](string: string): number;
+
+  /**
+   * Returns an array of substrings that were delimited by strings in the original input that
+   * match against this regular expression.
+   *
+   * If the regular expression contains capturing parentheses, then each time this
+   * regular expression matches, the results (including any undefined results) of the
+   * capturing parentheses are spliced.
+   *
+   * @param string string value to split
+   * @param limit if not undefined, the output array is truncated so that it contains no more
+   * than 'limit' elements.
+   */
+  [Symbol.split](string: string, limit?: number): string[];
+}
+
+interface RegExpConstructor {
+  readonly [Symbol.species]: RegExpConstructor;
+}
+
+interface String {
+  /**
+   * Matches a string or an object that supports being matched against, and returns an array
+   * containing the results of that search, or null if no matches are found.
+   * @param matcher An object that supports being matched against.
+   */
+  match(matcher: {
+    [Symbol.match](string: string): RegExpMatchArray | null;
+  }): RegExpMatchArray | null;
+
+  /**
+   * Passes a string and {@linkcode replaceValue} to the `[Symbol.replace]` method on {@linkcode searchValue}. This method is expected to implement its own replacement algorithm.
+   * @param searchValue An object that supports searching for and replacing matches within a string.
+   * @param replaceValue The replacement text.
+   */
+  replace(
+    searchValue: {
+      [Symbol.replace](string: string, replaceValue: string): string;
+    },
+    replaceValue: string,
+  ): string;
+
+  /**
+   * Replaces text in a string, using an object that supports replacement within a string.
+   * @param searchValue A object can search for and replace matches within a string.
+   * @param replacer A function that returns the replacement text.
+   */
+  replace(
+    searchValue: {
+      [Symbol.replace](
+        string: string,
+        replacer: (substring: string, ...args: readonly unknown[]) => string,
+      ): string;
+    },
+    replacer: (substring: string, ...args: readonly unknown[]) => string,
+  ): string;
+
+  /**
+   * Finds the first substring match in a regular expression search.
+   * @param searcher An object which supports searching within a string.
+   */
+  search(searcher: { [Symbol.search](string: string): number }): number;
+
+  /**
+   * Split a string into substrings using the specified separator and return them as an array.
+   * @param splitter An object that can split a string.
+   * @param limit A value used to limit the number of elements returned in the array.
+   */
+  split(
+    splitter: { [Symbol.split](string: string, limit?: number): string[] },
+    limit?: number,
+  ): string[];
+}
+
+interface ArrayBuffer {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface DataView<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: string;
+}
+
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Int8Array';
+}
+
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Uint8Array';
+}
+
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Uint8ClampedArray';
+}
+
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Int16Array';
+}
+
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Uint16Array';
+}
+
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Int32Array';
+}
+
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Uint32Array';
+}
+
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Float32Array';
+}
+
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
+  readonly [Symbol.toStringTag]: 'Float64Array';
+}
+
+interface ArrayConstructor {
+  readonly [Symbol.species]: ArrayConstructor;
+}
+interface MapConstructor {
+  readonly [Symbol.species]: MapConstructor;
+}
+interface SetConstructor {
+  readonly [Symbol.species]: SetConstructor;
+}
+interface ArrayBufferConstructor {
+  readonly [Symbol.species]: ArrayBufferConstructor;
+}

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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * 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,5 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015" />
+/// <reference lib="es2016.array.include" />
+/// <reference lib="es2016.intl" />

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

@@ -0,0 +1,15 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  /**
+   * The `Intl.getCanonicalLocales()` method returns an array containing
+   * the canonical locale names. Duplicates will be omitted and elements
+   * will be validated as structurally valid language tags.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales)
+   *
+   * @param locale A list of String values for which to get the canonical locale names
+   * @returns An array containing the canonical and validated locale names.
+   */
+  function getCanonicalLocales(locale?: string | readonly string[]): string[];
+}

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

@@ -0,0 +1,5 @@
+/// <reference no-default-lib="true"/>
+
+interface ArrayBufferConstructor {
+  new (): ArrayBuffer;
+}

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

@@ -0,0 +1,23 @@
+/// <reference no-default-lib="true"/>
+
+interface DateConstructor {
+  /**
+   * Returns the number of milliseconds between midnight, January 1, 1970 Universal Coordinated Time (UTC) (or GMT) and the specified date.
+   * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then year is assumed to be 1900 + year.
+   * @param monthIndex The month as a number between 0 and 11 (January to December).
+   * @param date The date as a number between 1 and 31.
+   * @param hours Must be supplied if minutes is supplied. A number from 0 to 23 (midnight to 11pm) that specifies the hour.
+   * @param minutes Must be supplied if seconds is supplied. A number from 0 to 59 that specifies the minutes.
+   * @param seconds Must be supplied if milliseconds is supplied. A number from 0 to 59 that specifies the seconds.
+   * @param ms A number from 0 to 999 that specifies the milliseconds.
+   */
+  UTC(
+    year: number,
+    monthIndex?: import('ts-type-forge').MonthIndexEnum,
+    date?: import('ts-type-forge').DateEnum,
+    hours?: import('ts-type-forge').HoursEnum,
+    minutes?: import('ts-type-forge').MinutesEnum,
+    seconds?: import('ts-type-forge').SecondsEnum,
+    ms?: import('ts-type-forge').MillisecondsEnum,
+  ): number;
+}

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,10 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2016" />
+/// <reference lib="es2017.arraybuffer" />
+/// <reference lib="es2017.date" />
+/// <reference lib="es2017.intl" />
+/// <reference lib="es2017.object" />
+/// <reference lib="es2017.sharedmemory" />
+/// <reference lib="es2017.string" />
+/// <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 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.
+   */
+  values<T>(o: { readonly [s: string]: T } | ArrayLike<T>): T[];
+
+  /**
+   * Returns an array of 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.
+   */
+  values(o: {}): unknown[];
+
+  /**
+   * 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.
+   *
+   * ```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 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(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;
+  };
+}