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

package/dist/file/makeTemporaryFile.d.ts

@@ -0,0 +1,36 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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

@@ -0,0 +1,50 @@
+import { implementFunction, nodeCrypto, nodeFileSystem, nodeOs } 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/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) {
+	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);
+	}
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return DEither.left("file-system-make-temporary-file-error", makeTemporaryFileError);
+}
+function handleDenoMakeTemporaryFileError(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 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 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,
+		suffix
+	}).then((value) => DEither.right("file-system-make-temporary-file", value)).catch(handleDenoMakeTemporaryFileError)
+});
+//#endregion
+export { MakeTemporaryFileError, MakeTemporaryFileErrorAlreadyExists, MakeTemporaryFileErrorInvalidArgument, MakeTemporaryFileErrorNoSpace, MakeTemporaryFileErrorNotDirectory, MakeTemporaryFileErrorPermissionDenied, MakeTemporaryFileErrorReadOnly, MakeTemporaryFileErrorTooManyOpenFiles, makeTemporaryFile };

package/dist/file/move.cjs

@@ -0,0 +1,71 @@
+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) {
+	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);
+	}
+	if (moveError === void 0) moveError = new MoveError(error);
+	return _duplojs_lang_either.left("file-system-move-error", moveError);
+}
+function handleDenoMoveError(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) => 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) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => moveImplementation(fromPath, toPath);
+	}
+	return moveImplementation(...args);
+}
+//#endregion
+exports.MoveError = MoveError;
+exports.MoveErrorAlreadyExists = MoveErrorAlreadyExists;
+exports.MoveErrorBusy = MoveErrorBusy;
+exports.MoveErrorCrossDevice = MoveErrorCrossDevice;
+exports.MoveErrorDirectoryNotEmpty = MoveErrorDirectoryNotEmpty;
+exports.MoveErrorInvalidArgument = MoveErrorInvalidArgument;
+exports.MoveErrorIsDirectory = MoveErrorIsDirectory;
+exports.MoveErrorNotDirectory = MoveErrorNotDirectory;
+exports.MoveErrorNotFound = MoveErrorNotFound;
+exports.MoveErrorPermissionDenied = MoveErrorPermissionDenied;
+exports.MoveErrorReadOnly = MoveErrorReadOnly;
+exports.move = move;

package/dist/file/move.d.ts

@@ -0,0 +1,46 @@
+import type * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export 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: DPath.AnyPath, toPath: DPath.AnyPath): Promise<MoveResult>;
+    }
+}
+export declare function move(toPath: DPath.AnyPath): (fromPath: DPath.AnyPath) => Promise<MoveResult>;
+export declare function move(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<MoveResult>;
+export {};

package/dist/file/move.mjs

@@ -0,0 +1,57 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/move.ts
+var MoveErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-move-not-found", Error) {};
+var MoveErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-move-permission-denied", Error) {};
+var MoveErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-move-already-exists", Error) {};
+var MoveErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-move-is-directory", Error) {};
+var MoveErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-move-not-directory", Error) {};
+var MoveErrorDirectoryNotEmpty = class extends DCommon.DuploJSError.parentClass("file-system-move-directory-not-empty", Error) {};
+var MoveErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-move-read-only", Error) {};
+var MoveErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-move-invalid-argument", Error) {};
+var MoveErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-move-busy", Error) {};
+var MoveErrorCrossDevice = class extends DCommon.DuploJSError.parentClass("file-system-move-cross-device", Error) {};
+var MoveError = class extends DCommon.DuploJSError.parentClass("file-system-move-error", Error) {};
+function handleNodeMoveError(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);
+	}
+	if (moveError === void 0) moveError = new MoveError(error);
+	return DEither.left("file-system-move-error", moveError);
+}
+function handleDenoMoveError(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 DEither.left("file-system-move-error", moveError);
+}
+const moveImplementation = implementFunction("move", {
+	NODE: async (fromPath, toPath) => nodeFileSystem.value.rename(fromPath, toPath).then(() => DEither.right("file-system-move")).catch(handleNodeMoveError),
+	DENO: (fromPath, toPath) => Deno.rename(fromPath, toPath).then(() => DEither.right("file-system-move")).catch(handleDenoMoveError)
+});
+function move(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => moveImplementation(fromPath, toPath);
+	}
+	return moveImplementation(...args);
+}
+//#endregion
+export { MoveError, MoveErrorAlreadyExists, MoveErrorBusy, MoveErrorCrossDevice, MoveErrorDirectoryNotEmpty, MoveErrorInvalidArgument, MoveErrorIsDirectory, MoveErrorNotDirectory, MoveErrorNotFound, MoveErrorPermissionDenied, MoveErrorReadOnly, move };

package/dist/file/readDirectory.cjs

@@ -0,0 +1,44 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+const require_getCurrentWorkDirectoryOrThrow = require("../common/getCurrentWorkDirectoryOrThrow.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);
+let _duplojs_lang_array = require("@duplojs/lang/array");
+_duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
+//#region scripts/file/readDirectory.ts
+var ReadDirectoryErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-not-found", Error) {};
+var ReadDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-permission-denied", Error) {};
+var ReadDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-not-directory", Error) {};
+var ReadDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-too-many-open-files", Error) {};
+var ReadDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-busy", Error) {};
+var ReadDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-error", Error) {};
+function handleNodeReadDirectoryError(error) {
+	let readDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readDirectoryError = new ReadDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readDirectoryError = new ReadDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") readDirectoryError = new ReadDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readDirectoryError = new ReadDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readDirectoryError = new ReadDirectoryErrorBusy(error);
+	}
+	if (readDirectoryError === void 0) readDirectoryError = new ReadDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-read-directory-error", readDirectoryError);
+}
+const readDirectory = require_implementor.implementFunction("readDirectory", { NODE: (path, params) => {
+	return (params?.absolute ? require_implementor.nodeFileSystem.value.readdir(path, {
+		recursive: params.recursive,
+		withFileTypes: true
+	}).then((value) => _duplojs_lang_array.map(value, ({ name, parentPath }) => _duplojs_lang_path.resolveFrom(require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow(), [_duplojs_lang_path.normalize(`${parentPath}/${name}`)]))) : require_implementor.nodeFileSystem.value.readdir(path, { recursive: params?.recursive }).then((value) => _duplojs_lang_array.map(value, (subPath) => _duplojs_lang_path.normalize(subPath)))).then(_duplojs_lang_common.innerPipe((paths) => params?.matcher ? _duplojs_lang_array.filter(paths, params.matcher) : paths, (value) => _duplojs_lang_either.right("file-system-read-directory", value))).catch(handleNodeReadDirectoryError);
+} });
+//#endregion
+exports.ReadDirectoryError = ReadDirectoryError;
+exports.ReadDirectoryErrorBusy = ReadDirectoryErrorBusy;
+exports.ReadDirectoryErrorNotDirectory = ReadDirectoryErrorNotDirectory;
+exports.ReadDirectoryErrorNotFound = ReadDirectoryErrorNotFound;
+exports.ReadDirectoryErrorPermissionDenied = ReadDirectoryErrorPermissionDenied;
+exports.ReadDirectoryErrorTooManyOpenFiles = ReadDirectoryErrorTooManyOpenFiles;
+exports.readDirectory = readDirectory;

package/dist/file/readDirectory.d.ts

@@ -0,0 +1,35 @@
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+declare const ReadDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-not-found", unknown>>, unknown>;
+export declare class ReadDirectoryErrorNotFound extends ReadDirectoryErrorNotFound_base {
+}
+declare const ReadDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-permission-denied", unknown>>, unknown>;
+export declare class ReadDirectoryErrorPermissionDenied extends ReadDirectoryErrorPermissionDenied_base {
+}
+declare const ReadDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-not-directory", unknown>>, unknown>;
+export declare class ReadDirectoryErrorNotDirectory extends ReadDirectoryErrorNotDirectory_base {
+}
+declare const ReadDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-directory-too-many-open-files", unknown>>, unknown>;
+export declare class ReadDirectoryErrorTooManyOpenFiles extends ReadDirectoryErrorTooManyOpenFiles_base {
+}
+declare const ReadDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-busy", unknown>>, unknown>;
+export declare class ReadDirectoryErrorBusy extends ReadDirectoryErrorBusy_base {
+}
+declare const ReadDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-error", unknown>>, unknown>;
+export declare class ReadDirectoryError extends ReadDirectoryError_base {
+}
+export type ReadDirectoryErrors = (ReadDirectoryErrorNotFound | ReadDirectoryErrorPermissionDenied | ReadDirectoryErrorNotDirectory | ReadDirectoryErrorTooManyOpenFiles | ReadDirectoryErrorBusy | ReadDirectoryError);
+interface ReadDirectoryParams {
+    recursive?: boolean;
+    absolute?: boolean;
+    matcher?: DPath.PathMatcher;
+}
+export type ReadDirectoryResult<GenericParams extends ReadDirectoryParams = ReadDirectoryParams> = (DEither.Right<"file-system-read-directory", readonly (string & DPath.Path & (DCommon.IsEqual<GenericParams["absolute"], true> extends true ? DPath.Absolute : unknown))[]> | DEither.Left<"file-system-read-directory-error", ReadDirectoryErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        readDirectory<const GenericParams extends ReadDirectoryParams = {}>(path: DPath.AnyPath, params?: GenericParams): Promise<ReadDirectoryResult<GenericParams>>;
+    }
+}
+export declare const readDirectory: <const GenericParams extends ReadDirectoryParams = {}>(path: DPath.AnyPath, params?: GenericParams) => Promise<ReadDirectoryResult<GenericParams>>;
+export {};

package/dist/file/readDirectory.mjs

@@ -0,0 +1,33 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import { getCurrentWorkDirectoryOrThrow } from "../common/getCurrentWorkDirectoryOrThrow.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+import * as DArray from "@duplojs/lang/array";
+//#region scripts/file/readDirectory.ts
+var ReadDirectoryErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-read-directory-not-found", Error) {};
+var ReadDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-read-directory-permission-denied", Error) {};
+var ReadDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-directory-not-directory", Error) {};
+var ReadDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-read-directory-too-many-open-files", Error) {};
+var ReadDirectoryErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-read-directory-busy", Error) {};
+var ReadDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-read-directory-error", Error) {};
+function handleNodeReadDirectoryError(error) {
+	let readDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readDirectoryError = new ReadDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readDirectoryError = new ReadDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") readDirectoryError = new ReadDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readDirectoryError = new ReadDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readDirectoryError = new ReadDirectoryErrorBusy(error);
+	}
+	if (readDirectoryError === void 0) readDirectoryError = new ReadDirectoryError(error);
+	return DEither.left("file-system-read-directory-error", readDirectoryError);
+}
+const readDirectory = implementFunction("readDirectory", { NODE: (path, params) => {
+	return (params?.absolute ? nodeFileSystem.value.readdir(path, {
+		recursive: params.recursive,
+		withFileTypes: true
+	}).then((value) => DArray.map(value, ({ name, parentPath }) => DPath.resolveFrom(getCurrentWorkDirectoryOrThrow(), [DPath.normalize(`${parentPath}/${name}`)]))) : nodeFileSystem.value.readdir(path, { recursive: params?.recursive }).then((value) => DArray.map(value, (subPath) => DPath.normalize(subPath)))).then(DCommon.innerPipe((paths) => params?.matcher ? DArray.filter(paths, params.matcher) : paths, (value) => DEither.right("file-system-read-directory", value))).catch(handleNodeReadDirectoryError);
+} });
+//#endregion
+export { ReadDirectoryError, ReadDirectoryErrorBusy, ReadDirectoryErrorNotDirectory, ReadDirectoryErrorNotFound, ReadDirectoryErrorPermissionDenied, ReadDirectoryErrorTooManyOpenFiles, readDirectory };

package/dist/file/readFile.cjs

@@ -0,0 +1,51 @@
+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/readFile.ts
+var ReadFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-file-not-found", Error) {};
+var ReadFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-file-permission-denied", Error) {};
+var ReadFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-file-is-directory", Error) {};
+var ReadFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-file-not-directory", Error) {};
+var ReadFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-file-too-many-open-files", Error) {};
+var ReadFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-file-busy", Error) {};
+var ReadFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-file-error", Error) {};
+function handleNodeReadFileError(error) {
+	let readFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readFileError = new ReadFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readFileError = new ReadFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") readFileError = new ReadFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") readFileError = new ReadFileErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readFileError = new ReadFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readFileError = new ReadFileErrorBusy(error);
+	}
+	if (readFileError === void 0) readFileError = new ReadFileError(error);
+	return _duplojs_lang_either.left("file-system-read-file-error", readFileError);
+}
+function handleDenoReadFileError(error) {
+	let readFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) readFileError = new ReadFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readFileError = new ReadFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) readFileError = new ReadFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) readFileError = new ReadFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) readFileError = new ReadFileErrorBusy(error);
+	if (readFileError === void 0) readFileError = new ReadFileError(error);
+	return _duplojs_lang_either.left("file-system-read-file-error", readFileError);
+}
+const readFile = require_implementor.implementFunction("readFile", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.readFile(path).then((value) => _duplojs_lang_either.right("file-system-read-file", value)).catch(handleNodeReadFileError),
+	DENO: (path) => Deno.readFile(path).then((value) => _duplojs_lang_either.right("file-system-read-file", value)).catch(handleDenoReadFileError),
+	BUN: (path) => Bun.file(path).bytes().then((value) => _duplojs_lang_either.right("file-system-read-file", value)).catch(handleNodeReadFileError)
+});
+//#endregion
+exports.ReadFileError = ReadFileError;
+exports.ReadFileErrorBusy = ReadFileErrorBusy;
+exports.ReadFileErrorIsDirectory = ReadFileErrorIsDirectory;
+exports.ReadFileErrorNotDirectory = ReadFileErrorNotDirectory;
+exports.ReadFileErrorNotFound = ReadFileErrorNotFound;
+exports.ReadFileErrorPermissionDenied = ReadFileErrorPermissionDenied;
+exports.ReadFileErrorTooManyOpenFiles = ReadFileErrorTooManyOpenFiles;
+exports.readFile = readFile;

package/dist/file/readFile.d.ts

@@ -0,0 +1,33 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+declare const ReadFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-not-found", unknown>>, unknown>;
+export declare class ReadFileErrorNotFound extends ReadFileErrorNotFound_base {
+}
+declare const ReadFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-permission-denied", unknown>>, unknown>;
+export declare class ReadFileErrorPermissionDenied extends ReadFileErrorPermissionDenied_base {
+}
+declare const ReadFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-is-directory", unknown>>, unknown>;
+export declare class ReadFileErrorIsDirectory extends ReadFileErrorIsDirectory_base {
+}
+declare const ReadFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-not-directory", unknown>>, unknown>;
+export declare class ReadFileErrorNotDirectory extends ReadFileErrorNotDirectory_base {
+}
+declare const ReadFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-file-too-many-open-files", unknown>>, unknown>;
+export declare class ReadFileErrorTooManyOpenFiles extends ReadFileErrorTooManyOpenFiles_base {
+}
+declare const ReadFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-busy", unknown>>, unknown>;
+export declare class ReadFileErrorBusy extends ReadFileErrorBusy_base {
+}
+declare const ReadFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-file-error", unknown>>, unknown>;
+export declare class ReadFileError extends ReadFileError_base {
+}
+export type ReadFileErrors = (ReadFileErrorNotFound | ReadFileErrorPermissionDenied | ReadFileErrorIsDirectory | ReadFileErrorNotDirectory | ReadFileErrorTooManyOpenFiles | ReadFileErrorBusy | ReadFileError);
+export type ReadFileResult = (DEither.Right<"file-system-read-file", Uint8Array> | DEither.Left<"file-system-read-file-error", ReadFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        readFile(path: DPath.AnyPath): Promise<ReadFileResult>;
+    }
+}
+export declare const readFile: (path: DPath.AnyPath) => Promise<ReadFileResult>;
+export {};

package/dist/file/readFile.mjs

@@ -0,0 +1,41 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readFile.ts
+var ReadFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-read-file-not-found", Error) {};
+var ReadFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-read-file-permission-denied", Error) {};
+var ReadFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-file-is-directory", Error) {};
+var ReadFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-file-not-directory", Error) {};
+var ReadFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-read-file-too-many-open-files", Error) {};
+var ReadFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-read-file-busy", Error) {};
+var ReadFileError = class extends DCommon.DuploJSError.parentClass("file-system-read-file-error", Error) {};
+function handleNodeReadFileError(error) {
+	let readFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readFileError = new ReadFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readFileError = new ReadFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") readFileError = new ReadFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") readFileError = new ReadFileErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readFileError = new ReadFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readFileError = new ReadFileErrorBusy(error);
+	}
+	if (readFileError === void 0) readFileError = new ReadFileError(error);
+	return DEither.left("file-system-read-file-error", readFileError);
+}
+function handleDenoReadFileError(error) {
+	let readFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) readFileError = new ReadFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readFileError = new ReadFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) readFileError = new ReadFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) readFileError = new ReadFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) readFileError = new ReadFileErrorBusy(error);
+	if (readFileError === void 0) readFileError = new ReadFileError(error);
+	return DEither.left("file-system-read-file-error", readFileError);
+}
+const readFile = implementFunction("readFile", {
+	NODE: async (path) => nodeFileSystem.value.readFile(path).then((value) => DEither.right("file-system-read-file", value)).catch(handleNodeReadFileError),
+	DENO: (path) => Deno.readFile(path).then((value) => DEither.right("file-system-read-file", value)).catch(handleDenoReadFileError),
+	BUN: (path) => Bun.file(path).bytes().then((value) => DEither.right("file-system-read-file", value)).catch(handleNodeReadFileError)
+});
+//#endregion
+export { ReadFileError, ReadFileErrorBusy, ReadFileErrorIsDirectory, ReadFileErrorNotDirectory, ReadFileErrorNotFound, ReadFileErrorPermissionDenied, ReadFileErrorTooManyOpenFiles, readFile };

package/dist/file/readJsonFile.cjs

@@ -0,0 +1,51 @@
+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/readJsonFile.ts
+var ReadJsonFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-json-file-not-found", Error) {};
+var ReadJsonFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-json-file-permission-denied", Error) {};
+var ReadJsonFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-json-file-is-directory", Error) {};
+var ReadJsonFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-json-file-not-directory", Error) {};
+var ReadJsonFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-json-file-too-many-open-files", Error) {};
+var ReadJsonFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-json-file-busy", Error) {};
+var ReadJsonFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-json-file-error", Error) {};
+function handleNodeReadJsonFileError(error) {
+	let readJsonFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readJsonFileError = new ReadJsonFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readJsonFileError = new ReadJsonFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") readJsonFileError = new ReadJsonFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") readJsonFileError = new ReadJsonFileErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readJsonFileError = new ReadJsonFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readJsonFileError = new ReadJsonFileErrorBusy(error);
+	}
+	if (readJsonFileError === void 0) readJsonFileError = new ReadJsonFileError(error);
+	return _duplojs_lang_either.left("file-system-read-json-file-error", readJsonFileError);
+}
+function handleDenoReadJsonFileError(error) {
+	let readJsonFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) readJsonFileError = new ReadJsonFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readJsonFileError = new ReadJsonFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) readJsonFileError = new ReadJsonFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) readJsonFileError = new ReadJsonFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) readJsonFileError = new ReadJsonFileErrorBusy(error);
+	if (readJsonFileError === void 0) readJsonFileError = new ReadJsonFileError(error);
+	return _duplojs_lang_either.left("file-system-read-json-file-error", readJsonFileError);
+}
+const readJsonFile = require_implementor.implementFunction("readJsonFile", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.readFile(path, { encoding: "utf-8" }).then(JSON.parse).then((value) => _duplojs_lang_either.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError),
+	DENO: (path) => Deno.readTextFile(path).then(JSON.parse).then((value) => _duplojs_lang_either.right("file-system-read-json-file", value)).catch(handleDenoReadJsonFileError),
+	BUN: (path) => Bun.file(path).text().then(JSON.parse).then((value) => _duplojs_lang_either.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError)
+});
+//#endregion
+exports.ReadJsonFileError = ReadJsonFileError;
+exports.ReadJsonFileErrorBusy = ReadJsonFileErrorBusy;
+exports.ReadJsonFileErrorIsDirectory = ReadJsonFileErrorIsDirectory;
+exports.ReadJsonFileErrorNotDirectory = ReadJsonFileErrorNotDirectory;
+exports.ReadJsonFileErrorNotFound = ReadJsonFileErrorNotFound;
+exports.ReadJsonFileErrorPermissionDenied = ReadJsonFileErrorPermissionDenied;
+exports.ReadJsonFileErrorTooManyOpenFiles = ReadJsonFileErrorTooManyOpenFiles;
+exports.readJsonFile = readJsonFile;