@sorrell/utilities 1.1.61 → 1.2.0

package/Distribution/Types/Array/index.d.mts

@@ -0,0 +1,9 @@
+/**
+ * @file      index.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+export * from "./Array.mjs";
+export * from "./Array.Types.mjs";
+//# sourceMappingURL=index.d.mts.map

package/Distribution/Types/Array/index.d.mts.map

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "index.d.mts",
+    "sourceRoot": "",
+    "sources": [
+        "../../../Source/Array/index.ts"
+    ],
+    "names": [],
+    "mappings": "AAAA;;;;;GAKG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"
+}

package/Distribution/Types/Async/Async.Types.d.cts

@@ -0,0 +1,150 @@
+/**
+ * @file      Promise.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+import type { TExtractFunction, TFunction } from "../Functional/index.cjs";
+import type { TPromise, TPromiseLike } from "./Async.cjs";
+/**
+ * @template DataType - The {@link Data} type of this.
+ *
+ * @property {DataType | undefined} Data - The data returned by the corresponding
+ * `async` function or `Promise<DataType>`,
+ * iff it resolved successfully.  Otherwise, it is `undefined`.
+ *
+ * @property {undefined | unknown} Error - The error thrown by the corresponding
+ * `async` function or `Promise<DataType>`.  This is `undefined` iff the
+ * corresponding `async` function or `Promise<DataType>` resolved successfully.
+ */
+export type TTryResult<DataType> = {
+    Data: DataType;
+    Error: undefined;
+} | {
+    Data: undefined;
+    Error: unknown | undefined;
+};
+/**
+ * An `async` function or `Promise` of the given {@link DataType}.
+ * This is the type of the argument of {@link Try}.
+ *
+ * @template DataType - The type of the data that the `async` function or `Promise<DataType>`.
+ */
+export type TTrySource<DataType> = Promise<DataType> | (() => DataType) | (() => Promise<DataType>);
+/**
+ * The type of the function passed to the `then` method of a `Promise`.
+ *
+ * @template ParameterType - The type of the parameter passed to the function.
+ * @template ReturnType - The type of the value returned by the function.
+ */
+export type TThen<ParameterType = unknown, ReturnType = unknown> = (Value: ParameterType) => ReturnType;
+/**
+ * The type of the function passed to the `catch` method of a `Promise`.
+ *
+ * @template Type - The type of the value returned by the `catch` function.
+ */
+export type TPromiseCatchFunction<Type = unknown> = Parameters<TExtractFunction<Promise<Type>["catch"]>>[0];
+/**
+ * Maps a function type to union of two functions, each with the original
+ * argument vector type.  One return type is wrapped with `Promise`, and
+ * the other is not.  The nuance regarding the return type is elaborated
+ * upon in the note below.
+ *
+ * @note It is expected that in *most* cases, the given {@link FunctionType}
+ * is a regular, synchronous function type (*i.e.*, its return type is *not*
+ * a `Promise`), but if it *does* return a `Promise`, the default behavior
+ * is to assume that this is the intended async form of the resulting union,
+ * and the type wrapped in the `Promise` will be inferred.  If the given
+ * {@link FunctionType} returns a `Promise` but is intended to be the *synchronous*
+ * form, then {@link RetainPromiseFlag} should be set to `true`.
+ *
+ * @template FunctionType - The function type from which this union is constructed.
+ * @template RetainPromiseFlag - If `true` and `ReturnType<{@link FunctionType}> extends
+ * Promise<unknown>`, then the {@link FunctionType} will be treated as the synchronous
+ * form, and the other type in this union will return a `Promise<Promise<infer ResolveType>>`.
+ */
+export type TMaybeAsync<FunctionType extends TFunction, RetainPromiseFlag extends boolean = false> = FunctionType extends TFunction<infer ArgumentVectorType, infer ReturnType> ? ReturnType extends Promise<infer ResolveType> ? RetainPromiseFlag extends true ? TFunction<ArgumentVectorType, ReturnType> : TFunction<ArgumentVectorType, ResolveType> : (TFunction<ArgumentVectorType, ReturnType> | TFunction<ArgumentVectorType, Promise<ReturnType>>) : never;
+/**
+ * A function that is an argument of a given {@link PromiseConstructorLike}`, which is called when
+ * the {@link PromiseLike} created by the given {@link PromiseConstructorLike} resolves, if it resolves.
+ *
+ * @param Value - The value to which the given {@link PromiseLike} will resolve by calling this.
+ *
+ * @template ResolveType - The type to which the given {@link PromiseLike} will resolve by calling this.
+ */
+export type TResolve<ResolveType> = (Value: ResolveType | PromiseLike<ResolveType>) => void;
+/**
+ * A function that is called by a given {@link PromiseLike}`, if the given {@link PromiseLike} resolves.
+ *
+ * @param Value - The value to which the given {@link PromiseLike} resolves when this is called,
+ * if it resolves (this is called precisely when the given {@link PromiseLike} resolves).
+ *
+ * @template ResolveType - The type to which the given {@link PromiseLike} provides once it has
+ * resolved, if it resolves.
+ *
+ * @template Result1Type - The type to which the resulting {@link PromiseLike} will resolve, if it resolves.
+ */
+export type TOnFulfilled<ResolveType, Result1Type = ResolveType> = {
+    (Value: ResolveType): Result1Type | PromiseLike<Result1Type>;
+};
+/**
+ * A function that is called by a given {@link Promise}`, if the given {@link Promise} rejects.
+ *
+ * @param Reason - The reason for why given {@link Promise} rejects when this is called,
+ * if it rejects (this is called precisely when the given {@link Promise} rejects).
+ *
+ * @template RejectType - The type to which the given {@link Promise} provides once it has
+ * rejected, if it rejects.
+ *
+ * @returns {Result2Type | PromiseLike<Result2Type>} A {@link PromiseLike} that resolves when this function
+ * has finished handling the rejection of the {@link Promise} which received this function via
+ * {@link Promise["catch"]}.
+ */
+export type TOnRejected<RejectType> = {
+    (Reason: unknown): RejectType | PromiseLike<RejectType>;
+};
+/**
+ * A function that is an argument of a given {@link PromiseConstructorLike}`, which is called when
+ * the {@link PromiseLike} created by the given {@link PromiseConstructorLike} rejects, if it rejects.
+ *
+ * @param Reason - The reason for why given {@link PromiseLike} will reject by calling this.
+ *
+ * @template RejectType - The type to which the given {@link PromiseLike} will  by calling this.
+ */
+export type TReject<RejectType = unknown> = (Reason: RejectType) => void;
+/**
+ * The argument of a {@link TPromise} (or other {@link PromiseLike}), such that a new
+ * {@link PromiseLike} is created by the given constructor using this argument.
+ *
+ * @param Resolve - The function that, if called, will cause the {@link PromiseLike}
+ * constructed with this to resolve.
+ *
+ * @param Reject - The function that, if called, will cause the {@link PromiseLike}
+ * constructed with this to resolve.
+ *
+ * @template ResolveType - The type to which the {@link PromiseLike} constructed with this will be resolved,
+ * if it resolves.
+ *
+ * @template RejectType - The type to which the {@link PromiseLike} constructed with this will be rejected,
+ * if it rejects.
+ *
+ * @returns {void} This does not return anything; control flow is handled entirely by calling either
+ * {@link Resolve} or {@link Reject}.
+ */
+export type TPromiseExecutor<ResolveType, RejectType = never> = {
+    (Resolve?: TResolve<ResolveType>, Reject?: TReject<RejectType>): void;
+};
+/**
+ * The type of the argument used to construct a {@link TPromise}.
+ *
+ * @template ResolveType - The type to which the {@link TPromise} constructed with
+ * this argument will resolve, if it resolves.
+ */
+export type TPromiseCtorArgument<ResolveType> = TPromiseExecutor<ResolveType> | TPromise<ResolveType> | Promise<ResolveType>;
+/**
+ * Either a given {@link ResultType}, or a {@link TPromiseLike} of a given {@link ResultType}.
+ *
+ * @template ResultType - The type which is either this, or of which this is a {@link PromiseLike}.
+ */
+export type TMaybePromiseLike<ResultType> = ResultType | TPromiseLike<ResultType>;
+//# sourceMappingURL=Async.Types.d.cts.map

package/Distribution/Types/Async/Async.Types.d.cts.map

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "Async.Types.d.cts",
+    "sourceRoot": "",
+    "sources": [
+        "../../../Source/Async/Async.Types.ts"
+    ],
+    "names": [],
+    "mappings": "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"
+}

package/Distribution/Types/Async/Async.Types.d.mts

@@ -0,0 +1,150 @@
+/**
+ * @file      Promise.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+import type { TExtractFunction, TFunction } from "../Functional/index.mjs";
+import type { TPromise, TPromiseLike } from "./Async.mjs";
+/**
+ * @template DataType - The {@link Data} type of this.
+ *
+ * @property {DataType | undefined} Data - The data returned by the corresponding
+ * `async` function or `Promise<DataType>`,
+ * iff it resolved successfully.  Otherwise, it is `undefined`.
+ *
+ * @property {undefined | unknown} Error - The error thrown by the corresponding
+ * `async` function or `Promise<DataType>`.  This is `undefined` iff the
+ * corresponding `async` function or `Promise<DataType>` resolved successfully.
+ */
+export type TTryResult<DataType> = {
+    Data: DataType;
+    Error: undefined;
+} | {
+    Data: undefined;
+    Error: unknown | undefined;
+};
+/**
+ * An `async` function or `Promise` of the given {@link DataType}.
+ * This is the type of the argument of {@link Try}.
+ *
+ * @template DataType - The type of the data that the `async` function or `Promise<DataType>`.
+ */
+export type TTrySource<DataType> = Promise<DataType> | (() => DataType) | (() => Promise<DataType>);
+/**
+ * The type of the function passed to the `then` method of a `Promise`.
+ *
+ * @template ParameterType - The type of the parameter passed to the function.
+ * @template ReturnType - The type of the value returned by the function.
+ */
+export type TThen<ParameterType = unknown, ReturnType = unknown> = (Value: ParameterType) => ReturnType;
+/**
+ * The type of the function passed to the `catch` method of a `Promise`.
+ *
+ * @template Type - The type of the value returned by the `catch` function.
+ */
+export type TPromiseCatchFunction<Type = unknown> = Parameters<TExtractFunction<Promise<Type>["catch"]>>[0];
+/**
+ * Maps a function type to union of two functions, each with the original
+ * argument vector type.  One return type is wrapped with `Promise`, and
+ * the other is not.  The nuance regarding the return type is elaborated
+ * upon in the note below.
+ *
+ * @note It is expected that in *most* cases, the given {@link FunctionType}
+ * is a regular, synchronous function type (*i.e.*, its return type is *not*
+ * a `Promise`), but if it *does* return a `Promise`, the default behavior
+ * is to assume that this is the intended async form of the resulting union,
+ * and the type wrapped in the `Promise` will be inferred.  If the given
+ * {@link FunctionType} returns a `Promise` but is intended to be the *synchronous*
+ * form, then {@link RetainPromiseFlag} should be set to `true`.
+ *
+ * @template FunctionType - The function type from which this union is constructed.
+ * @template RetainPromiseFlag - If `true` and `ReturnType<{@link FunctionType}> extends
+ * Promise<unknown>`, then the {@link FunctionType} will be treated as the synchronous
+ * form, and the other type in this union will return a `Promise<Promise<infer ResolveType>>`.
+ */
+export type TMaybeAsync<FunctionType extends TFunction, RetainPromiseFlag extends boolean = false> = FunctionType extends TFunction<infer ArgumentVectorType, infer ReturnType> ? ReturnType extends Promise<infer ResolveType> ? RetainPromiseFlag extends true ? TFunction<ArgumentVectorType, ReturnType> : TFunction<ArgumentVectorType, ResolveType> : (TFunction<ArgumentVectorType, ReturnType> | TFunction<ArgumentVectorType, Promise<ReturnType>>) : never;
+/**
+ * A function that is an argument of a given {@link PromiseConstructorLike}`, which is called when
+ * the {@link PromiseLike} created by the given {@link PromiseConstructorLike} resolves, if it resolves.
+ *
+ * @param Value - The value to which the given {@link PromiseLike} will resolve by calling this.
+ *
+ * @template ResolveType - The type to which the given {@link PromiseLike} will resolve by calling this.
+ */
+export type TResolve<ResolveType> = (Value: ResolveType | PromiseLike<ResolveType>) => void;
+/**
+ * A function that is called by a given {@link PromiseLike}`, if the given {@link PromiseLike} resolves.
+ *
+ * @param Value - The value to which the given {@link PromiseLike} resolves when this is called,
+ * if it resolves (this is called precisely when the given {@link PromiseLike} resolves).
+ *
+ * @template ResolveType - The type to which the given {@link PromiseLike} provides once it has
+ * resolved, if it resolves.
+ *
+ * @template Result1Type - The type to which the resulting {@link PromiseLike} will resolve, if it resolves.
+ */
+export type TOnFulfilled<ResolveType, Result1Type = ResolveType> = {
+    (Value: ResolveType): Result1Type | PromiseLike<Result1Type>;
+};
+/**
+ * A function that is called by a given {@link Promise}`, if the given {@link Promise} rejects.
+ *
+ * @param Reason - The reason for why given {@link Promise} rejects when this is called,
+ * if it rejects (this is called precisely when the given {@link Promise} rejects).
+ *
+ * @template RejectType - The type to which the given {@link Promise} provides once it has
+ * rejected, if it rejects.
+ *
+ * @returns {Result2Type | PromiseLike<Result2Type>} A {@link PromiseLike} that resolves when this function
+ * has finished handling the rejection of the {@link Promise} which received this function via
+ * {@link Promise["catch"]}.
+ */
+export type TOnRejected<RejectType> = {
+    (Reason: unknown): RejectType | PromiseLike<RejectType>;
+};
+/**
+ * A function that is an argument of a given {@link PromiseConstructorLike}`, which is called when
+ * the {@link PromiseLike} created by the given {@link PromiseConstructorLike} rejects, if it rejects.
+ *
+ * @param Reason - The reason for why given {@link PromiseLike} will reject by calling this.
+ *
+ * @template RejectType - The type to which the given {@link PromiseLike} will  by calling this.
+ */
+export type TReject<RejectType = unknown> = (Reason: RejectType) => void;
+/**
+ * The argument of a {@link TPromise} (or other {@link PromiseLike}), such that a new
+ * {@link PromiseLike} is created by the given constructor using this argument.
+ *
+ * @param Resolve - The function that, if called, will cause the {@link PromiseLike}
+ * constructed with this to resolve.
+ *
+ * @param Reject - The function that, if called, will cause the {@link PromiseLike}
+ * constructed with this to resolve.
+ *
+ * @template ResolveType - The type to which the {@link PromiseLike} constructed with this will be resolved,
+ * if it resolves.
+ *
+ * @template RejectType - The type to which the {@link PromiseLike} constructed with this will be rejected,
+ * if it rejects.
+ *
+ * @returns {void} This does not return anything; control flow is handled entirely by calling either
+ * {@link Resolve} or {@link Reject}.
+ */
+export type TPromiseExecutor<ResolveType, RejectType = never> = {
+    (Resolve?: TResolve<ResolveType>, Reject?: TReject<RejectType>): void;
+};
+/**
+ * The type of the argument used to construct a {@link TPromise}.
+ *
+ * @template ResolveType - The type to which the {@link TPromise} constructed with
+ * this argument will resolve, if it resolves.
+ */
+export type TPromiseCtorArgument<ResolveType> = TPromiseExecutor<ResolveType> | TPromise<ResolveType> | Promise<ResolveType>;
+/**
+ * Either a given {@link ResultType}, or a {@link TPromiseLike} of a given {@link ResultType}.
+ *
+ * @template ResultType - The type which is either this, or of which this is a {@link PromiseLike}.
+ */
+export type TMaybePromiseLike<ResultType> = ResultType | TPromiseLike<ResultType>;
+//# sourceMappingURL=Async.Types.d.mts.map

package/Distribution/Types/Async/Async.Types.d.mts.map

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "Async.Types.d.mts",
+    "sourceRoot": "",
+    "sources": [
+        "../../../Source/Async/Async.Types.ts"
+    ],
+    "names": [],
+    "mappings": "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"
+}

package/Distribution/Types/Async/Async.d.cts

@@ -0,0 +1,145 @@
+/**
+ * @file      Async.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+import { type TNullable } from "../Miscellaneous/Utility.Types.cjs";
+import type { TOnFulfilled, TOnRejected, TPromiseCtorArgument, TTryResult, TTrySource } from "./Async.Types.cjs";
+import type { TFunction } from "../Functional/Functional.Types.cjs";
+/**
+ * Implements "Errors-as-values" for `async` functions and `Promise<DataType>`s.
+ *
+ * If the `async` function or `Promise<DataType>` returns/resolves, then the `Error`
+ * property of the returned object will be `undefined`, and the result of the
+ * `async` function or `Promise<DataType>` will reside in the `Data` property of the
+ * returned object.
+ *
+ * Similarly, if the `async` function or `Promise<DataType>` throws, then the `Data`
+ * property of the returned object is `undefined`, and the `Error` property is what
+ * was thrown to the `catch` block.
+ *
+ * @template DataType - The type of the data that the `async` function or `Promise<DataType>`.
+ * @param Source - The `async` function or `Promise` to evaluate.
+ *
+ * @returns {TTryResult<DataType>} A {@link TTryResult} containing either the result
+ * ({@link TTryResult.Data}) or error {@link TTryResult.Error}.
+ *
+ * @example
+ * // With an `async` function,
+ * async function GetName(): Promise<string> { ... }
+ * // Or, with a `Promise`,
+ * const GetName: Promise<string> = new Promise<string>(...);
+ *
+ * // For both of the above cases, `Try` behaves the same:
+ * const { Data: Name, Error: NameError } = await Try(GetName);
+ * // If `GetName` returned,
+ * // `typeof Name` <- `"string"`
+ * // `typeof NameError` <- `"undefined"`
+ * // If `GetName` threw,
+ * // `typeof Name` <- `"undefined"`
+ * // `NameError !== undefined` <- `true` (Unless `GetName` threw `undefined`).
+ */
+export declare function Try<DataType>(Source: TTrySource<DataType>): Promise<TTryResult<DataType>>;
+/**
+ * A cleaner way of using `Array.prototype.map` with an `async` function.
+ *
+ * @template ArgumentElementType - The type of the given {@link Elements}.
+ * @template ReturnElementType - The type of the `Array` returned by this.
+ *
+ * @param Elements - The `Array` that will be transformed.
+ * @param Mapper - The function that maps each {@link ArgumentElementType}
+ * to a {@link ReturnElementType}.
+ *
+ * @returns {Array<ReturnElementType>} An `Array` of {@link ReturnElementType}.
+ *
+ * @example
+ * In an `async` function,
+ * ```typescript
+ * const ArgumentElements: Array<ArgumentElementType> = [ ... ];
+ * const ToReturnElement = async (Element: ArgumentElementType): Promise<ReturnElementType> => ...;
+ * const ReturnElements: Array<ReturnElementType> = await Map(ArgumentElements, ToReturnElement);
+ * ```
+ */
+export declare function Map<ArgumentElementType, ReturnElementType>(Elements: Array<ArgumentElementType>, Mapper: ((Element: ArgumentElementType) => Promise<ReturnElementType>)): Promise<Array<ReturnElementType>>;
+/**
+ * An abstract implementation of {@link PromiseLike}.  This exists only to maintain the
+ * project's naming convention.
+ */
+export declare abstract class TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {
+    then<ResultType = ResolveType, RejectType = never>(_OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, _OnRejected?: TOnRejected<RejectType>): TPromiseLike<ResultType | RejectType>;
+}
+/**
+ * The {@link TypeError} that is thrown by the constructor of {@link TPromise}
+ * iff it receives an argument that is not a {@link TPromiseCtorArgument}.
+ * It does not provide any additional information (in particular, it does not
+ * add any properties, and it does not set any properties inherited from
+ * {@link TypeError}).
+ *
+ * @note While the argument type of {@link TPromise}'s constructor is checked at runtime,
+ * the type checker should prevent the error described by this from happening.
+ */
+export declare class FPromiseInstantiationError extends TypeError {
+    constructor();
+}
+/**
+ * A `then`-able wrapper of {@link Promise}.
+ *
+ * @template ResolveType - The type to which this resolves, if it does resolve.
+ */
+export declare class TPromise<ResolveType> extends TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {
+    constructor(Argument: TPromiseCtorArgument<ResolveType>);
+    private readonly Underlying;
+    /**
+     * This class's extension of {@link Promise!then}.
+     *
+     * @template ResultType - The type to which the value underlying the {@link TPromise} returned by this
+     * will resolve, if the {@link TPromise} resolves.
+     *
+     * @template RejectType - The type to which the value underlying the {@link TPromise} returned by this
+     * will reject, if the {@link TPromise} rejects.
+     *
+     * @param OnFulfilled - The callback that is called when the underlying {@link Promise} resolves,
+     * if it resolves.
+     *
+     * @param OnRejected - The callback that is called when the underlying {@link Promise} rejects,
+     * if it rejects.
+     *
+     * @returns {TPromise<ResultType | RejectType>} A new {@link TPromise} of the result of the
+     * given callbacks.
+     *
+     * @example
+     * ```typescript
+     * const Example: TPromise<string> = new TPromise<string>((Resolve, Reject) =>
+     * {
+     *     if (Math.random() < 0.5)
+     *     {
+     *         Resolve("Success");
+     *     }
+     *     else
+     *     {
+     *         Reject("Error");
+     *     }
+     * });
+     *
+     * Example.then(
+     *     (Value: string): void =>
+     *     {
+     *         // `Value` <- `"Success"`
+     *     },
+     *     (Reason: unknown): void =>
+     *     {
+     *         // `Reason` <- `"Error"`
+     *     }
+     * );
+     * ```
+     */
+    Then<ResultType = ResolveType, RejectType = never>(OnFulfilled: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType>;
+    then<ResultType = ResolveType, RejectType = never>(OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType>;
+    Catch<ResultType = never>(OnRejected?: TNullable<TOnRejected<ResolveType>>): TPromiseLike<ResolveType | ResultType>;
+    Finally(OnFinally?: TNullable<TFunction>): TPromise<ResolveType>;
+    static Resolve<ResolveType>(Value: ResolveType | PromiseLike<ResolveType>): TPromise<Awaited<ResolveType>>;
+    static Reject<ResolveType = unknown>(Reason?: unknown): TPromise<ResolveType>;
+    Raw(): Promise<ResolveType>;
+}
+//# sourceMappingURL=Async.d.cts.map

package/Distribution/Types/Async/Async.d.cts.map

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "Async.d.cts",
+    "sourceRoot": "",
+    "sources": [
+        "../../../Source/Async/Async.ts"
+    ],
+    "names": [],
+    "mappings": "AAAA;;;;;GAKG;AAEH,OAAO,EAA2B,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC5F,OAAO,KAAK,EACR,YAAY,EACZ,WAAW,EACX,oBAAoB,EACpB,UAAU,EACV,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAqB/F;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAC5D,QAAQ,EAAE,KAAK,CAAC,mBAAmB,CAAC,EACpC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC,GACvE,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAUnC;AAED;;;GAGG;AACH,8BAAsB,YAAY,CAAC,WAAW,CAAE,YAAW,WAAW,CAAC,WAAW,CAAC;IAExE,IAAI,CAAC,UAAU,GAAG,WAAW,EAAE,UAAU,GAAG,KAAK,EACpD,YAAY,CAAC,EAAE,YAAY,CAAC,WAAW,EAAE,UAAU,CAAC,EACpD,WAAW,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,GACtC,YAAY,CAAC,UAAU,GAAG,UAAU,CAAC;CAI3C;AAED;;;;;;;;;GASG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;;CAMxD;AAED;;;;GAIG;AACH,qBAAa,QAAQ,CAAC,WAAW,CAAE,SAAQ,YAAY,CAAC,WAAW,CAAE,YAAW,WAAW,CAAC,WAAW,CAAC;gBAEjF,QAAQ,EAAE,oBAAoB,CAAC,WAAW,CAAC;IAsB9D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuB;IAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACI,IAAI,CAAC,UAAU,GAAG,WAAW,EAAE,UAAU,GAAG,KAAK,EACpD,WAAW,EAAE,YAAY,CAAC,WAAW,EAAE,UAAU,CAAC,EAClD,UAAU,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,GACrC,QAAQ,CAAC,UAAU,GAAG,UAAU,CAAC;IAKpB,IAAI,CAAC,UAAU,GAAG,WAAW,EAAE,UAAU,GAAG,KAAK,EAC7D,WAAW,CAAC,EAAE,YAAY,CAAC,WAAW,EAAE,UAAU,CAAC,EACnD,UAAU,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,GACrC,QAAQ,CAAC,UAAU,GAAG,UAAU,CAAC;IAK7B,KAAK,CAAC,UAAU,GAAG,KAAK,EAC3B,UAAU,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,GACjD,YAAY,CAAC,WAAW,GAAG,UAAU,CAAC;IAOlC,OAAO,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC;WAKzD,OAAO,CAAC,WAAW,EAC7B,KAAK,EAAE,WAAW,GAAG,WAAW,CAAC,WAAW,CAAC,GAC9C,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;WAKnB,MAAM,CAAC,WAAW,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC,WAAW,CAAC;IAK7E,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC;CAIrC"
+}

package/Distribution/Types/Async/Async.d.mts

@@ -0,0 +1,145 @@
+/**
+ * @file      Async.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+import { type TNullable } from "../Miscellaneous/Utility.Types.mjs";
+import type { TOnFulfilled, TOnRejected, TPromiseCtorArgument, TTryResult, TTrySource } from "./Async.Types.mjs";
+import type { TFunction } from "../Functional/Functional.Types.mjs";
+/**
+ * Implements "Errors-as-values" for `async` functions and `Promise<DataType>`s.
+ *
+ * If the `async` function or `Promise<DataType>` returns/resolves, then the `Error`
+ * property of the returned object will be `undefined`, and the result of the
+ * `async` function or `Promise<DataType>` will reside in the `Data` property of the
+ * returned object.
+ *
+ * Similarly, if the `async` function or `Promise<DataType>` throws, then the `Data`
+ * property of the returned object is `undefined`, and the `Error` property is what
+ * was thrown to the `catch` block.
+ *
+ * @template DataType - The type of the data that the `async` function or `Promise<DataType>`.
+ * @param Source - The `async` function or `Promise` to evaluate.
+ *
+ * @returns {TTryResult<DataType>} A {@link TTryResult} containing either the result
+ * ({@link TTryResult.Data}) or error {@link TTryResult.Error}.
+ *
+ * @example
+ * // With an `async` function,
+ * async function GetName(): Promise<string> { ... }
+ * // Or, with a `Promise`,
+ * const GetName: Promise<string> = new Promise<string>(...);
+ *
+ * // For both of the above cases, `Try` behaves the same:
+ * const { Data: Name, Error: NameError } = await Try(GetName);
+ * // If `GetName` returned,
+ * // `typeof Name` <- `"string"`
+ * // `typeof NameError` <- `"undefined"`
+ * // If `GetName` threw,
+ * // `typeof Name` <- `"undefined"`
+ * // `NameError !== undefined` <- `true` (Unless `GetName` threw `undefined`).
+ */
+export declare function Try<DataType>(Source: TTrySource<DataType>): Promise<TTryResult<DataType>>;
+/**
+ * A cleaner way of using `Array.prototype.map` with an `async` function.
+ *
+ * @template ArgumentElementType - The type of the given {@link Elements}.
+ * @template ReturnElementType - The type of the `Array` returned by this.
+ *
+ * @param Elements - The `Array` that will be transformed.
+ * @param Mapper - The function that maps each {@link ArgumentElementType}
+ * to a {@link ReturnElementType}.
+ *
+ * @returns {Array<ReturnElementType>} An `Array` of {@link ReturnElementType}.
+ *
+ * @example
+ * In an `async` function,
+ * ```typescript
+ * const ArgumentElements: Array<ArgumentElementType> = [ ... ];
+ * const ToReturnElement = async (Element: ArgumentElementType): Promise<ReturnElementType> => ...;
+ * const ReturnElements: Array<ReturnElementType> = await Map(ArgumentElements, ToReturnElement);
+ * ```
+ */
+export declare function Map<ArgumentElementType, ReturnElementType>(Elements: Array<ArgumentElementType>, Mapper: ((Element: ArgumentElementType) => Promise<ReturnElementType>)): Promise<Array<ReturnElementType>>;
+/**
+ * An abstract implementation of {@link PromiseLike}.  This exists only to maintain the
+ * project's naming convention.
+ */
+export declare abstract class TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {
+    then<ResultType = ResolveType, RejectType = never>(_OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, _OnRejected?: TOnRejected<RejectType>): TPromiseLike<ResultType | RejectType>;
+}
+/**
+ * The {@link TypeError} that is thrown by the constructor of {@link TPromise}
+ * iff it receives an argument that is not a {@link TPromiseCtorArgument}.
+ * It does not provide any additional information (in particular, it does not
+ * add any properties, and it does not set any properties inherited from
+ * {@link TypeError}).
+ *
+ * @note While the argument type of {@link TPromise}'s constructor is checked at runtime,
+ * the type checker should prevent the error described by this from happening.
+ */
+export declare class FPromiseInstantiationError extends TypeError {
+    constructor();
+}
+/**
+ * A `then`-able wrapper of {@link Promise}.
+ *
+ * @template ResolveType - The type to which this resolves, if it does resolve.
+ */
+export declare class TPromise<ResolveType> extends TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {
+    constructor(Argument: TPromiseCtorArgument<ResolveType>);
+    private readonly Underlying;
+    /**
+     * This class's extension of {@link Promise!then}.
+     *
+     * @template ResultType - The type to which the value underlying the {@link TPromise} returned by this
+     * will resolve, if the {@link TPromise} resolves.
+     *
+     * @template RejectType - The type to which the value underlying the {@link TPromise} returned by this
+     * will reject, if the {@link TPromise} rejects.
+     *
+     * @param OnFulfilled - The callback that is called when the underlying {@link Promise} resolves,
+     * if it resolves.
+     *
+     * @param OnRejected - The callback that is called when the underlying {@link Promise} rejects,
+     * if it rejects.
+     *
+     * @returns {TPromise<ResultType | RejectType>} A new {@link TPromise} of the result of the
+     * given callbacks.
+     *
+     * @example
+     * ```typescript
+     * const Example: TPromise<string> = new TPromise<string>((Resolve, Reject) =>
+     * {
+     *     if (Math.random() < 0.5)
+     *     {
+     *         Resolve("Success");
+     *     }
+     *     else
+     *     {
+     *         Reject("Error");
+     *     }
+     * });
+     *
+     * Example.then(
+     *     (Value: string): void =>
+     *     {
+     *         // `Value` <- `"Success"`
+     *     },
+     *     (Reason: unknown): void =>
+     *     {
+     *         // `Reason` <- `"Error"`
+     *     }
+     * );
+     * ```
+     */
+    Then<ResultType = ResolveType, RejectType = never>(OnFulfilled: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType>;
+    then<ResultType = ResolveType, RejectType = never>(OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType>;
+    Catch<ResultType = never>(OnRejected?: TNullable<TOnRejected<ResolveType>>): TPromiseLike<ResolveType | ResultType>;
+    Finally(OnFinally?: TNullable<TFunction>): TPromise<ResolveType>;
+    static Resolve<ResolveType>(Value: ResolveType | PromiseLike<ResolveType>): TPromise<Awaited<ResolveType>>;
+    static Reject<ResolveType = unknown>(Reason?: unknown): TPromise<ResolveType>;
+    Raw(): Promise<ResolveType>;
+}
+//# sourceMappingURL=Async.d.mts.map