@duplojs/server 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/file/truncate.mjs

@@ -2,34 +2,46 @@ import { implementFunction, nodeFileSystem } from "../implementor.mjs";
 import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/truncate.ts
+var TruncateErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-truncate-not-found", Error) {};
+var TruncateErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-truncate-permission-denied", Error) {};
+var TruncateErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-truncate-is-directory", Error) {};
+var TruncateErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-truncate-not-directory", Error) {};
+var TruncateErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-truncate-no-space", Error) {};
+var TruncateErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-truncate-read-only", Error) {};
+var TruncateErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-truncate-invalid-argument", Error) {};
+var TruncateErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-truncate-too-many-open-files", Error) {};
+var TruncateErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-truncate-busy", Error) {};
+var TruncateError = class extends DCommon.DuploJSError.parentClass("file-system-truncate-error", Error) {};
 function handleNodeTruncateError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-truncate-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-truncate-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-truncate-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-truncate-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-truncate-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-truncate-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-truncate-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-truncate-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-truncate-busy", error);
+	let truncateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") truncateError = new TruncateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") truncateError = new TruncateErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") truncateError = new TruncateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") truncateError = new TruncateErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") truncateError = new TruncateErrorNoSpace(error);
+		else if (error.code === "EROFS") truncateError = new TruncateErrorReadOnly(error);
+		else if (error.code === "EINVAL") truncateError = new TruncateErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") truncateError = new TruncateErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") truncateError = new TruncateErrorBusy(error);
 	}
-	return DEither.left("file-system-truncate-error", error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return DEither.left("file-system-truncate-error", truncateError);
 }
 function handleDenoTruncateError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-truncate-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-truncate-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-truncate-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-truncate-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-truncate-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-truncate-busy", error);
-	return DEither.left("file-system-truncate-error", error);
+	let truncateError = void 0;
+	if (error instanceof Deno.errors.NotFound) truncateError = new TruncateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) truncateError = new TruncateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) truncateError = new TruncateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) truncateError = new TruncateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) truncateError = new TruncateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) truncateError = new TruncateErrorBusy(error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return DEither.left("file-system-truncate-error", truncateError);
 }
 const truncate = implementFunction("truncate", {
-	NODE: async (path, size) => {
-		return (await nodeFileSystem.value).truncate(path, size).then(() => DEither.right("file-system-truncate")).catch(handleNodeTruncateError);
-	},
+	NODE: async (path, size) => nodeFileSystem.value.truncate(path, size).then(() => DEither.right("file-system-truncate")).catch(handleNodeTruncateError),
 	DENO: (path, size) => DCommon.pipe(path, DCommon.when(DCommon.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => DEither.right("file-system-truncate")).catch(handleDenoTruncateError))
 });
 //#endregion
-export { truncate };
+export { TruncateError, TruncateErrorBusy, TruncateErrorInvalidArgument, TruncateErrorIsDirectory, TruncateErrorNoSpace, TruncateErrorNotDirectory, TruncateErrorNotFound, TruncateErrorPermissionDenied, TruncateErrorReadOnly, TruncateErrorTooManyOpenFiles, truncate };

package/dist/file/unknownEntryInterface.cjs

@@ -2,6 +2,8 @@ const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("../kind.cjs");
 const require_stat = require("./stat.cjs");
 const require_exists = require("./exists.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 //#region scripts/file/unknownEntryInterface.ts
@@ -20,7 +22,7 @@ function createUnknownEntryInterface(path) {
 		return require_exists.exists(path);
 	}
 	return {
-		path,
+		path: _duplojs_lang_common.cast(path),
 		getName,
 		getParentPath,
 		stat: localStat,
@@ -31,6 +33,8 @@ function createUnknownEntryInterface(path) {
 function isUnknownEntryInterface(input) {
 	return unknownInterfaceKind.has(input);
 }
+const isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterface;
 //#endregion
 exports.createUnknownEntryInterface = createUnknownEntryInterface;
 exports.isUnknownEntryInterface = isUnknownEntryInterface;
+exports.isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterfaceFromUnknown;

package/dist/file/unknownEntryInterface.d.ts

@@ -3,13 +3,15 @@ import { ExistsResult } from './exists';
 import type * as DKind from "@duplojs/lang/kind";
 import * as DPath from "@duplojs/lang/path";
 declare const unknownInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/unknownInterface", unknown>>;
-export interface UnknownEntryInterface extends DKind.Kind<typeof unknownInterfaceKind> {
-    path: string & DPath.Path;
-    getName(): (string & DPath.Segment) | null;
-    getParentPath(): (string & DPath.Path) | null;
+export type EntryPath = DPath.AnyPath;
+export interface UnknownEntryInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath> extends DKind.Kind<typeof unknownInterfaceKind> {
+    path: GenericPath & DPath.Path;
+    getName(): (string & DPath.Segment & DPath.Path) | null;
+    getParentPath(): ReturnType<typeof DPath.getParentFolderPath<GenericPath>>;
     stat(): Promise<StatResult>;
     exist(): Promise<ExistsResult>;
 }
-export declare function createUnknownEntryInterface(path: string & DPath.Path): UnknownEntryInterface;
-export declare function isUnknownEntryInterface(input: unknown): input is UnknownEntryInterface;
+export declare function createUnknownEntryInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath>(path: GenericPath): UnknownEntryInterface<GenericPath>;
+export declare function isUnknownEntryInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, UnknownEntryInterface>;
+export declare const isUnknownEntryInterfaceFromUnknown: (input: unknown) => input is UnknownEntryInterface;
 export {};

package/dist/file/unknownEntryInterface.mjs

@@ -1,6 +1,7 @@
 import { createKind } from "../kind.mjs";
 import { stat } from "./stat.mjs";
 import { exists } from "./exists.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DPath from "@duplojs/lang/path";
 //#region scripts/file/unknownEntryInterface.ts
 const unknownInterfaceKind = createKind("unknownInterface");
@@ -18,7 +19,7 @@ function createUnknownEntryInterface(path) {
 		return exists(path);
 	}
 	return {
-		path,
+		path: DCommon.cast(path),
 		getName,
 		getParentPath,
 		stat: localStat,
@@ -29,5 +30,6 @@ function createUnknownEntryInterface(path) {
 function isUnknownEntryInterface(input) {
 	return unknownInterfaceKind.has(input);
 }
+const isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterface;
 //#endregion
-export { createUnknownEntryInterface, isUnknownEntryInterface };
+export { createUnknownEntryInterface, isUnknownEntryInterface, isUnknownEntryInterfaceFromUnknown };

package/dist/file/walkDirectory.cjs

@@ -1,34 +1,57 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_implementor = require("../implementor.cjs");
+const require_getCurrentWorkDirectoryOrThrow = require("../common/getCurrentWorkDirectoryOrThrow.cjs");
 const require_fileInterface = require("./fileInterface.cjs");
 const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
 const require_folderInterface = require("./folderInterface.cjs");
 let _duplojs_lang_common = require("@duplojs/lang/common");
 _duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
-let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
-_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
 let _duplojs_lang_generator = require("@duplojs/lang/generator");
 _duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
 //#region scripts/file/walkDirectory.ts
+var WalkDirectoryErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-not-found", Error) {};
+var WalkDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-permission-denied", Error) {};
+var WalkDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-not-directory", Error) {};
+var WalkDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-too-many-open-files", Error) {};
+var WalkDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-busy", Error) {};
+var WalkDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-error", Error) {};
 function handleNodeWalkDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-walk-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-walk-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-walk-directory-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-walk-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-walk-directory-busy", error);
+	let walkDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") walkDirectoryError = new WalkDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") walkDirectoryError = new WalkDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") walkDirectoryError = new WalkDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") walkDirectoryError = new WalkDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") walkDirectoryError = new WalkDirectoryErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-walk-directory-error", error);
+	if (walkDirectoryError === void 0) walkDirectoryError = new WalkDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-walk-directory-error", walkDirectoryError);
 }
-const walkDirectory = require_implementor.implementFunction("walkDirectory", { NODE: async (path, params) => {
-	return (await require_implementor.nodeFileSystem.value).readdir(path, {
-		recursive: params?.recursive ?? false,
-		withFileTypes: true
-	}).then(_duplojs_lang_common.innerPipe(_duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when((dirent) => dirent.isFile(), ({ parentPath, name }) => require_fileInterface.createFileInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))), _duplojs_lang_pattern.when((dirent) => dirent.isDirectory(), ({ parentPath, name }) => require_folderInterface.createFolderInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))), _duplojs_lang_pattern.otherwise(({ parentPath, name }) => require_unknownEntryInterface.createUnknownEntryInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value))).catch(handleNodeWalkDirectoryError);
-} });
+const walkDirectory = require_implementor.implementFunction("walkDirectory", { NODE: async (path, params) => require_implementor.nodeFileSystem.value.readdir(path, {
+	recursive: params?.recursive ?? false,
+	withFileTypes: true
+}).then((result) => {
+	const currentWorkDirectory = require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow();
+	return _duplojs_lang_common.pipe(result, _duplojs_lang_generator.map((dirent) => ({
+		dirent,
+		path: _duplojs_lang_path.resolveFrom(currentWorkDirectory, [_duplojs_lang_path.normalize(`${dirent.parentPath}/${dirent.name}`)])
+	})), (generator) => {
+		const matcher = params?.matcher;
+		if (!matcher) return generator;
+		return _duplojs_lang_generator.filter(generator, ({ path }) => matcher(path));
+	}, _duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when(({ dirent }) => dirent.isFile(), ({ path }) => require_fileInterface.createFileInterface(path)), _duplojs_lang_pattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => require_folderInterface.createFolderInterface(path)), _duplojs_lang_pattern.otherwise(({ path }) => require_unknownEntryInterface.createUnknownEntryInterface(path)))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value));
+}).catch(handleNodeWalkDirectoryError) });
 //#endregion
+exports.WalkDirectoryError = WalkDirectoryError;
+exports.WalkDirectoryErrorBusy = WalkDirectoryErrorBusy;
+exports.WalkDirectoryErrorNotDirectory = WalkDirectoryErrorNotDirectory;
+exports.WalkDirectoryErrorNotFound = WalkDirectoryErrorNotFound;
+exports.WalkDirectoryErrorPermissionDenied = WalkDirectoryErrorPermissionDenied;
+exports.WalkDirectoryErrorTooManyOpenFiles = WalkDirectoryErrorTooManyOpenFiles;
 exports.walkDirectory = walkDirectory;

package/dist/file/walkDirectory.d.ts

@@ -1,16 +1,37 @@
 import { FileInterface } from './fileInterface';
 import { FolderInterface } from './folderInterface';
 import { UnknownEntryInterface } from './unknownEntryInterface';
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
+declare const WalkDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-not-found", unknown>>, unknown>;
+export declare class WalkDirectoryErrorNotFound extends WalkDirectoryErrorNotFound_base {
+}
+declare const WalkDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-permission-denied", unknown>>, unknown>;
+export declare class WalkDirectoryErrorPermissionDenied extends WalkDirectoryErrorPermissionDenied_base {
+}
+declare const WalkDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-not-directory", unknown>>, unknown>;
+export declare class WalkDirectoryErrorNotDirectory extends WalkDirectoryErrorNotDirectory_base {
+}
+declare const WalkDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-too-many-open-files", unknown>>, unknown>;
+export declare class WalkDirectoryErrorTooManyOpenFiles extends WalkDirectoryErrorTooManyOpenFiles_base {
+}
+declare const WalkDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-busy", unknown>>, unknown>;
+export declare class WalkDirectoryErrorBusy extends WalkDirectoryErrorBusy_base {
+}
+declare const WalkDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-error", unknown>>, unknown>;
+export declare class WalkDirectoryError extends WalkDirectoryError_base {
+}
+export type WalkDirectoryErrors = (WalkDirectoryErrorNotFound | WalkDirectoryErrorPermissionDenied | WalkDirectoryErrorNotDirectory | WalkDirectoryErrorTooManyOpenFiles | WalkDirectoryErrorBusy | WalkDirectoryError);
 export interface WalkDirectoryParams {
     recursive?: boolean;
+    matcher?: DPath.PathMatcher<string & DPath.Absolute>;
 }
-export type WalkDirectoryResult = FileSystemEither<DEither.Right<"walk-directory", Generator<FileInterface | FolderInterface | UnknownEntryInterface>> | DEither.Left<"walk-directory-not-found", unknown> | DEither.Left<"walk-directory-permission-denied", unknown> | DEither.Left<"walk-directory-not-directory", unknown> | DEither.Left<"walk-directory-too-many-open-files", unknown> | DEither.Left<"walk-directory-busy", unknown> | DEither.Left<"walk-directory-error", unknown>>;
+export type WalkDirectoryResult = (DEither.Right<"file-system-walk-directory", Generator<FileInterface<string & DPath.Absolute> | FolderInterface<string & DPath.Absolute> | UnknownEntryInterface<string & DPath.Absolute>>> | DEither.Left<"file-system-walk-directory-error", WalkDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        walkDirectory(path: string & DPath.Path, params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
+        walkDirectory(path: DPath.AnyPath, params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
     }
 }
-export declare const walkDirectory: (path: string & DPath.Path, params?: WalkDirectoryParams) => Promise<WalkDirectoryResult>;
+export declare const walkDirectory: (path: DPath.AnyPath, params?: WalkDirectoryParams) => Promise<WalkDirectoryResult>;
+export {};

package/dist/file/walkDirectory.mjs

@@ -1,28 +1,45 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import { getCurrentWorkDirectoryOrThrow } from "../common/getCurrentWorkDirectoryOrThrow.mjs";
 import { createFileInterface } from "./fileInterface.mjs";
 import { createUnknownEntryInterface } from "./unknownEntryInterface.mjs";
 import { createFolderInterface } from "./folderInterface.mjs";
 import * as DCommon from "@duplojs/lang/common";
+import * as DPattern from "@duplojs/lang/pattern";
 import * as DEither from "@duplojs/lang/either";
 import * as DPath from "@duplojs/lang/path";
-import * as DPattern from "@duplojs/lang/pattern";
 import * as DGenerator from "@duplojs/lang/generator";
 //#region scripts/file/walkDirectory.ts
+var WalkDirectoryErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-not-found", Error) {};
+var WalkDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-permission-denied", Error) {};
+var WalkDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-not-directory", Error) {};
+var WalkDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-too-many-open-files", Error) {};
+var WalkDirectoryErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-busy", Error) {};
+var WalkDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-error", Error) {};
 function handleNodeWalkDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-walk-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-walk-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-walk-directory-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-walk-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-walk-directory-busy", error);
+	let walkDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") walkDirectoryError = new WalkDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") walkDirectoryError = new WalkDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") walkDirectoryError = new WalkDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") walkDirectoryError = new WalkDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") walkDirectoryError = new WalkDirectoryErrorBusy(error);
 	}
-	return DEither.left("file-system-walk-directory-error", error);
+	if (walkDirectoryError === void 0) walkDirectoryError = new WalkDirectoryError(error);
+	return DEither.left("file-system-walk-directory-error", walkDirectoryError);
 }
-const walkDirectory = implementFunction("walkDirectory", { NODE: async (path, params) => {
-	return (await nodeFileSystem.value).readdir(path, {
-		recursive: params?.recursive ?? false,
-		withFileTypes: true
-	}).then(DCommon.innerPipe(DGenerator.map(DCommon.innerPipe(DPattern.when((dirent) => dirent.isFile(), ({ parentPath, name }) => createFileInterface(DCommon.forwardAsserts(DPath.normalize(`${parentPath}/${name}`), (result) => DCommon.isType(result, "string") && DPath.is(result)))), DPattern.when((dirent) => dirent.isDirectory(), ({ parentPath, name }) => createFolderInterface(DCommon.forwardAsserts(DPath.normalize(`${parentPath}/${name}`), (result) => DCommon.isType(result, "string") && DPath.is(result)))), DPattern.otherwise(({ parentPath, name }) => createUnknownEntryInterface(DCommon.forwardAsserts(DPath.normalize(`${parentPath}/${name}`), (result) => DCommon.isType(result, "string") && DPath.is(result)))))), (value) => DEither.right("file-system-walk-directory", value))).catch(handleNodeWalkDirectoryError);
-} });
+const walkDirectory = implementFunction("walkDirectory", { NODE: async (path, params) => nodeFileSystem.value.readdir(path, {
+	recursive: params?.recursive ?? false,
+	withFileTypes: true
+}).then((result) => {
+	const currentWorkDirectory = getCurrentWorkDirectoryOrThrow();
+	return DCommon.pipe(result, DGenerator.map((dirent) => ({
+		dirent,
+		path: DPath.resolveFrom(currentWorkDirectory, [DPath.normalize(`${dirent.parentPath}/${dirent.name}`)])
+	})), (generator) => {
+		const matcher = params?.matcher;
+		if (!matcher) return generator;
+		return DGenerator.filter(generator, ({ path }) => matcher(path));
+	}, DGenerator.map(DCommon.innerPipe(DPattern.when(({ dirent }) => dirent.isFile(), ({ path }) => createFileInterface(path)), DPattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => createFolderInterface(path)), DPattern.otherwise(({ path }) => createUnknownEntryInterface(path)))), (value) => DEither.right("file-system-walk-directory", value));
+}).catch(handleNodeWalkDirectoryError) });
 //#endregion
-export { walkDirectory };
+export { WalkDirectoryError, WalkDirectoryErrorBusy, WalkDirectoryErrorNotDirectory, WalkDirectoryErrorNotFound, WalkDirectoryErrorPermissionDenied, WalkDirectoryErrorTooManyOpenFiles, walkDirectory };

package/dist/file/writeFile.cjs

@@ -1,35 +1,49 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 //#region scripts/file/writeFile.ts
+var WriteFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-not-found", Error) {};
+var WriteFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-permission-denied", Error) {};
+var WriteFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-is-directory", Error) {};
+var WriteFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-not-directory", Error) {};
+var WriteFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-no-space", Error) {};
+var WriteFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-read-only", Error) {};
+var WriteFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-invalid-argument", Error) {};
+var WriteFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-too-many-open-files", Error) {};
+var WriteFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-busy", Error) {};
+var WriteFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-error", Error) {};
 function handleNodeWriteFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-write-file-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-write-file-permission-denied", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-write-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-write-file-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-write-file-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-write-file-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-write-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-write-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-write-file-busy", error);
+	let writeFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeFileError = new WriteFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeFileError = new WriteFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeFileError = new WriteFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeFileError = new WriteFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeFileError = new WriteFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeFileError = new WriteFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeFileError = new WriteFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeFileError = new WriteFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeFileError = new WriteFileErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-write-file-error", error);
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return _duplojs_lang_either.left("file-system-write-file-error", writeFileError);
 }
 function handleDenoWriteFileError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-write-file-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-write-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-write-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-write-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-write-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-write-file-busy", error);
-	return _duplojs_lang_either.left("file-system-write-file-error", error);
+	let writeFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeFileError = new WriteFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeFileError = new WriteFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeFileError = new WriteFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeFileError = new WriteFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeFileError = new WriteFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeFileError = new WriteFileErrorBusy(error);
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return _duplojs_lang_either.left("file-system-write-file-error", writeFileError);
 }
 const writeFileImplementation = require_implementor.implementFunction("writeFile", {
-	NODE: async (path, data) => {
-		return (await require_implementor.nodeFileSystem.value).writeFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleNodeWriteFileError);
-	},
+	NODE: async (path, data) => require_implementor.nodeFileSystem.value.writeFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleNodeWriteFileError),
 	DENO: (path, data) => Deno.writeFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleDenoWriteFileError),
 	BUN: (path, data) => Bun.file(path).write(data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleNodeWriteFileError)
 });
@@ -41,4 +55,14 @@ function writeFile(...args) {
 	return writeFileImplementation(...args);
 }
 //#endregion
+exports.WriteFileError = WriteFileError;
+exports.WriteFileErrorBusy = WriteFileErrorBusy;
+exports.WriteFileErrorInvalidArgument = WriteFileErrorInvalidArgument;
+exports.WriteFileErrorIsDirectory = WriteFileErrorIsDirectory;
+exports.WriteFileErrorNoSpace = WriteFileErrorNoSpace;
+exports.WriteFileErrorNotDirectory = WriteFileErrorNotDirectory;
+exports.WriteFileErrorNotFound = WriteFileErrorNotFound;
+exports.WriteFileErrorPermissionDenied = WriteFileErrorPermissionDenied;
+exports.WriteFileErrorReadOnly = WriteFileErrorReadOnly;
+exports.WriteFileErrorTooManyOpenFiles = WriteFileErrorTooManyOpenFiles;
 exports.writeFile = writeFile;

package/dist/file/writeFile.d.ts

@@ -1,11 +1,43 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type WriteFileResult = FileSystemEither<DEither.Right<"write-file", void> | DEither.Left<"write-file-not-found", unknown> | DEither.Left<"write-file-permission-denied", unknown> | DEither.Left<"write-file-is-directory", unknown> | DEither.Left<"write-file-not-directory", unknown> | DEither.Left<"write-file-no-space", unknown> | DEither.Left<"write-file-read-only", unknown> | DEither.Left<"write-file-invalid-argument", unknown> | DEither.Left<"write-file-too-many-open-files", unknown> | DEither.Left<"write-file-busy", unknown> | DEither.Left<"write-file-error", unknown>>;
+declare const WriteFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-not-found", unknown>>, unknown>;
+export declare class WriteFileErrorNotFound extends WriteFileErrorNotFound_base {
+}
+declare const WriteFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-permission-denied", unknown>>, unknown>;
+export declare class WriteFileErrorPermissionDenied extends WriteFileErrorPermissionDenied_base {
+}
+declare const WriteFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-is-directory", unknown>>, unknown>;
+export declare class WriteFileErrorIsDirectory extends WriteFileErrorIsDirectory_base {
+}
+declare const WriteFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-not-directory", unknown>>, unknown>;
+export declare class WriteFileErrorNotDirectory extends WriteFileErrorNotDirectory_base {
+}
+declare const WriteFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-no-space", unknown>>, unknown>;
+export declare class WriteFileErrorNoSpace extends WriteFileErrorNoSpace_base {
+}
+declare const WriteFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-read-only", unknown>>, unknown>;
+export declare class WriteFileErrorReadOnly extends WriteFileErrorReadOnly_base {
+}
+declare const WriteFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-invalid-argument", unknown>>, unknown>;
+export declare class WriteFileErrorInvalidArgument extends WriteFileErrorInvalidArgument_base {
+}
+declare const WriteFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-too-many-open-files", unknown>>, unknown>;
+export declare class WriteFileErrorTooManyOpenFiles extends WriteFileErrorTooManyOpenFiles_base {
+}
+declare const WriteFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-busy", unknown>>, unknown>;
+export declare class WriteFileErrorBusy extends WriteFileErrorBusy_base {
+}
+declare const WriteFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-error", unknown>>, unknown>;
+export declare class WriteFileError extends WriteFileError_base {
+}
+export type WriteFileErrors = (WriteFileErrorNotFound | WriteFileErrorPermissionDenied | WriteFileErrorIsDirectory | WriteFileErrorNotDirectory | WriteFileErrorNoSpace | WriteFileErrorReadOnly | WriteFileErrorInvalidArgument | WriteFileErrorTooManyOpenFiles | WriteFileErrorBusy | WriteFileError);
+export type WriteFileResult = (DEither.Right<"file-system-write-file", void> | DEither.Left<"file-system-write-file-error", WriteFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        writeFile(path: string & DPath.Path, data: Uint8Array): Promise<WriteFileResult>;
+        writeFile(path: DPath.AnyPath, data: Uint8Array): Promise<WriteFileResult>;
     }
 }
-export declare function writeFile(data: Uint8Array): (path: string & DPath.Path) => Promise<WriteFileResult>;
-export declare function writeFile(path: string & DPath.Path, data: Uint8Array): Promise<WriteFileResult>;
+export declare function writeFile(data: Uint8Array): (path: DPath.AnyPath) => Promise<WriteFileResult>;
+export declare function writeFile(path: DPath.AnyPath, data: Uint8Array): Promise<WriteFileResult>;
+export {};

package/dist/file/writeFile.mjs

@@ -1,33 +1,46 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/writeFile.ts
+var WriteFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-write-file-not-found", Error) {};
+var WriteFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-write-file-permission-denied", Error) {};
+var WriteFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-file-is-directory", Error) {};
+var WriteFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-file-not-directory", Error) {};
+var WriteFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-write-file-no-space", Error) {};
+var WriteFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-write-file-read-only", Error) {};
+var WriteFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-write-file-invalid-argument", Error) {};
+var WriteFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-write-file-too-many-open-files", Error) {};
+var WriteFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-write-file-busy", Error) {};
+var WriteFileError = class extends DCommon.DuploJSError.parentClass("file-system-write-file-error", Error) {};
 function handleNodeWriteFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-write-file-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-write-file-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-write-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-write-file-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-write-file-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-write-file-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-write-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-write-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-write-file-busy", error);
+	let writeFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeFileError = new WriteFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeFileError = new WriteFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeFileError = new WriteFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeFileError = new WriteFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeFileError = new WriteFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeFileError = new WriteFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeFileError = new WriteFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeFileError = new WriteFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeFileError = new WriteFileErrorBusy(error);
 	}
-	return DEither.left("file-system-write-file-error", error);
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return DEither.left("file-system-write-file-error", writeFileError);
 }
 function handleDenoWriteFileError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-write-file-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-write-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-write-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-write-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-write-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-write-file-busy", error);
-	return DEither.left("file-system-write-file-error", error);
+	let writeFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeFileError = new WriteFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeFileError = new WriteFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeFileError = new WriteFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeFileError = new WriteFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeFileError = new WriteFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeFileError = new WriteFileErrorBusy(error);
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return DEither.left("file-system-write-file-error", writeFileError);
 }
 const writeFileImplementation = implementFunction("writeFile", {
-	NODE: async (path, data) => {
-		return (await nodeFileSystem.value).writeFile(path, data).then(() => DEither.right("file-system-write-file")).catch(handleNodeWriteFileError);
-	},
+	NODE: async (path, data) => nodeFileSystem.value.writeFile(path, data).then(() => DEither.right("file-system-write-file")).catch(handleNodeWriteFileError),
 	DENO: (path, data) => Deno.writeFile(path, data).then(() => DEither.right("file-system-write-file")).catch(handleDenoWriteFileError),
 	BUN: (path, data) => Bun.file(path).write(data).then(() => DEither.right("file-system-write-file")).catch(handleNodeWriteFileError)
 });
@@ -39,4 +52,4 @@ function writeFile(...args) {
 	return writeFileImplementation(...args);
 }
 //#endregion
-export { writeFile };
+export { WriteFileError, WriteFileErrorBusy, WriteFileErrorInvalidArgument, WriteFileErrorIsDirectory, WriteFileErrorNoSpace, WriteFileErrorNotDirectory, WriteFileErrorNotFound, WriteFileErrorPermissionDenied, WriteFileErrorReadOnly, WriteFileErrorTooManyOpenFiles, writeFile };