@sorrell/utilities 1.2.8 → 1.2.11

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

@@ -6,5 +6,5 @@
         "../../../Source/String/String.ts"
     ],
     "names": [],
-    "mappings": "AAAA;;;;;GAKG;AAEH;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAG3C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAG7C"
+    "mappings": "AAAA;;;;;GAKG;AAEH;;;GAGG;AAKH;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CA4BrE"
 }

package/Distribution/Types/String/String.d.ts

@@ -9,20 +9,65 @@
  * Functions for manipulating strings.
  */
 /**
- * @param In - The string that you wish to test.
- * @returns Whether the given string contains *only* (Latin alphabet) letters.
+ * Does the given {@link TestString} contain only letters?
+ * This is equivalent to Python's
+ * {@link https://docs.python.org/3/library/stdtypes.html#str.isalpha | isalpha} function.
+ *
+ * @remarks This is an alias for {@link IsAlpha}.
+ *
+ * @param TestString - The string that you wish to test.
+ *
+ * @returns {boolean} Whether the given string contains *only* (Latin alphabet) letters.
+ */
+export declare function IsLetters(TestString: string): boolean;
+/**
+ * Does the given {@link TestString} contain only letters?
+ * This is equivalent to Python's
+ * {@link https://docs.python.org/3/library/stdtypes.html#str.isalpha | isalpha} function.
+ *
+ * @param TestString - The string that you wish to test.
+ *
+ * @returns {boolean} Whether the given string contains *only* (Latin alphabet) letters.
  */
-export declare function IsLetters(In: string): boolean;
+export declare function IsAlpha(TestString: string): boolean;
 /**
- * @remarks *(This is an alias for `IsOnlyLetters`).*
+ * Does the given {@link TestString} contain only digits?
  *
- * @param In - The string that you wish to test.
- * @returns Whether the given string contains *only* (Latin alphabet) letters.
+ * This is equivalent to Python's
+ * {@link https://docs.python.org/3/library/stdtypes.html#str.isnumeric | isnumeric} function.
+ *
+ * @param TestString - The string that you wish to test.
+ *
+ * @returns {boolean} Whether the given string contains *only* numeric digits.
  */
-export declare function IsAlpha(In: string): boolean;
+export declare function IsNumeric(TestString: string): boolean;
 /**
- * @param In - The string that you wish to test.
- * @returns Whether the given string contains *only* numeric digits.
+ * This function provides a convenient way to define long strings across multiple lines.
+ * The linebreaks and leading indentation are removed from the final string.
+ * Please see the example below for how this is to be done.
+ *
+ * @param Content - The given string to dedent.
+ * @param IndentLength - The number of spaces for which this function will check.  This
+ * is necessary only if the number of spaces used in the {@link Content} is not a multiple
+ * of two.
+ *
+ * @returns {string} The given {@link Content}, but with the spaces at the beginning
+ * of each line (excluding the first line if no spaces exist in the first line) removed.
+ *
+ * @example
+ * ```typescript
+ * import { Dedent } from "@sorrell/utilities/string";
+ *
+ * const MyLongString: string = Dedent(`Lorem ipsum dolor sit amet, consectetur adipiscing elit,
+ *             sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad
+ *                 minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
+ *             commodo consequat.`);
+ *
+ * // `MyLongString` <- `"Lorem ipsum dolor sit amet, consectetur adipiscing elit, \
+ * sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad \
+ *     minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea \
+ * commodo consequat."`
+ * ```
  */
-export declare function IsNumeric(In: string): boolean;
+export declare function Dedent(Content: string, IndentLength?: number): string;
 //# sourceMappingURL=String.d.ts.map

package/Distribution/Types/String/String.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"String.d.ts","sourceRoot":"","sources":["../../../Source/String/String.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAG3C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAG7C"}
+{"version":3,"file":"String.d.ts","sourceRoot":"","sources":["../../../Source/String/String.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AAKH;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CA4BrE"}

package/Distribution/Types/TsConfig/TsConfig.Types.d.cts

@@ -0,0 +1,32 @@
+/**
+ * @file      TsConfig.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+import type TypeScript from "typescript";
+export type FOverriddenCompilerOptions = "jsx" | "lib" | "module" | "moduleResolution" | "target";
+export type FCompilerOptions = Omit<TypeScript.server.protocol.CompilerOptions, FOverriddenCompilerOptions> & Partial<{
+    jsx: JsxEmit;
+    lib: Array<string>;
+    module: FModuleKind;
+    moduleResolution: FModuleResolutionKind;
+    target: FTarget;
+}>;
+export type JsxEmit = "none" | "preserve" | "react-native" | "react" | "react-jsx" | "react-jsxdev";
+export type FModuleKind = "none" | "commonjs" | "amd" | "umd" | "system" | "es6" | "es2015" | "es2020" | "es2022" | "esnext" | "node16" | "node18" | "node20" | "nodenext" | "preserve";
+export type FModuleResolutionKind = "classic" | "node" | "node" | "node10" | "node16" | "nodenext" | "bundler";
+export type FTarget = "es3" | "es5" | "es6" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "es2025" | "esnext" | "json" | "esnext" | "es2025";
+/** The type corresponding to the schema of `tsconfig.json`. */
+export interface TsConfigSchema {
+    extends?: string | Array<string>;
+    files?: Array<string>;
+    include?: Array<string>;
+    exclude?: Array<string>;
+    references?: Array<TypeScript.ProjectReference>;
+    compilerOptions?: FCompilerOptions;
+    watchOptions?: TypeScript.WatchOptions;
+    typeAcquisition?: TypeScript.TypeAcquisition;
+    compileOnSave?: boolean;
+}
+//# sourceMappingURL=TsConfig.Types.d.cts.map

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

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "TsConfig.Types.d.cts",
+    "sourceRoot": "",
+    "sources": [
+        "../../../Source/TsConfig/TsConfig.Types.ts"
+    ],
+    "names": [],
+    "mappings": "AAAA;;;;;GAKG;AAEH,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC;AAIzC,MAAM,MAAM,0BAA0B,GAChC,KAAK,GACL,KAAK,GACL,QAAQ,GACR,kBAAkB,GAClB,QAAQ,CAAC;AAEf,MAAM,MAAM,gBAAgB,GACxB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,0BAA0B,CAAC,GAC5E,OAAO,CAAC;IACJ,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,MAAM,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEP,MAAM,MAAM,OAAO,GACb,MAAM,GACN,UAAU,GACV,cAAc,GACd,OAAO,GACP,WAAW,GACX,cAAc,CAAC;AAErB,MAAM,MAAM,WAAW,GACjB,MAAM,GACN,UAAU,GACV,KAAK,GACL,KAAK,GACL,QAAQ,GACR,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,UAAU,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAC3B,SAAS,GACT,MAAM,GACN,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,SAAS,CAAC;AAEhB,MAAM,MAAM,OAAO,GACb,KAAK,GACL,KAAK,GACL,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,QAAQ,GACR,QAAQ,CAAC;AAIf,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAE3B,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,UAAU,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAChD,eAAe,CAAC,EAAE,gBAAgB,CAAC;IACnC,YAAY,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC;IACvC,eAAe,CAAC,EAAE,UAAU,CAAC,eAAe,CAAC;IAC7C,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B"
+}

package/Distribution/Types/TsConfig/TsConfig.Types.d.mts

@@ -0,0 +1,32 @@
+/**
+ * @file      TsConfig.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+import type TypeScript from "typescript";
+export type FOverriddenCompilerOptions = "jsx" | "lib" | "module" | "moduleResolution" | "target";
+export type FCompilerOptions = Omit<TypeScript.server.protocol.CompilerOptions, FOverriddenCompilerOptions> & Partial<{
+    jsx: JsxEmit;
+    lib: Array<string>;
+    module: FModuleKind;
+    moduleResolution: FModuleResolutionKind;
+    target: FTarget;
+}>;
+export type JsxEmit = "none" | "preserve" | "react-native" | "react" | "react-jsx" | "react-jsxdev";
+export type FModuleKind = "none" | "commonjs" | "amd" | "umd" | "system" | "es6" | "es2015" | "es2020" | "es2022" | "esnext" | "node16" | "node18" | "node20" | "nodenext" | "preserve";
+export type FModuleResolutionKind = "classic" | "node" | "node" | "node10" | "node16" | "nodenext" | "bundler";
+export type FTarget = "es3" | "es5" | "es6" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "es2025" | "esnext" | "json" | "esnext" | "es2025";
+/** The type corresponding to the schema of `tsconfig.json`. */
+export interface TsConfigSchema {
+    extends?: string | Array<string>;
+    files?: Array<string>;
+    include?: Array<string>;
+    exclude?: Array<string>;
+    references?: Array<TypeScript.ProjectReference>;
+    compilerOptions?: FCompilerOptions;
+    watchOptions?: TypeScript.WatchOptions;
+    typeAcquisition?: TypeScript.TypeAcquisition;
+    compileOnSave?: boolean;
+}
+//# sourceMappingURL=TsConfig.Types.d.mts.map

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

@@ -0,0 +1,10 @@
+{
+    "version": 3,
+    "file": "TsConfig.Types.d.mts",
+    "sourceRoot": "",
+    "sources": [
+        "../../../Source/TsConfig/TsConfig.Types.ts"
+    ],
+    "names": [],
+    "mappings": "AAAA;;;;;GAKG;AAEH,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC;AAIzC,MAAM,MAAM,0BAA0B,GAChC,KAAK,GACL,KAAK,GACL,QAAQ,GACR,kBAAkB,GAClB,QAAQ,CAAC;AAEf,MAAM,MAAM,gBAAgB,GACxB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,0BAA0B,CAAC,GAC5E,OAAO,CAAC;IACJ,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,MAAM,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEP,MAAM,MAAM,OAAO,GACb,MAAM,GACN,UAAU,GACV,cAAc,GACd,OAAO,GACP,WAAW,GACX,cAAc,CAAC;AAErB,MAAM,MAAM,WAAW,GACjB,MAAM,GACN,UAAU,GACV,KAAK,GACL,KAAK,GACL,QAAQ,GACR,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,UAAU,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAC3B,SAAS,GACT,MAAM,GACN,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,SAAS,CAAC;AAEhB,MAAM,MAAM,OAAO,GACb,KAAK,GACL,KAAK,GACL,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,QAAQ,GACR,QAAQ,CAAC;AAIf,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAE3B,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,UAAU,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAChD,eAAe,CAAC,EAAE,gBAAgB,CAAC;IACnC,YAAY,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC;IACvC,eAAe,CAAC,EAAE,UAAU,CAAC,eAAe,CAAC;IAC7C,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B"
+}

package/Distribution/Types/TsConfig/TsConfig.Types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file      TsConfig.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+import type TypeScript from "typescript";
+export type FOverriddenCompilerOptions = "jsx" | "lib" | "module" | "moduleResolution" | "target";
+export type FCompilerOptions = Omit<TypeScript.server.protocol.CompilerOptions, FOverriddenCompilerOptions> & Partial<{
+    jsx: JsxEmit;
+    lib: Array<string>;
+    module: FModuleKind;
+    moduleResolution: FModuleResolutionKind;
+    target: FTarget;
+}>;
+export type JsxEmit = "none" | "preserve" | "react-native" | "react" | "react-jsx" | "react-jsxdev";
+export type FModuleKind = "none" | "commonjs" | "amd" | "umd" | "system" | "es6" | "es2015" | "es2020" | "es2022" | "esnext" | "node16" | "node18" | "node20" | "nodenext" | "preserve";
+export type FModuleResolutionKind = "classic" | "node" | "node" | "node10" | "node16" | "nodenext" | "bundler";
+export type FTarget = "es3" | "es5" | "es6" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "es2025" | "esnext" | "json" | "esnext" | "es2025";
+/** The type corresponding to the schema of `tsconfig.json`. */
+export interface TsConfigSchema {
+    extends?: string | Array<string>;
+    files?: Array<string>;
+    include?: Array<string>;
+    exclude?: Array<string>;
+    references?: Array<TypeScript.ProjectReference>;
+    compilerOptions?: FCompilerOptions;
+    watchOptions?: TypeScript.WatchOptions;
+    typeAcquisition?: TypeScript.TypeAcquisition;
+    compileOnSave?: boolean;
+}
+//# sourceMappingURL=TsConfig.Types.d.ts.map

package/Distribution/Types/TsConfig/TsConfig.Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TsConfig.Types.d.ts","sourceRoot":"","sources":["../../../Source/TsConfig/TsConfig.Types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC;AAIzC,MAAM,MAAM,0BAA0B,GAChC,KAAK,GACL,KAAK,GACL,QAAQ,GACR,kBAAkB,GAClB,QAAQ,CAAC;AAEf,MAAM,MAAM,gBAAgB,GACxB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,0BAA0B,CAAC,GAC5E,OAAO,CAAC;IACJ,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,MAAM,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEP,MAAM,MAAM,OAAO,GACb,MAAM,GACN,UAAU,GACV,cAAc,GACd,OAAO,GACP,WAAW,GACX,cAAc,CAAC;AAErB,MAAM,MAAM,WAAW,GACjB,MAAM,GACN,UAAU,GACV,KAAK,GACL,KAAK,GACL,QAAQ,GACR,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,UAAU,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAC3B,SAAS,GACT,MAAM,GACN,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,SAAS,CAAC;AAEhB,MAAM,MAAM,OAAO,GACb,KAAK,GACL,KAAK,GACL,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,QAAQ,GACR,QAAQ,CAAC;AAIf,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAE3B,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,UAAU,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAChD,eAAe,CAAC,EAAE,gBAAgB,CAAC;IACnC,YAAY,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC;IACvC,eAAe,CAAC,EAAE,UAAU,CAAC,eAAe,CAAC;IAC7C,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B"}

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

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

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

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

package/Distribution/Types/TsConfig/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 "./TsConfig.Types.mjs";
+//# sourceMappingURL=index.d.mts.map

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

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

package/Distribution/Types/TsConfig/index.d.ts

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

package/Distribution/Types/TsConfig/index.d.ts.map

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

package/Distribution/Types/index.d.cts

@@ -21,4 +21,5 @@ 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";
+export * as TsConfig from "./TsConfig/index.cjs";
 //# sourceMappingURL=index.d.cts.map

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

@@ -6,5 +6,5 @@
         "../../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"
+    "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;AAC5C,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC"
 }

package/Distribution/Types/index.d.mts

@@ -21,4 +21,5 @@ 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";
+export * as TsConfig from "./TsConfig/index.mjs";
 //# sourceMappingURL=index.d.mts.map

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

@@ -6,5 +6,5 @@
         "../../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"
+    "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;AAC5C,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC"
 }

package/Distribution/Types/index.d.ts

@@ -21,4 +21,5 @@ export * as Miscellaneous from "./Miscellaneous/index.ts";
 export * as Npm from "./Npm/index.ts";
 export * as Path from "./Path/index.ts";
 export * as String from "./String/index.ts";
+export * as TsConfig from "./TsConfig/index.ts";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","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"}
+{"version":3,"file":"index.d.ts","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;AAC5C,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC"}

package/Distribution/async.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "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 { NoOptions } from \"./Utility.Internal.ts\";\nimport type TypeScript from \"typescript\";\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 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;\n/**\n * The opposite of {@link NonNullable}: the union of a given {@link Type}, `null`, and `undefined`.\n *\n * @template Type - The nontrivial type in this union.\n */\nexport type TNullable<Type> = Type | null | undefined;\n/** An error that is thrown in default implementations of `abstract` `class`es. */\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\";\ntype FTarget = \"es3\" | \"es5\" | \"es6\" | \"es2015\" | \"es2016\" | \"es2017\" | \"es2018\" | \"es2019\" | \"es2020\" | \"es2021\" | \"es2022\" | \"es2023\" | \"es2024\" | \"es2025\" | \"esnext\" | \"json\" | \"esnext\" | \"es2025\";\n/**\n * Maps a given {@link RecordLike} type to an identical {@link Record} type, but\n * the properties are wrapped with {@link NonNullable}.\n *\n * @template RecordLike - The `Record`-like type from which this type is defined.\n */\nexport type TRecordNonNullable<RecordLike> = {\n    [Key in keyof RecordLike]: NonNullable<RecordLike[Key]>;\n};\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;",
+  "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 { 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 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;\n/**\n * The opposite of {@link NonNullable}: the union of a given {@link Type}, `null`, and `undefined`.\n *\n * @template Type - The nontrivial type in this union.\n */\nexport type TNullable<Type> = Type | null | undefined;\n/** An error that is thrown in default implementations of `abstract` `class`es. */\nexport class AbstractMethodCallError extends Error {\n    public constructor(ClassName?: string) {\n        super(ClassName);\n    }\n}\n/**\n * Maps a given {@link RecordLike} type to an identical {@link Record} type, but\n * the properties are wrapped with {@link NonNullable}.\n *\n * @template RecordLike - The `Record`-like type from which this type is defined.\n */\nexport type TRecordNonNullable<RecordLike> = {\n    [Key in keyof RecordLike]: NonNullable<RecordLike[Key]>;\n};\n/**\n * A \"safe\" intersection of two types, such that if exactly one\n * of the two types is `never`, then this evaluates to the other type.\n * This evaluates to the intersection of the two types iff *both*\n * type parameters.\n *\n * @template LeftType - The first type parameter.\n * @template RightType - The second type parameter.\n */\nexport type TSafeIntersection<LeftType, RightType> = [\n    LeftType\n] extends [\n    never\n] ? [\n    RightType\n] extends [\n    never\n] ? never : RightType : [\n    RightType\n] extends [\n    never\n] ? LeftType : (LeftType & RightType);\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;;;ACyEO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EACxC,YAAY,WAAoB;AACnC,UAAM,SAAS;AAAA,EACnB;AACJ;;;ACnCA,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/async.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "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 { NoOptions } from \"./Utility.Internal.ts\";\nimport type TypeScript from \"typescript\";\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 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;\n/**\n * The opposite of {@link NonNullable}: the union of a given {@link Type}, `null`, and `undefined`.\n *\n * @template Type - The nontrivial type in this union.\n */\nexport type TNullable<Type> = Type | null | undefined;\n/** An error that is thrown in default implementations of `abstract` `class`es. */\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\";\ntype FTarget = \"es3\" | \"es5\" | \"es6\" | \"es2015\" | \"es2016\" | \"es2017\" | \"es2018\" | \"es2019\" | \"es2020\" | \"es2021\" | \"es2022\" | \"es2023\" | \"es2024\" | \"es2025\" | \"esnext\" | \"json\" | \"esnext\" | \"es2025\";\n/**\n * Maps a given {@link RecordLike} type to an identical {@link Record} type, but\n * the properties are wrapped with {@link NonNullable}.\n *\n * @template RecordLike - The `Record`-like type from which this type is defined.\n */\nexport type TRecordNonNullable<RecordLike> = {\n    [Key in keyof RecordLike]: NonNullable<RecordLike[Key]>;\n};\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;",
+  "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 { 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 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;\n/**\n * The opposite of {@link NonNullable}: the union of a given {@link Type}, `null`, and `undefined`.\n *\n * @template Type - The nontrivial type in this union.\n */\nexport type TNullable<Type> = Type | null | undefined;\n/** An error that is thrown in default implementations of `abstract` `class`es. */\nexport class AbstractMethodCallError extends Error {\n    public constructor(ClassName?: string) {\n        super(ClassName);\n    }\n}\n/**\n * Maps a given {@link RecordLike} type to an identical {@link Record} type, but\n * the properties are wrapped with {@link NonNullable}.\n *\n * @template RecordLike - The `Record`-like type from which this type is defined.\n */\nexport type TRecordNonNullable<RecordLike> = {\n    [Key in keyof RecordLike]: NonNullable<RecordLike[Key]>;\n};\n/**\n * A \"safe\" intersection of two types, such that if exactly one\n * of the two types is `never`, then this evaluates to the other type.\n * This evaluates to the intersection of the two types iff *both*\n * type parameters.\n *\n * @template LeftType - The first type parameter.\n * @template RightType - The second type parameter.\n */\nexport type TSafeIntersection<LeftType, RightType> = [\n    LeftType\n] extends [\n    never\n] ? [\n    RightType\n] extends [\n    never\n] ? never : RightType : [\n    RightType\n] extends [\n    never\n] ? LeftType : (LeftType & RightType);\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": ";AAyEO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EACxC,YAAY,WAAoB;AACnC,UAAM,SAAS;AAAA,EACnB;AACJ;;;ACnCA,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/fs.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // Source/FileSystem/index.ts
 var FileSystem_exports = {};
 __export(FileSystem_exports, {
+  DeleteWithProgress: () => DeleteWithProgress,
   GetSafeNewPath: () => GetSafeNewPath,
   IsSupportedFileExtension: () => IsSupportedFileExtension,
   IsValidFileName: () => IsValidFileName,
@@ -42,9 +43,11 @@ 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) {
+var FileSystem = __toESM(require("node:fs/promises"), 1);
+var Path = __toESM(require("node:path"), 1);
+async function PathExists(Path2) {
   try {
-    await import_fs.promises.access(Path, import_fs2.constants.F_OK);
+    await import_fs.promises.access(Path2, import_fs2.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -104,8 +107,95 @@ async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false,
     return false;
   }
 }
-async function WriteTextFile(Path, Contents) {
-  await import_fs.promises.writeFile(Path, Contents, { encoding: "utf-8" });
+async function WriteTextFile(Path2, Contents) {
+  await import_fs.promises.writeFile(Path2, Contents, { encoding: "utf-8" });
+}
+function IsMissingFileError(ErrorValue) {
+  return typeof ErrorValue === "object" && ErrorValue !== null && "code" in ErrorValue && ErrorValue.code === "ENOENT";
+}
+function CloneProgress(Progress) {
+  return { ...Progress };
+}
+async function BuildDeletionPlan(RootPath, Progress, Options) {
+  const Entries = [];
+  async function Visit(CurrentPath) {
+    Options.Signal?.throwIfAborted();
+    Progress.Phase = "Scanning";
+    Progress.CurrentPath = CurrentPath;
+    Options.OnProgress?.(CloneProgress(Progress));
+    let Stats;
+    try {
+      Stats = await FileSystem.lstat(CurrentPath);
+    } catch (ErrorValue) {
+      if (IsMissingFileError(ErrorValue)) {
+        return;
+      }
+      throw ErrorValue;
+    }
+    if (Stats.isDirectory()) {
+      const Children = await FileSystem.readdir(CurrentPath, {
+        withFileTypes: true
+      });
+      for (const Child of Children) {
+        await Visit(Path.join(CurrentPath, Child.name));
+      }
+      Entries.push({
+        EntryPath: CurrentPath,
+        Kind: "Directory",
+        Size: 0
+      });
+    } else {
+      const Size = Stats.isFile() ? Stats.size : 0;
+      Entries.push({
+        EntryPath: CurrentPath,
+        Kind: Stats.isFile() ? "File" : "Other",
+        Size
+      });
+      Progress.TotalBytes += Size;
+    }
+    Progress.DiscoveredEntries = Entries.length;
+    Options.OnProgress?.(CloneProgress(Progress));
+  }
+  await Visit(RootPath);
+  return Entries;
+}
+async function DeleteWithProgress(RootPath, Options = {}) {
+  const Progress = {
+    Phase: "Scanning",
+    CurrentPath: null,
+    DiscoveredEntries: 0,
+    TotalEntries: 0,
+    DeletedEntries: 0,
+    TotalBytes: 0,
+    DeletedBytes: 0
+  };
+  const Entries = await BuildDeletionPlan(RootPath, Progress, Options);
+  Progress.Phase = "Deleting";
+  Progress.TotalEntries = Entries.length;
+  Progress.CurrentPath = null;
+  Options.OnProgress?.(CloneProgress(Progress));
+  for (const Entry of Entries) {
+    Options.Signal?.throwIfAborted();
+    Progress.CurrentPath = Entry.EntryPath;
+    Options.OnProgress?.(CloneProgress(Progress));
+    try {
+      if (Entry.Kind === "Directory") {
+        await FileSystem.rmdir(Entry.EntryPath);
+      } else {
+        await FileSystem.unlink(Entry.EntryPath);
+      }
+    } catch (ErrorValue) {
+      if (!IsMissingFileError(ErrorValue)) {
+        throw ErrorValue;
+      }
+    }
+    Progress.DeletedEntries += 1;
+    Progress.DeletedBytes += Entry.Size;
+    Options.OnProgress?.(CloneProgress(Progress));
+  }
+  Progress.Phase = "Done";
+  Progress.CurrentPath = null;
+  Options.OnProgress?.(CloneProgress(Progress));
 }
 /**
  * @file      FileSystem.ts