@sorrell/utilities 1.1.59 → 1.1.61

package/Distribution/CJS/npm-effect.js

@@ -0,0 +1,130 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// Source/Npm/Index.Effect.ts
+var Index_Effect_exports = {};
+__export(Index_Effect_exports, {
+  GetPackageJson: () => GetPackageJson,
+  GetPackageRootDirectory: () => GetPackageRootDirectory
+});
+module.exports = __toCommonJS(Index_Effect_exports);
+
+// Source/Npm/Npm.Effect.ts
+var import_fs = require("fs");
+
+// Source/Npm/Npm.Error.ts
+var import_effect = require("effect");
+var PackageJsonParseError = class extends import_effect.Data.TaggedError("PackageJsonParseError") {
+};
+var RootDirectoryNotFoundError = class extends import_effect.Data.TaggedError("RootDirectoryNotFound") {
+};
+
+// Source/Npm/Npm.Effect.ts
+var import_path = require("path");
+var import_effect2 = require("effect");
+
+// Source/Npm/Npm.Effect.Internal.ts
+function HasErrorCode(Value) {
+  return typeof Value === "object" && Value !== null && "code" in Value && typeof Value.code === "string";
+}
+
+// Source/Npm/Npm.Effect.ts
+var import_process = __toESM(require("process"), 1);
+function GetPackageJson(Path) {
+  return import_effect2.Effect.gen(function* () {
+    const RootDirectory = yield* GetPackageRootDirectory(Path);
+    const PackageJsonPath = (0, import_path.join)(RootDirectory, "package.json");
+    const FileContents = yield* import_effect2.Effect.tryPromise({
+      catch: (Cause) => Cause,
+      try: () => import_fs.promises.readFile(PackageJsonPath, "utf-8")
+    }).pipe(import_effect2.Effect.catchAll((Cause) => import_effect2.Effect.die(Cause)));
+    const PackageJson = yield* import_effect2.Effect.try({
+      catch: (Cause) => new PackageJsonParseError({
+        Cause,
+        Path: PackageJsonPath
+      }),
+      try: () => JSON.parse(FileContents)
+    });
+    return PackageJson;
+  });
+}
+function GetPackageRootDirectory(Path) {
+  return import_effect2.Effect.gen(function* () {
+    let CurrentDirectory = yield* import_effect2.Effect.tryPromise({
+      catch: (Cause) => Cause,
+      try: () => import_fs.promises.realpath(Path ?? import_process.default.cwd())
+    }).pipe(import_effect2.Effect.catchAll((Cause) => import_effect2.Effect.die(Cause)));
+    while (true) {
+      const PackageJsonPath = (0, import_path.join)(CurrentDirectory, "package.json");
+      const PackageJsonExists = yield* import_effect2.Effect.tryPromise({
+        catch: (Cause) => Cause,
+        try: () => import_fs.promises.access(PackageJsonPath, import_fs.constants.F_OK)
+      }).pipe(import_effect2.Effect.as(true), import_effect2.Effect.catchIf((Cause) => HasErrorCode(Cause) && Cause.code === "ENOENT", () => import_effect2.Effect.succeed(false)), import_effect2.Effect.catchAll((Cause) => import_effect2.Effect.die(Cause)));
+      if (PackageJsonExists) {
+        return CurrentDirectory;
+      }
+      const ParentDirectory = (0, import_path.dirname)(CurrentDirectory);
+      if (ParentDirectory === CurrentDirectory) {
+        return yield* import_effect2.Effect.fail(new RootDirectoryNotFoundError({ Path }));
+      }
+      CurrentDirectory = ParentDirectory;
+    }
+  });
+}
+/**
+ * @file      Npm.Error.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Npm.Effect.Internal.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Npm.Effect.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Npm.Effect.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Index.Effect.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+//# sourceMappingURL=npm-effect.js.map

package/Distribution/CJS/npm-effect.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../Source/Npm/Index.Effect.ts", "../../Source/Npm/Npm.Effect.ts", "../../Source/Npm/Npm.Error.ts", "../../Source/Npm/Npm.Effect.Internal.ts"],
+  "sourcesContent": ["/**\n * @file      Index.Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nexport * from \"./Npm.Effect.ts\";\nexport * from \"./Npm.Effect.Types.ts\";\n", "/**\n * @file      Npm.Effect.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport type { EGetPackageJson, EGetPackageRootDirectory } from \"./Npm.Effect.Types.ts\";\nimport { promises as Fs, constants as FsConstants } from \"fs\";\nimport { PackageJsonParseError, RootDirectoryNotFoundError } from \"./Npm.Error.ts\";\nimport { dirname, join } from \"path\";\nimport { Effect } from \"effect\";\nimport { HasErrorCode } from \"./Npm.Effect.Internal.ts\";\nimport type { IPackageJson } from \"package-json-type\";\nimport Process from \"process\";\n/**\n * Get the `package.json` of the Node.js project in which the\n * given path, or the current working directory, resides.\n *\n * @param Path - The given path from which to look for a root directory.\n *\n * @returns {EGetPackageJson} An Effect that succeeds with the parsed `package.json`, or fails\n * with {@link RootDirectoryNotFoundError} or {@link PackageJsonParseError}.\n *\n * @example\n * Suppose `process.cwd() === \"./MyPackage\"`,\n * ```typescript\n * Effect.gen(function* ()\n * {\n *     const PackageJson: IPackageJson = yield* GetPackageJson();\n *     // `PackageJson` <- *The parsed `package.json` of `MyPackage`.*\n * }\n * ```\n */\nexport function GetPackageJson(Path?: string): EGetPackageJson {\n    return Effect.gen(function* () {\n        const RootDirectory: string = yield* GetPackageRootDirectory(Path);\n        const PackageJsonPath: string = join(RootDirectory, \"package.json\");\n        const FileContents: string = yield* Effect.tryPromise({\n            catch: (Cause: unknown) => Cause,\n            try: () => Fs.readFile(PackageJsonPath, \"utf-8\")\n        }).pipe(Effect.catchAll((Cause: unknown) => Effect.die(Cause)));\n        const PackageJson: IPackageJson = yield* Effect.try({\n            catch: (Cause: unknown) => new PackageJsonParseError({\n                Cause,\n                Path: PackageJsonPath\n            }),\n            try: () => JSON.parse(FileContents) as IPackageJson\n        });\n        return PackageJson;\n    });\n}\n/**\n * Get the root directory of the Node.js project in which the\n * current working directory resides.\n *\n * @param Path - *(Optional)* The given path from which to look for a root directory.\n *\n * @returns {EGetPackageRootDirectory} An Effect that succeeds with the package root\n * directory, or fails with {@link RootDirectoryNotFoundError}.\n *\n * @example\n * Suppose `process.cwd()` is any one of the following,\n *   - `/home/alex/myPackage`,\n *   - `/home/alex/myPackage/src/MyModule`,\n *   - `/home/alex/myPackage/resource/Images`,\n *\n * then,\n *\n * ```typescript\n * import { Effect } from \"effect\";\n * const Root: string = await Effect.runPromise(GetPackageRootDirectory());\n * // `Root` <- `\"/home/alex/myPackage\"`\n * ```\n *\n * @example\n * Suppose `TestPath === \"/home/alex/Documents\"` is *not* a NodeJS package root\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * import { Effect } from \"effect\";\n * const TestPath: string = \"/home/alex/Documents\";\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await Effect.runPromise(\n *         GetPackageRootDirectory(TestPath)\n *     );\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n *\n * // `Root` <- `undefined`\n * ```\n *\n * @example\n * Suppose `process.cwd() === /home/alex/Downloads`, which is *not* a NodeJS package\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * import { Effect } from \"effect\";\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await Effect.runPromise(GetPackageRootDirectory());\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n * // `Root` <- `undefined`\n * ```\n */\nexport function GetPackageRootDirectory(Path?: string): EGetPackageRootDirectory {\n    return Effect.gen(function* () {\n        let CurrentDirectory: string = yield* Effect.tryPromise({\n            catch: (Cause: unknown) => Cause,\n            try: () => Fs.realpath(Path ?? Process.cwd())\n        }).pipe(Effect.catchAll((Cause: unknown) => Effect.die(Cause)));\n        while (true) {\n            const PackageJsonPath: string = join(CurrentDirectory, \"package.json\");\n            const PackageJsonExists: boolean = yield* Effect.tryPromise({\n                catch: (Cause: unknown) => Cause,\n                try: () => Fs.access(PackageJsonPath, FsConstants.F_OK)\n            }).pipe(Effect.as(true), Effect.catchIf((Cause: unknown): Cause is {\n                readonly code: string;\n            } => HasErrorCode(Cause) && Cause.code === \"ENOENT\", () => Effect.succeed(false)), Effect.catchAll((Cause: unknown) => Effect.die(Cause)));\n            if (PackageJsonExists) {\n                return CurrentDirectory;\n            }\n            const ParentDirectory: string = dirname(CurrentDirectory);\n            if (ParentDirectory === CurrentDirectory) {\n                return yield* Effect.fail(new RootDirectoryNotFoundError({ Path }));\n            }\n            CurrentDirectory = ParentDirectory;\n        }\n    });\n}\n", "/**\n * @file      Npm.Error.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { Data } from \"effect\";\n/**\n * An error describing that {@link GetPackageJson} failed to parse the discovered `package.json` file.\n *\n * @property {string | undefined} Path - The `Path` argument passed to the effect returning this error,\n * if one was given.\n * @property {unknown} Cause - The cause of this error.\n */\nexport class PackageJsonParseError extends Data.TaggedError(\"PackageJsonParseError\")<{\n    readonly Path: string | undefined;\n    readonly Cause: unknown;\n}> {\n}\n/**\n * An error describing that {@link GetPackageRootDirectory} failed.\n *\n * @property {string | undefined} Path - The `Path` argument passed to the effect returning\n * this error, if one was given.\n */\nexport class RootDirectoryNotFoundError extends Data.TaggedError(\"RootDirectoryNotFound\")<{\n    readonly Path: string | undefined;\n}> {\n}\n", "/**\n * @file      Npm.Effect.Internal.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 * Returns whether a given {@link Value} contains a `readonly` `string` `\"code\"`.\n *\n * @param Value - The value to test.\n * @returns {Value is { readonly code: string }} Whether {@link Value} is a\n * `{ readonly code: string }`.\n */\nexport function HasErrorCode(Value: unknown): Value is {\n    readonly code: string;\n} {\n    return typeof Value === \"object\"\n        && Value !== null\n        && \"code\" in Value\n        && typeof (Value as {\n            readonly code: unknown;\n        }).code === \"string\";\n}\n/* eslint-enable jsdoc/require-example */\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACOA,gBAAyD;;;ACDzD,oBAAqB;AAQd,IAAM,wBAAN,cAAoC,mBAAK,YAAY,uBAAuB,EAGhF;AACH;AAOO,IAAM,6BAAN,cAAyC,mBAAK,YAAY,uBAAuB,EAErF;AACH;;;ADnBA,kBAA8B;AAC9B,IAAAA,iBAAuB;;;AEIhB,SAAS,aAAa,OAE3B;AACE,SAAO,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,OAAQ,MAER,SAAS;AACpB;;;AFVA,qBAAoB;AAoBb,SAAS,eAAe,MAAgC;AAC3D,SAAO,sBAAO,IAAI,aAAa;AAC3B,UAAM,gBAAwB,OAAO,wBAAwB,IAAI;AACjE,UAAM,sBAA0B,kBAAK,eAAe,cAAc;AAClE,UAAM,eAAuB,OAAO,sBAAO,WAAW;AAAA,MAClD,OAAO,CAAC,UAAmB;AAAA,MAC3B,KAAK,MAAM,UAAAC,SAAG,SAAS,iBAAiB,OAAO;AAAA,IACnD,CAAC,EAAE,KAAK,sBAAO,SAAS,CAAC,UAAmB,sBAAO,IAAI,KAAK,CAAC,CAAC;AAC9D,UAAM,cAA4B,OAAO,sBAAO,IAAI;AAAA,MAChD,OAAO,CAAC,UAAmB,IAAI,sBAAsB;AAAA,QACjD;AAAA,QACA,MAAM;AAAA,MACV,CAAC;AAAA,MACD,KAAK,MAAM,KAAK,MAAM,YAAY;AAAA,IACtC,CAAC;AACD,WAAO;AAAA,EACX,CAAC;AACL;AAgEO,SAAS,wBAAwB,MAAyC;AAC7E,SAAO,sBAAO,IAAI,aAAa;AAC3B,QAAI,mBAA2B,OAAO,sBAAO,WAAW;AAAA,MACpD,OAAO,CAAC,UAAmB;AAAA,MAC3B,KAAK,MAAM,UAAAA,SAAG,SAAS,QAAQ,eAAAC,QAAQ,IAAI,CAAC;AAAA,IAChD,CAAC,EAAE,KAAK,sBAAO,SAAS,CAAC,UAAmB,sBAAO,IAAI,KAAK,CAAC,CAAC;AAC9D,WAAO,MAAM;AACT,YAAM,sBAA0B,kBAAK,kBAAkB,cAAc;AACrE,YAAM,oBAA6B,OAAO,sBAAO,WAAW;AAAA,QACxD,OAAO,CAAC,UAAmB;AAAA,QAC3B,KAAK,MAAM,UAAAD,SAAG,OAAO,iBAAiB,UAAAE,UAAY,IAAI;AAAA,MAC1D,CAAC,EAAE,KAAK,sBAAO,GAAG,IAAI,GAAG,sBAAO,QAAQ,CAAC,UAEpC,aAAa,KAAK,KAAK,MAAM,SAAS,UAAU,MAAM,sBAAO,QAAQ,KAAK,CAAC,GAAG,sBAAO,SAAS,CAAC,UAAmB,sBAAO,IAAI,KAAK,CAAC,CAAC;AACzI,UAAI,mBAAmB;AACnB,eAAO;AAAA,MACX;AACA,YAAM,sBAA0B,qBAAQ,gBAAgB;AACxD,UAAI,oBAAoB,kBAAkB;AACtC,eAAO,OAAO,sBAAO,KAAK,IAAI,2BAA2B,EAAE,KAAK,CAAC,CAAC;AAAA,MACtE;AACA,yBAAmB;AAAA,IACvB;AAAA,EACJ,CAAC;AACL;",
+  "names": ["import_effect", "Fs", "Process", "FsConstants"]
+}

package/Distribution/CJS/npm.js

@@ -49,51 +49,41 @@ var RootDirectoryNotFoundError = class extends import_effect.Data.TaggedError("R
 
 // Source/Npm/Npm.ts
 var import_path = require("path");
-var import_effect2 = require("effect");
 var import_process = __toESM(require("process"), 1);
-function HasErrorCode(Value) {
-  return typeof Value === "object" && Value !== null && "code" in Value && typeof Value.code === "string";
-}
-function GetPackageJson(Path) {
-  return import_effect2.Effect.gen(function* () {
-    const RootDirectory = yield* GetPackageRootDirectory(Path);
-    const PackageJsonPath = (0, import_path.join)(RootDirectory, "package.json");
-    const FileContents = yield* import_effect2.Effect.tryPromise({
-      catch: (Cause) => Cause,
-      try: () => import_fs.promises.readFile(PackageJsonPath, "utf-8")
-    }).pipe(import_effect2.Effect.catchAll((Cause) => import_effect2.Effect.die(Cause)));
-    const PackageJson = yield* import_effect2.Effect.try({
-      catch: (Cause) => new PackageJsonParseError({
-        Cause,
-        Path: PackageJsonPath
-      }),
-      try: () => JSON.parse(FileContents)
-    });
-    return PackageJson;
-  });
+async function GetPackageJson(Path) {
+  const RootDirectory = await GetPackageRootDirectory(Path);
+  const PackageJsonPath = (0, import_path.join)(RootDirectory, "package.json");
+  const FileContents = await import_fs.promises.readFile(PackageJsonPath, "utf-8");
+  const PackageJson = await (async () => {
+    try {
+      return JSON.parse(FileContents);
+    } catch (Cause) {
+      throw new PackageJsonParseError({ Cause, Path: PackageJsonPath });
+    }
+  })();
+  return PackageJson;
 }
-function GetPackageRootDirectory(Path) {
-  return import_effect2.Effect.gen(function* () {
-    let CurrentDirectory = yield* import_effect2.Effect.tryPromise({
-      catch: (Cause) => Cause,
-      try: () => import_fs.promises.realpath(Path ?? import_process.default.cwd())
-    }).pipe(import_effect2.Effect.catchAll((Cause) => import_effect2.Effect.die(Cause)));
-    while (true) {
-      const PackageJsonPath = (0, import_path.join)(CurrentDirectory, "package.json");
-      const PackageJsonExists = yield* import_effect2.Effect.tryPromise({
-        catch: (Cause) => Cause,
-        try: () => import_fs.promises.access(PackageJsonPath, import_fs.constants.F_OK)
-      }).pipe(import_effect2.Effect.as(true), import_effect2.Effect.catchIf((Cause) => HasErrorCode(Cause) && Cause.code === "ENOENT", () => import_effect2.Effect.succeed(false)), import_effect2.Effect.catchAll((Cause) => import_effect2.Effect.die(Cause)));
-      if (PackageJsonExists) {
-        return CurrentDirectory;
-      }
-      const ParentDirectory = (0, import_path.dirname)(CurrentDirectory);
-      if (ParentDirectory === CurrentDirectory) {
-        return yield* import_effect2.Effect.fail(new RootDirectoryNotFoundError({ Path }));
+async function GetPackageRootDirectory(Path) {
+  let CurrentDirectory = await import_fs.promises.realpath(Path ?? import_process.default.cwd());
+  while (true) {
+    const PackageJsonPath = (0, import_path.join)(CurrentDirectory, "package.json");
+    const PackageJsonExists = await (async () => {
+      try {
+        await import_fs.promises.access(PackageJsonPath, import_fs.constants.F_OK);
+        return true;
+      } catch {
+        return false;
       }
-      CurrentDirectory = ParentDirectory;
+    })();
+    if (PackageJsonExists) {
+      return CurrentDirectory;
     }
-  });
+    const ParentDirectory = (0, import_path.dirname)(CurrentDirectory);
+    if (ParentDirectory === CurrentDirectory) {
+      throw new RootDirectoryNotFoundError({ Path });
+    }
+    CurrentDirectory = ParentDirectory;
+  }
 }
 /**
  * @file      Npm.Error.ts
@@ -107,12 +97,6 @@ function GetPackageRootDirectory(Path) {
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-/**
- * @file      Npm.Types.ts
- * @author    Gage Sorrell <gage@sorrell.sh>
- * @copyright (c) 2026 Gage Sorrell
- * @license   MIT
- */
 /**
  * @file      index.ts
  * @author    Gage Sorrell <gage@sorrell.sh>

package/Distribution/CJS/npm.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../Source/Npm/index.ts", "../../Source/Npm/Npm.ts", "../../Source/Npm/Npm.Error.ts"],
-  "sourcesContent": ["/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/**\n * @module Npm\n * Utilities for working with `npm` (NodeJS) packages.\n * Many of these likely work with packages of other NodeJS\n * package managers and adjacent runtimes (*e.g.*, `bun` or `deno`).\n */\nexport * from \"./Npm.ts\";\nexport * from \"./Npm.Error.ts\";\nexport * from \"./Npm.Types.ts\";\n", "/**\n * @file      Npm.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { promises as Fs, constants as FsConstants } from \"fs\";\nimport { PackageJsonParseError, RootDirectoryNotFoundError } from \"./Npm.Error.ts\";\nimport { dirname, join } from \"path\";\nimport { Effect } from \"effect\";\nimport type { GetPackageJsonEffect } from \"./Npm.Types.ts\";\nimport type { IPackageJson } from \"package-json-type\";\nimport Process from \"process\";\n/* eslint-disable-next-line jsdoc/require-jsdoc */\nfunction HasErrorCode(Value: unknown): Value is {\n    readonly code: string;\n} {\n    return typeof Value === \"object\"\n        && Value !== null\n        && \"code\" in Value\n        && typeof (Value as {\n            readonly code: unknown;\n        }).code === \"string\";\n}\n/**\n * Get the `package.json` of the Node.js project in which the\n * given path, or the current working directory, resides.\n *\n * @param Path - *(Optional)* The given path from which to look for a root directory.\n *\n * @returns An Effect that succeeds with the parsed `package.json`, or fails\n * with {@link RootDirectoryNotFoundError} or {@link PackageJsonParseError}.\n */\nexport function GetPackageJson(Path?: string): GetPackageJsonEffect {\n    return Effect.gen(function* () {\n        const RootDirectory: string = yield* GetPackageRootDirectory(Path);\n        const PackageJsonPath: string = join(RootDirectory, \"package.json\");\n        const FileContents: string = yield* Effect.tryPromise({\n            catch: (Cause: unknown) => Cause,\n            try: () => Fs.readFile(PackageJsonPath, \"utf-8\")\n        }).pipe(Effect.catchAll((Cause: unknown) => Effect.die(Cause)));\n        const PackageJson: IPackageJson = yield* Effect.try({\n            catch: (Cause: unknown) => new PackageJsonParseError({\n                Cause,\n                Path: PackageJsonPath\n            }),\n            try: () => JSON.parse(FileContents) as IPackageJson\n        });\n        return PackageJson;\n    });\n}\n/**\n * Get the root directory of the Node.js project in which the\n * current working directory resides.\n *\n * @param Path - *(Optional)* The given path from which to look for a root directory.\n *\n * @returns An Effect that succeeds with the package root directory, or fails\n * with {@link RootDirectoryNotFoundError}.\n *\n * @example\n * Suppose `process.cwd()` is any one of the following,\n *   - `/home/alex/myPackage`,\n *   - `/home/alex/myPackage/src/MyModule`,\n *   - `/home/alex/myPackage/resource/Images`,\n *\n * then,\n *\n * ```typescript\n * import { Effect } from \"effect\";\n * const Root: string = await Effect.runPromise(GetPackageRootDirectory());\n * // `Root` <- `\"/home/alex/myPackage\"`\n * ```\n *\n * @example\n * Suppose `TestPath === \"/home/alex/Documents\"` is *not* a NodeJS package root\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * import { Effect } from \"effect\";\n * const TestPath: string = \"/home/alex/Documents\";\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await Effect.runPromise(\n *         GetPackageRootDirectory(TestPath)\n *     );\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n *\n * // `Root` <- `undefined`\n * ```\n *\n * @example\n * Suppose `process.cwd() === /home/alex/Downloads`, which is *not* a NodeJS package\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * import { Effect } from \"effect\";\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await Effect.runPromise(GetPackageRootDirectory());\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n * // `Root` <- `undefined`\n * ```\n */\nexport function GetPackageRootDirectory(Path?: string): Effect.Effect<string, RootDirectoryNotFoundError, never> {\n    return Effect.gen(function* () {\n        let CurrentDirectory: string = yield* Effect.tryPromise({\n            catch: (Cause: unknown) => Cause,\n            try: () => Fs.realpath(Path ?? Process.cwd())\n        }).pipe(Effect.catchAll((Cause: unknown) => Effect.die(Cause)));\n        while (true) {\n            const PackageJsonPath: string = join(CurrentDirectory, \"package.json\");\n            const PackageJsonExists: boolean = yield* Effect.tryPromise({\n                catch: (Cause: unknown) => Cause,\n                try: () => Fs.access(PackageJsonPath, FsConstants.F_OK)\n            }).pipe(Effect.as(true), Effect.catchIf((Cause: unknown): Cause is {\n                readonly code: string;\n            } => HasErrorCode(Cause) && Cause.code === \"ENOENT\", () => Effect.succeed(false)), Effect.catchAll((Cause: unknown) => Effect.die(Cause)));\n            if (PackageJsonExists) {\n                return CurrentDirectory;\n            }\n            const ParentDirectory: string = dirname(CurrentDirectory);\n            if (ParentDirectory === CurrentDirectory) {\n                return yield* Effect.fail(new RootDirectoryNotFoundError({ Path }));\n            }\n            CurrentDirectory = ParentDirectory;\n        }\n    });\n}\n// export async function GetPackageRootDirectory(Path?: string): Promise<string>\n// {\n//     let CurrentDirectory: string = await realpath(Path || Process.cwd());\n//     while (true)\n//     {\n//         const PackageJsonPath: string = join(CurrentDirectory, \"package.json\");\n//         try\n//         {\n//             await access(PackageJsonPath, FsConstants.F_OK);\n//             return CurrentDirectory;\n//         }\n//         catch { /* Empty */ }\n//         const ParentDirectory: string = dirname(CurrentDirectory);\n//         if (ParentDirectory === CurrentDirectory)\n//         {\n//             throw new Error(\n//                 `Could not find a Node.js project root above \"${ Path || Process.cwd() }\".`\n//             );\n//         }\n//         CurrentDirectory = ParentDirectory;\n//     }\n// }\n", "/**\n * @file      Npm.Error.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { Data } from \"effect\";\n/**\n * An error describing that {@link GetPackageJson} failed to parse the discovered `package.json` file.\n *\n * @field Path - The `Path` argument passed to the effect returning this error, if one was given.\n * @field Cause - The cause of this error.\n */\nexport class PackageJsonParseError extends Data.TaggedError(\"PackageJsonParseError\")<{\n    readonly Path: string | undefined;\n    readonly Cause: unknown;\n}> {\n}\n/**\n * An error describing that {@link GetPackageRootDirectory} failed.\n *\n * @field Path - The `Path` argument passed to the effect returning this error, if one was given.\n */\nexport class RootDirectoryNotFoundError extends Data.TaggedError(\"RootDirectoryNotFound\")<{\n    readonly Path: string | undefined;\n}> {\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMA,gBAAyD;;;ACAzD,oBAAqB;AAOd,IAAM,wBAAN,cAAoC,mBAAK,YAAY,uBAAuB,EAGhF;AACH;AAMO,IAAM,6BAAN,cAAyC,mBAAK,YAAY,uBAAuB,EAErF;AACH;;;ADlBA,kBAA8B;AAC9B,IAAAA,iBAAuB;AAGvB,qBAAoB;AAEpB,SAAS,aAAa,OAEpB;AACE,SAAO,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,OAAQ,MAER,SAAS;AACpB;AAUO,SAAS,eAAe,MAAqC;AAChE,SAAO,sBAAO,IAAI,aAAa;AAC3B,UAAM,gBAAwB,OAAO,wBAAwB,IAAI;AACjE,UAAM,sBAA0B,kBAAK,eAAe,cAAc;AAClE,UAAM,eAAuB,OAAO,sBAAO,WAAW;AAAA,MAClD,OAAO,CAAC,UAAmB;AAAA,MAC3B,KAAK,MAAM,UAAAC,SAAG,SAAS,iBAAiB,OAAO;AAAA,IACnD,CAAC,EAAE,KAAK,sBAAO,SAAS,CAAC,UAAmB,sBAAO,IAAI,KAAK,CAAC,CAAC;AAC9D,UAAM,cAA4B,OAAO,sBAAO,IAAI;AAAA,MAChD,OAAO,CAAC,UAAmB,IAAI,sBAAsB;AAAA,QACjD;AAAA,QACA,MAAM;AAAA,MACV,CAAC;AAAA,MACD,KAAK,MAAM,KAAK,MAAM,YAAY;AAAA,IACtC,CAAC;AACD,WAAO;AAAA,EACX,CAAC;AACL;AAgEO,SAAS,wBAAwB,MAAyE;AAC7G,SAAO,sBAAO,IAAI,aAAa;AAC3B,QAAI,mBAA2B,OAAO,sBAAO,WAAW;AAAA,MACpD,OAAO,CAAC,UAAmB;AAAA,MAC3B,KAAK,MAAM,UAAAA,SAAG,SAAS,QAAQ,eAAAC,QAAQ,IAAI,CAAC;AAAA,IAChD,CAAC,EAAE,KAAK,sBAAO,SAAS,CAAC,UAAmB,sBAAO,IAAI,KAAK,CAAC,CAAC;AAC9D,WAAO,MAAM;AACT,YAAM,sBAA0B,kBAAK,kBAAkB,cAAc;AACrE,YAAM,oBAA6B,OAAO,sBAAO,WAAW;AAAA,QACxD,OAAO,CAAC,UAAmB;AAAA,QAC3B,KAAK,MAAM,UAAAD,SAAG,OAAO,iBAAiB,UAAAE,UAAY,IAAI;AAAA,MAC1D,CAAC,EAAE,KAAK,sBAAO,GAAG,IAAI,GAAG,sBAAO,QAAQ,CAAC,UAEpC,aAAa,KAAK,KAAK,MAAM,SAAS,UAAU,MAAM,sBAAO,QAAQ,KAAK,CAAC,GAAG,sBAAO,SAAS,CAAC,UAAmB,sBAAO,IAAI,KAAK,CAAC,CAAC;AACzI,UAAI,mBAAmB;AACnB,eAAO;AAAA,MACX;AACA,YAAM,sBAA0B,qBAAQ,gBAAgB;AACxD,UAAI,oBAAoB,kBAAkB;AACtC,eAAO,OAAO,sBAAO,KAAK,IAAI,2BAA2B,EAAE,KAAK,CAAC,CAAC;AAAA,MACtE;AACA,yBAAmB;AAAA,IACvB;AAAA,EACJ,CAAC;AACL;",
-  "names": ["import_effect", "Fs", "Process", "FsConstants"]
+  "sourcesContent": ["/**\n * @file      index.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\n/**\n * @module Npm\n * Utilities for working with `npm` (NodeJS) packages.\n * Many of these likely work with packages of other NodeJS\n * package managers and adjacent runtimes (*e.g.*, `bun` or `deno`).\n */\nexport * from \"./Npm.ts\";\nexport * from \"./Npm.Error.ts\";\n", "/**\n * @file      Npm.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { promises as Fs, constants as FsConstants } from \"fs\";\nimport { PackageJsonParseError, RootDirectoryNotFoundError } from \"./Npm.Error.ts\";\nimport { dirname, join } from \"path\";\nimport type { IPackageJson } from \"package-json-type\";\nimport Process from \"process\";\n/**\n * Get the `package.json` of the Node.js project in which the\n * given path, or the current working directory, resides.\n *\n * @param Path - The given path from which to look for a root directory.\n *\n * @throws {RootDirectoryNotFoundError | PackageJsonParseError} An error\n * describing either failure to identify a root directory, or failing to\n * parse the discovered `package.json`.\n *\n * @returns {Promise<IPackageJson>} The {@link IPackageJson} of {@link Path}\n * if provided, otherwise of `process.cwd()`.\n *\n * @example\n * Suppose `process.cwd() === \"./MyPackage\"`,\n * ```typescript\n * const PackageJson: IPackageJson = await GetPackageJson();\n * // `PackageJson` <- *The parsed `package.json` of `MyPackage`.*\n * ```\n */\nexport async function GetPackageJson(Path?: string): Promise<IPackageJson> {\n    const RootDirectory: string = await GetPackageRootDirectory(Path);\n    const PackageJsonPath: string = join(RootDirectory, \"package.json\");\n    const FileContents: string = await Fs.readFile(PackageJsonPath, \"utf-8\");\n    const PackageJson: IPackageJson = await (async (): Promise<IPackageJson> => {\n        try {\n            return JSON.parse(FileContents) as IPackageJson;\n        }\n        catch (Cause: unknown) {\n            throw new PackageJsonParseError({ Cause, Path: PackageJsonPath });\n        }\n    })();\n    return PackageJson;\n}\n/**\n * Get the root directory of the Node.js project in which the\n * current working directory resides.\n *\n * @param Path - The given path from which to look for a root directory.\n *\n * @throws {RootDirectoryNotFoundError} An error iff the root directory\n * of a NodeJS package could not be found.\n *\n * @returns {Promise<string>} The path to the root directory of the package\n * containing {@link Path} if specified, otherwise containing `process.cwd()`.\n *\n * @example\n * Suppose `process.cwd()` is any one of the following,\n *   - `/home/alex/myPackage`,\n *   - `/home/alex/myPackage/src/MyModule`,\n *   - `/home/alex/myPackage/resource/Images`,\n *\n * then,\n *\n * ```typescript\n * const Root: string = await GetPackageRootDirectory();\n * // `Root` <- `\"/home/alex/myPackage\"`\n * ```\n *\n * @example\n * Suppose `TestPath === \"/home/alex/Documents\"` is *not* a NodeJS package root\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * const TestPath: string = \"/home/alex/Documents\";\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await GetPackageRootDirectory(TestPath);\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n *\n * // `Root` <- `undefined`\n * ```\n *\n * @example\n * Suppose `process.cwd() === /home/alex/Downloads`, which is *not* a NodeJS package\n * (of course, neither are `/home/alex` or `/home`).  Then,\n *\n * ```typescript\n * let Root: string | undefined = undefined;\n * try\n * {\n *     Root = await GetPackageRootDirectory();\n * }\n * catch (Error: unknown)\n * {\n *      // `Error instanceof RootDirectoryNotFound`\n * }\n * // `Root` <- `undefined`\n * ```\n */\nexport async function GetPackageRootDirectory(Path?: string): Promise<string> {\n    let CurrentDirectory: string = await Fs.realpath(Path ?? Process.cwd());\n    while (true) {\n        const PackageJsonPath: string = join(CurrentDirectory, \"package.json\");\n        const PackageJsonExists: boolean = await (async (): Promise<boolean> => {\n            try {\n                await Fs.access(PackageJsonPath, FsConstants.F_OK);\n                return true;\n            }\n            catch {\n                return false;\n            }\n        })();\n        if (PackageJsonExists) {\n            return CurrentDirectory;\n        }\n        const ParentDirectory: string = dirname(CurrentDirectory);\n        if (ParentDirectory === CurrentDirectory) {\n            throw new RootDirectoryNotFoundError({ Path });\n        }\n        CurrentDirectory = ParentDirectory;\n    }\n}\n", "/**\n * @file      Npm.Error.ts\n * @author    Gage Sorrell <gage@sorrell.sh>\n * @copyright (c) 2026 Gage Sorrell\n * @license   MIT\n */\nimport { Data } from \"effect\";\n/**\n * An error describing that {@link GetPackageJson} failed to parse the discovered `package.json` file.\n *\n * @property {string | undefined} Path - The `Path` argument passed to the effect returning this error,\n * if one was given.\n * @property {unknown} Cause - The cause of this error.\n */\nexport class PackageJsonParseError extends Data.TaggedError(\"PackageJsonParseError\")<{\n    readonly Path: string | undefined;\n    readonly Cause: unknown;\n}> {\n}\n/**\n * An error describing that {@link GetPackageRootDirectory} failed.\n *\n * @property {string | undefined} Path - The `Path` argument passed to the effect returning\n * this error, if one was given.\n */\nexport class RootDirectoryNotFoundError extends Data.TaggedError(\"RootDirectoryNotFound\")<{\n    readonly Path: string | undefined;\n}> {\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMA,gBAAyD;;;ACAzD,oBAAqB;AAQd,IAAM,wBAAN,cAAoC,mBAAK,YAAY,uBAAuB,EAGhF;AACH;AAOO,IAAM,6BAAN,cAAyC,mBAAK,YAAY,uBAAuB,EAErF;AACH;;;ADpBA,kBAA8B;AAE9B,qBAAoB;AAqBpB,eAAsB,eAAe,MAAsC;AACvE,QAAM,gBAAwB,MAAM,wBAAwB,IAAI;AAChE,QAAM,sBAA0B,kBAAK,eAAe,cAAc;AAClE,QAAM,eAAuB,MAAM,UAAAA,SAAG,SAAS,iBAAiB,OAAO;AACvE,QAAM,cAA4B,OAAO,YAAmC;AACxE,QAAI;AACA,aAAO,KAAK,MAAM,YAAY;AAAA,IAClC,SACO,OAAgB;AACnB,YAAM,IAAI,sBAAsB,EAAE,OAAO,MAAM,gBAAgB,CAAC;AAAA,IACpE;AAAA,EACJ,GAAG;AACH,SAAO;AACX;AA8DA,eAAsB,wBAAwB,MAAgC;AAC1E,MAAI,mBAA2B,MAAM,UAAAA,SAAG,SAAS,QAAQ,eAAAC,QAAQ,IAAI,CAAC;AACtE,SAAO,MAAM;AACT,UAAM,sBAA0B,kBAAK,kBAAkB,cAAc;AACrE,UAAM,oBAA6B,OAAO,YAA8B;AACpE,UAAI;AACA,cAAM,UAAAD,SAAG,OAAO,iBAAiB,UAAAE,UAAY,IAAI;AACjD,eAAO;AAAA,MACX,QACM;AACF,eAAO;AAAA,MACX;AAAA,IACJ,GAAG;AACH,QAAI,mBAAmB;AACnB,aAAO;AAAA,IACX;AACA,UAAM,sBAA0B,qBAAQ,gBAAgB;AACxD,QAAI,oBAAoB,kBAAkB;AACtC,YAAM,IAAI,2BAA2B,EAAE,KAAK,CAAC;AAAA,IACjD;AACA,uBAAmB;AAAA,EACvB;AACJ;",
+  "names": ["Fs", "Process", "FsConstants"]
 }

package/Distribution/ESM/fs.js

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

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

package/Distribution/ESM/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 */\nexport function Identity<Type>(...Arguments: Array<Type>) {\n    return Arguments;\n}\n"],
-  "mappings": ";AAMO,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 */\nimport { CurriedArgument } from \"./Functional.Internal\";\nimport type { FCurriedArgument } from \"./Functional.Internal.Types\";\nimport type { TFunction } from \"./Functional.Types\";\nexport function Identity<Type>(...Arguments: Array<Type>) {\n    return Arguments;\n}\n"],
+  "mappings": ";AASO,SAAS,YAAkB,WAAwB;AACtD,SAAO;AACX;",
   "names": []
 }

package/Distribution/ESM/index.js

@@ -217,17 +217,18 @@ var FileSystem_exports = {};
 __export(FileSystem_exports, {
   GetSafeNewPath: () => GetSafeNewPath,
   IsSupportedFileExtension: () => IsSupportedFileExtension,
-  IsValidFileName: () => IsValidFileName
+  IsValidFileName: () => IsValidFileName,
+  WriteTextFile: () => WriteTextFile
 });
 
 // Source/FileSystem/FileSystem.ts
-import { access, open, unlink } from "fs/promises";
 import { basename, dirname, extname, join } from "path";
+import { promises as Fs } from "fs";
 import { constants as FsConstants } from "fs";
 import os from "os";
 async function PathExists(Path) {
   try {
-    await access(Path, FsConstants.F_OK);
+    await Fs.access(Path, FsConstants.F_OK);
     return true;
   } catch {
     return false;
@@ -277,16 +278,19 @@ async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false,
   }
   const FilePath = join(DirectoryPath, FileName);
   try {
-    const ThisFileHandle = await open(FilePath, "wx");
+    const ThisFileHandle = await Fs.open(FilePath, "wx");
     await ThisFileHandle.close();
     if (!PersistNewFile) {
-      await unlink(FilePath);
+      await Fs.unlink(FilePath);
     }
     return true;
   } catch {
     return false;
   }
 }
+async function WriteTextFile(Path, Contents) {
+  await Fs.writeFile(Path, Contents, { encoding: "utf-8" });
+}
 
 // Source/Functional/index.ts
 var Functional_exports = {};
@@ -432,7 +436,7 @@ __export(Npm_exports, {
 });
 
 // Source/Npm/Npm.ts
-import { promises as Fs, constants as FsConstants2 } from "fs";
+import { promises as Fs2, constants as FsConstants2 } from "fs";
 
 // Source/Npm/Npm.Error.ts
 import { Data } from "effect";
@@ -443,51 +447,41 @@ var RootDirectoryNotFoundError = class extends Data.TaggedError("RootDirectoryNo
 
 // Source/Npm/Npm.ts
 import { dirname as dirname2, join as join2 } from "path";
-import { Effect } from "effect";
 import Process from "process";
-function HasErrorCode(Value) {
-  return typeof Value === "object" && Value !== null && "code" in Value && typeof Value.code === "string";
-}
-function GetPackageJson(Path) {
-  return Effect.gen(function* () {
-    const RootDirectory = yield* GetPackageRootDirectory(Path);
-    const PackageJsonPath = join2(RootDirectory, "package.json");
-    const FileContents = yield* Effect.tryPromise({
-      catch: (Cause) => Cause,
-      try: () => Fs.readFile(PackageJsonPath, "utf-8")
-    }).pipe(Effect.catchAll((Cause) => Effect.die(Cause)));
-    const PackageJson = yield* Effect.try({
-      catch: (Cause) => new PackageJsonParseError({
-        Cause,
-        Path: PackageJsonPath
-      }),
-      try: () => JSON.parse(FileContents)
-    });
-    return PackageJson;
-  });
+async function GetPackageJson(Path) {
+  const RootDirectory = await GetPackageRootDirectory(Path);
+  const PackageJsonPath = join2(RootDirectory, "package.json");
+  const FileContents = await Fs2.readFile(PackageJsonPath, "utf-8");
+  const PackageJson = await (async () => {
+    try {
+      return JSON.parse(FileContents);
+    } catch (Cause) {
+      throw new PackageJsonParseError({ Cause, Path: PackageJsonPath });
+    }
+  })();
+  return PackageJson;
 }
-function GetPackageRootDirectory(Path) {
-  return Effect.gen(function* () {
-    let CurrentDirectory = yield* Effect.tryPromise({
-      catch: (Cause) => Cause,
-      try: () => Fs.realpath(Path ?? Process.cwd())
-    }).pipe(Effect.catchAll((Cause) => Effect.die(Cause)));
-    while (true) {
-      const PackageJsonPath = join2(CurrentDirectory, "package.json");
-      const PackageJsonExists = yield* Effect.tryPromise({
-        catch: (Cause) => Cause,
-        try: () => Fs.access(PackageJsonPath, FsConstants2.F_OK)
-      }).pipe(Effect.as(true), Effect.catchIf((Cause) => HasErrorCode(Cause) && Cause.code === "ENOENT", () => Effect.succeed(false)), Effect.catchAll((Cause) => Effect.die(Cause)));
-      if (PackageJsonExists) {
-        return CurrentDirectory;
+async function GetPackageRootDirectory(Path) {
+  let CurrentDirectory = await Fs2.realpath(Path ?? Process.cwd());
+  while (true) {
+    const PackageJsonPath = join2(CurrentDirectory, "package.json");
+    const PackageJsonExists = await (async () => {
+      try {
+        await Fs2.access(PackageJsonPath, FsConstants2.F_OK);
+        return true;
+      } catch {
+        return false;
       }
-      const ParentDirectory = dirname2(CurrentDirectory);
-      if (ParentDirectory === CurrentDirectory) {
-        return yield* Effect.fail(new RootDirectoryNotFoundError({ Path }));
-      }
-      CurrentDirectory = ParentDirectory;
+    })();
+    if (PackageJsonExists) {
+      return CurrentDirectory;
     }
-  });
+    const ParentDirectory = dirname2(CurrentDirectory);
+    if (ParentDirectory === CurrentDirectory) {
+      throw new RootDirectoryNotFoundError({ Path });
+    }
+    CurrentDirectory = ParentDirectory;
+  }
 }
 
 // Source/Path/index.ts
@@ -665,12 +659,6 @@ export {
  * @copyright (c) 2026 Gage Sorrell
  * @license   MIT
  */
-/**
- * @file      Npm.Types.ts
- * @author    Gage Sorrell <gage@sorrell.sh>
- * @copyright (c) 2026 Gage Sorrell
- * @license   MIT
- */
 /**
  * @file      Path.ts
  * @author    Gage Sorrell <gage@sorrell.sh>