strict-ts-lib-v5.4 0.4.0

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

@@ -0,0 +1,112 @@
+/// <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?: LocalesArgument, 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: LocalesArgument,
+      options?: Pick<SegmenterOptions, 'localeMatcher'>,
+    ): UnicodeBCP47LocaleIdentifier[];
+  };
+
+  /**
+   * Returns a sorted array of the supported collation, calendar, currency, numbering system, timezones, and units by the implementation.
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf)
+   *
+   * @param key A string indicating the category of values to return.
+   * @returns A sorted array of the supported values.
+   */
+  function supportedValuesOf(
+    key:
+      | 'calendar'
+      | 'collation'
+      | 'currency'
+      | 'numberingSystem'
+      | 'timeZone'
+      | 'unit',
+  ): string[];
+}

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;
+}

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

@@ -0,0 +1,37 @@
+/// <reference no-default-lib="true"/>
+
+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'> };
+}

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

@@ -0,0 +1,9 @@
+/// <reference no-default-lib="true"/>
+
+interface String {
+  /**
+   * Returns a new String consisting of the single UTF-16 code unit 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): string | undefined;
+}