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

package/dist/dataStructure/index.mjs

@@ -0,0 +1,51 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { createKind } from "./kind.mjs";
+import { TheFile, fileFundamentalTypeKind } from "./fundamentalType/file.mjs";
+import { TheFolder, folderFundamentalTypeKind } from "./fundamentalType/folder.mjs";
+import { codecsJson } from "./common/codec/defaults/json.mjs";
+import { codecsString } from "./common/codec/defaults/string.mjs";
+import { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary } from "./common/error/defaultInterpreter.mjs";
+import { FileExistConstraint, fileExistConstraintKind } from "./constraint/fileExist.mjs";
+import { FolderExistConstraint, folderExistConstraintKind } from "./constraint/folderExist.mjs";
+import { MimeTypeConstraint, mimeTypeConstraintKind } from "./constraint/mimeType.mjs";
+import { SizeConstraint, sizeConstraintKind } from "./constraint/size.mjs";
+import { fileExist } from "./helper/fileExist.mjs";
+import { FileType, fileTypeKind } from "./type/file.mjs";
+import { FolderType, folderTypeKind } from "./type/folder.mjs";
+import { file } from "./helper/file.mjs";
+import { folder } from "./helper/folder.mjs";
+import { folderExist } from "./helper/folderExist.mjs";
+import { mimeType } from "./helper/mimeType.mjs";
+import { size } from "./helper/size.mjs";
+//#region scripts/dataStructure/index.ts
+var dataStructure_exports = /* @__PURE__ */ __exportAll({
+	FileExistConstraint: () => FileExistConstraint,
+	FileType: () => FileType,
+	FolderExistConstraint: () => FolderExistConstraint,
+	FolderType: () => FolderType,
+	MimeTypeConstraint: () => MimeTypeConstraint,
+	SizeConstraint: () => SizeConstraint,
+	TheFile: () => TheFile,
+	TheFolder: () => TheFolder,
+	codecsJson: () => codecsJson,
+	codecsString: () => codecsString,
+	createKind: () => createKind,
+	defaultErrorInterpreterCodecDictionary: () => defaultErrorInterpreterCodecDictionary,
+	defaultErrorInterpreterDataStructureDictionary: () => defaultErrorInterpreterDataStructureDictionary,
+	file: () => file,
+	fileExist: () => fileExist,
+	fileExistConstraintKind: () => fileExistConstraintKind,
+	fileFundamentalTypeKind: () => fileFundamentalTypeKind,
+	fileTypeKind: () => fileTypeKind,
+	folder: () => folder,
+	folderExist: () => folderExist,
+	folderExistConstraintKind: () => folderExistConstraintKind,
+	folderFundamentalTypeKind: () => folderFundamentalTypeKind,
+	folderTypeKind: () => folderTypeKind,
+	mimeType: () => mimeType,
+	mimeTypeConstraintKind: () => mimeTypeConstraintKind,
+	size: () => size,
+	sizeConstraintKind: () => sizeConstraintKind
+});
+//#endregion
+export { FileExistConstraint, FileType, FolderExistConstraint, FolderType, MimeTypeConstraint, SizeConstraint, TheFile, TheFolder, codecsJson, codecsString, createKind, dataStructure_exports, defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary, file, fileExist, fileExistConstraintKind, fileFundamentalTypeKind, fileTypeKind, folder, folderExist, folderExistConstraintKind, folderFundamentalTypeKind, folderTypeKind, mimeType, mimeTypeConstraintKind, size, sizeConstraintKind };

package/dist/dataStructure/kind.cjs

@@ -0,0 +1,7 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let _duplojs_lang_kind = require("@duplojs/lang/kind");
+_duplojs_lang_kind = require_runtime.__toESM(_duplojs_lang_kind, 1);
+//#region scripts/dataStructure/kind.ts
+const createKind = _duplojs_lang_kind.createNamespace("DuplojsServerDataStructure");
+//#endregion
+exports.createKind = createKind;

package/dist/dataStructure/kind.d.ts

@@ -0,0 +1,2 @@
+import * as DKind from "@duplojs/lang/kind";
+export declare const createKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import('@duplojs/lang/string').ForbiddenContain<GenericName, DKind.ForbiddenKindNameCharacter>) => DKind.Handler<DKind.Definition<`@DuplojsServerDataStructure/${GenericName}`, GenericKindValue>>;

package/dist/dataStructure/kind.mjs

@@ -0,0 +1,5 @@
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/dataStructure/kind.ts
+const createKind = DKind.createNamespace("DuplojsServerDataStructure");
+//#endregion
+export { createKind };

package/dist/dataStructure/type/file.cjs

@@ -0,0 +1,14 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_file = require("../fundamentalType/file.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/type/file.ts
+const fileTypeKind = require_kind.createKind("file-type");
+const FileType = _duplojs_lang_dataStructure.createType(require_file.TheFile, fileTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => _duplojs_lang_dataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.FileType = FileType;
+exports.fileTypeKind = fileTypeKind;

package/dist/dataStructure/type/file.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+import * as FundamentalType from "../fundamentalType";
+export declare const fileTypeKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/file-type", unknown>>;
+export interface TimeTypeDefinition extends DDataStructure.TypeDefinition {
+}
+export interface FileType extends DCommon.UnionToIntersection<DDataStructure.Type<FundamentalType.TheFile, DSFile.FileInterface, TimeTypeDefinition> & DKind.Kind<typeof fileTypeKind>> {
+}
+export declare const FileType: () => FileType;

package/dist/dataStructure/type/file.mjs

@@ -0,0 +1,11 @@
+import { createKind } from "../kind.mjs";
+import { TheFile } from "../fundamentalType/file.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/type/file.ts
+const fileTypeKind = createKind("file-type");
+const FileType = DDataStructure.createType(TheFile, fileTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => DDataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { FileType, fileTypeKind };

package/dist/dataStructure/type/folder.cjs

@@ -0,0 +1,14 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_folder = require("../fundamentalType/folder.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/type/folder.ts
+const folderTypeKind = require_kind.createKind("folder-type");
+const FolderType = _duplojs_lang_dataStructure.createType(require_folder.TheFolder, folderTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => _duplojs_lang_dataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.FolderType = FolderType;
+exports.folderTypeKind = folderTypeKind;

package/dist/dataStructure/type/folder.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+import * as FundamentalType from "../fundamentalType";
+export declare const folderTypeKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/folder-type", unknown>>;
+export interface FolderTypeDefinition extends DDataStructure.TypeDefinition {
+}
+export interface FolderType extends DCommon.UnionToIntersection<DDataStructure.Type<FundamentalType.TheFolder, DSFile.FolderInterface, FolderTypeDefinition> & DKind.Kind<typeof folderTypeKind>> {
+}
+export declare const FolderType: () => FolderType;

package/dist/dataStructure/type/folder.mjs

@@ -0,0 +1,11 @@
+import { createKind } from "../kind.mjs";
+import { TheFolder } from "../fundamentalType/folder.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/type/folder.ts
+const folderTypeKind = createKind("folder-type");
+const FolderType = DDataStructure.createType(TheFolder, folderTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => DDataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { FolderType, folderTypeKind };

package/dist/dataStructure/type/index.d.ts

@@ -0,0 +1,3 @@
+export * from './file';
+export * from './folder';
+export type * from './types';

package/dist/dataStructure/type/types/index.d.ts

@@ -0,0 +1 @@
+export type * from './types';

package/dist/dataStructure/type/types/types.d.ts

@@ -0,0 +1,8 @@
+import { FileType } from '../file';
+import { FolderType } from '../folder';
+declare module "@duplojs/lang/dataStructure" {
+    interface TypesStore {
+        serverFile: FileType;
+        serverFolder: FolderType;
+    }
+}

package/dist/file/appendFile.cjs

@@ -0,0 +1,67 @@
+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/appendFile.ts
+var AppendFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-not-found", Error) {};
+var AppendFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-permission-denied", Error) {};
+var AppendFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-is-directory", Error) {};
+var AppendFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-not-directory", Error) {};
+var AppendFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-no-space", Error) {};
+var AppendFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-read-only", Error) {};
+var AppendFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-invalid-argument", Error) {};
+var AppendFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-too-many-open-files", Error) {};
+var AppendFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-busy", Error) {};
+var AppendFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-error", Error) {};
+function handleNodeAppendFileError(error) {
+	let appendFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") appendFileError = new AppendFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendFileError = new AppendFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendFileError = new AppendFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendFileError = new AppendFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendFileError = new AppendFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendFileError = new AppendFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendFileError = new AppendFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendFileError = new AppendFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendFileError = new AppendFileErrorBusy(error);
+		else appendFileError = new AppendFileError(error);
+	} else appendFileError = new AppendFileError(error);
+	return _duplojs_lang_either.left("file-system-append-file-error", appendFileError);
+}
+function handleDenoAppendFileError(error) {
+	let appendFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendFileError = new AppendFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendFileError = new AppendFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendFileError = new AppendFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendFileError = new AppendFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendFileError = new AppendFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendFileError = new AppendFileErrorBusy(error);
+	else appendFileError = new AppendFileError(error);
+	return _duplojs_lang_either.left("file-system-append-file-error", appendFileError);
+}
+const appendFileImplementation = require_implementor.implementFunction("appendFile", {
+	NODE: async (path, data) => require_implementor.nodeFileSystem.value.appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-file")).catch(handleNodeAppendFileError),
+	DENO: (path, data) => Deno.writeFile(path, data, { append: true }).then(() => _duplojs_lang_either.right("file-system-append-file")).catch(handleDenoAppendFileError)
+});
+function appendFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendFileImplementation(path, data);
+	}
+	return appendFileImplementation(...args);
+}
+//#endregion
+exports.AppendFileError = AppendFileError;
+exports.AppendFileErrorBusy = AppendFileErrorBusy;
+exports.AppendFileErrorInvalidArgument = AppendFileErrorInvalidArgument;
+exports.AppendFileErrorIsDirectory = AppendFileErrorIsDirectory;
+exports.AppendFileErrorNoSpace = AppendFileErrorNoSpace;
+exports.AppendFileErrorNotDirectory = AppendFileErrorNotDirectory;
+exports.AppendFileErrorNotFound = AppendFileErrorNotFound;
+exports.AppendFileErrorPermissionDenied = AppendFileErrorPermissionDenied;
+exports.AppendFileErrorReadOnly = AppendFileErrorReadOnly;
+exports.AppendFileErrorTooManyOpenFiles = AppendFileErrorTooManyOpenFiles;
+exports.appendFile = appendFile;

package/dist/file/appendFile.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 AppendFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-found", unknown>>, unknown>;
+export declare class AppendFileErrorNotFound extends AppendFileErrorNotFound_base {
+}
+declare const AppendFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-permission-denied", unknown>>, unknown>;
+export declare class AppendFileErrorPermissionDenied extends AppendFileErrorPermissionDenied_base {
+}
+declare const AppendFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-is-directory", unknown>>, unknown>;
+export declare class AppendFileErrorIsDirectory extends AppendFileErrorIsDirectory_base {
+}
+declare const AppendFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-directory", unknown>>, unknown>;
+export declare class AppendFileErrorNotDirectory extends AppendFileErrorNotDirectory_base {
+}
+declare const AppendFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-no-space", unknown>>, unknown>;
+export declare class AppendFileErrorNoSpace extends AppendFileErrorNoSpace_base {
+}
+declare const AppendFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-read-only", unknown>>, unknown>;
+export declare class AppendFileErrorReadOnly extends AppendFileErrorReadOnly_base {
+}
+declare const AppendFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-invalid-argument", unknown>>, unknown>;
+export declare class AppendFileErrorInvalidArgument extends AppendFileErrorInvalidArgument_base {
+}
+declare const AppendFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-file-too-many-open-files", unknown>>, unknown>;
+export declare class AppendFileErrorTooManyOpenFiles extends AppendFileErrorTooManyOpenFiles_base {
+}
+declare const AppendFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-busy", unknown>>, unknown>;
+export declare class AppendFileErrorBusy extends AppendFileErrorBusy_base {
+}
+declare const AppendFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-error", unknown>>, unknown>;
+export declare class AppendFileError extends AppendFileError_base {
+}
+export type AppendFileErrors = (AppendFileErrorNotFound | AppendFileErrorPermissionDenied | AppendFileErrorIsDirectory | AppendFileErrorNotDirectory | AppendFileErrorNoSpace | AppendFileErrorReadOnly | AppendFileErrorInvalidArgument | AppendFileErrorTooManyOpenFiles | AppendFileErrorBusy | AppendFileError);
+export type AppendFileResult = (DEither.Right<"file-system-append-file", void> | DEither.Left<"file-system-append-file-error", AppendFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        appendFile(path: DPath.AnyPath, data: Uint8Array): Promise<AppendFileResult>;
+    }
+}
+export declare function appendFile(data: Uint8Array): (path: DPath.AnyPath) => Promise<AppendFileResult>;
+export declare function appendFile(path: DPath.AnyPath, data: Uint8Array): Promise<AppendFileResult>;
+export {};

package/dist/file/appendFile.mjs

@@ -0,0 +1,54 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/appendFile.ts
+var AppendFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-append-file-not-found", Error) {};
+var AppendFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-append-file-permission-denied", Error) {};
+var AppendFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-file-is-directory", Error) {};
+var AppendFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-file-not-directory", Error) {};
+var AppendFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-append-file-no-space", Error) {};
+var AppendFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-append-file-read-only", Error) {};
+var AppendFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-append-file-invalid-argument", Error) {};
+var AppendFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-append-file-too-many-open-files", Error) {};
+var AppendFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-append-file-busy", Error) {};
+var AppendFileError = class extends DCommon.DuploJSError.parentClass("file-system-append-file-error", Error) {};
+function handleNodeAppendFileError(error) {
+	let appendFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") appendFileError = new AppendFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendFileError = new AppendFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendFileError = new AppendFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendFileError = new AppendFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendFileError = new AppendFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendFileError = new AppendFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendFileError = new AppendFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendFileError = new AppendFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendFileError = new AppendFileErrorBusy(error);
+		else appendFileError = new AppendFileError(error);
+	} else appendFileError = new AppendFileError(error);
+	return DEither.left("file-system-append-file-error", appendFileError);
+}
+function handleDenoAppendFileError(error) {
+	let appendFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendFileError = new AppendFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendFileError = new AppendFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendFileError = new AppendFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendFileError = new AppendFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendFileError = new AppendFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendFileError = new AppendFileErrorBusy(error);
+	else appendFileError = new AppendFileError(error);
+	return DEither.left("file-system-append-file-error", appendFileError);
+}
+const appendFileImplementation = implementFunction("appendFile", {
+	NODE: async (path, data) => nodeFileSystem.value.appendFile(path, data).then(() => DEither.right("file-system-append-file")).catch(handleNodeAppendFileError),
+	DENO: (path, data) => Deno.writeFile(path, data, { append: true }).then(() => DEither.right("file-system-append-file")).catch(handleDenoAppendFileError)
+});
+function appendFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendFileImplementation(path, data);
+	}
+	return appendFileImplementation(...args);
+}
+//#endregion
+export { AppendFileError, AppendFileErrorBusy, AppendFileErrorInvalidArgument, AppendFileErrorIsDirectory, AppendFileErrorNoSpace, AppendFileErrorNotDirectory, AppendFileErrorNotFound, AppendFileErrorPermissionDenied, AppendFileErrorReadOnly, AppendFileErrorTooManyOpenFiles, appendFile };

package/dist/file/appendTextFile.cjs

@@ -0,0 +1,67 @@
+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/appendTextFile.ts
+var AppendTextFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-not-found", Error) {};
+var AppendTextFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-permission-denied", Error) {};
+var AppendTextFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-is-directory", Error) {};
+var AppendTextFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-not-directory", Error) {};
+var AppendTextFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-no-space", Error) {};
+var AppendTextFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-read-only", Error) {};
+var AppendTextFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-invalid-argument", Error) {};
+var AppendTextFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-too-many-open-files", Error) {};
+var AppendTextFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-busy", Error) {};
+var AppendTextFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-error", Error) {};
+function handleNodeAppendTextFileError(error) {
+	let appendTextFileError = void 0;
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") appendTextFileError = new AppendTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendTextFileError = new AppendTextFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendTextFileError = new AppendTextFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendTextFileError = new AppendTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendTextFileError = new AppendTextFileErrorBusy(error);
+	}
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return _duplojs_lang_either.left("file-system-append-text-file-error", appendTextFileError);
+}
+function handleDenoAppendTextFileError(error) {
+	let appendTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendTextFileError = new AppendTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendTextFileError = new AppendTextFileErrorBusy(error);
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return _duplojs_lang_either.left("file-system-append-text-file-error", appendTextFileError);
+}
+const appendTextFileImplementation = require_implementor.implementFunction("appendTextFile", {
+	NODE: async (path, data) => require_implementor.nodeFileSystem.value.appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError),
+	DENO: (path, data) => Deno.writeTextFile(path, data, { append: true }).then(() => _duplojs_lang_either.right("file-system-append-text-file")).catch(handleDenoAppendTextFileError)
+});
+function appendTextFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendTextFileImplementation(path, data);
+	}
+	return appendTextFileImplementation(...args);
+}
+//#endregion
+exports.AppendTextFileError = AppendTextFileError;
+exports.AppendTextFileErrorBusy = AppendTextFileErrorBusy;
+exports.AppendTextFileErrorInvalidArgument = AppendTextFileErrorInvalidArgument;
+exports.AppendTextFileErrorIsDirectory = AppendTextFileErrorIsDirectory;
+exports.AppendTextFileErrorNoSpace = AppendTextFileErrorNoSpace;
+exports.AppendTextFileErrorNotDirectory = AppendTextFileErrorNotDirectory;
+exports.AppendTextFileErrorNotFound = AppendTextFileErrorNotFound;
+exports.AppendTextFileErrorPermissionDenied = AppendTextFileErrorPermissionDenied;
+exports.AppendTextFileErrorReadOnly = AppendTextFileErrorReadOnly;
+exports.AppendTextFileErrorTooManyOpenFiles = AppendTextFileErrorTooManyOpenFiles;
+exports.appendTextFile = appendTextFile;

package/dist/file/appendTextFile.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 AppendTextFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-not-found", unknown>>, unknown>;
+export declare class AppendTextFileErrorNotFound extends AppendTextFileErrorNotFound_base {
+}
+declare const AppendTextFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-permission-denied", unknown>>, unknown>;
+export declare class AppendTextFileErrorPermissionDenied extends AppendTextFileErrorPermissionDenied_base {
+}
+declare const AppendTextFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-is-directory", unknown>>, unknown>;
+export declare class AppendTextFileErrorIsDirectory extends AppendTextFileErrorIsDirectory_base {
+}
+declare const AppendTextFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-not-directory", unknown>>, unknown>;
+export declare class AppendTextFileErrorNotDirectory extends AppendTextFileErrorNotDirectory_base {
+}
+declare const AppendTextFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-no-space", unknown>>, unknown>;
+export declare class AppendTextFileErrorNoSpace extends AppendTextFileErrorNoSpace_base {
+}
+declare const AppendTextFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-read-only", unknown>>, unknown>;
+export declare class AppendTextFileErrorReadOnly extends AppendTextFileErrorReadOnly_base {
+}
+declare const AppendTextFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-invalid-argument", unknown>>, unknown>;
+export declare class AppendTextFileErrorInvalidArgument extends AppendTextFileErrorInvalidArgument_base {
+}
+declare const AppendTextFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-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-append-text-file-too-many-open-files", unknown>>, unknown>;
+export declare class AppendTextFileErrorTooManyOpenFiles extends AppendTextFileErrorTooManyOpenFiles_base {
+}
+declare const AppendTextFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-busy", unknown>>, unknown>;
+export declare class AppendTextFileErrorBusy extends AppendTextFileErrorBusy_base {
+}
+declare const AppendTextFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-error", unknown>>, unknown>;
+export declare class AppendTextFileError extends AppendTextFileError_base {
+}
+export type AppendTextFileErrors = (AppendTextFileErrorNotFound | AppendTextFileErrorPermissionDenied | AppendTextFileErrorIsDirectory | AppendTextFileErrorNotDirectory | AppendTextFileErrorNoSpace | AppendTextFileErrorReadOnly | AppendTextFileErrorInvalidArgument | AppendTextFileErrorTooManyOpenFiles | AppendTextFileErrorBusy | AppendTextFileError);
+export type AppendTextFileResult = (DEither.Right<"file-system-append-text-file", void> | DEither.Left<"file-system-append-text-file-error", AppendTextFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        appendTextFile(path: DPath.AnyPath, data: string): Promise<AppendTextFileResult>;
+    }
+}
+export declare function appendTextFile(data: string): (path: DPath.AnyPath) => Promise<AppendTextFileResult>;
+export declare function appendTextFile(path: DPath.AnyPath, data: string): Promise<AppendTextFileResult>;
+export {};

package/dist/file/appendTextFile.mjs

@@ -0,0 +1,54 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/appendTextFile.ts
+var AppendTextFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-not-found", Error) {};
+var AppendTextFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-permission-denied", Error) {};
+var AppendTextFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-is-directory", Error) {};
+var AppendTextFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-not-directory", Error) {};
+var AppendTextFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-no-space", Error) {};
+var AppendTextFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-read-only", Error) {};
+var AppendTextFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-invalid-argument", Error) {};
+var AppendTextFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-too-many-open-files", Error) {};
+var AppendTextFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-busy", Error) {};
+var AppendTextFileError = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-error", Error) {};
+function handleNodeAppendTextFileError(error) {
+	let appendTextFileError = void 0;
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") appendTextFileError = new AppendTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendTextFileError = new AppendTextFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendTextFileError = new AppendTextFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendTextFileError = new AppendTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendTextFileError = new AppendTextFileErrorBusy(error);
+	}
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return DEither.left("file-system-append-text-file-error", appendTextFileError);
+}
+function handleDenoAppendTextFileError(error) {
+	let appendTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendTextFileError = new AppendTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendTextFileError = new AppendTextFileErrorBusy(error);
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return DEither.left("file-system-append-text-file-error", appendTextFileError);
+}
+const appendTextFileImplementation = implementFunction("appendTextFile", {
+	NODE: async (path, data) => nodeFileSystem.value.appendFile(path, data).then(() => DEither.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError),
+	DENO: (path, data) => Deno.writeTextFile(path, data, { append: true }).then(() => DEither.right("file-system-append-text-file")).catch(handleDenoAppendTextFileError)
+});
+function appendTextFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendTextFileImplementation(path, data);
+	}
+	return appendTextFileImplementation(...args);
+}
+//#endregion
+export { AppendTextFileError, AppendTextFileErrorBusy, AppendTextFileErrorInvalidArgument, AppendTextFileErrorIsDirectory, AppendTextFileErrorNoSpace, AppendTextFileErrorNotDirectory, AppendTextFileErrorNotFound, AppendTextFileErrorPermissionDenied, AppendTextFileErrorReadOnly, AppendTextFileErrorTooManyOpenFiles, appendTextFile };

package/dist/file/copy.cjs

@@ -0,0 +1,53 @@
+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/copy.ts
+var CopyErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-not-found", Error) {};
+var CopyErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-permission-denied", Error) {};
+var CopyErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-already-exists", Error) {};
+var CopyErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-not-directory", Error) {};
+var CopyErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-no-space", Error) {};
+var CopyErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-read-only", Error) {};
+var CopyErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-invalid-argument", Error) {};
+var CopyErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-too-many-open-files", Error) {};
+var CopyErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-busy", Error) {};
+var CopyError = class extends _duplojs_lang_common.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 _duplojs_lang_either.left("file-system-copy-error", copyError);
+}
+const copyImplementation = require_implementor.implementFunction("copy", { NODE: async (fromPath, toPath) => require_implementor.nodeFileSystem.value.cp(fromPath, toPath, { recursive: true }).then(() => _duplojs_lang_either.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
+exports.CopyError = CopyError;
+exports.CopyErrorAlreadyExists = CopyErrorAlreadyExists;
+exports.CopyErrorBusy = CopyErrorBusy;
+exports.CopyErrorInvalidArgument = CopyErrorInvalidArgument;
+exports.CopyErrorNoSpace = CopyErrorNoSpace;
+exports.CopyErrorNotDirectory = CopyErrorNotDirectory;
+exports.CopyErrorNotFound = CopyErrorNotFound;
+exports.CopyErrorPermissionDenied = CopyErrorPermissionDenied;
+exports.CopyErrorReadOnly = CopyErrorReadOnly;
+exports.CopyErrorTooManyOpenFiles = CopyErrorTooManyOpenFiles;
+exports.copy = copy;