@sorrell/utilities 1.2.8 → 1.2.11

package/Distribution/fs.cjs.map

@@ -1,7 +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"]
+  "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}\nimport * as FileSystem from \"node:fs/promises\";\nimport * as Path from \"node:path\";\nimport * as Readline from \"node:readline\";\ntype DeletePhase = \"Scanning\" | \"Deleting\" | \"Done\";\ntype DeleteEntryKind = \"File\" | \"Directory\" | \"Other\";\ntype DeleteEntry = {\n    EntryPath: string;\n    Kind: DeleteEntryKind;\n    Size: number;\n};\ntype DeleteProgress = {\n    Phase: DeletePhase;\n    CurrentPath: string | null;\n    DiscoveredEntries: number;\n    TotalEntries: number;\n    DeletedEntries: number;\n    TotalBytes: number;\n    DeletedBytes: number;\n};\ntype DeleteWithProgressOptions = {\n    OnProgress?: (Progress: DeleteProgress) => void;\n    Signal?: AbortSignal;\n};\nfunction IsMissingFileError(ErrorValue: unknown): boolean {\n    return (typeof ErrorValue === \"object\" &&\n        ErrorValue !== null &&\n        \"code\" in ErrorValue &&\n        ErrorValue.code === \"ENOENT\");\n}\nfunction CloneProgress(Progress: DeleteProgress): DeleteProgress {\n    return { ...Progress };\n}\nasync function BuildDeletionPlan(RootPath: string, Progress: DeleteProgress, Options: DeleteWithProgressOptions): Promise<DeleteEntry[]> {\n    const Entries: DeleteEntry[] = [];\n    async function Visit(CurrentPath: string): Promise<void> {\n        Options.Signal?.throwIfAborted();\n        Progress.Phase = \"Scanning\";\n        Progress.CurrentPath = CurrentPath;\n        Options.OnProgress?.(CloneProgress(Progress));\n        let Stats;\n        try {\n            Stats = await FileSystem.lstat(CurrentPath);\n        }\n        catch (ErrorValue) {\n            if (IsMissingFileError(ErrorValue)) {\n                return;\n            }\n            throw ErrorValue;\n        }\n        if (Stats.isDirectory()) {\n            const Children = await FileSystem.readdir(CurrentPath, {\n                withFileTypes: true\n            });\n            for (const Child of Children) {\n                await Visit(Path.join(CurrentPath, Child.name));\n            }\n            Entries.push({\n                EntryPath: CurrentPath,\n                Kind: \"Directory\",\n                Size: 0\n            });\n        }\n        else {\n            const Size = Stats.isFile() ? Stats.size : 0;\n            Entries.push({\n                EntryPath: CurrentPath,\n                Kind: Stats.isFile() ? \"File\" : \"Other\",\n                Size\n            });\n            Progress.TotalBytes += Size;\n        }\n        Progress.DiscoveredEntries = Entries.length;\n        Options.OnProgress?.(CloneProgress(Progress));\n    }\n    await Visit(RootPath);\n    return Entries;\n}\nexport async function DeleteWithProgress(RootPath: string, Options: DeleteWithProgressOptions = {}): Promise<void> {\n    const Progress: DeleteProgress = {\n        Phase: \"Scanning\",\n        CurrentPath: null,\n        DiscoveredEntries: 0,\n        TotalEntries: 0,\n        DeletedEntries: 0,\n        TotalBytes: 0,\n        DeletedBytes: 0\n    };\n    const Entries = await BuildDeletionPlan(RootPath, Progress, Options);\n    Progress.Phase = \"Deleting\";\n    Progress.TotalEntries = Entries.length;\n    Progress.CurrentPath = null;\n    Options.OnProgress?.(CloneProgress(Progress));\n    for (const Entry of Entries) {\n        Options.Signal?.throwIfAborted();\n        Progress.CurrentPath = Entry.EntryPath;\n        Options.OnProgress?.(CloneProgress(Progress));\n        try {\n            if (Entry.Kind === \"Directory\") {\n                await FileSystem.rmdir(Entry.EntryPath);\n            }\n            else {\n                await FileSystem.unlink(Entry.EntryPath);\n            }\n        }\n        catch (ErrorValue) {\n            if (!IsMissingFileError(ErrorValue)) {\n                throw ErrorValue;\n            }\n        }\n        Progress.DeletedEntries += 1;\n        Progress.DeletedBytes += Entry.Size;\n        Options.OnProgress?.(CloneProgress(Progress));\n    }\n    Progress.Phase = \"Done\";\n    Progress.CurrentPath = null;\n    Options.OnProgress?.(CloneProgress(Progress));\n}\nfunction FormatBytes(Bytes: number): string {\n    const Units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    let Value = Bytes;\n    let UnitIndex = 0;\n    while (Value >= 1024 && UnitIndex < Units.length - 1) {\n        Value /= 1024;\n        UnitIndex += 1;\n    }\n    return `${Value.toFixed(UnitIndex === 0 ? 0 : 1)} ${Units[UnitIndex]}`;\n}\n"],
+  "mappings": "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",
+  "names": ["import_fs", "Path", "Fs", "FsConstants", "os"]
 }

package/Distribution/fs.js

@@ -3,9 +3,11 @@ 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) {
+import * as FileSystem from "node:fs/promises";
+import * as Path from "node:path";
+async function PathExists(Path2) {
   try {
-    await Fs.access(Path, FsConstants.F_OK);
+    await Fs.access(Path2, FsConstants.F_OK);
     return true;
   } catch {
     return false;
@@ -65,10 +67,98 @@ async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false,
     return false;
   }
 }
-async function WriteTextFile(Path, Contents) {
-  await Fs.writeFile(Path, Contents, { encoding: "utf-8" });
+async function WriteTextFile(Path2, Contents) {
+  await Fs.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));
 }
 export {
+  DeleteWithProgress,
   GetSafeNewPath,
   IsSupportedFileExtension,
   IsValidFileName,

package/Distribution/fs.js.map

@@ -1,7 +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": []
+  "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}\nimport * as FileSystem from \"node:fs/promises\";\nimport * as Path from \"node:path\";\nimport * as Readline from \"node:readline\";\ntype DeletePhase = \"Scanning\" | \"Deleting\" | \"Done\";\ntype DeleteEntryKind = \"File\" | \"Directory\" | \"Other\";\ntype DeleteEntry = {\n    EntryPath: string;\n    Kind: DeleteEntryKind;\n    Size: number;\n};\ntype DeleteProgress = {\n    Phase: DeletePhase;\n    CurrentPath: string | null;\n    DiscoveredEntries: number;\n    TotalEntries: number;\n    DeletedEntries: number;\n    TotalBytes: number;\n    DeletedBytes: number;\n};\ntype DeleteWithProgressOptions = {\n    OnProgress?: (Progress: DeleteProgress) => void;\n    Signal?: AbortSignal;\n};\nfunction IsMissingFileError(ErrorValue: unknown): boolean {\n    return (typeof ErrorValue === \"object\" &&\n        ErrorValue !== null &&\n        \"code\" in ErrorValue &&\n        ErrorValue.code === \"ENOENT\");\n}\nfunction CloneProgress(Progress: DeleteProgress): DeleteProgress {\n    return { ...Progress };\n}\nasync function BuildDeletionPlan(RootPath: string, Progress: DeleteProgress, Options: DeleteWithProgressOptions): Promise<DeleteEntry[]> {\n    const Entries: DeleteEntry[] = [];\n    async function Visit(CurrentPath: string): Promise<void> {\n        Options.Signal?.throwIfAborted();\n        Progress.Phase = \"Scanning\";\n        Progress.CurrentPath = CurrentPath;\n        Options.OnProgress?.(CloneProgress(Progress));\n        let Stats;\n        try {\n            Stats = await FileSystem.lstat(CurrentPath);\n        }\n        catch (ErrorValue) {\n            if (IsMissingFileError(ErrorValue)) {\n                return;\n            }\n            throw ErrorValue;\n        }\n        if (Stats.isDirectory()) {\n            const Children = await FileSystem.readdir(CurrentPath, {\n                withFileTypes: true\n            });\n            for (const Child of Children) {\n                await Visit(Path.join(CurrentPath, Child.name));\n            }\n            Entries.push({\n                EntryPath: CurrentPath,\n                Kind: \"Directory\",\n                Size: 0\n            });\n        }\n        else {\n            const Size = Stats.isFile() ? Stats.size : 0;\n            Entries.push({\n                EntryPath: CurrentPath,\n                Kind: Stats.isFile() ? \"File\" : \"Other\",\n                Size\n            });\n            Progress.TotalBytes += Size;\n        }\n        Progress.DiscoveredEntries = Entries.length;\n        Options.OnProgress?.(CloneProgress(Progress));\n    }\n    await Visit(RootPath);\n    return Entries;\n}\nexport async function DeleteWithProgress(RootPath: string, Options: DeleteWithProgressOptions = {}): Promise<void> {\n    const Progress: DeleteProgress = {\n        Phase: \"Scanning\",\n        CurrentPath: null,\n        DiscoveredEntries: 0,\n        TotalEntries: 0,\n        DeletedEntries: 0,\n        TotalBytes: 0,\n        DeletedBytes: 0\n    };\n    const Entries = await BuildDeletionPlan(RootPath, Progress, Options);\n    Progress.Phase = \"Deleting\";\n    Progress.TotalEntries = Entries.length;\n    Progress.CurrentPath = null;\n    Options.OnProgress?.(CloneProgress(Progress));\n    for (const Entry of Entries) {\n        Options.Signal?.throwIfAborted();\n        Progress.CurrentPath = Entry.EntryPath;\n        Options.OnProgress?.(CloneProgress(Progress));\n        try {\n            if (Entry.Kind === \"Directory\") {\n                await FileSystem.rmdir(Entry.EntryPath);\n            }\n            else {\n                await FileSystem.unlink(Entry.EntryPath);\n            }\n        }\n        catch (ErrorValue) {\n            if (!IsMissingFileError(ErrorValue)) {\n                throw ErrorValue;\n            }\n        }\n        Progress.DeletedEntries += 1;\n        Progress.DeletedBytes += Entry.Size;\n        Options.OnProgress?.(CloneProgress(Progress));\n    }\n    Progress.Phase = \"Done\";\n    Progress.CurrentPath = null;\n    Options.OnProgress?.(CloneProgress(Progress));\n}\nfunction FormatBytes(Bytes: number): string {\n    const Units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    let Value = Bytes;\n    let UnitIndex = 0;\n    while (Value >= 1024 && UnitIndex < Units.length - 1) {\n        Value /= 1024;\n        UnitIndex += 1;\n    }\n    return `${Value.toFixed(UnitIndex === 0 ? 0 : 1)} ${Units[UnitIndex]}`;\n}\n"],
+  "mappings": "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",
+  "names": ["Path"]
 }

package/Distribution/functional.cjs

@@ -25,8 +25,8 @@ __export(Functional_exports, {
 module.exports = __toCommonJS(Functional_exports);
 
 // Source/Functional/Functional.ts
-function Identity(...Arguments) {
-  return Arguments;
+function Identity(...ArgumentVector) {
+  return ArgumentVector;
 }
 /**
  * @file      Functional.ts

package/Distribution/functional.cjs.map

@@ -1,7 +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;",
+  "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 */\n/* eslint-disable jsdoc/require-example */\n/**\n * The identity mapping, for some {@link Array} of {@link ArgumentVector | given arguments}.\n *\n * @param ArgumentVector - The {@link Array} of given arguments.\n * @returns {typeof ArgumentVector} The {@link Array} of given arguments.\n */\nexport function Identity<ArgumentType>(...ArgumentVector: Array<ArgumentType>): typeof ArgumentVector {\n    return ArgumentVector;\n}\n/* eslint-enable jsdoc/require-example */\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACaO,SAAS,YAA0B,gBAA4D;AAClG,SAAO;AACX;",
   "names": []
 }

package/Distribution/functional.js

@@ -1,6 +1,6 @@
 // Source/Functional/Functional.ts
-function Identity(...Arguments) {
-  return Arguments;
+function Identity(...ArgumentVector) {
+  return ArgumentVector;
 }
 export {
   Identity

package/Distribution/functional.js.map

@@ -1,7 +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;",
+  "sourcesContent": ["/**\n * @file      Functional.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/* eslint-disable jsdoc/require-example */\n/**\n * The identity mapping, for some {@link Array} of {@link ArgumentVector | given arguments}.\n *\n * @param ArgumentVector - The {@link Array} of given arguments.\n * @returns {typeof ArgumentVector} The {@link Array} of given arguments.\n */\nexport function Identity<ArgumentType>(...ArgumentVector: Array<ArgumentType>): typeof ArgumentVector {\n    return ArgumentVector;\n}\n/* eslint-enable jsdoc/require-example */\n"],
+  "mappings": ";AAaO,SAAS,YAA0B,gBAA4D;AAClG,SAAO;AACX;",
   "names": []
 }

package/Distribution/higher-kind.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// Source/HigherKind/index.ts
+var HigherKind_exports = {};
+module.exports = __toCommonJS(HigherKind_exports);
+/**
+ * @file      HigherKind.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      index.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+//# sourceMappingURL=higher-kind.cjs.map

package/Distribution/higher-kind.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../Source/HigherKind/index.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 \"./HigherKind.Types.ts\";\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/Distribution/higher-kind.js

@@ -0,0 +1,13 @@
+/**
+ * @file      HigherKind.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      index.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+//# sourceMappingURL=higher-kind.js.map

package/Distribution/higher-kind.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/Distribution/index.cjs

@@ -39,7 +39,8 @@ __export(Source_exports, {
   Miscellaneous: () => Miscellaneous_exports,
   Npm: () => Npm_exports,
   Path: () => Path_exports,
-  String: () => String_exports
+  String: () => String_exports,
+  TsConfig: () => TsConfig_exports
 });
 module.exports = __toCommonJS(Source_exports);
 
@@ -254,6 +255,7 @@ var i = new FComplex(0, 1);
 // Source/FileSystem/index.ts
 var FileSystem_exports = {};
 __export(FileSystem_exports, {
+  DeleteWithProgress: () => DeleteWithProgress,
   GetSafeNewPath: () => GetSafeNewPath,
   IsSupportedFileExtension: () => IsSupportedFileExtension,
   IsValidFileName: () => IsValidFileName,
@@ -265,9 +267,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;
@@ -327,8 +331,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));
 }
 
 // Source/Functional/index.ts
@@ -338,8 +429,8 @@ __export(Functional_exports, {
 });
 
 // Source/Functional/Functional.ts
-function Identity(...Arguments) {
-  return Arguments;
+function Identity(...ArgumentVector) {
+  return ArgumentVector;
 }
 
 // Source/Math/index.ts
@@ -487,8 +578,8 @@ var RootDirectoryNotFoundError = class extends import_effect.Data.TaggedError("R
 // Source/Npm/Npm.ts
 var import_path2 = require("path");
 var import_process = __toESM(require("process"), 1);
-async function GetPackageJson(Path) {
-  const RootDirectory = await GetPackageRootDirectory(Path);
+async function GetPackageJson(Path2) {
+  const RootDirectory = await GetPackageRootDirectory(Path2);
   const PackageJsonPath = (0, import_path2.join)(RootDirectory, "package.json");
   const FileContents = await import_fs3.promises.readFile(PackageJsonPath, "utf-8");
   const PackageJson = await (async () => {
@@ -500,8 +591,8 @@ async function GetPackageJson(Path) {
   })();
   return PackageJson;
 }
-async function GetPackageRootDirectory(Path) {
-  let CurrentDirectory = await import_fs3.promises.realpath(Path ?? import_process.default.cwd());
+async function GetPackageRootDirectory(Path2) {
+  let CurrentDirectory = await import_fs3.promises.realpath(Path2 ?? import_process.default.cwd());
   while (true) {
     const PackageJsonPath = (0, import_path2.join)(CurrentDirectory, "package.json");
     const PackageJsonExists = await (async () => {
@@ -517,7 +608,7 @@ async function GetPackageRootDirectory(Path) {
     }
     const ParentDirectory = (0, import_path2.dirname)(CurrentDirectory);
     if (ParentDirectory === CurrentDirectory) {
-      throw new RootDirectoryNotFoundError({ Path });
+      throw new RootDirectoryNotFoundError({ Path: Path2 });
     }
     CurrentDirectory = ParentDirectory;
   }
@@ -557,21 +648,43 @@ var FPath = class _FPath {
 // Source/String/index.ts
 var String_exports = {};
 __export(String_exports, {
+  Dedent: () => Dedent,
   IsAlpha: () => IsAlpha,
   IsLetters: () => IsLetters,
   IsNumeric: () => IsNumeric
 });
 
 // Source/String/String.ts
-function IsLetters(In) {
-  return /^[a-zA-Z]*$/.test(In);
+function IsLetters(TestString) {
+  return /^[a-zA-Z]*$/.test(TestString);
+}
+function IsAlpha(TestString) {
+  return IsLetters(TestString);
 }
-function IsAlpha(In) {
-  return IsLetters(In);
+function IsNumeric(TestString) {
+  return /^\d+$/.test(TestString);
 }
-function IsNumeric(In) {
-  return /^\d+$/.test(In);
+function Dedent(Content, IndentLength) {
+  const WhitespaceSubstring = (() => {
+    if (IndentLength !== void 0) {
+      return "\n" + " ".repeat(IndentLength);
+    }
+    let WhitespaceSubstring2 = "\n";
+    while (true) {
+      const TestString = WhitespaceSubstring2 + "  ";
+      if (Content.includes(TestString)) {
+        WhitespaceSubstring2 = TestString;
+      } else {
+        break;
+      }
+    }
+    return WhitespaceSubstring2;
+  })();
+  return Content.replaceAll(WhitespaceSubstring, "");
 }
+
+// Source/TsConfig/index.ts
+var TsConfig_exports = {};
 /**
  * @file      Array.ts
  * @author    Gage Sorrell <gage@sorrell.sh>
@@ -698,4 +811,10 @@ function IsNumeric(In) {
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
+/**
+ * @file      TsConfig.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
 //# sourceMappingURL=index.cjs.map