@duplojs/server 0.0.0-stage → 0.1.0-beta.10

package/dist/file/relocate.mjs

@@ -0,0 +1,68 @@
+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) {
+	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);
+	}
+	if (relocateError === void 0) relocateError = new RelocateError(error);
+	return DEither.left("file-system-relocate-error", relocateError);
+}
+function handleDenoRelocateError(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 baseName = DPath.getBaseName(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 nodeFileSystem.value.rename(fromPath, newPath).then(() => DEither.right("file-system-relocate", newPath)).catch(handleNodeRelocateError);
+	},
+	DENO: async (fromPath, newParentPath) => {
+		const baseName = DPath.getBaseName(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);
+	}
+});
+function relocate(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => relocateImplementation(fromPath, toPath);
+	}
+	return relocateImplementation(...args);
+}
+//#endregion
+export { RelocateError, RelocateErrorAlreadyExists, RelocateErrorBusy, RelocateErrorCrossDevice, RelocateErrorDirectoryNotEmpty, RelocateErrorInvalidArgument, RelocateErrorIsDirectory, RelocateErrorNotDirectory, RelocateErrorNotFound, RelocateErrorPermissionDenied, RelocateErrorReadOnly, relocate };

package/dist/file/remove.cjs

@@ -0,0 +1,60 @@
+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) {
+	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);
+	}
+	if (removeError === void 0) removeError = new RemoveError(error);
+	return _duplojs_lang_either.left("file-system-remove-error", removeError);
+}
+function handleDenoRemoveError(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) => 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
+exports.RemoveError = RemoveError;
+exports.RemoveErrorBusy = RemoveErrorBusy;
+exports.RemoveErrorDirectoryNotEmpty = RemoveErrorDirectoryNotEmpty;
+exports.RemoveErrorInvalidArgument = RemoveErrorInvalidArgument;
+exports.RemoveErrorIsDirectory = RemoveErrorIsDirectory;
+exports.RemoveErrorNotDirectory = RemoveErrorNotDirectory;
+exports.RemoveErrorNotFound = RemoveErrorNotFound;
+exports.RemoveErrorPermissionDenied = RemoveErrorPermissionDenied;
+exports.RemoveErrorReadOnly = RemoveErrorReadOnly;
+exports.remove = remove;

package/dist/file/remove.d.ts

@@ -0,0 +1,42 @@
+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;
+}
+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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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: DPath.AnyPath, params?: RemoveDirectoryParams): Promise<RemoveResult>;
+    }
+}
+export declare const remove: (path: DPath.AnyPath, params?: RemoveDirectoryParams) => Promise<RemoveResult>;
+export {};

package/dist/file/remove.mjs

@@ -0,0 +1,48 @@
+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) {
+	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);
+	}
+	if (removeError === void 0) removeError = new RemoveError(error);
+	return DEither.left("file-system-remove-error", removeError);
+}
+function handleDenoRemoveError(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) => 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
+export { RemoveError, RemoveErrorBusy, RemoveErrorDirectoryNotEmpty, RemoveErrorInvalidArgument, RemoveErrorIsDirectory, RemoveErrorNotDirectory, RemoveErrorNotFound, RemoveErrorPermissionDenied, RemoveErrorReadOnly, remove };

package/dist/file/rename.cjs

@@ -0,0 +1,83 @@
+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) {
+	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);
+	}
+	if (renameError === void 0) renameError = new RenameError(error);
+	return _duplojs_lang_either.left("file-system-rename-error", renameError);
+}
+function handleDenoRenameError(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 parentPath = _duplojs_lang_path.getParentFolderPath(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 require_implementor.nodeFileSystem.value.rename(path, newPath).then(() => _duplojs_lang_either.right("file-system-rename", newPath)).catch(handleNodeRenameError);
+	},
+	DENO: async (path, newName) => {
+		const parentPath = _duplojs_lang_path.getParentFolderPath(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);
+	}
+});
+function rename(...args) {
+	if (args.length === 1) {
+		const [newName] = args;
+		return (path) => renameImplementation(path, newName);
+	}
+	return renameImplementation(...args);
+}
+//#endregion
+exports.RenameError = RenameError;
+exports.RenameErrorAlreadyExists = RenameErrorAlreadyExists;
+exports.RenameErrorBusy = RenameErrorBusy;
+exports.RenameErrorCrossDevice = RenameErrorCrossDevice;
+exports.RenameErrorDirectoryNotEmpty = RenameErrorDirectoryNotEmpty;
+exports.RenameErrorInvalidArgument = RenameErrorInvalidArgument;
+exports.RenameErrorIsDirectory = RenameErrorIsDirectory;
+exports.RenameErrorNotDirectory = RenameErrorNotDirectory;
+exports.RenameErrorNotFound = RenameErrorNotFound;
+exports.RenameErrorPermissionDenied = RenameErrorPermissionDenied;
+exports.RenameErrorReadOnly = RenameErrorReadOnly;
+exports.rename = rename;

package/dist/file/rename.d.ts

@@ -0,0 +1,46 @@
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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: DPath.AnyPath, newName: string & DPath.Segment): Promise<RenameResult>;
+    }
+}
+export declare function rename(newName: string & DPath.Segment): (path: DPath.AnyPath) => Promise<RenameResult>;
+export declare function rename(path: DPath.AnyPath, newName: string & DPath.Segment): Promise<RenameResult>;
+export {};

package/dist/file/rename.mjs

@@ -0,0 +1,68 @@
+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) {
+	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);
+	}
+	if (renameError === void 0) renameError = new RenameError(error);
+	return DEither.left("file-system-rename-error", renameError);
+}
+function handleDenoRenameError(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 parentPath = DPath.getParentFolderPath(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 nodeFileSystem.value.rename(path, newPath).then(() => DEither.right("file-system-rename", newPath)).catch(handleNodeRenameError);
+	},
+	DENO: async (path, newName) => {
+		const parentPath = DPath.getParentFolderPath(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);
+	}
+});
+function rename(...args) {
+	if (args.length === 1) {
+		const [newName] = args;
+		return (path) => renameImplementation(path, newName);
+	}
+	return renameImplementation(...args);
+}
+//#endregion
+export { RenameError, RenameErrorAlreadyExists, RenameErrorBusy, RenameErrorCrossDevice, RenameErrorDirectoryNotEmpty, RenameErrorInvalidArgument, RenameErrorIsDirectory, RenameErrorNotDirectory, RenameErrorNotFound, RenameErrorPermissionDenied, RenameErrorReadOnly, rename };

package/dist/file/setMode.cjs

@@ -0,0 +1,65 @@
+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/setMode.ts
+var SetModeErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-not-found", Error) {};
+var SetModeErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-permission-denied", Error) {};
+var SetModeErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-not-directory", Error) {};
+var SetModeErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-read-only", Error) {};
+var SetModeErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-invalid-argument", Error) {};
+var SetModeError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-error", Error) {};
+function handleNodeSetModeError(error) {
+	let setModeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setModeError = new SetModeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setModeError = new SetModeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setModeError = new SetModeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setModeError = new SetModeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setModeError = new SetModeErrorInvalidArgument(error);
+	}
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return _duplojs_lang_either.left("file-system-set-mode-error", setModeError);
+}
+function handleDenoSetModeError(error) {
+	let setModeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setModeError = new SetModeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setModeError = new SetModeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setModeError = new SetModeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setModeError = new SetModeErrorInvalidArgument(error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return _duplojs_lang_either.left("file-system-set-mode-error", setModeError);
+}
+function calculatePermissions(permissions) {
+	if (!permissions) return 0;
+	return (permissions.read ? 4 : 0) + (permissions.write ? 2 : 0) + (permissions.exec ? 1 : 0);
+}
+function toMode(mode) {
+	if (_duplojs_lang_common.isType(mode, "number")) return mode;
+	const special = (mode.setUserId ? 4 : 0) + (mode.setGroupId ? 2 : 0) + (mode.sticky ? 1 : 0);
+	const user = calculatePermissions(mode.user);
+	const group = calculatePermissions(mode.group);
+	const other = calculatePermissions(mode.other);
+	return special * 512 + user * 64 + group * 8 + other;
+}
+const setModeImplementation = require_implementor.implementFunction("setMode", {
+	NODE: async (path, mode) => require_implementor.nodeFileSystem.value.chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleNodeSetModeError),
+	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleDenoSetModeError)
+});
+function setMode(...args) {
+	if (args.length === 1) {
+		const [mode] = args;
+		return (path) => setModeImplementation(path, mode);
+	}
+	return setModeImplementation(...args);
+}
+//#endregion
+exports.SetModeError = SetModeError;
+exports.SetModeErrorInvalidArgument = SetModeErrorInvalidArgument;
+exports.SetModeErrorNotDirectory = SetModeErrorNotDirectory;
+exports.SetModeErrorNotFound = SetModeErrorNotFound;
+exports.SetModeErrorPermissionDenied = SetModeErrorPermissionDenied;
+exports.SetModeErrorReadOnly = SetModeErrorReadOnly;
+exports.setMode = setMode;

package/dist/file/setMode.d.ts

@@ -0,0 +1,45 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+interface Permissions {
+    read?: boolean;
+    write?: boolean;
+    exec?: boolean;
+}
+interface ModeObject {
+    user?: Permissions;
+    group?: Permissions;
+    other?: Permissions;
+    setUserId?: boolean;
+    setGroupId?: boolean;
+    sticky?: boolean;
+}
+type SetMode = ModeObject | number;
+declare const SetModeErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-not-found", unknown>>, unknown>;
+export declare class SetModeErrorNotFound extends SetModeErrorNotFound_base {
+}
+declare const SetModeErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-permission-denied", unknown>>, unknown>;
+export declare class SetModeErrorPermissionDenied extends SetModeErrorPermissionDenied_base {
+}
+declare const SetModeErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-not-directory", unknown>>, unknown>;
+export declare class SetModeErrorNotDirectory extends SetModeErrorNotDirectory_base {
+}
+declare const SetModeErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-read-only", unknown>>, unknown>;
+export declare class SetModeErrorReadOnly extends SetModeErrorReadOnly_base {
+}
+declare const SetModeErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-invalid-argument", unknown>>, unknown>;
+export declare class SetModeErrorInvalidArgument extends SetModeErrorInvalidArgument_base {
+}
+declare const SetModeError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-error", unknown>>, unknown>;
+export declare class SetModeError extends SetModeError_base {
+}
+export type SetModeErrors = (SetModeErrorNotFound | SetModeErrorPermissionDenied | SetModeErrorNotDirectory | SetModeErrorReadOnly | SetModeErrorInvalidArgument | SetModeError);
+export type SetModeResult = (DEither.Right<"file-system-set-mode", void> | DEither.Left<"file-system-set-mode-error", SetModeErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        setMode(path: DPath.AnyPath, mode: SetMode): Promise<SetModeResult>;
+    }
+}
+export declare function setMode(mode: SetMode): (path: DPath.AnyPath) => Promise<SetModeResult>;
+export declare function setMode(path: DPath.AnyPath, mode: SetMode): Promise<SetModeResult>;
+export {};

package/dist/file/setMode.mjs

@@ -0,0 +1,56 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/setMode.ts
+var SetModeErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-not-found", Error) {};
+var SetModeErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-permission-denied", Error) {};
+var SetModeErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-not-directory", Error) {};
+var SetModeErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-read-only", Error) {};
+var SetModeErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-invalid-argument", Error) {};
+var SetModeError = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-error", Error) {};
+function handleNodeSetModeError(error) {
+	let setModeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setModeError = new SetModeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setModeError = new SetModeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setModeError = new SetModeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setModeError = new SetModeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setModeError = new SetModeErrorInvalidArgument(error);
+	}
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return DEither.left("file-system-set-mode-error", setModeError);
+}
+function handleDenoSetModeError(error) {
+	let setModeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setModeError = new SetModeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setModeError = new SetModeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setModeError = new SetModeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setModeError = new SetModeErrorInvalidArgument(error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return DEither.left("file-system-set-mode-error", setModeError);
+}
+function calculatePermissions(permissions) {
+	if (!permissions) return 0;
+	return (permissions.read ? 4 : 0) + (permissions.write ? 2 : 0) + (permissions.exec ? 1 : 0);
+}
+function toMode(mode) {
+	if (DCommon.isType(mode, "number")) return mode;
+	const special = (mode.setUserId ? 4 : 0) + (mode.setGroupId ? 2 : 0) + (mode.sticky ? 1 : 0);
+	const user = calculatePermissions(mode.user);
+	const group = calculatePermissions(mode.group);
+	const other = calculatePermissions(mode.other);
+	return special * 512 + user * 64 + group * 8 + other;
+}
+const setModeImplementation = implementFunction("setMode", {
+	NODE: async (path, mode) => nodeFileSystem.value.chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleNodeSetModeError),
+	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleDenoSetModeError)
+});
+function setMode(...args) {
+	if (args.length === 1) {
+		const [mode] = args;
+		return (path) => setModeImplementation(path, mode);
+	}
+	return setModeImplementation(...args);
+}
+//#endregion
+export { SetModeError, SetModeErrorInvalidArgument, SetModeErrorNotDirectory, SetModeErrorNotFound, SetModeErrorPermissionDenied, SetModeErrorReadOnly, setMode };