strict-ts-lib-v5.0 0.4.0

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

@@ -0,0 +1,21 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.iterable" />
+/// <reference lib="es2015.symbol" />
+
+interface SymbolConstructor {
+  /**
+   * A regular expression method that matches the regular expression against a string. Called
+   * by the String.prototype.matchAll method.
+   */
+  readonly matchAll: unique symbol;
+}
+
+interface RegExp {
+  /**
+   * Matches a string with this regular expression, and returns an iterable of matches
+   * containing the results of that search.
+   * @param string A string to search within.
+   */
+  [Symbol.matchAll](str: string): IterableIterator<RegExpMatchArray>;
+}

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

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

package/libs/es2021/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2020" />
+/// <reference lib="es2021.promise" />
+/// <reference lib="es2021.string" />
+/// <reference lib="es2021.weakref" />
+/// <reference lib="es2021.intl" />

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

@@ -0,0 +1,164 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  interface DateTimeFormatPartTypesRegistry {
+    readonly fractionalSecond: unknown;
+  }
+
+  interface DateTimeFormatOptions {
+    readonly formatMatcher?: 'basic' | 'best fit' | 'best fit' | undefined;
+    readonly dateStyle?: 'full' | 'long' | 'medium' | 'short' | undefined;
+    readonly timeStyle?: 'full' | 'long' | 'medium' | 'short' | undefined;
+    readonly dayPeriod?: 'narrow' | 'short' | 'long' | undefined;
+    readonly fractionalSecondDigits?: 1 | 2 | 3 | undefined;
+  }
+
+  interface DateTimeRangeFormatPart extends DateTimeFormatPart {
+    readonly source: 'startRange' | 'endRange' | 'shared';
+  }
+
+  interface DateTimeFormat {
+    formatRange(
+      startDate: Date | number | bigint,
+      endDate: Date | number | bigint,
+    ): string;
+    formatRangeToParts(
+      startDate: Date | number | bigint,
+      endDate: Date | number | bigint,
+    ): DateTimeRangeFormatPart[];
+  }
+
+  interface ResolvedDateTimeFormatOptions {
+    readonly formatMatcher?: 'basic' | 'best fit' | 'best fit';
+    readonly dateStyle?: 'full' | 'long' | 'medium' | 'short';
+    readonly timeStyle?: 'full' | 'long' | 'medium' | 'short';
+    readonly hourCycle?: 'h11' | 'h12' | 'h23' | 'h24';
+    readonly dayPeriod?: 'narrow' | 'short' | 'long';
+    readonly fractionalSecondDigits?: 1 | 2 | 3;
+  }
+
+  /**
+   * The locale matching algorithm to use.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+   */
+  type ListFormatLocaleMatcher = 'lookup' | 'best fit';
+
+  /**
+   * The format of output message.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+   */
+  type ListFormatType = 'conjunction' | 'disjunction' | 'unit';
+
+  /**
+   * The length of the formatted message.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+   */
+  type ListFormatStyle = 'long' | 'short' | 'narrow';
+
+  /**
+   * An object with some or all properties of the `Intl.ListFormat` constructor `options` parameter.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+   */
+  interface ListFormatOptions {
+    /** The locale matching algorithm to use. For information about this option, see [Intl page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation). */
+    readonly localeMatcher?: ListFormatLocaleMatcher | undefined;
+    /** The format of output message. */
+    readonly type?: ListFormatType | undefined;
+    /** The length of the internationalized message. */
+    readonly style?: ListFormatStyle | undefined;
+  }
+
+  interface ResolvedListFormatOptions {
+    readonly locale: string;
+    readonly style: ListFormatStyle;
+    readonly type: ListFormatType;
+  }
+
+  interface ListFormat {
+    /**
+     * Returns a string with a language-specific representation of the list.
+     *
+     * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
+     *
+     * @throws `TypeError` if `list` includes something other than the possible values.
+     *
+     * @returns {string} A language-specific formatted string representing the elements of the list.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/format).
+     */
+    format(list: Iterable<string>): string;
+
+    /**
+     * Returns an Array of objects representing the different components that can be used to format a list of values in a locale-aware fashion.
+     *
+     * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array), to be formatted according to a locale.
+     *
+     * @throws `TypeError` if `list` includes something other than the possible values.
+     *
+     * @returns {{ type: "element" | "literal", value: string; }[]} An Array of components which contains the formatted parts from the list.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/formatToParts).
+     */
+    formatToParts(
+      list: Iterable<string>,
+    ): { type: 'element' | 'literal'; value: string }[];
+
+    /**
+     * Returns a new object with properties reflecting the locale and style
+     * formatting options computed during the construction of the current
+     * `Intl.ListFormat` object.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/resolvedOptions).
+     */
+    resolvedOptions(): ResolvedListFormatOptions;
+  }
+
+  const ListFormat: {
+    readonly prototype: ListFormat;
+
+    /**
+     * Creates [Intl.ListFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) objects that
+     * enable language-sensitive list formatting.
+     *
+     * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+     *  For the general form and interpretation of the `locales` argument,
+     *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+     *
+     * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters)
+     *  with some or all options of `ListFormatOptions`.
+     *
+     * @returns [Intl.ListFormatOptions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) object.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat).
+     */
+    new (
+      locales?: BCP47LanguageTag | readonly BCP47LanguageTag[],
+      options?: ListFormatOptions,
+    ): ListFormat;
+
+    /**
+     * Returns an array containing those of the provided locales that are
+     * supported in list formatting without having to fall back to the runtime's default locale.
+     *
+     * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+     *  For the general form and interpretation of the `locales` argument,
+     *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+     *
+     * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf#parameters).
+     *  with some or all possible options.
+     *
+     * @returns An array of strings representing a subset of the given locale tags that are supported in list
+     *  formatting without having to fall back to the runtime's default locale.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf).
+     */
+    supportedLocalesOf(
+      locales: BCP47LanguageTag | readonly BCP47LanguageTag[],
+      options?: Pick<ListFormatOptions, 'localeMatcher'>,
+    ): BCP47LanguageTag[];
+  };
+}

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

@@ -0,0 +1,34 @@
+/// <reference no-default-lib="true"/>
+
+interface AggregateError extends Error {
+  readonly errors: readonly unknown[];
+}
+
+interface AggregateErrorConstructor {
+  new (errors: Iterable<unknown>, message?: string): AggregateError;
+  (errors: Iterable<unknown>, message?: string): AggregateError;
+  readonly prototype: AggregateError;
+}
+
+declare const AggregateError: AggregateErrorConstructor;
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface PromiseConstructor {
+  /**
+   * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
+   * @param values An array or iterable of Promises.
+   * @returns A new Promise.
+   */
+  any<T extends readonly unknown[] | readonly []>(
+    values: T,
+  ): Promise<Awaited<T[number]>>;
+
+  /**
+   * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
+   * @param values An array or iterable of Promises.
+   * @returns A new Promise.
+   */
+  any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+}

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

@@ -0,0 +1,20 @@
+/// <reference no-default-lib="true"/>
+
+interface String {
+  /**
+   * Replace all instances of a substring in a string, using a regular expression or search string.
+   * @param searchValue A string to search for.
+   * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
+   */
+  replaceAll(searchValue: string | RegExp, replaceValue: string): string;
+
+  /**
+   * Replace all instances of a substring in a string, using a regular expression or search string.
+   * @param searchValue A string to search for.
+   * @param replacer A function that returns the replacement text.
+   */
+  replaceAll(
+    searchValue: string | RegExp,
+    replacer: (substring: string, ...args: readonly unknown[]) => string,
+  ): string;
+}

package/libs/es2021/weakref/index.d.ts

@@ -0,0 +1,57 @@
+/// <reference no-default-lib="true"/>
+
+interface WeakRef<T extends object> {
+  readonly [Symbol.toStringTag]: 'WeakRef';
+
+  /**
+   * Returns the WeakRef instance's target object, or undefined if the target object has been
+   * reclaimed.
+   */
+  deref(): T | undefined;
+}
+
+interface WeakRefConstructor {
+  readonly prototype: WeakRef<object>;
+
+  /**
+   * Creates a WeakRef instance for the given target object.
+   * @param target The target object for the WeakRef instance.
+   */
+  new <T extends object>(target: T): WeakRef<T>;
+}
+
+declare const WeakRef: WeakRefConstructor;
+
+interface FinalizationRegistry<T> {
+  readonly [Symbol.toStringTag]: 'FinalizationRegistry';
+
+  /**
+   * Registers an object with the registry.
+   * @param target The target object to register.
+   * @param heldValue The value to pass to the finalizer for this object. This cannot be the
+   * target object.
+   * @param unregisterToken The token to pass to the unregister method to unregister the target
+   * object. If provided (and not undefined), this must be an object. If not provided, the target
+   * cannot be unregistered.
+   */
+  register(target: object, heldValue: T, unregisterToken?: object): void;
+
+  /**
+   * Unregisters an object from the registry.
+   * @param unregisterToken The token that was used as the unregisterToken argument when calling
+   * register to register the target object.
+   */
+  unregister(unregisterToken: object): void;
+}
+
+interface FinalizationRegistryConstructor {
+  readonly prototype: FinalizationRegistry<unknown>;
+
+  /**
+   * Creates a finalization registry with an associated cleanup callback
+   * @param cleanupCallback The callback to call after an object in the registry has been reclaimed.
+   */
+  new <T>(cleanupCallback: (heldValue: T) => void): FinalizationRegistry<T>;
+}
+
+declare const FinalizationRegistry: FinalizationRegistryConstructor;

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

@@ -0,0 +1,105 @@
+/// <reference no-default-lib="true"/>
+
+interface Array<T> {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): T | undefined;
+}
+
+interface ReadonlyArray<T> {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): T | undefined;
+}
+
+interface Int8Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): import('ts-type-forge').Int8 | undefined;
+}
+
+interface Uint8Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): import('ts-type-forge').Uint8 | undefined;
+}
+
+interface Uint8ClampedArray {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): import('ts-type-forge').Uint8 | undefined;
+}
+
+interface Int16Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): number | undefined;
+}
+
+interface Uint16Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): number | undefined;
+}
+
+interface Int32Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): number | undefined;
+}
+
+interface Uint32Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): number | undefined;
+}
+
+interface Float32Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): number | undefined;
+}
+
+interface Float64Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): number | undefined;
+}
+
+interface BigInt64Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): bigint | undefined;
+}
+
+interface BigUint64Array {
+  /**
+   * Returns the item located at the specified index.
+   * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+   */
+  at(index: number): bigint | undefined;
+}

package/libs/es2022/error/index.d.ts

@@ -0,0 +1,57 @@
+/// <reference no-default-lib="true"/>
+
+interface ErrorOptions {
+  readonly cause?: unknown;
+}
+
+interface Error {
+  readonly cause?: unknown;
+}
+
+interface ErrorConstructor {
+  new (message?: string, options?: ErrorOptions): Error;
+  (message?: string, options?: ErrorOptions): Error;
+}
+
+interface EvalErrorConstructor {
+  new (message?: string, options?: ErrorOptions): EvalError;
+  (message?: string, options?: ErrorOptions): EvalError;
+}
+
+interface RangeErrorConstructor {
+  new (message?: string, options?: ErrorOptions): RangeError;
+  (message?: string, options?: ErrorOptions): RangeError;
+}
+
+interface ReferenceErrorConstructor {
+  new (message?: string, options?: ErrorOptions): ReferenceError;
+  (message?: string, options?: ErrorOptions): ReferenceError;
+}
+
+interface SyntaxErrorConstructor {
+  new (message?: string, options?: ErrorOptions): SyntaxError;
+  (message?: string, options?: ErrorOptions): SyntaxError;
+}
+
+interface TypeErrorConstructor {
+  new (message?: string, options?: ErrorOptions): TypeError;
+  (message?: string, options?: ErrorOptions): TypeError;
+}
+
+interface URIErrorConstructor {
+  new (message?: string, options?: ErrorOptions): URIError;
+  (message?: string, options?: ErrorOptions): URIError;
+}
+
+interface AggregateErrorConstructor {
+  new (
+    errors: Iterable<unknown>,
+    message?: string,
+    options?: ErrorOptions,
+  ): AggregateError;
+  (
+    errors: Iterable<unknown>,
+    message?: string,
+    options?: ErrorOptions,
+  ): AggregateError;
+}

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

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

package/libs/es2022/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2021" />
+/// <reference lib="es2022.array" />
+/// <reference lib="es2022.error" />
+/// <reference lib="es2022.intl" />
+/// <reference lib="es2022.object" />
+/// <reference lib="es2022.sharedmemory" />
+/// <reference lib="es2022.string" />
+/// <reference lib="es2022.regexp" />

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

@@ -0,0 +1,98 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  /**
+   * An object with some or all properties of the `Intl.Segmenter` constructor `options` parameter.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/Segmenter#parameters)
+   */
+  interface SegmenterOptions {
+    /** The locale matching algorithm to use. For information about this option, see [Intl page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation). */
+    readonly localeMatcher?: 'best fit' | 'lookup' | undefined;
+    /** The type of input to be split */
+    readonly granularity?: 'grapheme' | 'word' | 'sentence' | undefined;
+  }
+
+  interface Segmenter {
+    /**
+     * Returns `Segments` object containing the segments of the input string, using the segmenter's locale and granularity.
+     *
+     * @param input - The text to be segmented as a `string`.
+     *
+     * @returns A new iterable Segments object containing the segments of the input string, using the segmenter's locale and granularity.
+     */
+    segment(input: string): Segments;
+    resolvedOptions(): ResolvedSegmenterOptions;
+  }
+
+  interface ResolvedSegmenterOptions {
+    readonly locale: string;
+    readonly granularity: 'grapheme' | 'word' | 'sentence';
+  }
+
+  interface Segments {
+    /**
+     * Returns an object describing the segment in the original string that includes the code unit at a specified index.
+     *
+     * @param codeUnitIndex - A number specifying the index of the code unit in the original input string. If the value is omitted, it defaults to `0`.
+     */
+    containing(codeUnitIndex?: number): SegmentData;
+
+    /** Returns an iterator to iterate over the segments. */
+    [Symbol.iterator](): IterableIterator<SegmentData>;
+  }
+
+  interface SegmentData {
+    /** A string containing the segment extracted from the original input string. */
+    readonly segment: string;
+    /** The code unit index in the original input string at which the segment begins. */
+    readonly index: number;
+    /** The complete input string that was segmented. */
+    readonly input: string;
+    /**
+     * A boolean value only if granularity is "word"; otherwise, undefined.
+     * If granularity is "word", then isWordLike is true when the segment is word-like (i.e., consists of letters/numbers/ideographs/etc.); otherwise, false.
+     */
+    readonly isWordLike?: boolean;
+  }
+
+  const Segmenter: {
+    readonly prototype: Segmenter;
+
+    /**
+     * Creates a new `Intl.Segmenter` object.
+     *
+     * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+     *  For the general form and interpretation of the `locales` argument,
+     *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+     *
+     * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/Segmenter#parameters)
+     *  with some or all options of `SegmenterOptions`.
+     *
+     * @returns [Intl.Segmenter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segments) object.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter).
+     */
+    new (
+      locales?: BCP47LanguageTag | readonly BCP47LanguageTag[],
+      options?: SegmenterOptions,
+    ): Segmenter;
+
+    /**
+     * Returns an array containing those of the provided locales that are supported without having to fall back to the runtime's default locale.
+     *
+     * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+     *  For the general form and interpretation of the `locales` argument,
+     *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+     *
+     * @param options An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/supportedLocalesOf#parameters).
+     *  with some or all possible options.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/supportedLocalesOf)
+     */
+    supportedLocalesOf(
+      locales: BCP47LanguageTag | readonly BCP47LanguageTag[],
+      options?: Pick<SegmenterOptions, 'localeMatcher'>,
+    ): BCP47LanguageTag[];
+  };
+}

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

@@ -0,0 +1,41 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="es5" />
+
+/**
+ * @internal
+ * R が union 型（要素数1の場合も含む）のとき、 union の要素の中に K をキーとして含むものが一つでもあれば、
+ * union 型を K をキーとして含むもののみに絞った型を返す。
+ * union の要素の中に K をキーとして含むものが一つも無ければ、`MutableRecord<K, unknown>` を返す。
+ * 結果には Readonly を付ける。
+ */
+declare namespace StrictLibInternals {
+  export type HasOwnReturnType<
+    R extends import('ts-type-forge').UnknownRecord,
+    K extends PropertyKey,
+  > = R extends R // union distribution
+    ? K extends keyof R
+      ? string extends keyof R
+        ? import('ts-type-forge').MutableRecord<K, R[keyof R]> & R
+        : number extends keyof R
+          ? import('ts-type-forge').MutableRecord<K, R[keyof R]> & R
+          : symbol extends keyof R
+            ? import('ts-type-forge').MutableRecord<K, R[keyof R]> & R
+            : R
+      : never // omit union member that does not have key K
+    : never; // dummy case for union distribution
+}
+
+interface ObjectConstructor {
+  /**
+   * Determines whether an object has a property with the specified name.
+   * @param obj An object.
+   * @param key A property name.
+   */
+  hasOwn<
+    R extends import('ts-type-forge').UnknownRecord,
+    K extends PropertyKey,
+  >(
+    obj: R,
+    key: K,
+  ): obj is StrictLibInternals.HasOwnReturnType<R, K>;
+}

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

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