@sorrell/utilities 1.1.60 → 1.2.0

package/Distribution/Types/String/index.d.cts.map

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

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

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

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

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

package/Distribution/Types/index.d.cts

@@ -0,0 +1,24 @@
+/**
+ * @file      index.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @module
+ * General-purpose utility types and functions.
+ * This module barrel-exports each scoped export of this package.
+ * Use the scoped exports of this package to access only specific
+ * utilities (*e.g.*, `async`, `npm`, *etc.*).
+ */
+export * as Array from "./Array/index.cjs";
+export * as Async from "./Async/index.cjs";
+export * as Complex from "./Math/Complex.cjs";
+export * as FileSystem from "./FileSystem/index.cjs";
+export * as Functional from "./Functional/index.cjs";
+export * as Math from "./Math/index.cjs";
+export * as Miscellaneous from "./Miscellaneous/index.cjs";
+export * as Npm from "./Npm/index.cjs";
+export * as Path from "./Path/index.cjs";
+export * as String from "./String/index.cjs";
+//# sourceMappingURL=index.d.cts.map

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

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "index.d.cts",
+    "sourceRoot": "",
+    "sources": [
+        "../../Source/index.ts"
+    ],
+    "names": [],
+    "mappings": "AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,KAAK,aAAa,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC"
+}

package/Distribution/Types/index.d.mts

@@ -0,0 +1,24 @@
+/**
+ * @file      index.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @module
+ * General-purpose utility types and functions.
+ * This module barrel-exports each scoped export of this package.
+ * Use the scoped exports of this package to access only specific
+ * utilities (*e.g.*, `async`, `npm`, *etc.*).
+ */
+export * as Array from "./Array/index.mjs";
+export * as Async from "./Async/index.mjs";
+export * as Complex from "./Math/Complex.mjs";
+export * as FileSystem from "./FileSystem/index.mjs";
+export * as Functional from "./Functional/index.mjs";
+export * as Math from "./Math/index.mjs";
+export * as Miscellaneous from "./Miscellaneous/index.mjs";
+export * as Npm from "./Npm/index.mjs";
+export * as Path from "./Path/index.mjs";
+export * as String from "./String/index.mjs";
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "index.d.mts",
+    "sourceRoot": "",
+    "sources": [
+        "../../Source/index.ts"
+    ],
+    "names": [],
+    "mappings": "AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,KAAK,aAAa,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC"
+}

package/Distribution/{CJS/array.js → array.cjs}

@@ -48,4 +48,4 @@ function FilterDefined(Array) {
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-//# sourceMappingURL=array.js.map
+//# sourceMappingURL=array.cjs.map

package/Distribution/{CJS/array.js.map → array.cjs.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Array/index.ts", "../../Source/Array/Array.ts"],
+  "sources": ["../Source/Array/index.ts", "../Source/Array/Array.ts"],
   "sourcesContent": ["/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Array.ts\";\nexport * from \"./Array.Types.ts\";\n", "/**\n * @file      Array.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport type { FilteredArray, Options, TArrayType } from \"./Array.Types.ts\";\nimport type { NoOptions } from \"../Miscellaneous/Utility.Types.ts\";\n/**\n * Filter out all instances of `undefined` from a given {@link Array:param}.\n * @param Array - The array to filter.\n *\n * @template ElementType - The type of the elements in the array.\n *\n * @returns {TArrayType<Exclude<ElementType, undefined>, Exclude<OptionsType, Options.MaybeDefined>>}\n * A new `Array` of type `Exclude<ElementType, undefined>` and `OptionsType` that is the given\n * {@link OptionsType}, with the {@link Options.MaybeDefined} option removed.\n *\n * @example With the given {@link ElementType} including `undefined`.\n * ```typescript\n * const MaybeOddNumbers: TArray<number | undefined> = [ 1, 3, undefined, 5 ];\n * const OddNumbers: TArray<number> = FilterDefined(MaybeOddNumbers);\n * ```\n * @example With the given {@link OptionsType} including `Options.MaybeDefined`.\n * ```typescript\n * const MaybeOddNumbers: TArray<number, Options.MaybeDefined> = [ 1, 3, undefined, 5 ];\n * const OddNumbers: TArray<number> = FilterDefined(MaybeOddNumbers);\n * ```\n */\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType> {\n    return Array.filter((Element: ElementType | undefined): boolean => {\n        return Element !== undefined;\n    }) as FilteredArray<ElementType>;\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgCO,SAAS,cAAuG,OAAuH;AAC1O,SAAO,MAAM,OAAO,CAAC,YAA8C;AAC/D,WAAO,YAAY;AAAA,EACvB,CAAC;AACL;",
   "names": []

package/Distribution/{ESM/array.js.map → array.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Array/Array.ts"],
+  "sources": ["../Source/Array/Array.ts"],
   "sourcesContent": ["/**\n * @file      Array.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport type { FilteredArray, Options, TArrayType } from \"./Array.Types.ts\";\nimport type { NoOptions } from \"../Miscellaneous/Utility.Types.ts\";\n/**\n * Filter out all instances of `undefined` from a given {@link Array:param}.\n * @param Array - The array to filter.\n *\n * @template ElementType - The type of the elements in the array.\n *\n * @returns {TArrayType<Exclude<ElementType, undefined>, Exclude<OptionsType, Options.MaybeDefined>>}\n * A new `Array` of type `Exclude<ElementType, undefined>` and `OptionsType` that is the given\n * {@link OptionsType}, with the {@link Options.MaybeDefined} option removed.\n *\n * @example With the given {@link ElementType} including `undefined`.\n * ```typescript\n * const MaybeOddNumbers: TArray<number | undefined> = [ 1, 3, undefined, 5 ];\n * const OddNumbers: TArray<number> = FilterDefined(MaybeOddNumbers);\n * ```\n * @example With the given {@link OptionsType} including `Options.MaybeDefined`.\n * ```typescript\n * const MaybeOddNumbers: TArray<number, Options.MaybeDefined> = [ 1, 3, undefined, 5 ];\n * const OddNumbers: TArray<number> = FilterDefined(MaybeOddNumbers);\n * ```\n */\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType>;\nexport function FilterDefined<ElementType, OptionsType extends Options = NoOptions, ArraySize extends number = number>(Array: TArrayType<ElementType | undefined, OptionsType | Options.MaybeDefined, ArraySize>): FilteredArray<ElementType> {\n    return Array.filter((Element: ElementType | undefined): boolean => {\n        return Element !== undefined;\n    }) as FilteredArray<ElementType>;\n}\n"],
   "mappings": ";AAgCO,SAAS,cAAuG,OAAuH;AAC1O,SAAO,MAAM,OAAO,CAAC,YAA8C;AAC/D,WAAO,YAAY;AAAA,EACvB,CAAC;AACL;",
   "names": []

package/Distribution/{CJS/async.js → async.cjs}

@@ -171,4 +171,4 @@ var TPromise = class _TPromise extends TPromiseLike {
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-//# sourceMappingURL=async.js.map
+//# sourceMappingURL=async.cjs.map

package/Distribution/{CJS/async.js.map → async.cjs.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Async/index.ts", "../../Source/Miscellaneous/Utility.Types.ts", "../../Source/Async/Async.ts"],
+  "sources": ["../Source/Async/index.ts", "../Source/Miscellaneous/Utility.Types.ts", "../Source/Async/Async.ts"],
   "sourcesContent": ["/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Async.ts\";\nexport * from \"./Async.Types.ts\";\n", "/**\n * @file      Utility.Types.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport type * as TypeScript from \"typescript\";\nimport type { NoOptions } from \"./Utility.Internal.ts\";\n/**\n * @deprecated Use {@link TMutable} instead.\n *\n * Defines a type that corresponds to {@link RecordLike}, such that every\n * `readonly` modifier is removed, recursively.\n *\n * @template RecordLike - The type to make writeable.\n */\nexport type TDeepWriteable<RecordLike> = {\n    -readonly [Key in keyof RecordLike]: TDeepWriteable<RecordLike[Key]>;\n};\n/**\n * Defines a type that corresponds to {@link RecordLike}, such that every\n * `readonly` modifier is removed, recursively.\n *\n * @template RecordLike - The type to make writeable.\n * @template ShallowOption - Whether the `readonly` modifier should be stripped recursively.\n * If `true` (the default), then only the properties of the given type will have the `readonly`\n * modifier stripped (that is, if any of these properties is a {@link Record} type with `readonly`\n * modifiers, then those will *not* be removed if {@link ShallowOption} is `true`).\n */\nexport type TMutable<RecordLike, ShallowOption extends boolean = true> = ShallowOption extends false ? {\n    -readonly [Key in keyof RecordLike]: RecordLike[Key];\n} : ShallowOption extends true ? {\n    -readonly [Key in keyof RecordLike]: TMutable<RecordLike[Key]>;\n} : never;\n/**\n * Given a {@link RecordLike | record-like type}, this type is the union\n * of the values of all properties in the {@link RecordLike | record-like type}.\n *\n * @template RecordLike - The record-like type from which this type extracts value types.\n */\nexport type TValues<RecordLike> = RecordLike[keyof RecordLike];\n/**\n * The union of a given {@link ElementType} and the array of a given {@link ElementType}.\n *\n * @template ElementType - The type of this, or the type of elements contained by this.\n */\nexport type TMaybeArray<ElementType> = ElementType | Array<ElementType>;\n/**\n * The element type of the return value of `Object.entries()`.\n *\n * @template RecordLike - The record-like type of the argument of `Object.entries()`.\n * @template KeyType - The subset of keys used by this type.\n */\nexport type TEntry<RecordLike, KeyType extends keyof RecordLike = keyof RecordLike> = [\n    KeyType,\n    RecordLike[KeyType]\n];\n/** The type used in `OptionsType`s when no options are specified. */\nexport type NoOptions = typeof NoOptions;\n/**\n * Define options for a given type as a union of `unique symbol` types.\n * All options must be *optional* by the type that uses these options.\n * The type that uses these options should have a type parameter `OptionsType`\n * defined with `OptionsType extends TOptions = NoOptions`.  You will have to import\n * {@link NoOptions}, but this should be done anyway, since making all options types\n * optional should be optional.  For this reason {@link NoOptions} is exported from the\n * same module as this type.\n *\n * @template OptionsType - The `unique symbol` types that act as options.\n *\n * @example * See the {@link Array.Options:type} type as an example.\n */\nexport type TOptions<OptionsType extends symbol = NoOptions> = OptionsType | NoOptions;\nexport type TNullable<Type> = Type | null | undefined;\nexport class AbstractMethodCallError extends Error {\n    public constructor(ClassName?: string) {\n        super(ClassName);\n    }\n}\n/** The type corresponding to the schema of `tsconfig.json`. */\nexport interface FTsConfig {\n    extends?: string | Array<string>;\n    files?: Array<string>;\n    include?: Array<string>;\n    exclude?: Array<string>;\n    references?: Array<TypeScript.ProjectReference>;\n    compilerOptions?: FCompilerOptions;\n    watchOptions?: TypeScript.WatchOptions;\n    typeAcquisition?: TypeScript.TypeAcquisition;\n    compileOnSave?: boolean;\n}\ntype FOverriddenCompilerOptions = \"jsx\" | \"lib\" | \"module\" | \"moduleResolution\" | \"target\";\ntype FCompilerOptions = Omit<TypeScript.server.protocol.CompilerOptions, FOverriddenCompilerOptions> & Partial<{\n    jsx: JsxEmit;\n    lib: Array<string>;\n    module: FModuleKind;\n    moduleResolution: FModuleResolutionKind;\n    target: FTarget;\n}>;\ntype JsxEmit = \"none\" | \"preserve\" | \"react-native\" | \"react\" | \"react-jsx\" | \"react-jsxdev\";\ntype FModuleKind = \"none\" | \"commonjs\" | \"amd\" | \"umd\" | \"system\" | \"es6\" | \"es2015\" | \"es2020\" | \"es2022\" | \"esnext\" | \"node16\" | \"node18\" | \"node20\" | \"nodenext\" | \"preserve\";\ntype FModuleResolutionKind = \"classic\" | \"node\" | \"node\" | \"node10\" | \"node16\" | \"nodenext\" | \"bundler\";\nexport type FTarget = \"es3\" | \"es5\" | \"es6\" | \"es2015\" | \"es2016\" | \"es2017\" | \"es2018\" | \"es2019\" | \"es2020\" | \"es2021\" | \"es2022\" | \"es2023\" | \"es2024\" | \"es2025\" | \"esnext\" | \"json\" | \"esnext\" | \"es2025\";\n", "/**\n * @file      Async.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { AbstractMethodCallError, type TNullable } from \"../Miscellaneous/Utility.Types.ts\";\nimport type { TOnFulfilled, TOnRejected, TPromiseCtorArgument, TTryResult, TTrySource } from \"./Async.Types.ts\";\nimport type { TFunction } from \"../Functional/Functional.Types.ts\";\n/**\n * Implements \"Errors-as-values\" for `async` functions and `Promise<DataType>`s.\n *\n * If the `async` function or `Promise<DataType>` returns/resolves, then the `Error`\n * property of the returned object will be `undefined`, and the result of the\n * `async` function or `Promise<DataType>` will reside in the `Data` property of the\n * returned object.\n *\n * Similarly, if the `async` function or `Promise<DataType>` throws, then the `Data`\n * property of the returned object is `undefined`, and the `Error` property is what\n * was thrown to the `catch` block.\n *\n * @template DataType - The type of the data that the `async` function or `Promise<DataType>`.\n * @param Source - The `async` function or `Promise` to evaluate.\n *\n * @returns {TTryResult<DataType>} A {@link TTryResult} containing either the result\n * ({@link TTryResult.Data}) or error {@link TTryResult.Error}.\n *\n * @example\n * // With an `async` function,\n * async function GetName(): Promise<string> { ... }\n * // Or, with a `Promise`,\n * const GetName: Promise<string> = new Promise<string>(...);\n *\n * // For both of the above cases, `Try` behaves the same:\n * const { Data: Name, Error: NameError } = await Try(GetName);\n * // If `GetName` returned,\n * // `typeof Name` <- `\"string\"`\n * // `typeof NameError` <- `\"undefined\"`\n * // If `GetName` threw,\n * // `typeof Name` <- `\"undefined\"`\n * // `NameError !== undefined` <- `true` (Unless `GetName` threw `undefined`).\n */\nexport async function Try<DataType>(Source: TTrySource<DataType>): Promise<TTryResult<DataType>> {\n    try {\n        const Data: DataType = typeof Source === \"function\"\n            ? await Source()\n            : await Source;\n        return {\n            Data,\n            Error: undefined\n        };\n    }\n    catch (ErrorValue: unknown) {\n        return {\n            Data: undefined,\n            Error: ErrorValue\n        };\n    }\n}\n/**\n * A cleaner way of using `Array.prototype.map` with an `async` function.\n *\n * @template ArgumentElementType - The type of the given {@link Elements}.\n * @template ReturnElementType - The type of the `Array` returned by this.\n *\n * @param Elements - The `Array` that will be transformed.\n * @param Mapper - The function that maps each {@link ArgumentElementType}\n * to a {@link ReturnElementType}.\n *\n * @returns {Array<ReturnElementType>} An `Array` of {@link ReturnElementType}.\n *\n * @example\n * In an `async` function,\n * ```typescript\n * const ArgumentElements: Array<ArgumentElementType> = [ ... ];\n * const ToReturnElement = async (Element: ArgumentElementType): Promise<ReturnElementType> => ...;\n * const ReturnElements: Array<ReturnElementType> = await Map(ArgumentElements, ToReturnElement);\n * ```\n */\nexport async function Map<ArgumentElementType, ReturnElementType>(Elements: Array<ArgumentElementType>, Mapper: ((Element: ArgumentElementType) => Promise<ReturnElementType>)): Promise<Array<ReturnElementType>> {\n    const MapperWrapped = async (Element: ArgumentElementType): Promise<ReturnElementType> => {\n        return Mapper(Element);\n    };\n    const Out: Array<Promise<ReturnElementType>> = Elements.map(MapperWrapped);\n    return await Promise.all(Out);\n}\n/**\n * An abstract implementation of {@link PromiseLike}.  This exists only to maintain the\n * project's naming convention.\n */\nexport abstract class TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {\n    public then<ResultType = ResolveType, RejectType = never>(_OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, _OnRejected?: TOnRejected<RejectType>): TPromiseLike<ResultType | RejectType> {\n        throw new AbstractMethodCallError(\"TPromiseLike\");\n    }\n}\n/**\n * The {@link TypeError} that is thrown by the constructor of {@link TPromise}\n * iff it receives an argument that is not a {@link TPromiseCtorArgument}.\n * It does not provide any additional information (in particular, it does not\n * add any properties, and it does not set any properties inherited from\n * {@link TypeError}).\n *\n * @note While the argument type of {@link TPromise}'s constructor is checked at runtime,\n * the type checker should prevent the error described by this from happening.\n */\nexport class FPromiseInstantiationError extends TypeError {\n    public constructor() {\n        super();\n    }\n}\n/**\n * A `then`-able wrapper of {@link Promise}.\n *\n * @template ResolveType - The type to which this resolves, if it does resolve.\n */\nexport class TPromise<ResolveType> extends TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {\n    public constructor(Argument: TPromiseCtorArgument<ResolveType>) {\n        super();\n        if (typeof Argument === \"function\") {\n            this.Underlying = new Promise<ResolveType>(Argument);\n        }\n        else {\n            if (Argument instanceof TPromise) {\n                this.Underlying = Argument.Raw();\n            }\n            else if (Argument instanceof Promise) {\n                this.Underlying = Argument;\n            }\n        }\n        throw new FPromiseInstantiationError();\n    }\n    private readonly Underlying: Promise<ResolveType>;\n    /**\n     * This class's extension of {@link Promise!then}.\n     *\n     * @template ResultType - The type to which the value underlying the {@link TPromise} returned by this\n     * will resolve, if the {@link TPromise} resolves.\n     *\n     * @template RejectType - The type to which the value underlying the {@link TPromise} returned by this\n     * will reject, if the {@link TPromise} rejects.\n     *\n     * @param OnFulfilled - The callback that is called when the underlying {@link Promise} resolves,\n     * if it resolves.\n     *\n     * @param OnRejected - The callback that is called when the underlying {@link Promise} rejects,\n     * if it rejects.\n     *\n     * @returns {TPromise<ResultType | RejectType>} A new {@link TPromise} of the result of the\n     * given callbacks.\n     *\n     * @example\n     * ```typescript\n     * const Example: TPromise<string> = new TPromise<string>((Resolve, Reject) =>\n     * {\n     *     if (Math.random() < 0.5)\n     *     {\n     *         Resolve(\"Success\");\n     *     }\n     *     else\n     *     {\n     *         Reject(\"Error\");\n     *     }\n     * });\n     *\n     * Example.then(\n     *     (Value: string): void =>\n     *     {\n     *         // `Value` <- `\"Success\"`\n     *     },\n     *     (Reason: unknown): void =>\n     *     {\n     *         // `Reason` <- `\"Error\"`\n     *     }\n     * );\n     * ```\n     */\n    public Then<ResultType = ResolveType, RejectType = never>(OnFulfilled: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType> {\n        return new TPromise<ResultType | RejectType>(this.Underlying.then(OnFulfilled, OnRejected));\n    }\n    public override then<ResultType = ResolveType, RejectType = never>(OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType> {\n        return new TPromise<ResultType | RejectType>(this.Underlying.then(OnFulfilled, OnRejected));\n    }\n    public Catch<ResultType = never>(OnRejected?: TNullable<TOnRejected<ResolveType>>): TPromiseLike<ResolveType | ResultType> {\n        return new TPromise<ResolveType | ResultType>(this.Underlying.catch(OnRejected));\n    }\n    public Finally(OnFinally?: TNullable<TFunction>): TPromise<ResolveType> {\n        return new TPromise(this.Underlying.finally(OnFinally));\n    }\n    public static Resolve<ResolveType>(Value: ResolveType | PromiseLike<ResolveType>): TPromise<Awaited<ResolveType>> {\n        return new TPromise(Promise.resolve(Value));\n    }\n    public static Reject<ResolveType = unknown>(Reason?: unknown): TPromise<ResolveType> {\n        return new TPromise(Promise.reject<ResolveType>(Reason));\n    }\n    public Raw(): Promise<ResolveType> {\n        return this.Underlying;\n    }\n}\n;\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC0EO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EACxC,YAAY,WAAoB;AACnC,UAAM,SAAS;AAAA,EACnB;AACJ;;;ACpCA,eAAsB,IAAc,QAA6D;AAC7F,MAAI;AACA,UAAM,OAAiB,OAAO,WAAW,aACnC,MAAM,OAAO,IACb,MAAM;AACZ,WAAO;AAAA,MACH;AAAA,MACA,OAAO;AAAA,IACX;AAAA,EACJ,SACO,YAAqB;AACxB,WAAO;AAAA,MACH,MAAM;AAAA,MACN,OAAO;AAAA,IACX;AAAA,EACJ;AACJ;AAqBA,eAAsB,IAA4C,UAAsC,QAA2G;AAC/M,QAAM,gBAAgB,OAAO,YAA6D;AACtF,WAAO,OAAO,OAAO;AAAA,EACzB;AACA,QAAM,MAAyC,SAAS,IAAI,aAAa;AACzE,SAAO,MAAM,QAAQ,IAAI,GAAG;AAChC;AAKO,IAAe,eAAf,MAA6E;AAAA,EACzE,KAAmD,cAAsD,aAA8E;AAC1L,UAAM,IAAI,wBAAwB,cAAc;AAAA,EACpD;AACJ;AAWO,IAAM,6BAAN,cAAyC,UAAU;AAAA,EAC/C,cAAc;AACjB,UAAM;AAAA,EACV;AACJ;AAMO,IAAM,WAAN,MAAM,kBAA8B,aAA8D;AAAA,EAC9F,YAAY,UAA6C;AAC5D,UAAM;AACN,QAAI,OAAO,aAAa,YAAY;AAChC,WAAK,aAAa,IAAI,QAAqB,QAAQ;AAAA,IACvD,OACK;AACD,UAAI,oBAAoB,WAAU;AAC9B,aAAK,aAAa,SAAS,IAAI;AAAA,MACnC,WACS,oBAAoB,SAAS;AAClC,aAAK,aAAa;AAAA,MACtB;AAAA,IACJ;AACA,UAAM,IAAI,2BAA2B;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA8CO,KAAmD,aAAoD,YAAyE;AACnL,WAAO,IAAI,UAAkC,KAAK,WAAW,KAAK,aAAa,UAAU,CAAC;AAAA,EAC9F;AAAA,EACgB,KAAmD,aAAqD,YAAyE;AAC7L,WAAO,IAAI,UAAkC,KAAK,WAAW,KAAK,aAAa,UAAU,CAAC;AAAA,EAC9F;AAAA,EACO,MAA0B,YAA0F;AACvH,WAAO,IAAI,UAAmC,KAAK,WAAW,MAAM,UAAU,CAAC;AAAA,EACnF;AAAA,EACO,QAAQ,WAAyD;AACpE,WAAO,IAAI,UAAS,KAAK,WAAW,QAAQ,SAAS,CAAC;AAAA,EAC1D;AAAA,EACA,OAAc,QAAqB,OAA+E;AAC9G,WAAO,IAAI,UAAS,QAAQ,QAAQ,KAAK,CAAC;AAAA,EAC9C;AAAA,EACA,OAAc,OAA8B,QAAyC;AACjF,WAAO,IAAI,UAAS,QAAQ,OAAoB,MAAM,CAAC;AAAA,EAC3D;AAAA,EACO,MAA4B;AAC/B,WAAO,KAAK;AAAA,EAChB;AACJ;",
   "names": []

package/Distribution/{ESM/async.js.map → async.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Miscellaneous/Utility.Types.ts", "../../Source/Async/Async.ts"],
+  "sources": ["../Source/Miscellaneous/Utility.Types.ts", "../Source/Async/Async.ts"],
   "sourcesContent": ["/**\n * @file      Utility.Types.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport type * as TypeScript from \"typescript\";\nimport type { NoOptions } from \"./Utility.Internal.ts\";\n/**\n * @deprecated Use {@link TMutable} instead.\n *\n * Defines a type that corresponds to {@link RecordLike}, such that every\n * `readonly` modifier is removed, recursively.\n *\n * @template RecordLike - The type to make writeable.\n */\nexport type TDeepWriteable<RecordLike> = {\n    -readonly [Key in keyof RecordLike]: TDeepWriteable<RecordLike[Key]>;\n};\n/**\n * Defines a type that corresponds to {@link RecordLike}, such that every\n * `readonly` modifier is removed, recursively.\n *\n * @template RecordLike - The type to make writeable.\n * @template ShallowOption - Whether the `readonly` modifier should be stripped recursively.\n * If `true` (the default), then only the properties of the given type will have the `readonly`\n * modifier stripped (that is, if any of these properties is a {@link Record} type with `readonly`\n * modifiers, then those will *not* be removed if {@link ShallowOption} is `true`).\n */\nexport type TMutable<RecordLike, ShallowOption extends boolean = true> = ShallowOption extends false ? {\n    -readonly [Key in keyof RecordLike]: RecordLike[Key];\n} : ShallowOption extends true ? {\n    -readonly [Key in keyof RecordLike]: TMutable<RecordLike[Key]>;\n} : never;\n/**\n * Given a {@link RecordLike | record-like type}, this type is the union\n * of the values of all properties in the {@link RecordLike | record-like type}.\n *\n * @template RecordLike - The record-like type from which this type extracts value types.\n */\nexport type TValues<RecordLike> = RecordLike[keyof RecordLike];\n/**\n * The union of a given {@link ElementType} and the array of a given {@link ElementType}.\n *\n * @template ElementType - The type of this, or the type of elements contained by this.\n */\nexport type TMaybeArray<ElementType> = ElementType | Array<ElementType>;\n/**\n * The element type of the return value of `Object.entries()`.\n *\n * @template RecordLike - The record-like type of the argument of `Object.entries()`.\n * @template KeyType - The subset of keys used by this type.\n */\nexport type TEntry<RecordLike, KeyType extends keyof RecordLike = keyof RecordLike> = [\n    KeyType,\n    RecordLike[KeyType]\n];\n/** The type used in `OptionsType`s when no options are specified. */\nexport type NoOptions = typeof NoOptions;\n/**\n * Define options for a given type as a union of `unique symbol` types.\n * All options must be *optional* by the type that uses these options.\n * The type that uses these options should have a type parameter `OptionsType`\n * defined with `OptionsType extends TOptions = NoOptions`.  You will have to import\n * {@link NoOptions}, but this should be done anyway, since making all options types\n * optional should be optional.  For this reason {@link NoOptions} is exported from the\n * same module as this type.\n *\n * @template OptionsType - The `unique symbol` types that act as options.\n *\n * @example * See the {@link Array.Options:type} type as an example.\n */\nexport type TOptions<OptionsType extends symbol = NoOptions> = OptionsType | NoOptions;\nexport type TNullable<Type> = Type | null | undefined;\nexport class AbstractMethodCallError extends Error {\n    public constructor(ClassName?: string) {\n        super(ClassName);\n    }\n}\n/** The type corresponding to the schema of `tsconfig.json`. */\nexport interface FTsConfig {\n    extends?: string | Array<string>;\n    files?: Array<string>;\n    include?: Array<string>;\n    exclude?: Array<string>;\n    references?: Array<TypeScript.ProjectReference>;\n    compilerOptions?: FCompilerOptions;\n    watchOptions?: TypeScript.WatchOptions;\n    typeAcquisition?: TypeScript.TypeAcquisition;\n    compileOnSave?: boolean;\n}\ntype FOverriddenCompilerOptions = \"jsx\" | \"lib\" | \"module\" | \"moduleResolution\" | \"target\";\ntype FCompilerOptions = Omit<TypeScript.server.protocol.CompilerOptions, FOverriddenCompilerOptions> & Partial<{\n    jsx: JsxEmit;\n    lib: Array<string>;\n    module: FModuleKind;\n    moduleResolution: FModuleResolutionKind;\n    target: FTarget;\n}>;\ntype JsxEmit = \"none\" | \"preserve\" | \"react-native\" | \"react\" | \"react-jsx\" | \"react-jsxdev\";\ntype FModuleKind = \"none\" | \"commonjs\" | \"amd\" | \"umd\" | \"system\" | \"es6\" | \"es2015\" | \"es2020\" | \"es2022\" | \"esnext\" | \"node16\" | \"node18\" | \"node20\" | \"nodenext\" | \"preserve\";\ntype FModuleResolutionKind = \"classic\" | \"node\" | \"node\" | \"node10\" | \"node16\" | \"nodenext\" | \"bundler\";\nexport type FTarget = \"es3\" | \"es5\" | \"es6\" | \"es2015\" | \"es2016\" | \"es2017\" | \"es2018\" | \"es2019\" | \"es2020\" | \"es2021\" | \"es2022\" | \"es2023\" | \"es2024\" | \"es2025\" | \"esnext\" | \"json\" | \"esnext\" | \"es2025\";\n", "/**\n * @file      Async.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { AbstractMethodCallError, type TNullable } from \"../Miscellaneous/Utility.Types.ts\";\nimport type { TOnFulfilled, TOnRejected, TPromiseCtorArgument, TTryResult, TTrySource } from \"./Async.Types.ts\";\nimport type { TFunction } from \"../Functional/Functional.Types.ts\";\n/**\n * Implements \"Errors-as-values\" for `async` functions and `Promise<DataType>`s.\n *\n * If the `async` function or `Promise<DataType>` returns/resolves, then the `Error`\n * property of the returned object will be `undefined`, and the result of the\n * `async` function or `Promise<DataType>` will reside in the `Data` property of the\n * returned object.\n *\n * Similarly, if the `async` function or `Promise<DataType>` throws, then the `Data`\n * property of the returned object is `undefined`, and the `Error` property is what\n * was thrown to the `catch` block.\n *\n * @template DataType - The type of the data that the `async` function or `Promise<DataType>`.\n * @param Source - The `async` function or `Promise` to evaluate.\n *\n * @returns {TTryResult<DataType>} A {@link TTryResult} containing either the result\n * ({@link TTryResult.Data}) or error {@link TTryResult.Error}.\n *\n * @example\n * // With an `async` function,\n * async function GetName(): Promise<string> { ... }\n * // Or, with a `Promise`,\n * const GetName: Promise<string> = new Promise<string>(...);\n *\n * // For both of the above cases, `Try` behaves the same:\n * const { Data: Name, Error: NameError } = await Try(GetName);\n * // If `GetName` returned,\n * // `typeof Name` <- `\"string\"`\n * // `typeof NameError` <- `\"undefined\"`\n * // If `GetName` threw,\n * // `typeof Name` <- `\"undefined\"`\n * // `NameError !== undefined` <- `true` (Unless `GetName` threw `undefined`).\n */\nexport async function Try<DataType>(Source: TTrySource<DataType>): Promise<TTryResult<DataType>> {\n    try {\n        const Data: DataType = typeof Source === \"function\"\n            ? await Source()\n            : await Source;\n        return {\n            Data,\n            Error: undefined\n        };\n    }\n    catch (ErrorValue: unknown) {\n        return {\n            Data: undefined,\n            Error: ErrorValue\n        };\n    }\n}\n/**\n * A cleaner way of using `Array.prototype.map` with an `async` function.\n *\n * @template ArgumentElementType - The type of the given {@link Elements}.\n * @template ReturnElementType - The type of the `Array` returned by this.\n *\n * @param Elements - The `Array` that will be transformed.\n * @param Mapper - The function that maps each {@link ArgumentElementType}\n * to a {@link ReturnElementType}.\n *\n * @returns {Array<ReturnElementType>} An `Array` of {@link ReturnElementType}.\n *\n * @example\n * In an `async` function,\n * ```typescript\n * const ArgumentElements: Array<ArgumentElementType> = [ ... ];\n * const ToReturnElement = async (Element: ArgumentElementType): Promise<ReturnElementType> => ...;\n * const ReturnElements: Array<ReturnElementType> = await Map(ArgumentElements, ToReturnElement);\n * ```\n */\nexport async function Map<ArgumentElementType, ReturnElementType>(Elements: Array<ArgumentElementType>, Mapper: ((Element: ArgumentElementType) => Promise<ReturnElementType>)): Promise<Array<ReturnElementType>> {\n    const MapperWrapped = async (Element: ArgumentElementType): Promise<ReturnElementType> => {\n        return Mapper(Element);\n    };\n    const Out: Array<Promise<ReturnElementType>> = Elements.map(MapperWrapped);\n    return await Promise.all(Out);\n}\n/**\n * An abstract implementation of {@link PromiseLike}.  This exists only to maintain the\n * project's naming convention.\n */\nexport abstract class TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {\n    public then<ResultType = ResolveType, RejectType = never>(_OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, _OnRejected?: TOnRejected<RejectType>): TPromiseLike<ResultType | RejectType> {\n        throw new AbstractMethodCallError(\"TPromiseLike\");\n    }\n}\n/**\n * The {@link TypeError} that is thrown by the constructor of {@link TPromise}\n * iff it receives an argument that is not a {@link TPromiseCtorArgument}.\n * It does not provide any additional information (in particular, it does not\n * add any properties, and it does not set any properties inherited from\n * {@link TypeError}).\n *\n * @note While the argument type of {@link TPromise}'s constructor is checked at runtime,\n * the type checker should prevent the error described by this from happening.\n */\nexport class FPromiseInstantiationError extends TypeError {\n    public constructor() {\n        super();\n    }\n}\n/**\n * A `then`-able wrapper of {@link Promise}.\n *\n * @template ResolveType - The type to which this resolves, if it does resolve.\n */\nexport class TPromise<ResolveType> extends TPromiseLike<ResolveType> implements PromiseLike<ResolveType> {\n    public constructor(Argument: TPromiseCtorArgument<ResolveType>) {\n        super();\n        if (typeof Argument === \"function\") {\n            this.Underlying = new Promise<ResolveType>(Argument);\n        }\n        else {\n            if (Argument instanceof TPromise) {\n                this.Underlying = Argument.Raw();\n            }\n            else if (Argument instanceof Promise) {\n                this.Underlying = Argument;\n            }\n        }\n        throw new FPromiseInstantiationError();\n    }\n    private readonly Underlying: Promise<ResolveType>;\n    /**\n     * This class's extension of {@link Promise!then}.\n     *\n     * @template ResultType - The type to which the value underlying the {@link TPromise} returned by this\n     * will resolve, if the {@link TPromise} resolves.\n     *\n     * @template RejectType - The type to which the value underlying the {@link TPromise} returned by this\n     * will reject, if the {@link TPromise} rejects.\n     *\n     * @param OnFulfilled - The callback that is called when the underlying {@link Promise} resolves,\n     * if it resolves.\n     *\n     * @param OnRejected - The callback that is called when the underlying {@link Promise} rejects,\n     * if it rejects.\n     *\n     * @returns {TPromise<ResultType | RejectType>} A new {@link TPromise} of the result of the\n     * given callbacks.\n     *\n     * @example\n     * ```typescript\n     * const Example: TPromise<string> = new TPromise<string>((Resolve, Reject) =>\n     * {\n     *     if (Math.random() < 0.5)\n     *     {\n     *         Resolve(\"Success\");\n     *     }\n     *     else\n     *     {\n     *         Reject(\"Error\");\n     *     }\n     * });\n     *\n     * Example.then(\n     *     (Value: string): void =>\n     *     {\n     *         // `Value` <- `\"Success\"`\n     *     },\n     *     (Reason: unknown): void =>\n     *     {\n     *         // `Reason` <- `\"Error\"`\n     *     }\n     * );\n     * ```\n     */\n    public Then<ResultType = ResolveType, RejectType = never>(OnFulfilled: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType> {\n        return new TPromise<ResultType | RejectType>(this.Underlying.then(OnFulfilled, OnRejected));\n    }\n    public override then<ResultType = ResolveType, RejectType = never>(OnFulfilled?: TOnFulfilled<ResolveType, ResultType>, OnRejected?: TOnRejected<RejectType>): TPromise<ResultType | RejectType> {\n        return new TPromise<ResultType | RejectType>(this.Underlying.then(OnFulfilled, OnRejected));\n    }\n    public Catch<ResultType = never>(OnRejected?: TNullable<TOnRejected<ResolveType>>): TPromiseLike<ResolveType | ResultType> {\n        return new TPromise<ResolveType | ResultType>(this.Underlying.catch(OnRejected));\n    }\n    public Finally(OnFinally?: TNullable<TFunction>): TPromise<ResolveType> {\n        return new TPromise(this.Underlying.finally(OnFinally));\n    }\n    public static Resolve<ResolveType>(Value: ResolveType | PromiseLike<ResolveType>): TPromise<Awaited<ResolveType>> {\n        return new TPromise(Promise.resolve(Value));\n    }\n    public static Reject<ResolveType = unknown>(Reason?: unknown): TPromise<ResolveType> {\n        return new TPromise(Promise.reject<ResolveType>(Reason));\n    }\n    public Raw(): Promise<ResolveType> {\n        return this.Underlying;\n    }\n}\n;\n"],
   "mappings": ";AA0EO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EACxC,YAAY,WAAoB;AACnC,UAAM,SAAS;AAAA,EACnB;AACJ;;;ACpCA,eAAsB,IAAc,QAA6D;AAC7F,MAAI;AACA,UAAM,OAAiB,OAAO,WAAW,aACnC,MAAM,OAAO,IACb,MAAM;AACZ,WAAO;AAAA,MACH;AAAA,MACA,OAAO;AAAA,IACX;AAAA,EACJ,SACO,YAAqB;AACxB,WAAO;AAAA,MACH,MAAM;AAAA,MACN,OAAO;AAAA,IACX;AAAA,EACJ;AACJ;AAqBA,eAAsB,IAA4C,UAAsC,QAA2G;AAC/M,QAAM,gBAAgB,OAAO,YAA6D;AACtF,WAAO,OAAO,OAAO;AAAA,EACzB;AACA,QAAM,MAAyC,SAAS,IAAI,aAAa;AACzE,SAAO,MAAM,QAAQ,IAAI,GAAG;AAChC;AAKO,IAAe,eAAf,MAA6E;AAAA,EACzE,KAAmD,cAAsD,aAA8E;AAC1L,UAAM,IAAI,wBAAwB,cAAc;AAAA,EACpD;AACJ;AAWO,IAAM,6BAAN,cAAyC,UAAU;AAAA,EAC/C,cAAc;AACjB,UAAM;AAAA,EACV;AACJ;AAMO,IAAM,WAAN,MAAM,kBAA8B,aAA8D;AAAA,EAC9F,YAAY,UAA6C;AAC5D,UAAM;AACN,QAAI,OAAO,aAAa,YAAY;AAChC,WAAK,aAAa,IAAI,QAAqB,QAAQ;AAAA,IACvD,OACK;AACD,UAAI,oBAAoB,WAAU;AAC9B,aAAK,aAAa,SAAS,IAAI;AAAA,MACnC,WACS,oBAAoB,SAAS;AAClC,aAAK,aAAa;AAAA,MACtB;AAAA,IACJ;AACA,UAAM,IAAI,2BAA2B;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA8CO,KAAmD,aAAoD,YAAyE;AACnL,WAAO,IAAI,UAAkC,KAAK,WAAW,KAAK,aAAa,UAAU,CAAC;AAAA,EAC9F;AAAA,EACgB,KAAmD,aAAqD,YAAyE;AAC7L,WAAO,IAAI,UAAkC,KAAK,WAAW,KAAK,aAAa,UAAU,CAAC;AAAA,EAC9F;AAAA,EACO,MAA0B,YAA0F;AACvH,WAAO,IAAI,UAAmC,KAAK,WAAW,MAAM,UAAU,CAAC;AAAA,EACnF;AAAA,EACO,QAAQ,WAAyD;AACpE,WAAO,IAAI,UAAS,KAAK,WAAW,QAAQ,SAAS,CAAC;AAAA,EAC1D;AAAA,EACA,OAAc,QAAqB,OAA+E;AAC9G,WAAO,IAAI,UAAS,QAAQ,QAAQ,KAAK,CAAC;AAAA,EAC9C;AAAA,EACA,OAAc,OAA8B,QAAyC;AACjF,WAAO,IAAI,UAAS,QAAQ,OAAoB,MAAM,CAAC;AAAA,EAC3D;AAAA,EACO,MAA4B;AAC/B,WAAO,KAAK;AAAA,EAChB;AACJ;",
   "names": []

package/Distribution/{CJS/complex.js → complex.cjs}

@@ -94,4 +94,4 @@ var i = new FComplex(0, 1);
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-//# sourceMappingURL=complex.js.map
+//# sourceMappingURL=complex.cjs.map

package/Distribution/{CJS/complex.js.map → complex.cjs.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Math/Complex.ts", "../../Source/Math/Complex.Internal.ts"],
+  "sources": ["../Source/Math/Complex.ts", "../Source/Math/Complex.Internal.ts"],
   "sourcesContent": ["/**\n * @file      Complex.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { MathBuiltin } from \"./Complex.Internal\";\nimport { Operator } from \"tsover-runtime\";\n/**\n * Elements of the complex plane, $\\mathbf{C} = \\mathbf{R}[x] / [ x^2 + 1 ]$.\n */\nexport class FComplex {\n    public readonly Re: number;\n    public readonly Im: number;\n    public static Zero: FComplex = new FComplex(0, 0);\n    /**\n     * The copy constructor for {@link FComplex} numbers.\n     *\n     * @param Z - The existing {@link FComplex} number to copy.\n     *\n     * @example\n     * ```typescript\n     * const Z: FComplex = 3 + 2 * i;\n     * const W: FComplex = new FComplex(Z);\n     * // `W.Re === Z.Re` <- `true`\n     * // `W.Im === Z.Im` <- `true`\n     * ```\n     */\n    public constructor(Z: FComplex);\n    /**\n     * Construct an {@link FComplex} number by specifying the real\n     * and imaginary components.\n     *\n     * @param A - The real component of the {@link FComplex} number.\n     * @param B - The imaginary component of the {@link FComplex} number.\n     *\n     * @example\n     * ```typescript\n     * const Theta: number = 0.5;\n     * const OnUnitDisk: FComplex = new FComplex(Math.sin(Theta), Math.cos(Theta));\n     * ```\n     */\n    public constructor(A: number, B: number);\n    public constructor(A: FComplex | number, B: number = 0) {\n        if (typeof A === \"number\") {\n            this.Re = A;\n            this.Im = B;\n        }\n        else {\n            this.Re = A.Re;\n            this.Im = A.Im;\n        }\n    }\n    /**\n     * Get the modulus of this {@link FComplex} number.\n     *\n     * @returns {number} The modulus of this {@link FComplex} number.\n     */\n    public get Mod(): number {\n        return MathBuiltin.sqrt((this.Re ** 2) + (this.Im ** 2));\n    }\n    /**\n     * Get the modulus of this {@link FComplex} number.\n     *\n     * @returns {number} The modulus of this {@link FComplex} number.\n     */\n    public get Theta(): number {\n        const Out: number = MathBuiltin.atan2(this.Im, this.Re);\n        if (Out < 0) {\n            return Out + 2 * MathBuiltin.PI;\n        }\n        return Out;\n    }\n    [Operator.star](A: FComplex, B: FComplex): FComplex;\n    [Operator.star](A: FComplex, B: number): FComplex;\n    [Operator.star](A: number, B: FComplex): FComplex;\n    [Operator.star](A: FComplex | number, B: number | FComplex): FComplex {\n        if (typeof A === \"number\") {\n            return new FComplex((B as FComplex).Re * A, (B as FComplex).Im * A);\n        }\n        else if (typeof B === \"number\") {\n            return new FComplex((A as FComplex).Re * B, (A as FComplex).Im * B);\n        }\n        else {\n            return new FComplex((((A as FComplex).Re + (B as FComplex).Re) -\n                ((A as FComplex).Im + (B as FComplex).Im)), (((A as FComplex).Re + (B as FComplex).Im) +\n                ((B as FComplex).Re + (A as FComplex).Im)));\n        }\n    }\n    [Operator.plus](A: FComplex, B: FComplex): FComplex;\n    [Operator.plus](A: FComplex, B: number): FComplex;\n    [Operator.plus](A: number, B: FComplex): FComplex;\n    [Operator.plus](A: FComplex | number, B: number | FComplex): FComplex {\n        if (typeof A === \"number\") {\n            return new FComplex(A + (B as FComplex).Re, (B as FComplex).Im);\n        }\n        else if (typeof B === \"number\") {\n            return new FComplex((A as FComplex).Re + B, (A as FComplex).Im);\n        }\n        else {\n            return new FComplex((A as FComplex).Re + (B as FComplex).Re, (A as FComplex).Im + (B as FComplex).Im);\n        }\n    }\n}\nexport /**\n       * The imaginary unit.\n       */ const i: FComplex = new FComplex(0, 1);\n", "/**\n * @file      Complex.Internal.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport const MathBuiltin: typeof Math = Math;\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMO,IAAM,cAA2B;;;ADCxC,4BAAyB;AAIlB,IAAM,YAAN,MAAM,UAAS;AAAA,EAgCX,YAAY,GAAsB,IAAY,GAAG;AACpD,QAAI,OAAO,MAAM,UAAU;AACvB,WAAK,KAAK;AACV,WAAK,KAAK;AAAA,IACd,OACK;AACD,WAAK,KAAK,EAAE;AACZ,WAAK,KAAK,EAAE;AAAA,IAChB;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAW,MAAc;AACrB,WAAO,YAAY,KAAM,KAAK,MAAM,IAAM,KAAK,MAAM,CAAE;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAW,QAAgB;AACvB,UAAM,MAAc,YAAY,MAAM,KAAK,IAAI,KAAK,EAAE;AACtD,QAAI,MAAM,GAAG;AACT,aAAO,MAAM,IAAI,YAAY;AAAA,IACjC;AACA,WAAO;AAAA,EACX;AAAA,EAIA,CAAC,+BAAS,IAAI,EAAE,GAAsB,GAAgC;AAClE,QAAI,OAAO,MAAM,UAAU;AACvB,aAAO,IAAI,UAAU,EAAe,KAAK,GAAI,EAAe,KAAK,CAAC;AAAA,IACtE,WACS,OAAO,MAAM,UAAU;AAC5B,aAAO,IAAI,UAAU,EAAe,KAAK,GAAI,EAAe,KAAK,CAAC;AAAA,IACtE,OACK;AACD,aAAO,IAAI,UAAY,EAAe,KAAM,EAAe,MACrD,EAAe,KAAM,EAAe,KAAS,EAAe,KAAM,EAAe,MACjF,EAAe,KAAM,EAAe,GAAI;AAAA,IAClD;AAAA,EACJ;AAAA,EAIA,CAAC,+BAAS,IAAI,EAAE,GAAsB,GAAgC;AAClE,QAAI,OAAO,MAAM,UAAU;AACvB,aAAO,IAAI,UAAS,IAAK,EAAe,IAAK,EAAe,EAAE;AAAA,IAClE,WACS,OAAO,MAAM,UAAU;AAC5B,aAAO,IAAI,UAAU,EAAe,KAAK,GAAI,EAAe,EAAE;AAAA,IAClE,OACK;AACD,aAAO,IAAI,UAAU,EAAe,KAAM,EAAe,IAAK,EAAe,KAAM,EAAe,EAAE;AAAA,IACxG;AAAA,EACJ;AACJ;AA5Fa,UAGK,OAAiB,IAAI,UAAS,GAAG,CAAC;AAH7C,IAAM,WAAN;AA+FG,IAAM,IAAc,IAAI,SAAS,GAAG,CAAC;",
   "names": []

package/Distribution/{ESM/complex.js.map → complex.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Math/Complex.Internal.ts", "../../Source/Math/Complex.ts"],
+  "sources": ["../Source/Math/Complex.Internal.ts", "../Source/Math/Complex.ts"],
   "sourcesContent": ["/**\n * @file      Complex.Internal.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport const MathBuiltin: typeof Math = Math;\n", "/**\n * @file      Complex.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { MathBuiltin } from \"./Complex.Internal\";\nimport { Operator } from \"tsover-runtime\";\n/**\n * Elements of the complex plane, $\\mathbf{C} = \\mathbf{R}[x] / [ x^2 + 1 ]$.\n */\nexport class FComplex {\n    public readonly Re: number;\n    public readonly Im: number;\n    public static Zero: FComplex = new FComplex(0, 0);\n    /**\n     * The copy constructor for {@link FComplex} numbers.\n     *\n     * @param Z - The existing {@link FComplex} number to copy.\n     *\n     * @example\n     * ```typescript\n     * const Z: FComplex = 3 + 2 * i;\n     * const W: FComplex = new FComplex(Z);\n     * // `W.Re === Z.Re` <- `true`\n     * // `W.Im === Z.Im` <- `true`\n     * ```\n     */\n    public constructor(Z: FComplex);\n    /**\n     * Construct an {@link FComplex} number by specifying the real\n     * and imaginary components.\n     *\n     * @param A - The real component of the {@link FComplex} number.\n     * @param B - The imaginary component of the {@link FComplex} number.\n     *\n     * @example\n     * ```typescript\n     * const Theta: number = 0.5;\n     * const OnUnitDisk: FComplex = new FComplex(Math.sin(Theta), Math.cos(Theta));\n     * ```\n     */\n    public constructor(A: number, B: number);\n    public constructor(A: FComplex | number, B: number = 0) {\n        if (typeof A === \"number\") {\n            this.Re = A;\n            this.Im = B;\n        }\n        else {\n            this.Re = A.Re;\n            this.Im = A.Im;\n        }\n    }\n    /**\n     * Get the modulus of this {@link FComplex} number.\n     *\n     * @returns {number} The modulus of this {@link FComplex} number.\n     */\n    public get Mod(): number {\n        return MathBuiltin.sqrt((this.Re ** 2) + (this.Im ** 2));\n    }\n    /**\n     * Get the modulus of this {@link FComplex} number.\n     *\n     * @returns {number} The modulus of this {@link FComplex} number.\n     */\n    public get Theta(): number {\n        const Out: number = MathBuiltin.atan2(this.Im, this.Re);\n        if (Out < 0) {\n            return Out + 2 * MathBuiltin.PI;\n        }\n        return Out;\n    }\n    [Operator.star](A: FComplex, B: FComplex): FComplex;\n    [Operator.star](A: FComplex, B: number): FComplex;\n    [Operator.star](A: number, B: FComplex): FComplex;\n    [Operator.star](A: FComplex | number, B: number | FComplex): FComplex {\n        if (typeof A === \"number\") {\n            return new FComplex((B as FComplex).Re * A, (B as FComplex).Im * A);\n        }\n        else if (typeof B === \"number\") {\n            return new FComplex((A as FComplex).Re * B, (A as FComplex).Im * B);\n        }\n        else {\n            return new FComplex((((A as FComplex).Re + (B as FComplex).Re) -\n                ((A as FComplex).Im + (B as FComplex).Im)), (((A as FComplex).Re + (B as FComplex).Im) +\n                ((B as FComplex).Re + (A as FComplex).Im)));\n        }\n    }\n    [Operator.plus](A: FComplex, B: FComplex): FComplex;\n    [Operator.plus](A: FComplex, B: number): FComplex;\n    [Operator.plus](A: number, B: FComplex): FComplex;\n    [Operator.plus](A: FComplex | number, B: number | FComplex): FComplex {\n        if (typeof A === \"number\") {\n            return new FComplex(A + (B as FComplex).Re, (B as FComplex).Im);\n        }\n        else if (typeof B === \"number\") {\n            return new FComplex((A as FComplex).Re + B, (A as FComplex).Im);\n        }\n        else {\n            return new FComplex((A as FComplex).Re + (B as FComplex).Re, (A as FComplex).Im + (B as FComplex).Im);\n        }\n    }\n}\nexport /**\n       * The imaginary unit.\n       */ const i: FComplex = new FComplex(0, 1);\n"],
   "mappings": ";AAMO,IAAM,cAA2B;;;ACCxC,SAAS,gBAAgB;AAIlB,IAAM,YAAN,MAAM,UAAS;AAAA,EAgCX,YAAY,GAAsB,IAAY,GAAG;AACpD,QAAI,OAAO,MAAM,UAAU;AACvB,WAAK,KAAK;AACV,WAAK,KAAK;AAAA,IACd,OACK;AACD,WAAK,KAAK,EAAE;AACZ,WAAK,KAAK,EAAE;AAAA,IAChB;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAW,MAAc;AACrB,WAAO,YAAY,KAAM,KAAK,MAAM,IAAM,KAAK,MAAM,CAAE;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAW,QAAgB;AACvB,UAAM,MAAc,YAAY,MAAM,KAAK,IAAI,KAAK,EAAE;AACtD,QAAI,MAAM,GAAG;AACT,aAAO,MAAM,IAAI,YAAY;AAAA,IACjC;AACA,WAAO;AAAA,EACX;AAAA,EAIA,CAAC,SAAS,IAAI,EAAE,GAAsB,GAAgC;AAClE,QAAI,OAAO,MAAM,UAAU;AACvB,aAAO,IAAI,UAAU,EAAe,KAAK,GAAI,EAAe,KAAK,CAAC;AAAA,IACtE,WACS,OAAO,MAAM,UAAU;AAC5B,aAAO,IAAI,UAAU,EAAe,KAAK,GAAI,EAAe,KAAK,CAAC;AAAA,IACtE,OACK;AACD,aAAO,IAAI,UAAY,EAAe,KAAM,EAAe,MACrD,EAAe,KAAM,EAAe,KAAS,EAAe,KAAM,EAAe,MACjF,EAAe,KAAM,EAAe,GAAI;AAAA,IAClD;AAAA,EACJ;AAAA,EAIA,CAAC,SAAS,IAAI,EAAE,GAAsB,GAAgC;AAClE,QAAI,OAAO,MAAM,UAAU;AACvB,aAAO,IAAI,UAAS,IAAK,EAAe,IAAK,EAAe,EAAE;AAAA,IAClE,WACS,OAAO,MAAM,UAAU;AAC5B,aAAO,IAAI,UAAU,EAAe,KAAK,GAAI,EAAe,EAAE;AAAA,IAClE,OACK;AACD,aAAO,IAAI,UAAU,EAAe,KAAM,EAAe,IAAK,EAAe,KAAM,EAAe,EAAE;AAAA,IACxG;AAAA,EACJ;AACJ;AA5Fa,UAGK,OAAiB,IAAI,UAAS,GAAG,CAAC;AAH7C,IAAM,WAAN;AA+FG,IAAM,IAAc,IAAI,SAAS,GAAG,CAAC;",
   "names": []

package/Distribution/{CJS/effect.js → effect.cjs}

@@ -60,4 +60,4 @@ __reExport(Index_Effect_exports, require("effect"));
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-//# sourceMappingURL=effect.js.map
+//# sourceMappingURL=effect.cjs.map

package/Distribution/{CJS/effect.js.map → effect.cjs.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Effect/index.ts", "../../Source/Effect/Index.Effect.ts", "../../Source/Effect/Effect.ts"],
+  "sources": ["../Source/Effect/index.ts", "../Source/Effect/Index.Effect.ts", "../Source/Effect/Effect.ts"],
   "sourcesContent": ["/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * as Effect from \"./Index.Effect.ts\";\n", "/**\n * @file      Index.Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Effect.ts\";\nexport * from \"./Effect.Types.ts\";\nexport * from \"effect\";\n", "/**\n * @file      Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport const FooEffect: string = \"\";\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;;;ACMO,IAAM,YAAoB;;;ADEjC,iCAAc;",
   "names": []

package/Distribution/{ESM/effect.js.map → effect.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../Source/Effect/Index.Effect.ts", "../../Source/Effect/Effect.ts"],
+  "sources": ["../Source/Effect/Index.Effect.ts", "../Source/Effect/Effect.ts"],
   "sourcesContent": ["/**\n * @file      Index.Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Effect.ts\";\nexport * from \"./Effect.Types.ts\";\nexport * from \"effect\";\n", "/**\n * @file      Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport const FooEffect: string = \"\";\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;;;ACMO,IAAM,YAAoB;;;ADEjC;AAAA,6BAAc;",
   "names": []

package/Distribution/{CJS/fs.js → fs.cjs}

@@ -32,18 +32,19 @@ var FileSystem_exports = {};
 __export(FileSystem_exports, {
   GetSafeNewPath: () => GetSafeNewPath,
   IsSupportedFileExtension: () => IsSupportedFileExtension,
-  IsValidFileName: () => IsValidFileName
+  IsValidFileName: () => IsValidFileName,
+  WriteTextFile: () => WriteTextFile
 });
 module.exports = __toCommonJS(FileSystem_exports);
 
 // Source/FileSystem/FileSystem.ts
-var import_promises = require("fs/promises");
 var import_path = require("path");
 var import_fs = require("fs");
+var import_fs2 = require("fs");
 var import_os = __toESM(require("os"), 1);
 async function PathExists(Path) {
   try {
-    await (0, import_promises.access)(Path, import_fs.constants.F_OK);
+    await import_fs.promises.access(Path, import_fs2.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -93,16 +94,19 @@ async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false,
   }
   const FilePath = (0, import_path.join)(DirectoryPath, FileName);
   try {
-    const ThisFileHandle = await (0, import_promises.open)(FilePath, "wx");
+    const ThisFileHandle = await import_fs.promises.open(FilePath, "wx");
     await ThisFileHandle.close();
     if (!PersistNewFile) {
-      await (0, import_promises.unlink)(FilePath);
+      await import_fs.promises.unlink(FilePath);
     }
     return true;
   } catch {
     return false;
   }
 }
+async function WriteTextFile(Path, Contents) {
+  await import_fs.promises.writeFile(Path, Contents, { encoding: "utf-8" });
+}
 /**
  * @file      FileSystem.ts
  * @author    Gage Sorrell <gage@sorrell.sh>
@@ -121,4 +125,4 @@ async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false,
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-//# sourceMappingURL=fs.js.map
+//# sourceMappingURL=fs.cjs.map

package/Distribution/fs.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../Source/FileSystem/index.ts", "../Source/FileSystem/FileSystem.ts"],
+  "sourcesContent": ["/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./FileSystem.ts\";\nexport * from \"./FileSystem.Types.ts\";\n", "/**\n * @file      FileSystem.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { basename, dirname, extname, join } from \"path\";\nimport { type FFileExtension } from \"./FileSystem.Types.ts\";\nimport { type FileHandle } from \"fs/promises\";\nimport { promises as Fs } from \"fs\";\nimport { constants as FsConstants } from \"fs\";\nimport os from \"os\";\nasync function PathExists(Path: string): Promise<boolean> {\n    try {\n        await Fs.access(Path, FsConstants.F_OK);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * @param Extension - The file extension that you wish to test.\n * @returns Whether the file extension is valid on the current platform.\n */\nexport function IsSupportedFileExtension(Extension: FFileExtension): boolean {\n    let NormalizedExtension: string = Extension.slice(1);\n    if (NormalizedExtension.startsWith(\".\")) {\n        NormalizedExtension = NormalizedExtension.slice(1);\n    }\n    if (NormalizedExtension.length === 0) {\n        return false;\n    }\n    if (NormalizedExtension.includes(\"/\")\n        || NormalizedExtension.includes(\"\\\\\")\n        || NormalizedExtension.includes(\"\\0\")) {\n        return false;\n    }\n    if (os.platform() === \"win32\") {\n        /* eslint-disable-next-line no-control-regex */\n        const HasIllegalCharacters: boolean = /[<>:\"/\\\\|?*\\x00-\\x1F]/u.test(NormalizedExtension);\n        if (HasIllegalCharacters) {\n            return false;\n        }\n        if (/[ .]$/u.test(NormalizedExtension)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Given a path at which we wish to create a new file, check if a file at that\n * path already exists, and if so, then append `(${ number })` before the file\n * extension, consistent with the Windows Explorer handles conflicting file\n * names when pasting files.\n */\nexport async function GetSafeNewPath(InPath: string): Promise<string> {\n    const DirectoryPath: string = dirname(InPath);\n    const Extension: string = extname(InPath);\n    const FileName: string = basename(InPath);\n    const BaseFileName: string = Extension === \"\"\n        ? FileName\n        : basename(InPath, Extension);\n    let CandidatePath: string = InPath;\n    let Index: number = 1;\n    while (await PathExists(CandidatePath)) {\n        const CandidateFileName: string = `${BaseFileName} (${Index})${Extension}`;\n        CandidatePath = join(DirectoryPath, CandidateFileName);\n        Index++;\n    }\n    return CandidatePath;\n}\n/**\n * @param DirectoryPath - The path to the directory in which you wish to check.\n * @param FileName - The desired file name.\n * @param PersistNewFile - *(Optional)* Whether to keep the otherwise-temporary\n *                         file created at the desired path.\n * @param Extension - *(Optional)* If provided, the function will only return `true`\n *                    if `FileName.endsWith(Extension)` *and* the `Extension` is a valid\n *                    file extension.\n * @returns Whether a file of the given `FileName` can be created in `DirectoryPath`.\n *\n * @remarks This *does* attempt to create a file at the desired path.  The file is\n *       temporary iff `!PersistNewFile`, and is never created when this function\n *       returns `false`.\n */\nexport async function IsValidFileName(DirectoryPath: string, FileName: string, PersistNewFile: boolean = false, Extension: FFileExtension | undefined = undefined): Promise<boolean> {\n    const ExtensionSafe: FFileExtension | null | \"\" = Extension !== undefined\n        ? (Extension.startsWith(\".\") && IsSupportedFileExtension(Extension))\n            ? Extension\n            : null\n        : \"\";\n    const IsExtensionImproper: boolean = (ExtensionSafe === null ||\n        ExtensionSafe === \".\" ||\n        !FileName.endsWith(ExtensionSafe));\n    if (IsExtensionImproper) {\n        return false;\n    }\n    const FilePath: string = join(DirectoryPath, FileName);\n    try {\n        const ThisFileHandle: FileHandle = await Fs.open(FilePath, \"wx\");\n        await ThisFileHandle.close();\n        if (!PersistNewFile) {\n            await Fs.unlink(FilePath);\n        }\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Write a text file to a given {@link Path} having contents {@link Contents}.\n *\n * @param Path - The path of the file that will be written.\n * @param Contents - The text contents of the file to write.\n *\n * @returns {Promise<void>} A {@link Promise} that resolves when the call to {@link Fs.writeFile} resolves.\n *\n * @example\n * ```typescript\n * import { WriteTextFile } from \"@sorrell/utilities/fs\";\n * import { resolve } from \"path\";\n *\n * const MyReadMe: string = \"# ReadMe\\n\\nThis package accomplishes...\\n\";\n * const MyReadMePath: string = resolve(\".\");\n *\n * await WriteTextFile(MyReadMePath, MyReadMe);\n * ```\n */\nexport async function WriteTextFile(Path: string, Contents: string): Promise<void> {\n    await Fs.writeFile(Path, Contents, { encoding: \"utf-8\" });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMA,kBAAiD;AAGjD,gBAA+B;AAC/B,IAAAA,aAAyC;AACzC,gBAAe;AACf,eAAe,WAAW,MAAgC;AACtD,MAAI;AACA,UAAM,UAAAC,SAAG,OAAO,MAAM,WAAAC,UAAY,IAAI;AACtC,WAAO;AAAA,EACX,QACM;AACF,WAAO;AAAA,EACX;AACJ;AAKO,SAAS,yBAAyB,WAAoC;AACzE,MAAI,sBAA8B,UAAU,MAAM,CAAC;AACnD,MAAI,oBAAoB,WAAW,GAAG,GAAG;AACrC,0BAAsB,oBAAoB,MAAM,CAAC;AAAA,EACrD;AACA,MAAI,oBAAoB,WAAW,GAAG;AAClC,WAAO;AAAA,EACX;AACA,MAAI,oBAAoB,SAAS,GAAG,KAC7B,oBAAoB,SAAS,IAAI,KACjC,oBAAoB,SAAS,IAAI,GAAG;AACvC,WAAO;AAAA,EACX;AACA,MAAI,UAAAC,QAAG,SAAS,MAAM,SAAS;AAE3B,UAAM,uBAAgC,yBAAyB,KAAK,mBAAmB;AACvF,QAAI,sBAAsB;AACtB,aAAO;AAAA,IACX;AACA,QAAI,SAAS,KAAK,mBAAmB,GAAG;AACpC,aAAO;AAAA,IACX;AAAA,EACJ;AACA,SAAO;AACX;AAOA,eAAsB,eAAe,QAAiC;AAClE,QAAM,oBAAwB,qBAAQ,MAAM;AAC5C,QAAM,gBAAoB,qBAAQ,MAAM;AACxC,QAAM,eAAmB,sBAAS,MAAM;AACxC,QAAM,eAAuB,cAAc,KACrC,eACA,sBAAS,QAAQ,SAAS;AAChC,MAAI,gBAAwB;AAC5B,MAAI,QAAgB;AACpB,SAAO,MAAM,WAAW,aAAa,GAAG;AACpC,UAAM,oBAA4B,GAAG,YAAY,KAAK,KAAK,IAAI,SAAS;AACxE,wBAAgB,kBAAK,eAAe,iBAAiB;AACrD;AAAA,EACJ;AACA,SAAO;AACX;AAeA,eAAsB,gBAAgB,eAAuB,UAAkB,iBAA0B,OAAO,YAAwC,QAA6B;AACjL,QAAM,gBAA4C,cAAc,SACzD,UAAU,WAAW,GAAG,KAAK,yBAAyB,SAAS,IAC5D,YACA,OACJ;AACN,QAAM,sBAAgC,kBAAkB,QACpD,kBAAkB,OAClB,CAAC,SAAS,SAAS,aAAa;AACpC,MAAI,qBAAqB;AACrB,WAAO;AAAA,EACX;AACA,QAAM,eAAmB,kBAAK,eAAe,QAAQ;AACrD,MAAI;AACA,UAAM,iBAA6B,MAAM,UAAAF,SAAG,KAAK,UAAU,IAAI;AAC/D,UAAM,eAAe,MAAM;AAC3B,QAAI,CAAC,gBAAgB;AACjB,YAAM,UAAAA,SAAG,OAAO,QAAQ;AAAA,IAC5B;AACA,WAAO;AAAA,EACX,QACM;AACF,WAAO;AAAA,EACX;AACJ;AAoBA,eAAsB,cAAc,MAAc,UAAiC;AAC/E,QAAM,UAAAA,SAAG,UAAU,MAAM,UAAU,EAAE,UAAU,QAAQ,CAAC;AAC5D;",
+  "names": ["import_fs", "Fs", "FsConstants", "os"]
+}

package/Distribution/{ESM/fs.js → fs.js}

@@ -1,11 +1,11 @@
 // Source/FileSystem/FileSystem.ts
-import { access, open, unlink } from "fs/promises";
 import { basename, dirname, extname, join } from "path";
+import { promises as Fs } from "fs";
 import { constants as FsConstants } from "fs";
 import os from "os";
 async function PathExists(Path) {
   try {
-    await access(Path, FsConstants.F_OK);
+    await Fs.access(Path, FsConstants.F_OK);
     return true;
   } catch {
     return false;
@@ -55,20 +55,24 @@ async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false,
   }
   const FilePath = join(DirectoryPath, FileName);
   try {
-    const ThisFileHandle = await open(FilePath, "wx");
+    const ThisFileHandle = await Fs.open(FilePath, "wx");
     await ThisFileHandle.close();
     if (!PersistNewFile) {
-      await unlink(FilePath);
+      await Fs.unlink(FilePath);
     }
     return true;
   } catch {
     return false;
   }
 }
+async function WriteTextFile(Path, Contents) {
+  await Fs.writeFile(Path, Contents, { encoding: "utf-8" });
+}
 export {
   GetSafeNewPath,
   IsSupportedFileExtension,
-  IsValidFileName
+  IsValidFileName,
+  WriteTextFile
 };
 /**
  * @file      FileSystem.ts

package/Distribution/fs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../Source/FileSystem/FileSystem.ts"],
+  "sourcesContent": ["/**\n * @file      FileSystem.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { basename, dirname, extname, join } from \"path\";\nimport { type FFileExtension } from \"./FileSystem.Types.ts\";\nimport { type FileHandle } from \"fs/promises\";\nimport { promises as Fs } from \"fs\";\nimport { constants as FsConstants } from \"fs\";\nimport os from \"os\";\nasync function PathExists(Path: string): Promise<boolean> {\n    try {\n        await Fs.access(Path, FsConstants.F_OK);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * @param Extension - The file extension that you wish to test.\n * @returns Whether the file extension is valid on the current platform.\n */\nexport function IsSupportedFileExtension(Extension: FFileExtension): boolean {\n    let NormalizedExtension: string = Extension.slice(1);\n    if (NormalizedExtension.startsWith(\".\")) {\n        NormalizedExtension = NormalizedExtension.slice(1);\n    }\n    if (NormalizedExtension.length === 0) {\n        return false;\n    }\n    if (NormalizedExtension.includes(\"/\")\n        || NormalizedExtension.includes(\"\\\\\")\n        || NormalizedExtension.includes(\"\\0\")) {\n        return false;\n    }\n    if (os.platform() === \"win32\") {\n        /* eslint-disable-next-line no-control-regex */\n        const HasIllegalCharacters: boolean = /[<>:\"/\\\\|?*\\x00-\\x1F]/u.test(NormalizedExtension);\n        if (HasIllegalCharacters) {\n            return false;\n        }\n        if (/[ .]$/u.test(NormalizedExtension)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Given a path at which we wish to create a new file, check if a file at that\n * path already exists, and if so, then append `(${ number })` before the file\n * extension, consistent with the Windows Explorer handles conflicting file\n * names when pasting files.\n */\nexport async function GetSafeNewPath(InPath: string): Promise<string> {\n    const DirectoryPath: string = dirname(InPath);\n    const Extension: string = extname(InPath);\n    const FileName: string = basename(InPath);\n    const BaseFileName: string = Extension === \"\"\n        ? FileName\n        : basename(InPath, Extension);\n    let CandidatePath: string = InPath;\n    let Index: number = 1;\n    while (await PathExists(CandidatePath)) {\n        const CandidateFileName: string = `${BaseFileName} (${Index})${Extension}`;\n        CandidatePath = join(DirectoryPath, CandidateFileName);\n        Index++;\n    }\n    return CandidatePath;\n}\n/**\n * @param DirectoryPath - The path to the directory in which you wish to check.\n * @param FileName - The desired file name.\n * @param PersistNewFile - *(Optional)* Whether to keep the otherwise-temporary\n *                         file created at the desired path.\n * @param Extension - *(Optional)* If provided, the function will only return `true`\n *                    if `FileName.endsWith(Extension)` *and* the `Extension` is a valid\n *                    file extension.\n * @returns Whether a file of the given `FileName` can be created in `DirectoryPath`.\n *\n * @remarks This *does* attempt to create a file at the desired path.  The file is\n *       temporary iff `!PersistNewFile`, and is never created when this function\n *       returns `false`.\n */\nexport async function IsValidFileName(DirectoryPath: string, FileName: string, PersistNewFile: boolean = false, Extension: FFileExtension | undefined = undefined): Promise<boolean> {\n    const ExtensionSafe: FFileExtension | null | \"\" = Extension !== undefined\n        ? (Extension.startsWith(\".\") && IsSupportedFileExtension(Extension))\n            ? Extension\n            : null\n        : \"\";\n    const IsExtensionImproper: boolean = (ExtensionSafe === null ||\n        ExtensionSafe === \".\" ||\n        !FileName.endsWith(ExtensionSafe));\n    if (IsExtensionImproper) {\n        return false;\n    }\n    const FilePath: string = join(DirectoryPath, FileName);\n    try {\n        const ThisFileHandle: FileHandle = await Fs.open(FilePath, \"wx\");\n        await ThisFileHandle.close();\n        if (!PersistNewFile) {\n            await Fs.unlink(FilePath);\n        }\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Write a text file to a given {@link Path} having contents {@link Contents}.\n *\n * @param Path - The path of the file that will be written.\n * @param Contents - The text contents of the file to write.\n *\n * @returns {Promise<void>} A {@link Promise} that resolves when the call to {@link Fs.writeFile} resolves.\n *\n * @example\n * ```typescript\n * import { WriteTextFile } from \"@sorrell/utilities/fs\";\n * import { resolve } from \"path\";\n *\n * const MyReadMe: string = \"# ReadMe\\n\\nThis package accomplishes...\\n\";\n * const MyReadMePath: string = resolve(\".\");\n *\n * await WriteTextFile(MyReadMePath, MyReadMe);\n * ```\n */\nexport async function WriteTextFile(Path: string, Contents: string): Promise<void> {\n    await Fs.writeFile(Path, Contents, { encoding: \"utf-8\" });\n}\n"],
+  "mappings": ";AAMA,SAAS,UAAU,SAAS,SAAS,YAAY;AAGjD,SAAS,YAAY,UAAU;AAC/B,SAAS,aAAa,mBAAmB;AACzC,OAAO,QAAQ;AACf,eAAe,WAAW,MAAgC;AACtD,MAAI;AACA,UAAM,GAAG,OAAO,MAAM,YAAY,IAAI;AACtC,WAAO;AAAA,EACX,QACM;AACF,WAAO;AAAA,EACX;AACJ;AAKO,SAAS,yBAAyB,WAAoC;AACzE,MAAI,sBAA8B,UAAU,MAAM,CAAC;AACnD,MAAI,oBAAoB,WAAW,GAAG,GAAG;AACrC,0BAAsB,oBAAoB,MAAM,CAAC;AAAA,EACrD;AACA,MAAI,oBAAoB,WAAW,GAAG;AAClC,WAAO;AAAA,EACX;AACA,MAAI,oBAAoB,SAAS,GAAG,KAC7B,oBAAoB,SAAS,IAAI,KACjC,oBAAoB,SAAS,IAAI,GAAG;AACvC,WAAO;AAAA,EACX;AACA,MAAI,GAAG,SAAS,MAAM,SAAS;AAE3B,UAAM,uBAAgC,yBAAyB,KAAK,mBAAmB;AACvF,QAAI,sBAAsB;AACtB,aAAO;AAAA,IACX;AACA,QAAI,SAAS,KAAK,mBAAmB,GAAG;AACpC,aAAO;AAAA,IACX;AAAA,EACJ;AACA,SAAO;AACX;AAOA,eAAsB,eAAe,QAAiC;AAClE,QAAM,gBAAwB,QAAQ,MAAM;AAC5C,QAAM,YAAoB,QAAQ,MAAM;AACxC,QAAM,WAAmB,SAAS,MAAM;AACxC,QAAM,eAAuB,cAAc,KACrC,WACA,SAAS,QAAQ,SAAS;AAChC,MAAI,gBAAwB;AAC5B,MAAI,QAAgB;AACpB,SAAO,MAAM,WAAW,aAAa,GAAG;AACpC,UAAM,oBAA4B,GAAG,YAAY,KAAK,KAAK,IAAI,SAAS;AACxE,oBAAgB,KAAK,eAAe,iBAAiB;AACrD;AAAA,EACJ;AACA,SAAO;AACX;AAeA,eAAsB,gBAAgB,eAAuB,UAAkB,iBAA0B,OAAO,YAAwC,QAA6B;AACjL,QAAM,gBAA4C,cAAc,SACzD,UAAU,WAAW,GAAG,KAAK,yBAAyB,SAAS,IAC5D,YACA,OACJ;AACN,QAAM,sBAAgC,kBAAkB,QACpD,kBAAkB,OAClB,CAAC,SAAS,SAAS,aAAa;AACpC,MAAI,qBAAqB;AACrB,WAAO;AAAA,EACX;AACA,QAAM,WAAmB,KAAK,eAAe,QAAQ;AACrD,MAAI;AACA,UAAM,iBAA6B,MAAM,GAAG,KAAK,UAAU,IAAI;AAC/D,UAAM,eAAe,MAAM;AAC3B,QAAI,CAAC,gBAAgB;AACjB,YAAM,GAAG,OAAO,QAAQ;AAAA,IAC5B;AACA,WAAO;AAAA,EACX,QACM;AACF,WAAO;AAAA,EACX;AACJ;AAoBA,eAAsB,cAAc,MAAc,UAAiC;AAC/E,QAAM,GAAG,UAAU,MAAM,UAAU,EAAE,UAAU,QAAQ,CAAC;AAC5D;",
+  "names": []
+}

package/Distribution/{CJS/functional.js → functional.cjs}

@@ -46,4 +46,4 @@ function Identity(...Arguments) {
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-//# sourceMappingURL=functional.js.map
+//# sourceMappingURL=functional.cjs.map

package/Distribution/functional.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../Source/Functional/index.ts", "../Source/Functional/Functional.ts"],
+  "sourcesContent": ["/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Functional.ts\";\nexport * from \"./Functional.Types.ts\";\n", "/**\n * @file      Functional.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { CurriedArgument } from \"./Functional.Internal\";\nimport type { FCurriedArgument } from \"./Functional.Internal.Types\";\nimport type { TFunction } from \"./Functional.Types\";\nexport function Identity<Type>(...Arguments: Array<Type>) {\n    return Arguments;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACSO,SAAS,YAAkB,WAAwB;AACtD,SAAO;AACX;",
+  "names": []
+}

package/Distribution/functional.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../Source/Functional/Functional.ts"],
+  "sourcesContent": ["/**\n * @file      Functional.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { CurriedArgument } from \"./Functional.Internal\";\nimport type { FCurriedArgument } from \"./Functional.Internal.Types\";\nimport type { TFunction } from \"./Functional.Types\";\nexport function Identity<Type>(...Arguments: Array<Type>) {\n    return Arguments;\n}\n"],
+  "mappings": ";AASO,SAAS,YAAkB,WAAwB;AACtD,SAAO;AACX;",
+  "names": []
+}

package/Distribution/{CJS/index.js → index.cjs}

@@ -256,17 +256,18 @@ var FileSystem_exports = {};
 __export(FileSystem_exports, {
   GetSafeNewPath: () => GetSafeNewPath,
   IsSupportedFileExtension: () => IsSupportedFileExtension,
-  IsValidFileName: () => IsValidFileName
+  IsValidFileName: () => IsValidFileName,
+  WriteTextFile: () => WriteTextFile
 });
 
 // Source/FileSystem/FileSystem.ts
-var import_promises = require("fs/promises");
 var import_path = require("path");
 var import_fs = require("fs");
+var import_fs2 = require("fs");
 var import_os = __toESM(require("os"), 1);
 async function PathExists(Path) {
   try {
-    await (0, import_promises.access)(Path, import_fs.constants.F_OK);
+    await import_fs.promises.access(Path, import_fs2.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -316,16 +317,19 @@ async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false,
   }
   const FilePath = (0, import_path.join)(DirectoryPath, FileName);
   try {
-    const ThisFileHandle = await (0, import_promises.open)(FilePath, "wx");
+    const ThisFileHandle = await import_fs.promises.open(FilePath, "wx");
     await ThisFileHandle.close();
     if (!PersistNewFile) {
-      await (0, import_promises.unlink)(FilePath);
+      await import_fs.promises.unlink(FilePath);
     }
     return true;
   } catch {
     return false;
   }
 }
+async function WriteTextFile(Path, Contents) {
+  await import_fs.promises.writeFile(Path, Contents, { encoding: "utf-8" });
+}
 
 // Source/Functional/index.ts
 var Functional_exports = {};
@@ -471,7 +475,7 @@ __export(Npm_exports, {
 });
 
 // Source/Npm/Npm.ts
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 
 // Source/Npm/Npm.Error.ts
 var import_effect = require("effect");
@@ -486,23 +490,23 @@ var import_process = __toESM(require("process"), 1);
 async function GetPackageJson(Path) {
   const RootDirectory = await GetPackageRootDirectory(Path);
   const PackageJsonPath = (0, import_path2.join)(RootDirectory, "package.json");
-  const FileContents = await import_fs2.promises.readFile(PackageJsonPath, "utf-8");
+  const FileContents = await import_fs3.promises.readFile(PackageJsonPath, "utf-8");
   const PackageJson = await (async () => {
     try {
       return JSON.parse(FileContents);
     } catch (Cause) {
       throw new PackageJsonParseError({ Cause, Path: PackageJsonPath });
     }
-  });
+  })();
   return PackageJson;
 }
 async function GetPackageRootDirectory(Path) {
-  let CurrentDirectory = await import_fs2.promises.realpath(Path ?? import_process.default.cwd());
+  let CurrentDirectory = await import_fs3.promises.realpath(Path ?? import_process.default.cwd());
   while (true) {
     const PackageJsonPath = (0, import_path2.join)(CurrentDirectory, "package.json");
     const PackageJsonExists = await (async () => {
       try {
-        await import_fs2.promises.access(PackageJsonPath, import_fs2.constants.F_OK);
+        await import_fs3.promises.access(PackageJsonPath, import_fs3.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -694,4 +698,4 @@ function IsNumeric(In) {
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.cjs.map