@duplojs/server 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/file/relocate.d.ts

@@ -1,7 +1,41 @@
-import { FileSystemEither } from './types';
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export type RelocateResult = FileSystemEither<DEither.Right<"relocate", string & DPath.Path> | DEither.Left<"relocate-not-found", unknown> | DEither.Left<"relocate-permission-denied", unknown> | DEither.Left<"relocate-already-exists", unknown> | DEither.Left<"relocate-is-directory", unknown> | DEither.Left<"relocate-not-directory", unknown> | DEither.Left<"relocate-directory-not-empty", unknown> | DEither.Left<"relocate-read-only", unknown> | DEither.Left<"relocate-invalid-argument", unknown> | DEither.Left<"relocate-busy", unknown> | DEither.Left<"relocate-cross-device", unknown> | DEither.Left<"relocate-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const RelocateErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-not-found", unknown>>, unknown>;
+declare class RelocateErrorNotFound extends RelocateErrorNotFound_base {
+}
+declare const RelocateErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-permission-denied", unknown>>, unknown>;
+declare class RelocateErrorPermissionDenied extends RelocateErrorPermissionDenied_base {
+}
+declare const RelocateErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-already-exists", unknown>>, unknown>;
+declare class RelocateErrorAlreadyExists extends RelocateErrorAlreadyExists_base {
+}
+declare const RelocateErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-is-directory", unknown>>, unknown>;
+declare class RelocateErrorIsDirectory extends RelocateErrorIsDirectory_base {
+}
+declare const RelocateErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-not-directory", unknown>>, unknown>;
+declare class RelocateErrorNotDirectory extends RelocateErrorNotDirectory_base {
+}
+declare const RelocateErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-directory-not-empty", unknown>>, unknown>;
+declare class RelocateErrorDirectoryNotEmpty extends RelocateErrorDirectoryNotEmpty_base {
+}
+declare const RelocateErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-read-only", unknown>>, unknown>;
+declare class RelocateErrorReadOnly extends RelocateErrorReadOnly_base {
+}
+declare const RelocateErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-invalid-argument", unknown>>, unknown>;
+declare class RelocateErrorInvalidArgument extends RelocateErrorInvalidArgument_base {
+}
+declare const RelocateErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-busy", unknown>>, unknown>;
+declare class RelocateErrorBusy extends RelocateErrorBusy_base {
+}
+declare const RelocateErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-cross-device", unknown>>, unknown>;
+declare class RelocateErrorCrossDevice extends RelocateErrorCrossDevice_base {
+}
+declare const RelocateError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-error", unknown>>, unknown>;
+declare class RelocateError extends RelocateError_base {
+}
+export type RelocateErrors = (RelocateErrorNotFound | RelocateErrorPermissionDenied | RelocateErrorAlreadyExists | RelocateErrorIsDirectory | RelocateErrorNotDirectory | RelocateErrorDirectoryNotEmpty | RelocateErrorReadOnly | RelocateErrorInvalidArgument | RelocateErrorBusy | RelocateErrorCrossDevice | RelocateError);
+export type RelocateResult = (DEither.Right<"file-system-relocate", string & DPath.Path> | DEither.Left<"file-system-relocate-error", RelocateErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         relocate(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<RelocateResult>;
@@ -9,3 +43,4 @@ declare module '../implementor' {
 }
 export declare function relocate(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<RelocateResult>;
 export declare function relocate(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<RelocateResult>;
+export {};

package/dist/file/relocate.mjs

@@ -1,43 +1,58 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DPath from "@duplojs/lang/path";
 //#region scripts/file/relocate.ts
+var RelocateErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-relocate-not-found", Error) {};
+var RelocateErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-relocate-permission-denied", Error) {};
+var RelocateErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-relocate-already-exists", Error) {};
+var RelocateErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-relocate-is-directory", Error) {};
+var RelocateErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-relocate-not-directory", Error) {};
+var RelocateErrorDirectoryNotEmpty = class extends DCommon.DuploJSError.parentClass("file-system-relocate-directory-not-empty", Error) {};
+var RelocateErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-relocate-read-only", Error) {};
+var RelocateErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-relocate-invalid-argument", Error) {};
+var RelocateErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-relocate-busy", Error) {};
+var RelocateErrorCrossDevice = class extends DCommon.DuploJSError.parentClass("file-system-relocate-cross-device", Error) {};
+var RelocateError = class extends DCommon.DuploJSError.parentClass("file-system-relocate-error", Error) {};
 function handleNodeRelocateError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-relocate-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-relocate-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-relocate-already-exists", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-relocate-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-relocate-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-relocate-directory-not-empty", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-relocate-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-relocate-invalid-argument", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-relocate-busy", error);
-		else if (error.code === "EXDEV") return DEither.left("file-system-relocate-cross-device", error);
+	let relocateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") relocateError = new RelocateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") relocateError = new RelocateErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") relocateError = new RelocateErrorAlreadyExists(error);
+		else if (error.code === "EISDIR") relocateError = new RelocateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") relocateError = new RelocateErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") relocateError = new RelocateErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") relocateError = new RelocateErrorReadOnly(error);
+		else if (error.code === "EINVAL") relocateError = new RelocateErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") relocateError = new RelocateErrorBusy(error);
+		else if (error.code === "EXDEV") relocateError = new RelocateErrorCrossDevice(error);
 	}
-	return DEither.left("file-system-relocate-error", error);
+	if (relocateError === void 0) relocateError = new RelocateError(error);
+	return DEither.left("file-system-relocate-error", relocateError);
 }
 function handleDenoRelocateError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-relocate-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-relocate-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-relocate-already-exists", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-relocate-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-relocate-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-relocate-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-relocate-busy", error);
-	return DEither.left("file-system-relocate-error", error);
+	let relocateError = void 0;
+	if (error instanceof Deno.errors.NotFound) relocateError = new RelocateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) relocateError = new RelocateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) relocateError = new RelocateErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.IsADirectory) relocateError = new RelocateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) relocateError = new RelocateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) relocateError = new RelocateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) relocateError = new RelocateErrorBusy(error);
+	if (relocateError === void 0) relocateError = new RelocateError(error);
+	return DEither.left("file-system-relocate-error", relocateError);
 }
 const relocateImplementation = implementFunction("relocate", {
 	NODE: async (fromPath, newParentPath) => {
-		const fs = await nodeFileSystem.value;
 		const baseName = DPath.getBaseName(fromPath);
-		if (!baseName) return DEither.left("file-system-relocate-invalid-argument", /* @__PURE__ */ new Error(`Invalid base name ${fromPath}`));
+		if (!baseName) return DEither.left("file-system-relocate-error", new RelocateErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid base name ${fromPath}`)));
 		const newPath = DPath.resolveRelative([newParentPath, baseName]);
-		return fs.rename(fromPath, newPath).then(() => DEither.right("file-system-relocate", newPath)).catch(handleNodeRelocateError);
+		return nodeFileSystem.value.rename(fromPath, newPath).then(() => DEither.right("file-system-relocate", newPath)).catch(handleNodeRelocateError);
 	},
-	DENO: (fromPath, newParentPath) => {
+	DENO: async (fromPath, newParentPath) => {
 		const baseName = DPath.getBaseName(fromPath);
-		if (!baseName) return Promise.resolve(DEither.left("file-system-relocate-invalid-argument", /* @__PURE__ */ new Error(`Invalid base name ${fromPath}`)));
+		if (!baseName) return Promise.resolve(DEither.left("file-system-relocate-error", new RelocateErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid base name ${fromPath}`))));
 		const newPath = DPath.resolveRelative([newParentPath, baseName]);
 		return Deno.rename(fromPath, newPath).then(() => DEither.right("file-system-relocate", newPath)).catch(handleDenoRelocateError);
 	}

package/dist/file/remove.cjs

@@ -1,37 +1,50 @@
 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/remove.ts
+var RemoveErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-not-found", Error) {};
+var RemoveErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-permission-denied", Error) {};
+var RemoveErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-is-directory", Error) {};
+var RemoveErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-not-directory", Error) {};
+var RemoveErrorDirectoryNotEmpty = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-directory-not-empty", Error) {};
+var RemoveErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-read-only", Error) {};
+var RemoveErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-invalid-argument", Error) {};
+var RemoveErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-busy", Error) {};
+var RemoveError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-remove-error", Error) {};
 function handleNodeRemoveError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-remove-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-remove-permission-denied", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-remove-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-remove-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-remove-directory-not-empty", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-remove-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-remove-invalid-argument", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-remove-busy", error);
+	let removeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") removeError = new RemoveErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") removeError = new RemoveErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") removeError = new RemoveErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") removeError = new RemoveErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") removeError = new RemoveErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") removeError = new RemoveErrorReadOnly(error);
+		else if (error.code === "EINVAL") removeError = new RemoveErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") removeError = new RemoveErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-remove-error", error);
+	if (removeError === void 0) removeError = new RemoveError(error);
+	return _duplojs_lang_either.left("file-system-remove-error", removeError);
 }
 function handleDenoRemoveError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-remove-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-remove-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-remove-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-remove-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-remove-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-remove-busy", error);
-	return _duplojs_lang_either.left("file-system-remove-error", error);
+	let removeError = void 0;
+	if (error instanceof Deno.errors.NotFound) removeError = new RemoveErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) removeError = new RemoveErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) removeError = new RemoveErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) removeError = new RemoveErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) removeError = new RemoveErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) removeError = new RemoveErrorBusy(error);
+	if (removeError === void 0) removeError = new RemoveError(error);
+	return _duplojs_lang_either.left("file-system-remove-error", removeError);
 }
 const remove = require_implementor.implementFunction("remove", {
-	NODE: async (path, params) => {
-		return (await require_implementor.nodeFileSystem.value).rm(path, {
-			recursive: params?.recursive ?? false,
-			force: true
-		}).then(() => _duplojs_lang_either.right("file-system-remove")).catch(handleNodeRemoveError);
-	},
+	NODE: async (path, params) => require_implementor.nodeFileSystem.value.rm(path, {
+		recursive: params?.recursive ?? false,
+		force: true
+	}).then(() => _duplojs_lang_either.right("file-system-remove")).catch(handleNodeRemoveError),
 	DENO: (path, params) => Deno.remove(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-remove")).catch(handleDenoRemoveError)
 });
 //#endregion

package/dist/file/remove.d.ts

@@ -1,10 +1,38 @@
-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";
 interface RemoveDirectoryParams {
     recursive?: boolean;
 }
-export type RemoveResult = FileSystemEither<DEither.Right<"remove", void> | DEither.Left<"remove-not-found", unknown> | DEither.Left<"remove-permission-denied", unknown> | DEither.Left<"remove-is-directory", unknown> | DEither.Left<"remove-not-directory", unknown> | DEither.Left<"remove-directory-not-empty", unknown> | DEither.Left<"remove-read-only", unknown> | DEither.Left<"remove-invalid-argument", unknown> | DEither.Left<"remove-busy", unknown> | DEither.Left<"remove-error", unknown>>;
+declare const RemoveErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-not-found", unknown>>, unknown>;
+declare class RemoveErrorNotFound extends RemoveErrorNotFound_base {
+}
+declare const RemoveErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-permission-denied", unknown>>, unknown>;
+declare class RemoveErrorPermissionDenied extends RemoveErrorPermissionDenied_base {
+}
+declare const RemoveErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-is-directory", unknown>>, unknown>;
+declare class RemoveErrorIsDirectory extends RemoveErrorIsDirectory_base {
+}
+declare const RemoveErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-not-directory", unknown>>, unknown>;
+declare class RemoveErrorNotDirectory extends RemoveErrorNotDirectory_base {
+}
+declare const RemoveErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-directory-not-empty", unknown>>, unknown>;
+declare class RemoveErrorDirectoryNotEmpty extends RemoveErrorDirectoryNotEmpty_base {
+}
+declare const RemoveErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-read-only", unknown>>, unknown>;
+declare class RemoveErrorReadOnly extends RemoveErrorReadOnly_base {
+}
+declare const RemoveErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-invalid-argument", unknown>>, unknown>;
+declare class RemoveErrorInvalidArgument extends RemoveErrorInvalidArgument_base {
+}
+declare const RemoveErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-busy", unknown>>, unknown>;
+declare class RemoveErrorBusy extends RemoveErrorBusy_base {
+}
+declare const RemoveError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-remove-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-remove-error", unknown>>, unknown>;
+declare class RemoveError extends RemoveError_base {
+}
+export type RemoveErrors = (RemoveErrorNotFound | RemoveErrorPermissionDenied | RemoveErrorIsDirectory | RemoveErrorNotDirectory | RemoveErrorDirectoryNotEmpty | RemoveErrorReadOnly | RemoveErrorInvalidArgument | RemoveErrorBusy | RemoveError);
+export type RemoveResult = (DEither.Right<"file-system-remove", void> | DEither.Left<"file-system-remove-error", RemoveErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         remove(path: string & DPath.Path, params?: RemoveDirectoryParams): Promise<RemoveResult>;

package/dist/file/remove.mjs

@@ -1,35 +1,47 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/remove.ts
+var RemoveErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-remove-not-found", Error) {};
+var RemoveErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-remove-permission-denied", Error) {};
+var RemoveErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-remove-is-directory", Error) {};
+var RemoveErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-remove-not-directory", Error) {};
+var RemoveErrorDirectoryNotEmpty = class extends DCommon.DuploJSError.parentClass("file-system-remove-directory-not-empty", Error) {};
+var RemoveErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-remove-read-only", Error) {};
+var RemoveErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-remove-invalid-argument", Error) {};
+var RemoveErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-remove-busy", Error) {};
+var RemoveError = class extends DCommon.DuploJSError.parentClass("file-system-remove-error", Error) {};
 function handleNodeRemoveError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-remove-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-remove-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-remove-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-remove-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-remove-directory-not-empty", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-remove-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-remove-invalid-argument", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-remove-busy", error);
+	let removeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") removeError = new RemoveErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") removeError = new RemoveErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") removeError = new RemoveErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") removeError = new RemoveErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") removeError = new RemoveErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") removeError = new RemoveErrorReadOnly(error);
+		else if (error.code === "EINVAL") removeError = new RemoveErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") removeError = new RemoveErrorBusy(error);
 	}
-	return DEither.left("file-system-remove-error", error);
+	if (removeError === void 0) removeError = new RemoveError(error);
+	return DEither.left("file-system-remove-error", removeError);
 }
 function handleDenoRemoveError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-remove-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-remove-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-remove-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-remove-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-remove-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-remove-busy", error);
-	return DEither.left("file-system-remove-error", error);
+	let removeError = void 0;
+	if (error instanceof Deno.errors.NotFound) removeError = new RemoveErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) removeError = new RemoveErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) removeError = new RemoveErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) removeError = new RemoveErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) removeError = new RemoveErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) removeError = new RemoveErrorBusy(error);
+	if (removeError === void 0) removeError = new RemoveError(error);
+	return DEither.left("file-system-remove-error", removeError);
 }
 const remove = implementFunction("remove", {
-	NODE: async (path, params) => {
-		return (await nodeFileSystem.value).rm(path, {
-			recursive: params?.recursive ?? false,
-			force: true
-		}).then(() => DEither.right("file-system-remove")).catch(handleNodeRemoveError);
-	},
+	NODE: async (path, params) => nodeFileSystem.value.rm(path, {
+		recursive: params?.recursive ?? false,
+		force: true
+	}).then(() => DEither.right("file-system-remove")).catch(handleNodeRemoveError),
 	DENO: (path, params) => Deno.remove(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-remove")).catch(handleDenoRemoveError)
 });
 //#endregion

package/dist/file/rename.cjs

@@ -1,46 +1,62 @@
 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);
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 //#region scripts/file/rename.ts
+var RenameErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-not-found", Error) {};
+var RenameErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-permission-denied", Error) {};
+var RenameErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-already-exists", Error) {};
+var RenameErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-is-directory", Error) {};
+var RenameErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-not-directory", Error) {};
+var RenameErrorDirectoryNotEmpty = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-directory-not-empty", Error) {};
+var RenameErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-read-only", Error) {};
+var RenameErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-invalid-argument", Error) {};
+var RenameErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-busy", Error) {};
+var RenameErrorCrossDevice = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-cross-device", Error) {};
+var RenameError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-rename-error", Error) {};
 function handleNodeRenameError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-rename-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-rename-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-rename-already-exists", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-rename-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-rename-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-rename-directory-not-empty", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-rename-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-rename-invalid-argument", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-rename-busy", error);
-		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-rename-cross-device", error);
+	let renameError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") renameError = new RenameErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") renameError = new RenameErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") renameError = new RenameErrorAlreadyExists(error);
+		else if (error.code === "EISDIR") renameError = new RenameErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") renameError = new RenameErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") renameError = new RenameErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") renameError = new RenameErrorReadOnly(error);
+		else if (error.code === "EINVAL") renameError = new RenameErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") renameError = new RenameErrorBusy(error);
+		else if (error.code === "EXDEV") renameError = new RenameErrorCrossDevice(error);
 	}
-	return _duplojs_lang_either.left("file-system-rename-error", error);
+	if (renameError === void 0) renameError = new RenameError(error);
+	return _duplojs_lang_either.left("file-system-rename-error", renameError);
 }
 function handleDenoRenameError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-rename-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-rename-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-rename-already-exists", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-rename-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-rename-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-rename-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-rename-busy", error);
-	return _duplojs_lang_either.left("file-system-rename-error", error);
+	let renameError = void 0;
+	if (error instanceof Deno.errors.NotFound) renameError = new RenameErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) renameError = new RenameErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) renameError = new RenameErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.IsADirectory) renameError = new RenameErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) renameError = new RenameErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) renameError = new RenameErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) renameError = new RenameErrorBusy(error);
+	if (renameError === void 0) renameError = new RenameError(error);
+	return _duplojs_lang_either.left("file-system-rename-error", renameError);
 }
 const renameImplementation = require_implementor.implementFunction("rename", {
 	NODE: async (path, newName) => {
-		const fs = await require_implementor.nodeFileSystem.value;
 		const parentPath = _duplojs_lang_path.getParentFolderPath(path);
-		if (!parentPath) return _duplojs_lang_either.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`));
+		if (!parentPath) return _duplojs_lang_either.left("file-system-rename-error", new RenameErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid parent path ${path}.`)));
 		const newPath = _duplojs_lang_path.resolveRelative([parentPath, newName]);
-		return fs.rename(path, newPath).then(() => _duplojs_lang_either.right("file-system-rename", newPath)).catch(handleNodeRenameError);
+		return require_implementor.nodeFileSystem.value.rename(path, newPath).then(() => _duplojs_lang_either.right("file-system-rename", newPath)).catch(handleNodeRenameError);
 	},
-	DENO: (path, newName) => {
+	DENO: async (path, newName) => {
 		const parentPath = _duplojs_lang_path.getParentFolderPath(path);
-		if (!parentPath) return Promise.resolve(_duplojs_lang_either.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`)));
+		if (!parentPath) return Promise.resolve(_duplojs_lang_either.left("file-system-rename-error", new RenameErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid parent path ${path}.`))));
 		const newPath = _duplojs_lang_path.resolveRelative([parentPath, newName]);
 		return Deno.rename(path, newPath).then(() => _duplojs_lang_either.right("file-system-rename", newPath)).catch(handleDenoRenameError);
 	}

package/dist/file/rename.d.ts

@@ -1,7 +1,41 @@
-import { FileSystemEither } from './types';
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export type RenameResult = FileSystemEither<DEither.Right<"rename", string & DPath.Path> | DEither.Left<"rename-not-found", unknown> | DEither.Left<"rename-permission-denied", unknown> | DEither.Left<"rename-already-exists", unknown> | DEither.Left<"rename-is-directory", unknown> | DEither.Left<"rename-not-directory", unknown> | DEither.Left<"rename-directory-not-empty", unknown> | DEither.Left<"rename-read-only", unknown> | DEither.Left<"rename-invalid-argument", unknown> | DEither.Left<"rename-busy", unknown> | DEither.Left<"rename-cross-device", unknown> | DEither.Left<"rename-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const RenameErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-not-found", unknown>>, unknown>;
+declare class RenameErrorNotFound extends RenameErrorNotFound_base {
+}
+declare const RenameErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-permission-denied", unknown>>, unknown>;
+declare class RenameErrorPermissionDenied extends RenameErrorPermissionDenied_base {
+}
+declare const RenameErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-already-exists", unknown>>, unknown>;
+declare class RenameErrorAlreadyExists extends RenameErrorAlreadyExists_base {
+}
+declare const RenameErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-is-directory", unknown>>, unknown>;
+declare class RenameErrorIsDirectory extends RenameErrorIsDirectory_base {
+}
+declare const RenameErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-not-directory", unknown>>, unknown>;
+declare class RenameErrorNotDirectory extends RenameErrorNotDirectory_base {
+}
+declare const RenameErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-directory-not-empty", unknown>>, unknown>;
+declare class RenameErrorDirectoryNotEmpty extends RenameErrorDirectoryNotEmpty_base {
+}
+declare const RenameErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-read-only", unknown>>, unknown>;
+declare class RenameErrorReadOnly extends RenameErrorReadOnly_base {
+}
+declare const RenameErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-invalid-argument", unknown>>, unknown>;
+declare class RenameErrorInvalidArgument extends RenameErrorInvalidArgument_base {
+}
+declare const RenameErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-busy", unknown>>, unknown>;
+declare class RenameErrorBusy extends RenameErrorBusy_base {
+}
+declare const RenameErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-cross-device", unknown>>, unknown>;
+declare class RenameErrorCrossDevice extends RenameErrorCrossDevice_base {
+}
+declare const RenameError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-rename-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-rename-error", unknown>>, unknown>;
+declare class RenameError extends RenameError_base {
+}
+export type RenameErrors = (RenameErrorNotFound | RenameErrorPermissionDenied | RenameErrorAlreadyExists | RenameErrorIsDirectory | RenameErrorNotDirectory | RenameErrorDirectoryNotEmpty | RenameErrorReadOnly | RenameErrorInvalidArgument | RenameErrorBusy | RenameErrorCrossDevice | RenameError);
+export type RenameResult = (DEither.Right<"file-system-rename", string & DPath.Path> | DEither.Left<"file-system-rename-error", RenameErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         rename(path: string & DPath.Path, newName: string & DPath.Segment): Promise<RenameResult>;
@@ -9,3 +43,4 @@ declare module '../implementor' {
 }
 export declare function rename(newName: string & DPath.Segment): (path: string & DPath.Path) => Promise<RenameResult>;
 export declare function rename(path: string & DPath.Path, newName: string & DPath.Segment): Promise<RenameResult>;
+export {};

package/dist/file/rename.mjs

@@ -1,43 +1,58 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DPath from "@duplojs/lang/path";
 //#region scripts/file/rename.ts
+var RenameErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-rename-not-found", Error) {};
+var RenameErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-rename-permission-denied", Error) {};
+var RenameErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-rename-already-exists", Error) {};
+var RenameErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-rename-is-directory", Error) {};
+var RenameErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-rename-not-directory", Error) {};
+var RenameErrorDirectoryNotEmpty = class extends DCommon.DuploJSError.parentClass("file-system-rename-directory-not-empty", Error) {};
+var RenameErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-rename-read-only", Error) {};
+var RenameErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-rename-invalid-argument", Error) {};
+var RenameErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-rename-busy", Error) {};
+var RenameErrorCrossDevice = class extends DCommon.DuploJSError.parentClass("file-system-rename-cross-device", Error) {};
+var RenameError = class extends DCommon.DuploJSError.parentClass("file-system-rename-error", Error) {};
 function handleNodeRenameError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-rename-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-rename-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-rename-already-exists", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-rename-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-rename-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-rename-directory-not-empty", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-rename-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-rename-invalid-argument", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-rename-busy", error);
-		else if (error.code === "EXDEV") return DEither.left("file-system-rename-cross-device", error);
+	let renameError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") renameError = new RenameErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") renameError = new RenameErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") renameError = new RenameErrorAlreadyExists(error);
+		else if (error.code === "EISDIR") renameError = new RenameErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") renameError = new RenameErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") renameError = new RenameErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") renameError = new RenameErrorReadOnly(error);
+		else if (error.code === "EINVAL") renameError = new RenameErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") renameError = new RenameErrorBusy(error);
+		else if (error.code === "EXDEV") renameError = new RenameErrorCrossDevice(error);
 	}
-	return DEither.left("file-system-rename-error", error);
+	if (renameError === void 0) renameError = new RenameError(error);
+	return DEither.left("file-system-rename-error", renameError);
 }
 function handleDenoRenameError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-rename-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-rename-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-rename-already-exists", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-rename-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-rename-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-rename-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-rename-busy", error);
-	return DEither.left("file-system-rename-error", error);
+	let renameError = void 0;
+	if (error instanceof Deno.errors.NotFound) renameError = new RenameErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) renameError = new RenameErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) renameError = new RenameErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.IsADirectory) renameError = new RenameErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) renameError = new RenameErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) renameError = new RenameErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) renameError = new RenameErrorBusy(error);
+	if (renameError === void 0) renameError = new RenameError(error);
+	return DEither.left("file-system-rename-error", renameError);
 }
 const renameImplementation = implementFunction("rename", {
 	NODE: async (path, newName) => {
-		const fs = await nodeFileSystem.value;
 		const parentPath = DPath.getParentFolderPath(path);
-		if (!parentPath) return DEither.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`));
+		if (!parentPath) return DEither.left("file-system-rename-error", new RenameErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid parent path ${path}.`)));
 		const newPath = DPath.resolveRelative([parentPath, newName]);
-		return fs.rename(path, newPath).then(() => DEither.right("file-system-rename", newPath)).catch(handleNodeRenameError);
+		return nodeFileSystem.value.rename(path, newPath).then(() => DEither.right("file-system-rename", newPath)).catch(handleNodeRenameError);
 	},
-	DENO: (path, newName) => {
+	DENO: async (path, newName) => {
 		const parentPath = DPath.getParentFolderPath(path);
-		if (!parentPath) return Promise.resolve(DEither.left("file-system-rename-invalid-argument", /* @__PURE__ */ new Error(`Invalid parent path ${path}.`)));
+		if (!parentPath) return Promise.resolve(DEither.left("file-system-rename-error", new RenameErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid parent path ${path}.`))));
 		const newPath = DPath.resolveRelative([parentPath, newName]);
 		return Deno.rename(path, newPath).then(() => DEither.right("file-system-rename", newPath)).catch(handleDenoRenameError);
 	}