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

package/dist/file/makeDirectory.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/makeDirectory.ts
+var MakeDirectoryErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-not-found", Error) {};
+var MakeDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-permission-denied", Error) {};
+var MakeDirectoryErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-already-exists", Error) {};
+var MakeDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-not-directory", Error) {};
+var MakeDirectoryErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-no-space", Error) {};
+var MakeDirectoryErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-read-only", Error) {};
+var MakeDirectoryErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-invalid-argument", Error) {};
+var MakeDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-too-many-open-files", Error) {};
+var MakeDirectoryErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-busy", Error) {};
+var MakeDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-error", Error) {};
 function handleNodeMakeDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-make-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-directory-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-make-directory-already-exists", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-make-directory-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-make-directory-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-make-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-make-directory-busy", error);
+	let makeDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeDirectoryError = new MakeDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeDirectoryError = new MakeDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeDirectoryError = new MakeDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") makeDirectoryError = new MakeDirectoryErrorBusy(error);
 	}
-	return DEither.left("file-system-make-directory-error", error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return DEither.left("file-system-make-directory-error", makeDirectoryError);
 }
 function handleDenoMakeDirectoryError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-make-directory-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-directory-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-make-directory-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-directory-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-make-directory-busy", error);
-	return DEither.left("file-system-make-directory-error", error);
+	let makeDirectoryError = void 0;
+	if (error instanceof Deno.errors.NotFound) makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) makeDirectoryError = new MakeDirectoryErrorBusy(error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return DEither.left("file-system-make-directory-error", makeDirectoryError);
 }
 const makeDirectory = implementFunction("makeDirectory", {
-	NODE: async (path, params) => {
-		return (await nodeFileSystem.value).mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError);
-	},
+	NODE: async (path, params) => nodeFileSystem.value.mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError),
 	DENO: (path, params) => Deno.mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleDenoMakeDirectoryError)
 });
 //#endregion

package/dist/file/makeTemporaryDirectory.cjs

@@ -1,29 +1,40 @@
 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/makeTemporaryDirectory.ts
+var MakeTemporaryDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-permission-denied", Error) {};
+var MakeTemporaryDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-not-directory", Error) {};
+var MakeTemporaryDirectoryErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-no-space", Error) {};
+var MakeTemporaryDirectoryErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-read-only", Error) {};
+var MakeTemporaryDirectoryErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-invalid-argument", Error) {};
+var MakeTemporaryDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-too-many-open-files", Error) {};
+var MakeTemporaryDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-error", Error) {};
 function handleNodeMakeTemporaryDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-make-temporary-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-temporary-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-temporary-directory-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-temporary-directory-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-temporary-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-temporary-directory-too-many-open-files", error);
+	let makeTemporaryDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorTooManyOpenFiles(error);
 	}
-	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 function handleDenoMakeTemporaryDirectoryError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-temporary-directory-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-temporary-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-temporary-directory-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", error);
+	let makeTemporaryDirectoryError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 const makeTemporaryDirectory = require_implementor.implementFunction("makeTemporaryDirectory", {
-	NODE: async (prefix) => {
-		return (await require_implementor.nodeFileSystem.value).mkdtemp(prefix).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError);
-	},
+	NODE: async (prefix) => require_implementor.nodeFileSystem.value.mkdtemp(prefix).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError),
 	DENO: (prefix) => Deno.makeTempDir({ prefix }).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleDenoMakeTemporaryDirectoryError)
 });
 //#endregion

package/dist/file/makeTemporaryDirectory.d.ts

@@ -1,9 +1,32 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
-export type MakeTemporaryDirectoryResult = FileSystemEither<DEither.Right<"make-temporary-directory", string> | DEither.Left<"make-temporary-directory-permission-denied", unknown> | DEither.Left<"make-temporary-directory-not-directory", unknown> | DEither.Left<"make-temporary-directory-no-space", unknown> | DEither.Left<"make-temporary-directory-read-only", unknown> | DEither.Left<"make-temporary-directory-invalid-argument", unknown> | DEither.Left<"make-temporary-directory-too-many-open-files", unknown> | DEither.Left<"make-temporary-directory-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const MakeTemporaryDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-permission-denied", unknown>>, unknown>;
+declare class MakeTemporaryDirectoryErrorPermissionDenied extends MakeTemporaryDirectoryErrorPermissionDenied_base {
+}
+declare const MakeTemporaryDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-not-directory", unknown>>, unknown>;
+declare class MakeTemporaryDirectoryErrorNotDirectory extends MakeTemporaryDirectoryErrorNotDirectory_base {
+}
+declare const MakeTemporaryDirectoryErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-no-space", unknown>>, unknown>;
+declare class MakeTemporaryDirectoryErrorNoSpace extends MakeTemporaryDirectoryErrorNoSpace_base {
+}
+declare const MakeTemporaryDirectoryErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-read-only", unknown>>, unknown>;
+declare class MakeTemporaryDirectoryErrorReadOnly extends MakeTemporaryDirectoryErrorReadOnly_base {
+}
+declare const MakeTemporaryDirectoryErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-invalid-argument", unknown>>, unknown>;
+declare class MakeTemporaryDirectoryErrorInvalidArgument extends MakeTemporaryDirectoryErrorInvalidArgument_base {
+}
+declare const MakeTemporaryDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-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-make-temporary-directory-too-many-open-files", unknown>>, unknown>;
+declare class MakeTemporaryDirectoryErrorTooManyOpenFiles extends MakeTemporaryDirectoryErrorTooManyOpenFiles_base {
+}
+declare const MakeTemporaryDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-error", unknown>>, unknown>;
+declare class MakeTemporaryDirectoryError extends MakeTemporaryDirectoryError_base {
+}
+export type MakeTemporaryDirectoryErrors = (MakeTemporaryDirectoryErrorPermissionDenied | MakeTemporaryDirectoryErrorNotDirectory | MakeTemporaryDirectoryErrorNoSpace | MakeTemporaryDirectoryErrorReadOnly | MakeTemporaryDirectoryErrorInvalidArgument | MakeTemporaryDirectoryErrorTooManyOpenFiles | MakeTemporaryDirectoryError);
+export type MakeTemporaryDirectoryResult = (DEither.Right<"file-system-make-temporary-directory", string> | DEither.Left<"file-system-make-temporary-directory-error", MakeTemporaryDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         makeTemporaryDirectory(prefix: string): Promise<MakeTemporaryDirectoryResult>;
     }
 }
 export declare const makeTemporaryDirectory: (prefix: string) => Promise<MakeTemporaryDirectoryResult>;
+export {};

package/dist/file/makeTemporaryDirectory.mjs

@@ -1,27 +1,37 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/makeTemporaryDirectory.ts
+var MakeTemporaryDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-permission-denied", Error) {};
+var MakeTemporaryDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-not-directory", Error) {};
+var MakeTemporaryDirectoryErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-no-space", Error) {};
+var MakeTemporaryDirectoryErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-read-only", Error) {};
+var MakeTemporaryDirectoryErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-invalid-argument", Error) {};
+var MakeTemporaryDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-too-many-open-files", Error) {};
+var MakeTemporaryDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-error", Error) {};
 function handleNodeMakeTemporaryDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-temporary-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-temporary-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-make-temporary-directory-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-make-temporary-directory-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-make-temporary-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-temporary-directory-too-many-open-files", error);
+	let makeTemporaryDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorTooManyOpenFiles(error);
 	}
-	return DEither.left("file-system-make-temporary-directory-error", error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return DEither.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 function handleDenoMakeTemporaryDirectoryError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-temporary-directory-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-temporary-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-temporary-directory-invalid-argument", error);
-	return DEither.left("file-system-make-temporary-directory-error", error);
+	let makeTemporaryDirectoryError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return DEither.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 const makeTemporaryDirectory = implementFunction("makeTemporaryDirectory", {
-	NODE: async (prefix) => {
-		return (await nodeFileSystem.value).mkdtemp(prefix).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError);
-	},
+	NODE: async (prefix) => nodeFileSystem.value.mkdtemp(prefix).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError),
 	DENO: (prefix) => Deno.makeTempDir({ prefix }).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleDenoMakeTemporaryDirectoryError)
 });
 //#endregion

package/dist/file/makeTemporaryFile.cjs

@@ -7,34 +7,43 @@ _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/makeTemporaryFile.ts
+var MakeTemporaryFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-permission-denied", Error) {};
+var MakeTemporaryFileErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-already-exists", Error) {};
+var MakeTemporaryFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-not-directory", Error) {};
+var MakeTemporaryFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-no-space", Error) {};
+var MakeTemporaryFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-read-only", Error) {};
+var MakeTemporaryFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-invalid-argument", Error) {};
+var MakeTemporaryFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-too-many-open-files", Error) {};
+var MakeTemporaryFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-error", Error) {};
 function handleNodeMakeTemporaryFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-make-temporary-file-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-make-temporary-file-already-exists", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-temporary-file-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-temporary-file-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-temporary-file-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-temporary-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-temporary-file-too-many-open-files", error);
+	let makeTemporaryFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryFileError = new MakeTemporaryFileErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryFileError = new MakeTemporaryFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryFileError = new MakeTemporaryFileErrorTooManyOpenFiles(error);
 	}
-	return _duplojs_lang_either.left("file-system-make-temporary-file-error", error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 function handleDenoMakeTemporaryFileError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-temporary-file-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-make-temporary-file-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-temporary-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-temporary-file-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-make-temporary-file-error", error);
+	let makeTemporaryFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 const makeTemporaryFile = require_implementor.implementFunction("makeTemporaryFile", {
 	NODE: async (prefix, suffix) => {
-		const fs = await require_implementor.nodeFileSystem.value;
-		const os = await require_implementor.nodeOs.value;
-		const crypto = await require_implementor.nodeCrypto.value;
-		const tempPath = _duplojs_lang_common.forwardAsserts(os.tmpdir(), _duplojs_lang_path.is);
-		const fileName = _duplojs_lang_common.forwardAsserts(`${prefix}${crypto.randomUUID()}${suffix ?? ""}`, _duplojs_lang_path.isSegment);
+		const tempPath = _duplojs_lang_common.forwardAsserts(require_implementor.nodeOs.value.tmpdir(), _duplojs_lang_path.is);
+		const fileName = _duplojs_lang_common.forwardAsserts(`${prefix}${require_implementor.nodeCrypto.value.randomUUID()}${suffix ?? ""}`, _duplojs_lang_path.isSegment);
 		const fileTemporaryPath = _duplojs_lang_path.resolveRelative([tempPath, fileName]);
-		return fs.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
+		return require_implementor.nodeFileSystem.value.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
 	},
 	DENO: (prefix, suffix) => Deno.makeTempFile({
 		prefix,

package/dist/file/makeTemporaryFile.d.ts

@@ -1,10 +1,36 @@
-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";
-export type MakeTemporaryFileResult = FileSystemEither<DEither.Right<"make-temporary-file", string> | DEither.Left<"make-temporary-file-permission-denied", unknown> | DEither.Left<"make-temporary-file-already-exists", unknown> | DEither.Left<"make-temporary-file-not-directory", unknown> | DEither.Left<"make-temporary-file-no-space", unknown> | DEither.Left<"make-temporary-file-read-only", unknown> | DEither.Left<"make-temporary-file-invalid-argument", unknown> | DEither.Left<"make-temporary-file-too-many-open-files", unknown> | DEither.Left<"make-temporary-file-error", unknown>>;
+declare const MakeTemporaryFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-permission-denied", unknown>>, unknown>;
+declare class MakeTemporaryFileErrorPermissionDenied extends MakeTemporaryFileErrorPermissionDenied_base {
+}
+declare const MakeTemporaryFileErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-already-exists", unknown>>, unknown>;
+declare class MakeTemporaryFileErrorAlreadyExists extends MakeTemporaryFileErrorAlreadyExists_base {
+}
+declare const MakeTemporaryFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-not-directory", unknown>>, unknown>;
+declare class MakeTemporaryFileErrorNotDirectory extends MakeTemporaryFileErrorNotDirectory_base {
+}
+declare const MakeTemporaryFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-no-space", unknown>>, unknown>;
+declare class MakeTemporaryFileErrorNoSpace extends MakeTemporaryFileErrorNoSpace_base {
+}
+declare const MakeTemporaryFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-read-only", unknown>>, unknown>;
+declare class MakeTemporaryFileErrorReadOnly extends MakeTemporaryFileErrorReadOnly_base {
+}
+declare const MakeTemporaryFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-invalid-argument", unknown>>, unknown>;
+declare class MakeTemporaryFileErrorInvalidArgument extends MakeTemporaryFileErrorInvalidArgument_base {
+}
+declare const MakeTemporaryFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-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-make-temporary-file-too-many-open-files", unknown>>, unknown>;
+declare class MakeTemporaryFileErrorTooManyOpenFiles extends MakeTemporaryFileErrorTooManyOpenFiles_base {
+}
+declare const MakeTemporaryFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-error", unknown>>, unknown>;
+declare class MakeTemporaryFileError extends MakeTemporaryFileError_base {
+}
+export type MakeTemporaryFileErrors = (MakeTemporaryFileErrorPermissionDenied | MakeTemporaryFileErrorAlreadyExists | MakeTemporaryFileErrorNotDirectory | MakeTemporaryFileErrorNoSpace | MakeTemporaryFileErrorReadOnly | MakeTemporaryFileErrorInvalidArgument | MakeTemporaryFileErrorTooManyOpenFiles | MakeTemporaryFileError);
+export type MakeTemporaryFileResult = (DEither.Right<"file-system-make-temporary-file", string> | DEither.Left<"file-system-make-temporary-file-error", MakeTemporaryFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         makeTemporaryFile(prefix: string & DPath.Segment, suffix?: string & DPath.Segment): Promise<MakeTemporaryFileResult>;
     }
 }
 export declare const makeTemporaryFile: (prefix: string & DPath.Segment, suffix?: string & DPath.Segment) => Promise<MakeTemporaryFileResult>;
+export {};

package/dist/file/makeTemporaryFile.mjs

@@ -3,34 +3,43 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DPath from "@duplojs/lang/path";
 //#region scripts/file/makeTemporaryFile.ts
+var MakeTemporaryFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-permission-denied", Error) {};
+var MakeTemporaryFileErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-already-exists", Error) {};
+var MakeTemporaryFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-not-directory", Error) {};
+var MakeTemporaryFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-no-space", Error) {};
+var MakeTemporaryFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-read-only", Error) {};
+var MakeTemporaryFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-invalid-argument", Error) {};
+var MakeTemporaryFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-too-many-open-files", Error) {};
+var MakeTemporaryFileError = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-error", Error) {};
 function handleNodeMakeTemporaryFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-temporary-file-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-make-temporary-file-already-exists", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-temporary-file-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-make-temporary-file-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-make-temporary-file-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-make-temporary-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-temporary-file-too-many-open-files", error);
+	let makeTemporaryFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryFileError = new MakeTemporaryFileErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryFileError = new MakeTemporaryFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryFileError = new MakeTemporaryFileErrorTooManyOpenFiles(error);
 	}
-	return DEither.left("file-system-make-temporary-file-error", error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return DEither.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 function handleDenoMakeTemporaryFileError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-temporary-file-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-make-temporary-file-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-temporary-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-temporary-file-invalid-argument", error);
-	return DEither.left("file-system-make-temporary-file-error", error);
+	let makeTemporaryFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return DEither.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 const makeTemporaryFile = implementFunction("makeTemporaryFile", {
 	NODE: async (prefix, suffix) => {
-		const fs = await nodeFileSystem.value;
-		const os = await nodeOs.value;
-		const crypto = await nodeCrypto.value;
-		const tempPath = DCommon.forwardAsserts(os.tmpdir(), DPath.is);
-		const fileName = DCommon.forwardAsserts(`${prefix}${crypto.randomUUID()}${suffix ?? ""}`, DPath.isSegment);
+		const tempPath = DCommon.forwardAsserts(nodeOs.value.tmpdir(), DPath.is);
+		const fileName = DCommon.forwardAsserts(`${prefix}${nodeCrypto.value.randomUUID()}${suffix ?? ""}`, DPath.isSegment);
 		const fileTemporaryPath = DPath.resolveRelative([tempPath, fileName]);
-		return fs.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => DEither.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
+		return nodeFileSystem.value.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => DEither.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
 	},
 	DENO: (prefix, suffix) => Deno.makeTempFile({
 		prefix,

package/dist/file/move.cjs

@@ -1,37 +1,52 @@
 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/move.ts
+var MoveErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-not-found", Error) {};
+var MoveErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-permission-denied", Error) {};
+var MoveErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-already-exists", Error) {};
+var MoveErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-is-directory", Error) {};
+var MoveErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-not-directory", Error) {};
+var MoveErrorDirectoryNotEmpty = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-directory-not-empty", Error) {};
+var MoveErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-read-only", Error) {};
+var MoveErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-invalid-argument", Error) {};
+var MoveErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-busy", Error) {};
+var MoveErrorCrossDevice = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-cross-device", Error) {};
+var MoveError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-error", Error) {};
 function handleNodeMoveError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-move-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-move-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-move-already-exists", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-move-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-move-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-move-directory-not-empty", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-move-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-move-invalid-argument", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-move-busy", error);
-		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-move-cross-device", error);
+	let moveError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") moveError = new MoveErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") moveError = new MoveErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") moveError = new MoveErrorAlreadyExists(error);
+		else if (error.code === "EISDIR") moveError = new MoveErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") moveError = new MoveErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") moveError = new MoveErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") moveError = new MoveErrorReadOnly(error);
+		else if (error.code === "EINVAL") moveError = new MoveErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") moveError = new MoveErrorBusy(error);
+		else if (error.code === "EXDEV") moveError = new MoveErrorCrossDevice(error);
 	}
-	return _duplojs_lang_either.left("file-system-move-error", error);
+	if (moveError === void 0) moveError = new MoveError(error);
+	return _duplojs_lang_either.left("file-system-move-error", moveError);
 }
 function handleDenoMoveError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-move-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-move-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-move-already-exists", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-move-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-move-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-move-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-move-busy", error);
-	return _duplojs_lang_either.left("file-system-move-error", error);
+	let moveError = void 0;
+	if (error instanceof Deno.errors.NotFound) moveError = new MoveErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) moveError = new MoveErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) moveError = new MoveErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.IsADirectory) moveError = new MoveErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) moveError = new MoveErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) moveError = new MoveErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) moveError = new MoveErrorBusy(error);
+	if (moveError === void 0) moveError = new MoveError(error);
+	return _duplojs_lang_either.left("file-system-move-error", moveError);
 }
 const moveImplementation = require_implementor.implementFunction("move", {
-	NODE: async (fromPath, toPath) => {
-		return (await require_implementor.nodeFileSystem.value).rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleNodeMoveError);
-	},
+	NODE: async (fromPath, toPath) => require_implementor.nodeFileSystem.value.rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleNodeMoveError),
 	DENO: (fromPath, toPath) => Deno.rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleDenoMoveError)
 });
 function move(...args) {

package/dist/file/move.d.ts

@@ -1,7 +1,41 @@
-import { FileSystemEither } from './types';
 import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export type MoveResult = FileSystemEither<DEither.Right<"move", void> | DEither.Left<"move-not-found", unknown> | DEither.Left<"move-permission-denied", unknown> | DEither.Left<"move-already-exists", unknown> | DEither.Left<"move-is-directory", unknown> | DEither.Left<"move-not-directory", unknown> | DEither.Left<"move-directory-not-empty", unknown> | DEither.Left<"move-read-only", unknown> | DEither.Left<"move-invalid-argument", unknown> | DEither.Left<"move-busy", unknown> | DEither.Left<"move-cross-device", unknown> | DEither.Left<"move-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const MoveErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-not-found", unknown>>, unknown>;
+declare class MoveErrorNotFound extends MoveErrorNotFound_base {
+}
+declare const MoveErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-permission-denied", unknown>>, unknown>;
+declare class MoveErrorPermissionDenied extends MoveErrorPermissionDenied_base {
+}
+declare const MoveErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-already-exists", unknown>>, unknown>;
+declare class MoveErrorAlreadyExists extends MoveErrorAlreadyExists_base {
+}
+declare const MoveErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-is-directory", unknown>>, unknown>;
+declare class MoveErrorIsDirectory extends MoveErrorIsDirectory_base {
+}
+declare const MoveErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-not-directory", unknown>>, unknown>;
+declare class MoveErrorNotDirectory extends MoveErrorNotDirectory_base {
+}
+declare const MoveErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-directory-not-empty", unknown>>, unknown>;
+declare class MoveErrorDirectoryNotEmpty extends MoveErrorDirectoryNotEmpty_base {
+}
+declare const MoveErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-read-only", unknown>>, unknown>;
+declare class MoveErrorReadOnly extends MoveErrorReadOnly_base {
+}
+declare const MoveErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-invalid-argument", unknown>>, unknown>;
+declare class MoveErrorInvalidArgument extends MoveErrorInvalidArgument_base {
+}
+declare const MoveErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-busy", unknown>>, unknown>;
+declare class MoveErrorBusy extends MoveErrorBusy_base {
+}
+declare const MoveErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-cross-device", unknown>>, unknown>;
+declare class MoveErrorCrossDevice extends MoveErrorCrossDevice_base {
+}
+declare const MoveError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-error", unknown>>, unknown>;
+declare class MoveError extends MoveError_base {
+}
+export type MoveErrors = (MoveErrorNotFound | MoveErrorPermissionDenied | MoveErrorAlreadyExists | MoveErrorIsDirectory | MoveErrorNotDirectory | MoveErrorDirectoryNotEmpty | MoveErrorReadOnly | MoveErrorInvalidArgument | MoveErrorBusy | MoveErrorCrossDevice | MoveError);
+export type MoveResult = (DEither.Right<"file-system-move", void> | DEither.Left<"file-system-move-error", MoveErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         move(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<MoveResult>;
@@ -9,3 +43,4 @@ declare module '../implementor' {
 }
 export declare function move(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<MoveResult>;
 export declare function move(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<MoveResult>;
+export {};