strict-ts-lib-v5.9 0.4.0

package/libs/esnext/iterator/index.d.ts

@@ -0,0 +1,172 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.iterable" />
+
+// NOTE: This is specified as what is essentially an unreachable module. All actual global declarations can be found
+//       in the `declare global` section, below. This is necessary as there is currently no way to declare an `abstract`
+//       member without declaring a `class`, but declaring `class Iterator<T>` globally would conflict with TypeScript's
+//       general purpose `Iterator<T>` interface.
+export {};
+
+// Abstract type that allows us to mark `next` as `abstract`
+declare abstract class Iterator<T, TResult = undefined, TNext = unknown> {
+  // eslint-disable-line @typescript-eslint/no-unsafe-declaration-merging
+  abstract next(value?: TNext): IteratorResult<T, TResult>;
+}
+
+// Merge all members of `IteratorObject<T>` into `Iterator<T>`
+interface Iterator<T, TResult, TNext> extends globalThis.IteratorObject<
+  T,
+  TResult,
+  TNext
+> {}
+
+// Capture the `Iterator` constructor in a type we can use in the `extends` clause of `IteratorConstructor`.
+type IteratorObjectConstructor = typeof Iterator;
+
+declare global {
+  // Global `IteratorObject<T, TReturn, TNext>` interface that can be augmented by polyfills
+  interface IteratorObject<T, TReturn, TNext> {
+    /**
+     * Returns this iterator.
+     */
+    [Symbol.iterator](): IteratorObject<T, TReturn, TNext>;
+
+    /**
+     * Creates an iterator whose values are the result of applying the callback to the values from this iterator.
+     * @param callbackfn A function that accepts up to two arguments to be used to transform values from the underlying iterator.
+     */
+    map<U>(
+      callbackfn: (value: T, index: number) => U,
+    ): IteratorObject<U, undefined, unknown>;
+
+    /**
+     * Creates an iterator whose values are those from this iterator for which the provided predicate returns true.
+     * @param predicate A function that accepts up to two arguments to be used to test values from the underlying iterator.
+     */
+    filter<S extends T>(
+      predicate: (value: T, index: number) => value is S,
+    ): IteratorObject<S, undefined, unknown>;
+
+    /**
+     * Creates an iterator whose values are those from this iterator for which the provided predicate returns true.
+     * @param predicate A function that accepts up to two arguments to be used to test values from the underlying iterator.
+     */
+    filter(
+      predicate: (value: T, index: number) => unknown,
+    ): IteratorObject<T, undefined, unknown>;
+
+    /**
+     * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.
+     * @param limit The maximum number of values to yield.
+     */
+    take(limit: number): IteratorObject<T, undefined, unknown>;
+
+    /**
+     * Creates an iterator whose values are the values from this iterator after skipping the provided count.
+     * @param count The number of values to drop.
+     */
+    drop(limit: number): IteratorObject<T, undefined, unknown>;
+
+    /**
+     * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.
+     * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.
+     */
+    flatMap<U>(
+      callback: (
+        value: T,
+        index: number,
+      ) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>,
+    ): IteratorObject<U, undefined, unknown>;
+
+    /**
+     * Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+     * @param callbackfn A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
+     * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of a value from the iterator.
+     */
+    reduce(
+      callbackfn: (
+        previousValue: T,
+        currentValue: T,
+        currentIndex: number,
+      ) => T,
+    ): T;
+    reduce(
+      callbackfn: (
+        previousValue: T,
+        currentValue: T,
+        currentIndex: number,
+      ) => T,
+      initialValue: T,
+    ): T;
+
+    /**
+     * Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+     * @param callbackfn A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
+     * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of a value from the iterator.
+     */
+    reduce<U>(
+      callbackfn: (
+        previousValue: U,
+        currentValue: T,
+        currentIndex: number,
+      ) => U,
+      initialValue: U,
+    ): U;
+
+    /**
+     * Creates a new array from the values yielded by this iterator.
+     */
+    toArray(): T[];
+
+    /**
+     * Performs the specified action for each element in the iterator.
+     * @param callbackfn A function that accepts up to two arguments. forEach calls the callbackfn function one time for each element in the iterator.
+     */
+    forEach(callbackfn: (value: T, index: number) => void): void;
+
+    /**
+     * Determines whether the specified callback function returns true for any element of this iterator.
+     * @param predicate A function that accepts up to two arguments. The some method calls
+     * the predicate function for each element in this iterator until the predicate returns a value
+     * true, or until the end of the iterator.
+     */
+    some(predicate: (value: T, index: number) => unknown): boolean;
+
+    /**
+     * Determines whether all the members of this iterator satisfy the specified test.
+     * @param predicate A function that accepts up to two arguments. The every method calls
+     * the predicate function for each element in this iterator until the predicate returns
+     * false, or until the end of this iterator.
+     */
+    every(predicate: (value: T, index: number) => unknown): boolean;
+
+    /**
+     * Returns the value of the first element in this iterator where predicate is true, and undefined
+     * otherwise.
+     * @param predicate find calls predicate once for each element of this iterator, in
+     * order, until it finds one where predicate returns true. If such an element is found, find
+     * immediately returns that element value. Otherwise, find returns undefined.
+     */
+    find<S extends T>(
+      predicate: (value: T, index: number) => value is S,
+    ): S | undefined;
+    find(predicate: (value: T, index: number) => unknown): T | undefined;
+
+    readonly [Symbol.toStringTag]: string;
+  }
+
+  // Global `IteratorConstructor` interface that can be augmented by polyfills
+  interface IteratorConstructor extends IteratorObjectConstructor {
+    /**
+     * Creates a native iterator from an iterator or iterable object.
+     * Returns its input if the input already inherits from the built-in Iterator class.
+     * @param value An iterator or iterable object to convert a native iterator.
+     */
+    from<T>(
+      value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>,
+    ): IteratorObject<T, undefined, unknown>;
+  }
+
+  const Iterator: IteratorConstructor;
+}

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

@@ -0,0 +1,21 @@
+/// <reference no-default-lib="true"/>
+
+interface PromiseConstructor {
+  /**
+   * Takes a callback of any kind (returns or throws, synchronously or asynchronously) and wraps its result
+   * in a Promise.
+   *
+   * @param callbackFn A function that is called synchronously. It can do anything: either return
+   * a value, throw an error, or return a promise.
+   * @param args Additional arguments, that will be passed to the callback.
+   *
+   * @returns A Promise that is:
+   * - Already fulfilled, if the callback synchronously returns a value.
+   * - Already rejected, if the callback synchronously throws an error.
+   * - Asynchronously fulfilled or rejected, if the callback returns a promise.
+   */
+  try<T, U extends readonly unknown[]>(
+    callbackFn: (...args: U) => T | PromiseLike<T>,
+    ...args: U
+  ): Promise<Awaited<T>>;
+}

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

@@ -0,0 +1,9 @@
+/// <reference no-default-lib="true"/>
+
+interface Atomics {
+  /**
+   * Performs a finite-time microwait by signaling to the operating system or
+   * CPU that the current executing code is in a spin-wait loop.
+   */
+  pause(n?: number): void;
+}

package/libs/scripthost/index.d.ts

@@ -0,0 +1,310 @@
+/// <reference no-default-lib="true"/>
+
+/////////////////////////////
+/// Windows Script Host APIS
+/////////////////////////////
+
+interface ActiveXObject {
+  new (s: string): unknown;
+}
+declare const ActiveXObject: ActiveXObject;
+
+interface ITextWriter {
+  Write(s: string): void;
+  WriteLine(s: string): void;
+  Close(): void;
+}
+
+interface TextStreamBase {
+  /**
+   * The column number of the current character position in an input stream.
+   */
+  readonly Column: number;
+
+  /**
+   * The current line number in an input stream.
+   */
+  readonly Line: number;
+
+  /**
+   * Closes a text stream.
+   * It is not necessary to close standard streams; they close automatically when the process ends. If
+   * you close a standard stream, be aware that any other pointers to that standard stream become invalid.
+   */
+  Close(): void;
+}
+
+interface TextStreamWriter extends TextStreamBase {
+  /**
+   * Sends a string to an output stream.
+   */
+  Write(s: string): void;
+
+  /**
+   * Sends a specified number of blank lines (newline characters) to an output stream.
+   */
+  WriteBlankLines(intLines: number): void;
+
+  /**
+   * Sends a string followed by a newline character to an output stream.
+   */
+  WriteLine(s: string): void;
+}
+
+interface TextStreamReader extends TextStreamBase {
+  /**
+   * Returns a specified number of characters from an input stream, starting at the current pointer position.
+   * Does not return until the ENTER key is pressed.
+   * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+   */
+  Read(characters: number): string;
+
+  /**
+   * Returns all characters from an input stream.
+   * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+   */
+  ReadAll(): string;
+
+  /**
+   * Returns an entire line from an input stream.
+   * Although this method extracts the newline character, it does not add it to the returned string.
+   * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+   */
+  ReadLine(): string;
+
+  /**
+   * Skips a specified number of characters when reading from an input text stream.
+   * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+   * @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
+   */
+  Skip(characters: number): void;
+
+  /**
+   * Skips the next line when reading from an input text stream.
+   * Can only be used on a stream in reading mode, not writing or appending mode.
+   */
+  SkipLine(): void;
+
+  /**
+   * Indicates whether the stream pointer position is at the end of a line.
+   */
+  readonly AtEndOfLine: boolean;
+
+  /**
+   * Indicates whether the stream pointer position is at the end of a stream.
+   */
+  readonly AtEndOfStream: boolean;
+}
+
+declare const WScript: {
+  /**
+   * Outputs text to either a message box (under WScript.exe) or the command console window followed by
+   * a newline (under CScript.exe).
+   */
+  Echo(s: unknown): void;
+
+  /**
+   * Exposes the write-only error output stream for the current script.
+   * Can be accessed only while using CScript.exe.
+   */
+  readonly StdErr: TextStreamWriter;
+
+  /**
+   * Exposes the write-only output stream for the current script.
+   * Can be accessed only while using CScript.exe.
+   */
+  readonly StdOut: TextStreamWriter;
+  readonly Arguments: { readonly length: number; Item(n: number): string };
+
+  /**
+   *  The full path of the currently running script.
+   */
+  readonly ScriptFullName: string;
+
+  /**
+   * Forces the script to stop immediately, with an optional exit code.
+   */
+  Quit(exitCode?: number): number;
+
+  /**
+   * The Windows Script Host build version number.
+   */
+  readonly BuildVersion: number;
+
+  /**
+   * Fully qualified path of the host executable.
+   */
+  readonly FullName: string;
+
+  /**
+   * Gets/sets the script mode - interactive(true) or batch(false).
+   */
+  readonly Interactive: boolean;
+
+  /**
+   * The name of the host executable (WScript.exe or CScript.exe).
+   */
+  readonly Name: string;
+
+  /**
+   * Path of the directory containing the host executable.
+   */
+  readonly Path: string;
+
+  /**
+   * The filename of the currently running script.
+   */
+  readonly ScriptName: string;
+
+  /**
+   * Exposes the read-only input stream for the current script.
+   * Can be accessed only while using CScript.exe.
+   */
+  readonly StdIn: TextStreamReader;
+
+  /**
+   * Windows Script Host version
+   */
+  readonly Version: string;
+
+  /**
+   * Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
+   */
+  ConnectObject(objEventSource: unknown, strPrefix: string): void;
+
+  /**
+   * Creates a COM object.
+   * @param strProgiID
+   * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+   */
+  CreateObject(strProgID: string, strPrefix?: string): unknown;
+
+  /**
+   * Disconnects a COM object from its event sources.
+   */
+  DisconnectObject(obj: unknown): void;
+
+  /**
+   * Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
+   * @param strPathname Fully qualified path to the file containing the object persisted to disk.
+   *                       For objects in memory, pass a zero-length string.
+   * @param strProgID
+   * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+   */
+  GetObject(
+    strPathname: string,
+    strProgID?: string,
+    strPrefix?: string,
+  ): unknown;
+
+  /**
+   * Suspends script execution for a specified length of time, then continues execution.
+   * @param intTime Interval (in milliseconds) to suspend script execution.
+   */
+  Sleep(intTime: number): void;
+};
+
+/**
+ * WSH is an alias for WScript under Windows Script Host
+ */
+declare const WSH: typeof WScript;
+
+/**
+ * Represents an Automation SAFEARRAY
+ */
+declare class SafeArray<T = unknown> {
+  private constructor();
+  private SafeArray_typekey: SafeArray<T>;
+}
+
+/**
+ * Allows enumerating over a COM collection, which may not have indexed item access.
+ */
+interface Enumerator<T = unknown> {
+  /**
+   * Returns true if the current item is the last one in the collection, or the collection is empty,
+   * or the current item is undefined.
+   */
+  atEnd(): boolean;
+
+  /**
+   * Returns the current item in the collection
+   */
+  item(): T;
+
+  /**
+   * Resets the current item in the collection to the first item. If there are no items in the collection,
+   * the current item is set to undefined.
+   */
+  moveFirst(): void;
+
+  /**
+   * Moves the current item to the next item in the collection. If the enumerator is at the end of
+   * the collection or the collection is empty, the current item is set to undefined.
+   */
+  moveNext(): void;
+}
+
+interface EnumeratorConstructor {
+  new <T = unknown>(safearray: SafeArray<T>): Enumerator<T>;
+  new <T = unknown>(collection: { Item(index: unknown): T }): Enumerator<T>;
+  new <T = unknown>(collection: unknown): Enumerator<T>;
+}
+
+declare const Enumerator: EnumeratorConstructor;
+
+/**
+ * Enables reading from a COM safe array, which might have an alternate lower bound, or multiple dimensions.
+ */
+interface VBArray<T = unknown> {
+  /**
+   * Returns the number of dimensions (1-based).
+   */
+  dimensions(): number;
+
+  /**
+   * Takes an index for each dimension in the array, and returns the item at the corresponding location.
+   */
+  getItem(dimension1Index: number, ...dimensionNIndexes: readonly number[]): T;
+
+  /**
+   * Returns the smallest available index for a given dimension.
+   * @param dimension 1-based dimension (defaults to 1)
+   */
+  lbound(dimension?: number): number;
+
+  /**
+   * Returns the largest available index for a given dimension.
+   * @param dimension 1-based dimension (defaults to 1)
+   */
+  ubound(dimension?: number): number;
+
+  /**
+   * Returns a Javascript array with all the elements in the VBArray. If there are multiple dimensions,
+   * each successive dimension is appended to the end of the array.
+   * Example: [[1,2,3],[4,5,6]] becomes [1,2,3,4,5,6]
+   */
+  toArray(): T[];
+}
+
+interface VBArrayConstructor {
+  new <T = unknown>(safeArray: SafeArray<T>): VBArray<T>;
+}
+
+declare const VBArray: VBArrayConstructor;
+
+/**
+ * Automation date (VT_DATE)
+ */
+declare class VarDate {
+  private constructor();
+  private VarDate_typekey: VarDate;
+}
+
+interface DateConstructor {
+  new (vd: VarDate): Date;
+}
+
+interface Date {
+  readonly getVarDate: () => VarDate;
+}

package/libs/webworker/asynciterable/index.d.ts

@@ -0,0 +1,41 @@
+/// <reference no-default-lib="true"/>
+
+/////////////////////////////
+/// Worker Async Iterable APIs
+/////////////////////////////
+
+interface FileSystemDirectoryHandleAsyncIterator<T> extends AsyncIteratorObject<
+  T,
+  BuiltinIteratorReturn,
+  unknown
+> {
+  [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<T>;
+}
+
+interface FileSystemDirectoryHandle {
+  [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<
+    readonly [string, FileSystemHandle]
+  >;
+  entries(): FileSystemDirectoryHandleAsyncIterator<
+    readonly [string, FileSystemHandle]
+  >;
+  keys(): FileSystemDirectoryHandleAsyncIterator<string>;
+  values(): FileSystemDirectoryHandleAsyncIterator<FileSystemHandle>;
+}
+
+interface ReadableStreamAsyncIterator<T> extends AsyncIteratorObject<
+  T,
+  BuiltinIteratorReturn,
+  unknown
+> {
+  [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
+}
+
+interface ReadableStream<R = unknown> {
+  [Symbol.asyncIterator](
+    options?: ReadableStreamIteratorOptions,
+  ): ReadableStreamAsyncIterator<R>;
+  values(
+    options?: ReadableStreamIteratorOptions,
+  ): ReadableStreamAsyncIterator<R>;
+}

package/libs/webworker/importscripts/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference no-default-lib="true"/>
+
+/////////////////////////////
+/// WorkerGlobalScope APIs
+/////////////////////////////
+// These are only available in a Web Worker
+declare function importScripts(...urls: readonly string[]): void;