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

package/dist/file/copy.d.ts

@@ -0,0 +1,43 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+declare const CopyErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-not-found", unknown>>, unknown>;
+export declare class CopyErrorNotFound extends CopyErrorNotFound_base {
+}
+declare const CopyErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-permission-denied", unknown>>, unknown>;
+export declare class CopyErrorPermissionDenied extends CopyErrorPermissionDenied_base {
+}
+declare const CopyErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-already-exists", unknown>>, unknown>;
+export declare class CopyErrorAlreadyExists extends CopyErrorAlreadyExists_base {
+}
+declare const CopyErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-not-directory", unknown>>, unknown>;
+export declare class CopyErrorNotDirectory extends CopyErrorNotDirectory_base {
+}
+declare const CopyErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-no-space", unknown>>, unknown>;
+export declare class CopyErrorNoSpace extends CopyErrorNoSpace_base {
+}
+declare const CopyErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-read-only", unknown>>, unknown>;
+export declare class CopyErrorReadOnly extends CopyErrorReadOnly_base {
+}
+declare const CopyErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-invalid-argument", unknown>>, unknown>;
+export declare class CopyErrorInvalidArgument extends CopyErrorInvalidArgument_base {
+}
+declare const CopyErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-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-copy-too-many-open-files", unknown>>, unknown>;
+export declare class CopyErrorTooManyOpenFiles extends CopyErrorTooManyOpenFiles_base {
+}
+declare const CopyErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-busy", unknown>>, unknown>;
+export declare class CopyErrorBusy extends CopyErrorBusy_base {
+}
+declare const CopyError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-error", unknown>>, unknown>;
+export declare class CopyError extends CopyError_base {
+}
+export type CopyErrors = (CopyErrorNotFound | CopyErrorPermissionDenied | CopyErrorAlreadyExists | CopyErrorNotDirectory | CopyErrorNoSpace | CopyErrorReadOnly | CopyErrorInvalidArgument | CopyErrorTooManyOpenFiles | CopyErrorBusy | CopyError);
+export type CopyResult = (DEither.Right<"file-system-copy", void> | DEither.Left<"file-system-copy-error", CopyErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        copy(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<CopyResult>;
+    }
+}
+export declare function copy(toPath: DPath.AnyPath): (fromPath: DPath.AnyPath) => Promise<CopyResult>;
+export declare function copy(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<CopyResult>;
+export {};

package/dist/file/copy.mjs

@@ -0,0 +1,40 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/copy.ts
+var CopyErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-copy-not-found", Error) {};
+var CopyErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-copy-permission-denied", Error) {};
+var CopyErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-copy-already-exists", Error) {};
+var CopyErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-copy-not-directory", Error) {};
+var CopyErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-copy-no-space", Error) {};
+var CopyErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-copy-read-only", Error) {};
+var CopyErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-copy-invalid-argument", Error) {};
+var CopyErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-copy-too-many-open-files", Error) {};
+var CopyErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-copy-busy", Error) {};
+var CopyError = class extends DCommon.DuploJSError.parentClass("file-system-copy-error", Error) {};
+function handleNodeCopyError(error) {
+	let copyError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") copyError = new CopyErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") copyError = new CopyErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") copyError = new CopyErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") copyError = new CopyErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") copyError = new CopyErrorNoSpace(error);
+		else if (error.code === "EROFS") copyError = new CopyErrorReadOnly(error);
+		else if (error.code === "EINVAL") copyError = new CopyErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") copyError = new CopyErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") copyError = new CopyErrorBusy(error);
+	}
+	if (copyError === void 0) copyError = new CopyError(error);
+	return DEither.left("file-system-copy-error", copyError);
+}
+const copyImplementation = implementFunction("copy", { NODE: async (fromPath, toPath) => nodeFileSystem.value.cp(fromPath, toPath, { recursive: true }).then(() => DEither.right("file-system-copy")).catch(handleNodeCopyError) });
+function copy(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => copyImplementation(fromPath, toPath);
+	}
+	return copyImplementation(...args);
+}
+//#endregion
+export { CopyError, CopyErrorAlreadyExists, CopyErrorBusy, CopyErrorInvalidArgument, CopyErrorNoSpace, CopyErrorNotDirectory, CopyErrorNotFound, CopyErrorPermissionDenied, CopyErrorReadOnly, CopyErrorTooManyOpenFiles, copy };

package/dist/file/createEntryInterface.cjs

@@ -0,0 +1,19 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_stat = require("./stat.cjs");
+const require_fileInterface = require("./fileInterface.cjs");
+const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
+const require_folderInterface = require("./folderInterface.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/createEntryInterface.ts
+async function createEntryInterface(path) {
+	const entryPath = _duplojs_lang_common.cast(path);
+	const result = await _duplojs_lang_either.rightAsyncPipe(require_stat.stat(path), _duplojs_lang_pattern.when(({ isFile }) => isFile, () => _duplojs_lang_either.right("file-interface", require_fileInterface.createFileInterface(entryPath))), _duplojs_lang_pattern.when(({ isDirectory }) => isDirectory, () => _duplojs_lang_either.right("folder-interface", require_folderInterface.createFolderInterface(entryPath))), _duplojs_lang_pattern.otherwise(() => _duplojs_lang_either.right("unknown-entry-interface", require_unknownEntryInterface.createUnknownEntryInterface(entryPath))));
+	return _duplojs_lang_either.whenIsLeft(result, (value) => _duplojs_lang_either.left("create-entry-interface-error", value));
+}
+//#endregion
+exports.createEntryInterface = createEntryInterface;

package/dist/file/createEntryInterface.d.ts

@@ -0,0 +1,3 @@
+import type * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export declare function createEntryInterface(path: DPath.AnyPath): Promise<DEither.Right<"file-interface", import('./fileInterface').FileInterface<string & DPath.Path>> | DEither.Right<"folder-interface", import('./folderInterface').FolderInterface<string & DPath.Path>> | DEither.Right<"unknown-entry-interface", import('./unknownEntryInterface').UnknownEntryInterface<string & DPath.Path>> | DEither.Left<"create-entry-interface-error", import('./stat').StatErrors>>;

package/dist/file/createEntryInterface.mjs

@@ -0,0 +1,15 @@
+import { stat } from "./stat.mjs";
+import { createFileInterface } from "./fileInterface.mjs";
+import { createUnknownEntryInterface } from "./unknownEntryInterface.mjs";
+import { createFolderInterface } from "./folderInterface.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/createEntryInterface.ts
+async function createEntryInterface(path) {
+	const entryPath = DCommon.cast(path);
+	const result = await DEither.rightAsyncPipe(stat(path), DPattern.when(({ isFile }) => isFile, () => DEither.right("file-interface", createFileInterface(entryPath))), DPattern.when(({ isDirectory }) => isDirectory, () => DEither.right("folder-interface", createFolderInterface(entryPath))), DPattern.otherwise(() => DEither.right("unknown-entry-interface", createUnknownEntryInterface(entryPath))));
+	return DEither.whenIsLeft(result, (value) => DEither.left("create-entry-interface-error", value));
+}
+//#endregion
+export { createEntryInterface };

package/dist/file/ensureDirectory.cjs

@@ -0,0 +1,52 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/ensureDirectory.ts
+var EnsureDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-permission-denied", Error) {};
+var EnsureDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-not-directory", Error) {};
+var EnsureDirectoryErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-no-space", Error) {};
+var EnsureDirectoryErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-read-only", Error) {};
+var EnsureDirectoryErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-invalid-argument", Error) {};
+var EnsureDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-too-many-open-files", Error) {};
+var EnsureDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-busy", Error) {};
+var EnsureDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-directory-error", Error) {};
+function handleNodeEnsureDirectoryError(error) {
+	let ensureDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") ensureDirectoryError = new EnsureDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") ensureDirectoryError = new EnsureDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") ensureDirectoryError = new EnsureDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") ensureDirectoryError = new EnsureDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") ensureDirectoryError = new EnsureDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") ensureDirectoryError = new EnsureDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") ensureDirectoryError = new EnsureDirectoryErrorBusy(error);
+	}
+	if (ensureDirectoryError === void 0) ensureDirectoryError = new EnsureDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-ensure-directory-error", ensureDirectoryError);
+}
+function handleDenoEnsureDirectoryError(error) {
+	let ensureDirectoryError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) ensureDirectoryError = new EnsureDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) ensureDirectoryError = new EnsureDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) ensureDirectoryError = new EnsureDirectoryErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) ensureDirectoryError = new EnsureDirectoryErrorBusy(error);
+	if (ensureDirectoryError === void 0) ensureDirectoryError = new EnsureDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-ensure-directory-error", ensureDirectoryError);
+}
+const ensureDirectory = require_implementor.implementFunction("ensureDirectory", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.mkdir(path, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-ensure-directory")).catch(handleNodeEnsureDirectoryError),
+	DENO: (path) => Deno.mkdir(path, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-ensure-directory")).catch(handleDenoEnsureDirectoryError)
+});
+//#endregion
+exports.EnsureDirectoryError = EnsureDirectoryError;
+exports.EnsureDirectoryErrorBusy = EnsureDirectoryErrorBusy;
+exports.EnsureDirectoryErrorInvalidArgument = EnsureDirectoryErrorInvalidArgument;
+exports.EnsureDirectoryErrorNoSpace = EnsureDirectoryErrorNoSpace;
+exports.EnsureDirectoryErrorNotDirectory = EnsureDirectoryErrorNotDirectory;
+exports.EnsureDirectoryErrorPermissionDenied = EnsureDirectoryErrorPermissionDenied;
+exports.EnsureDirectoryErrorReadOnly = EnsureDirectoryErrorReadOnly;
+exports.EnsureDirectoryErrorTooManyOpenFiles = EnsureDirectoryErrorTooManyOpenFiles;
+exports.ensureDirectory = ensureDirectory;

package/dist/file/ensureDirectory.d.ts

@@ -0,0 +1,36 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+declare const EnsureDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-permission-denied", unknown>>, unknown>;
+export declare class EnsureDirectoryErrorPermissionDenied extends EnsureDirectoryErrorPermissionDenied_base {
+}
+declare const EnsureDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-not-directory", unknown>>, unknown>;
+export declare class EnsureDirectoryErrorNotDirectory extends EnsureDirectoryErrorNotDirectory_base {
+}
+declare const EnsureDirectoryErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-no-space", unknown>>, unknown>;
+export declare class EnsureDirectoryErrorNoSpace extends EnsureDirectoryErrorNoSpace_base {
+}
+declare const EnsureDirectoryErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-read-only", unknown>>, unknown>;
+export declare class EnsureDirectoryErrorReadOnly extends EnsureDirectoryErrorReadOnly_base {
+}
+declare const EnsureDirectoryErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-invalid-argument", unknown>>, unknown>;
+export declare class EnsureDirectoryErrorInvalidArgument extends EnsureDirectoryErrorInvalidArgument_base {
+}
+declare const EnsureDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-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-ensure-directory-too-many-open-files", unknown>>, unknown>;
+export declare class EnsureDirectoryErrorTooManyOpenFiles extends EnsureDirectoryErrorTooManyOpenFiles_base {
+}
+declare const EnsureDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-busy", unknown>>, unknown>;
+export declare class EnsureDirectoryErrorBusy extends EnsureDirectoryErrorBusy_base {
+}
+declare const EnsureDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-directory-error", unknown>>, unknown>;
+export declare class EnsureDirectoryError extends EnsureDirectoryError_base {
+}
+export type EnsureDirectoryErrors = (EnsureDirectoryErrorPermissionDenied | EnsureDirectoryErrorNotDirectory | EnsureDirectoryErrorNoSpace | EnsureDirectoryErrorReadOnly | EnsureDirectoryErrorInvalidArgument | EnsureDirectoryErrorTooManyOpenFiles | EnsureDirectoryErrorBusy | EnsureDirectoryError);
+export type EnsureDirectoryResult = (DEither.Right<"file-system-ensure-directory", void> | DEither.Left<"file-system-ensure-directory-error", EnsureDirectoryErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        ensureDirectory(path: DPath.AnyPath): Promise<EnsureDirectoryResult>;
+    }
+}
+export declare const ensureDirectory: (path: DPath.AnyPath) => Promise<EnsureDirectoryResult>;
+export {};

package/dist/file/ensureDirectory.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/ensureDirectory.ts
+var EnsureDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-permission-denied", Error) {};
+var EnsureDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-not-directory", Error) {};
+var EnsureDirectoryErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-no-space", Error) {};
+var EnsureDirectoryErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-read-only", Error) {};
+var EnsureDirectoryErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-invalid-argument", Error) {};
+var EnsureDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-too-many-open-files", Error) {};
+var EnsureDirectoryErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-busy", Error) {};
+var EnsureDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-ensure-directory-error", Error) {};
+function handleNodeEnsureDirectoryError(error) {
+	let ensureDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") ensureDirectoryError = new EnsureDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") ensureDirectoryError = new EnsureDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") ensureDirectoryError = new EnsureDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") ensureDirectoryError = new EnsureDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") ensureDirectoryError = new EnsureDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") ensureDirectoryError = new EnsureDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") ensureDirectoryError = new EnsureDirectoryErrorBusy(error);
+	}
+	if (ensureDirectoryError === void 0) ensureDirectoryError = new EnsureDirectoryError(error);
+	return DEither.left("file-system-ensure-directory-error", ensureDirectoryError);
+}
+function handleDenoEnsureDirectoryError(error) {
+	let ensureDirectoryError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) ensureDirectoryError = new EnsureDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) ensureDirectoryError = new EnsureDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) ensureDirectoryError = new EnsureDirectoryErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) ensureDirectoryError = new EnsureDirectoryErrorBusy(error);
+	if (ensureDirectoryError === void 0) ensureDirectoryError = new EnsureDirectoryError(error);
+	return DEither.left("file-system-ensure-directory-error", ensureDirectoryError);
+}
+const ensureDirectory = implementFunction("ensureDirectory", {
+	NODE: async (path) => nodeFileSystem.value.mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleNodeEnsureDirectoryError),
+	DENO: (path) => Deno.mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleDenoEnsureDirectoryError)
+});
+//#endregion
+export { EnsureDirectoryError, EnsureDirectoryErrorBusy, EnsureDirectoryErrorInvalidArgument, EnsureDirectoryErrorNoSpace, EnsureDirectoryErrorNotDirectory, EnsureDirectoryErrorPermissionDenied, EnsureDirectoryErrorReadOnly, EnsureDirectoryErrorTooManyOpenFiles, ensureDirectory };

package/dist/file/ensureFile.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/ensureFile.ts
+var EnsureFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-permission-denied", Error) {};
+var EnsureFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-is-directory", Error) {};
+var EnsureFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-not-directory", Error) {};
+var EnsureFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-no-space", Error) {};
+var EnsureFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-read-only", Error) {};
+var EnsureFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-invalid-argument", Error) {};
+var EnsureFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-too-many-open-files", Error) {};
+var EnsureFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-busy", Error) {};
+var EnsureFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-ensure-file-error", Error) {};
+function handleNodeEnsureFileError(error) {
+	let ensureFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") ensureFileError = new EnsureFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") ensureFileError = new EnsureFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") ensureFileError = new EnsureFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") ensureFileError = new EnsureFileErrorNoSpace(error);
+		else if (error.code === "EROFS") ensureFileError = new EnsureFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") ensureFileError = new EnsureFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") ensureFileError = new EnsureFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") ensureFileError = new EnsureFileErrorBusy(error);
+	}
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return _duplojs_lang_either.left("file-system-ensure-file-error", ensureFileError);
+}
+function handleDenoEnsureFileError(error) {
+	let ensureFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) ensureFileError = new EnsureFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) ensureFileError = new EnsureFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) ensureFileError = new EnsureFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) ensureFileError = new EnsureFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) ensureFileError = new EnsureFileErrorBusy(error);
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return _duplojs_lang_either.left("file-system-ensure-file-error", ensureFileError);
+}
+const ensureFile = require_implementor.implementFunction("ensureFile", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.open(path, "a").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-ensure-file")).catch(handleNodeEnsureFileError),
+	DENO: (path) => Deno.open(path, {
+		write: true,
+		create: true,
+		append: true
+	}).then((fh) => void fh.close()).then(() => _duplojs_lang_either.right("file-system-ensure-file")).catch(handleDenoEnsureFileError)
+});
+//#endregion
+exports.EnsureFileError = EnsureFileError;
+exports.EnsureFileErrorBusy = EnsureFileErrorBusy;
+exports.EnsureFileErrorInvalidArgument = EnsureFileErrorInvalidArgument;
+exports.EnsureFileErrorIsDirectory = EnsureFileErrorIsDirectory;
+exports.EnsureFileErrorNoSpace = EnsureFileErrorNoSpace;
+exports.EnsureFileErrorNotDirectory = EnsureFileErrorNotDirectory;
+exports.EnsureFileErrorPermissionDenied = EnsureFileErrorPermissionDenied;
+exports.EnsureFileErrorReadOnly = EnsureFileErrorReadOnly;
+exports.EnsureFileErrorTooManyOpenFiles = EnsureFileErrorTooManyOpenFiles;
+exports.ensureFile = ensureFile;

package/dist/file/ensureFile.d.ts

@@ -0,0 +1,39 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+declare const EnsureFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-permission-denied", unknown>>, unknown>;
+export declare class EnsureFileErrorPermissionDenied extends EnsureFileErrorPermissionDenied_base {
+}
+declare const EnsureFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-is-directory", unknown>>, unknown>;
+export declare class EnsureFileErrorIsDirectory extends EnsureFileErrorIsDirectory_base {
+}
+declare const EnsureFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-not-directory", unknown>>, unknown>;
+export declare class EnsureFileErrorNotDirectory extends EnsureFileErrorNotDirectory_base {
+}
+declare const EnsureFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-no-space", unknown>>, unknown>;
+export declare class EnsureFileErrorNoSpace extends EnsureFileErrorNoSpace_base {
+}
+declare const EnsureFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-read-only", unknown>>, unknown>;
+export declare class EnsureFileErrorReadOnly extends EnsureFileErrorReadOnly_base {
+}
+declare const EnsureFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-invalid-argument", unknown>>, unknown>;
+export declare class EnsureFileErrorInvalidArgument extends EnsureFileErrorInvalidArgument_base {
+}
+declare const EnsureFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-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-ensure-file-too-many-open-files", unknown>>, unknown>;
+export declare class EnsureFileErrorTooManyOpenFiles extends EnsureFileErrorTooManyOpenFiles_base {
+}
+declare const EnsureFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-busy", unknown>>, unknown>;
+export declare class EnsureFileErrorBusy extends EnsureFileErrorBusy_base {
+}
+declare const EnsureFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-ensure-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-ensure-file-error", unknown>>, unknown>;
+export declare class EnsureFileError extends EnsureFileError_base {
+}
+export type EnsureFileErrors = (EnsureFileErrorPermissionDenied | EnsureFileErrorIsDirectory | EnsureFileErrorNotDirectory | EnsureFileErrorNoSpace | EnsureFileErrorReadOnly | EnsureFileErrorInvalidArgument | EnsureFileErrorTooManyOpenFiles | EnsureFileErrorBusy | EnsureFileError);
+export type EnsureFileResult = (DEither.Right<"file-system-ensure-file", void> | DEither.Left<"file-system-ensure-file-error", EnsureFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        ensureFile(path: DPath.AnyPath): Promise<EnsureFileResult>;
+    }
+}
+export declare const ensureFile: (path: DPath.AnyPath) => Promise<EnsureFileResult>;
+export {};

package/dist/file/ensureFile.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/ensureFile.ts
+var EnsureFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-permission-denied", Error) {};
+var EnsureFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-is-directory", Error) {};
+var EnsureFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-not-directory", Error) {};
+var EnsureFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-no-space", Error) {};
+var EnsureFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-read-only", Error) {};
+var EnsureFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-invalid-argument", Error) {};
+var EnsureFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-too-many-open-files", Error) {};
+var EnsureFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-busy", Error) {};
+var EnsureFileError = class extends DCommon.DuploJSError.parentClass("file-system-ensure-file-error", Error) {};
+function handleNodeEnsureFileError(error) {
+	let ensureFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") ensureFileError = new EnsureFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") ensureFileError = new EnsureFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") ensureFileError = new EnsureFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") ensureFileError = new EnsureFileErrorNoSpace(error);
+		else if (error.code === "EROFS") ensureFileError = new EnsureFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") ensureFileError = new EnsureFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") ensureFileError = new EnsureFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") ensureFileError = new EnsureFileErrorBusy(error);
+	}
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return DEither.left("file-system-ensure-file-error", ensureFileError);
+}
+function handleDenoEnsureFileError(error) {
+	let ensureFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) ensureFileError = new EnsureFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) ensureFileError = new EnsureFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) ensureFileError = new EnsureFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) ensureFileError = new EnsureFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) ensureFileError = new EnsureFileErrorBusy(error);
+	if (ensureFileError === void 0) ensureFileError = new EnsureFileError(error);
+	return DEither.left("file-system-ensure-file-error", ensureFileError);
+}
+const ensureFile = implementFunction("ensureFile", {
+	NODE: async (path) => nodeFileSystem.value.open(path, "a").then((fh) => fh.close()).then(() => DEither.right("file-system-ensure-file")).catch(handleNodeEnsureFileError),
+	DENO: (path) => Deno.open(path, {
+		write: true,
+		create: true,
+		append: true
+	}).then((fh) => void fh.close()).then(() => DEither.right("file-system-ensure-file")).catch(handleDenoEnsureFileError)
+});
+//#endregion
+export { EnsureFileError, EnsureFileErrorBusy, EnsureFileErrorInvalidArgument, EnsureFileErrorIsDirectory, EnsureFileErrorNoSpace, EnsureFileErrorNotDirectory, EnsureFileErrorPermissionDenied, EnsureFileErrorReadOnly, EnsureFileErrorTooManyOpenFiles, ensureFile };

package/dist/file/exists.cjs

@@ -0,0 +1,43 @@
+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/exists.ts
+var ExistsErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-not-found", Error) {};
+var ExistsErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-permission-denied", Error) {};
+var ExistsErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-not-directory", Error) {};
+var ExistsErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-too-many-open-files", Error) {};
+var ExistsError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-exists-error", Error) {};
+function handleNodeExistsError(error) {
+	let existsError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") existsError = new ExistsErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") existsError = new ExistsErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") existsError = new ExistsErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") existsError = new ExistsErrorTooManyOpenFiles(error);
+	}
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return _duplojs_lang_either.left("file-system-exists-error", existsError);
+}
+function handleDenoExistsError(error) {
+	let existsError = void 0;
+	if (error instanceof Deno.errors.NotFound) existsError = new ExistsErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) existsError = new ExistsErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) existsError = new ExistsErrorNotDirectory(error);
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return _duplojs_lang_either.left("file-system-exists-error", existsError);
+}
+const exists = require_implementor.implementFunction("exists", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.access(path).then(() => _duplojs_lang_either.right("file-system-exists")).catch(handleNodeExistsError),
+	DENO: (path) => Deno.stat(path).then(() => _duplojs_lang_either.right("file-system-exists")).catch(handleDenoExistsError),
+	BUN: (path) => Bun.file(path).exists().then((value) => value ? _duplojs_lang_either.right("file-system-exists") : _duplojs_lang_either.left("file-system-exists-error", new ExistsErrorNotFound(/* @__PURE__ */ new Error("Path does not exist")))).catch(handleNodeExistsError)
+});
+//#endregion
+exports.ExistsError = ExistsError;
+exports.ExistsErrorNotDirectory = ExistsErrorNotDirectory;
+exports.ExistsErrorNotFound = ExistsErrorNotFound;
+exports.ExistsErrorPermissionDenied = ExistsErrorPermissionDenied;
+exports.ExistsErrorTooManyOpenFiles = ExistsErrorTooManyOpenFiles;
+exports.exists = exists;

package/dist/file/exists.d.ts

@@ -0,0 +1,27 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+declare const ExistsErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-not-found", unknown>>, unknown>;
+export declare class ExistsErrorNotFound extends ExistsErrorNotFound_base {
+}
+declare const ExistsErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-permission-denied", unknown>>, unknown>;
+export declare class ExistsErrorPermissionDenied extends ExistsErrorPermissionDenied_base {
+}
+declare const ExistsErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-not-directory", unknown>>, unknown>;
+export declare class ExistsErrorNotDirectory extends ExistsErrorNotDirectory_base {
+}
+declare const ExistsErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-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-exists-too-many-open-files", unknown>>, unknown>;
+export declare class ExistsErrorTooManyOpenFiles extends ExistsErrorTooManyOpenFiles_base {
+}
+declare const ExistsError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-exists-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-exists-error", unknown>>, unknown>;
+export declare class ExistsError extends ExistsError_base {
+}
+export type ExistsErrors = (ExistsErrorNotFound | ExistsErrorPermissionDenied | ExistsErrorNotDirectory | ExistsErrorTooManyOpenFiles | ExistsError);
+export type ExistsResult = (DEither.Right<"file-system-exists", void> | DEither.Left<"file-system-exists-error", ExistsErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        exists(path: DPath.AnyPath): Promise<ExistsResult>;
+    }
+}
+export declare const exists: (path: DPath.AnyPath) => Promise<ExistsResult>;
+export {};

package/dist/file/exists.mjs

@@ -0,0 +1,35 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/exists.ts
+var ExistsErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-exists-not-found", Error) {};
+var ExistsErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-exists-permission-denied", Error) {};
+var ExistsErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-exists-not-directory", Error) {};
+var ExistsErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-exists-too-many-open-files", Error) {};
+var ExistsError = class extends DCommon.DuploJSError.parentClass("file-system-exists-error", Error) {};
+function handleNodeExistsError(error) {
+	let existsError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") existsError = new ExistsErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") existsError = new ExistsErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") existsError = new ExistsErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") existsError = new ExistsErrorTooManyOpenFiles(error);
+	}
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return DEither.left("file-system-exists-error", existsError);
+}
+function handleDenoExistsError(error) {
+	let existsError = void 0;
+	if (error instanceof Deno.errors.NotFound) existsError = new ExistsErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) existsError = new ExistsErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) existsError = new ExistsErrorNotDirectory(error);
+	if (existsError === void 0) existsError = new ExistsError(error);
+	return DEither.left("file-system-exists-error", existsError);
+}
+const exists = implementFunction("exists", {
+	NODE: async (path) => nodeFileSystem.value.access(path).then(() => DEither.right("file-system-exists")).catch(handleNodeExistsError),
+	DENO: (path) => Deno.stat(path).then(() => DEither.right("file-system-exists")).catch(handleDenoExistsError),
+	BUN: (path) => Bun.file(path).exists().then((value) => value ? DEither.right("file-system-exists") : DEither.left("file-system-exists-error", new ExistsErrorNotFound(/* @__PURE__ */ new Error("Path does not exist")))).catch(handleNodeExistsError)
+});
+//#endregion
+export { ExistsError, ExistsErrorNotDirectory, ExistsErrorNotFound, ExistsErrorPermissionDenied, ExistsErrorTooManyOpenFiles, exists };