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

package/dist/file/index.d.ts

@@ -0,0 +1,35 @@
+export * from './appendFile';
+export * from './appendTextFile';
+export * from './copy';
+export * from './createEntryInterface';
+export * from './ensureDirectory';
+export * from './ensureFile';
+export * from './exists';
+export * from './fileInterface';
+export * from './folderInterface';
+export * from './link';
+export * from './linkStat';
+export * from './makeDirectory';
+export * from './makeTemporaryDirectory';
+export * from './makeTemporaryFile';
+export * from './move';
+export * from './readDirectory';
+export * from './readFile';
+export * from './readJsonFile';
+export * from './readLink';
+export * from './readTextFile';
+export * from './realPath';
+export * from './relocate';
+export * from './remove';
+export * from './rename';
+export * from './setMode';
+export * from './setOwner';
+export * from './setTime';
+export * from './stat';
+export * from './symlink';
+export * from './truncate';
+export * from './unknownEntryInterface';
+export * from './walkDirectory';
+export * from './writeFile';
+export * from './writeJsonFile';
+export * from './writeTextFile';

package/dist/file/index.mjs

@@ -0,0 +1,335 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { AppendFileError, AppendFileErrorBusy, AppendFileErrorInvalidArgument, AppendFileErrorIsDirectory, AppendFileErrorNoSpace, AppendFileErrorNotDirectory, AppendFileErrorNotFound, AppendFileErrorPermissionDenied, AppendFileErrorReadOnly, AppendFileErrorTooManyOpenFiles, appendFile } from "./appendFile.mjs";
+import { AppendTextFileError, AppendTextFileErrorBusy, AppendTextFileErrorInvalidArgument, AppendTextFileErrorIsDirectory, AppendTextFileErrorNoSpace, AppendTextFileErrorNotDirectory, AppendTextFileErrorNotFound, AppendTextFileErrorPermissionDenied, AppendTextFileErrorReadOnly, AppendTextFileErrorTooManyOpenFiles, appendTextFile } from "./appendTextFile.mjs";
+import { CopyError, CopyErrorAlreadyExists, CopyErrorBusy, CopyErrorInvalidArgument, CopyErrorNoSpace, CopyErrorNotDirectory, CopyErrorNotFound, CopyErrorPermissionDenied, CopyErrorReadOnly, CopyErrorTooManyOpenFiles, copy } from "./copy.mjs";
+import { StatError, StatErrorBusy, StatErrorNotDirectory, StatErrorNotFound, StatErrorPermissionDenied, StatErrorTooManyOpenFiles, stat } from "./stat.mjs";
+import { RenameError, RenameErrorAlreadyExists, RenameErrorBusy, RenameErrorCrossDevice, RenameErrorDirectoryNotEmpty, RenameErrorInvalidArgument, RenameErrorIsDirectory, RenameErrorNotDirectory, RenameErrorNotFound, RenameErrorPermissionDenied, RenameErrorReadOnly, rename } from "./rename.mjs";
+import { ExistsError, ExistsErrorNotDirectory, ExistsErrorNotFound, ExistsErrorPermissionDenied, ExistsErrorTooManyOpenFiles, exists } from "./exists.mjs";
+import { MoveError, MoveErrorAlreadyExists, MoveErrorBusy, MoveErrorCrossDevice, MoveErrorDirectoryNotEmpty, MoveErrorInvalidArgument, MoveErrorIsDirectory, MoveErrorNotDirectory, MoveErrorNotFound, MoveErrorPermissionDenied, MoveErrorReadOnly, move } from "./move.mjs";
+import { RemoveError, RemoveErrorBusy, RemoveErrorDirectoryNotEmpty, RemoveErrorInvalidArgument, RemoveErrorIsDirectory, RemoveErrorNotDirectory, RemoveErrorNotFound, RemoveErrorPermissionDenied, RemoveErrorReadOnly, remove } from "./remove.mjs";
+import { RelocateError, RelocateErrorAlreadyExists, RelocateErrorBusy, RelocateErrorCrossDevice, RelocateErrorDirectoryNotEmpty, RelocateErrorInvalidArgument, RelocateErrorIsDirectory, RelocateErrorNotDirectory, RelocateErrorNotFound, RelocateErrorPermissionDenied, RelocateErrorReadOnly, relocate } from "./relocate.mjs";
+import { createFileInterface, isFileInterface, isFileInterfaceFromUnknown } from "./fileInterface.mjs";
+import { ReadDirectoryError, ReadDirectoryErrorBusy, ReadDirectoryErrorNotDirectory, ReadDirectoryErrorNotFound, ReadDirectoryErrorPermissionDenied, ReadDirectoryErrorTooManyOpenFiles, readDirectory } from "./readDirectory.mjs";
+import { createUnknownEntryInterface, isUnknownEntryInterface, isUnknownEntryInterfaceFromUnknown } from "./unknownEntryInterface.mjs";
+import { WalkDirectoryError, WalkDirectoryErrorBusy, WalkDirectoryErrorNotDirectory, WalkDirectoryErrorNotFound, WalkDirectoryErrorPermissionDenied, WalkDirectoryErrorTooManyOpenFiles, walkDirectory } from "./walkDirectory.mjs";
+import { createFolderInterface, isFolderInterface, isFolderInterfaceFromUnknown } from "./folderInterface.mjs";
+import { createEntryInterface } from "./createEntryInterface.mjs";
+import { EnsureDirectoryError, EnsureDirectoryErrorBusy, EnsureDirectoryErrorInvalidArgument, EnsureDirectoryErrorNoSpace, EnsureDirectoryErrorNotDirectory, EnsureDirectoryErrorPermissionDenied, EnsureDirectoryErrorReadOnly, EnsureDirectoryErrorTooManyOpenFiles, ensureDirectory } from "./ensureDirectory.mjs";
+import { EnsureFileError, EnsureFileErrorBusy, EnsureFileErrorInvalidArgument, EnsureFileErrorIsDirectory, EnsureFileErrorNoSpace, EnsureFileErrorNotDirectory, EnsureFileErrorPermissionDenied, EnsureFileErrorReadOnly, EnsureFileErrorTooManyOpenFiles, ensureFile } from "./ensureFile.mjs";
+import { LinkError, LinkErrorAlreadyExists, LinkErrorBusy, LinkErrorCrossDevice, LinkErrorInvalidArgument, LinkErrorNoSpace, LinkErrorNotDirectory, LinkErrorNotFound, LinkErrorPermissionDenied, LinkErrorReadOnly, LinkErrorTooManyOpenFiles, link } from "./link.mjs";
+import { LinkStatError, LinkStatErrorBusy, LinkStatErrorNotDirectory, LinkStatErrorNotFound, LinkStatErrorPermissionDenied, LinkStatErrorTooManyOpenFiles, linkStat } from "./linkStat.mjs";
+import { MakeDirectoryError, MakeDirectoryErrorAlreadyExists, MakeDirectoryErrorBusy, MakeDirectoryErrorInvalidArgument, MakeDirectoryErrorNoSpace, MakeDirectoryErrorNotDirectory, MakeDirectoryErrorNotFound, MakeDirectoryErrorPermissionDenied, MakeDirectoryErrorReadOnly, MakeDirectoryErrorTooManyOpenFiles, makeDirectory } from "./makeDirectory.mjs";
+import { MakeTemporaryDirectoryError, MakeTemporaryDirectoryErrorInvalidArgument, MakeTemporaryDirectoryErrorNoSpace, MakeTemporaryDirectoryErrorNotDirectory, MakeTemporaryDirectoryErrorPermissionDenied, MakeTemporaryDirectoryErrorReadOnly, MakeTemporaryDirectoryErrorTooManyOpenFiles, makeTemporaryDirectory } from "./makeTemporaryDirectory.mjs";
+import { MakeTemporaryFileError, MakeTemporaryFileErrorAlreadyExists, MakeTemporaryFileErrorInvalidArgument, MakeTemporaryFileErrorNoSpace, MakeTemporaryFileErrorNotDirectory, MakeTemporaryFileErrorPermissionDenied, MakeTemporaryFileErrorReadOnly, MakeTemporaryFileErrorTooManyOpenFiles, makeTemporaryFile } from "./makeTemporaryFile.mjs";
+import { ReadFileError, ReadFileErrorBusy, ReadFileErrorIsDirectory, ReadFileErrorNotDirectory, ReadFileErrorNotFound, ReadFileErrorPermissionDenied, ReadFileErrorTooManyOpenFiles, readFile } from "./readFile.mjs";
+import { ReadJsonFileError, ReadJsonFileErrorBusy, ReadJsonFileErrorIsDirectory, ReadJsonFileErrorNotDirectory, ReadJsonFileErrorNotFound, ReadJsonFileErrorPermissionDenied, ReadJsonFileErrorTooManyOpenFiles, readJsonFile } from "./readJsonFile.mjs";
+import { ReadLinkError, ReadLinkErrorInvalidArgument, ReadLinkErrorNotDirectory, ReadLinkErrorNotFound, ReadLinkErrorPermissionDenied, ReadLinkErrorTooManyOpenFiles, readLink } from "./readLink.mjs";
+import { ReadTextFileError, ReadTextFileErrorBusy, ReadTextFileErrorIsDirectory, ReadTextFileErrorNotDirectory, ReadTextFileErrorNotFound, ReadTextFileErrorPermissionDenied, ReadTextFileErrorTooManyOpenFiles, readTextFile } from "./readTextFile.mjs";
+import { RealPathError, RealPathErrorNotDirectory, RealPathErrorNotFound, RealPathErrorPermissionDenied, RealPathErrorTooManyOpenFiles, realPath } from "./realPath.mjs";
+import { SetModeError, SetModeErrorInvalidArgument, SetModeErrorNotDirectory, SetModeErrorNotFound, SetModeErrorPermissionDenied, SetModeErrorReadOnly, setMode } from "./setMode.mjs";
+import { SetOwnerError, SetOwnerErrorInvalidArgument, SetOwnerErrorNotDirectory, SetOwnerErrorNotFound, SetOwnerErrorPermissionDenied, SetOwnerErrorReadOnly, setOwner } from "./setOwner.mjs";
+import { SetTimeError, SetTimeErrorInvalidArgument, SetTimeErrorNotDirectory, SetTimeErrorNotFound, SetTimeErrorPermissionDenied, SetTimeErrorReadOnly, setTime } from "./setTime.mjs";
+import { SymlinkError, SymlinkErrorAlreadyExists, SymlinkErrorBusy, SymlinkErrorInvalidArgument, SymlinkErrorNotDirectory, SymlinkErrorNotFound, SymlinkErrorPermissionDenied, SymlinkErrorReadOnly, SymlinkErrorTooManyOpenFiles, symlink } from "./symlink.mjs";
+import { TruncateError, TruncateErrorBusy, TruncateErrorInvalidArgument, TruncateErrorIsDirectory, TruncateErrorNoSpace, TruncateErrorNotDirectory, TruncateErrorNotFound, TruncateErrorPermissionDenied, TruncateErrorReadOnly, TruncateErrorTooManyOpenFiles, truncate } from "./truncate.mjs";
+import { WriteFileError, WriteFileErrorBusy, WriteFileErrorInvalidArgument, WriteFileErrorIsDirectory, WriteFileErrorNoSpace, WriteFileErrorNotDirectory, WriteFileErrorNotFound, WriteFileErrorPermissionDenied, WriteFileErrorReadOnly, WriteFileErrorTooManyOpenFiles, writeFile } from "./writeFile.mjs";
+import { WriteJsonFileError, WriteJsonFileErrorBusy, WriteJsonFileErrorInvalidArgument, WriteJsonFileErrorIsDirectory, WriteJsonFileErrorNoSpace, WriteJsonFileErrorNotDirectory, WriteJsonFileErrorNotFound, WriteJsonFileErrorPermissionDenied, WriteJsonFileErrorReadOnly, WriteJsonFileErrorTooManyOpenFiles, writeJsonFile } from "./writeJsonFile.mjs";
+import { WriteTextFileError, WriteTextFileErrorBusy, WriteTextFileErrorInvalidArgument, WriteTextFileErrorIsDirectory, WriteTextFileErrorNoSpace, WriteTextFileErrorNotDirectory, WriteTextFileErrorNotFound, WriteTextFileErrorPermissionDenied, WriteTextFileErrorReadOnly, WriteTextFileErrorTooManyOpenFiles, writeTextFile } from "./writeTextFile.mjs";
+//#region scripts/file/index.ts
+var file_exports = /* @__PURE__ */ __exportAll({
+	AppendFileError: () => AppendFileError,
+	AppendFileErrorBusy: () => AppendFileErrorBusy,
+	AppendFileErrorInvalidArgument: () => AppendFileErrorInvalidArgument,
+	AppendFileErrorIsDirectory: () => AppendFileErrorIsDirectory,
+	AppendFileErrorNoSpace: () => AppendFileErrorNoSpace,
+	AppendFileErrorNotDirectory: () => AppendFileErrorNotDirectory,
+	AppendFileErrorNotFound: () => AppendFileErrorNotFound,
+	AppendFileErrorPermissionDenied: () => AppendFileErrorPermissionDenied,
+	AppendFileErrorReadOnly: () => AppendFileErrorReadOnly,
+	AppendFileErrorTooManyOpenFiles: () => AppendFileErrorTooManyOpenFiles,
+	AppendTextFileError: () => AppendTextFileError,
+	AppendTextFileErrorBusy: () => AppendTextFileErrorBusy,
+	AppendTextFileErrorInvalidArgument: () => AppendTextFileErrorInvalidArgument,
+	AppendTextFileErrorIsDirectory: () => AppendTextFileErrorIsDirectory,
+	AppendTextFileErrorNoSpace: () => AppendTextFileErrorNoSpace,
+	AppendTextFileErrorNotDirectory: () => AppendTextFileErrorNotDirectory,
+	AppendTextFileErrorNotFound: () => AppendTextFileErrorNotFound,
+	AppendTextFileErrorPermissionDenied: () => AppendTextFileErrorPermissionDenied,
+	AppendTextFileErrorReadOnly: () => AppendTextFileErrorReadOnly,
+	AppendTextFileErrorTooManyOpenFiles: () => AppendTextFileErrorTooManyOpenFiles,
+	CopyError: () => CopyError,
+	CopyErrorAlreadyExists: () => CopyErrorAlreadyExists,
+	CopyErrorBusy: () => CopyErrorBusy,
+	CopyErrorInvalidArgument: () => CopyErrorInvalidArgument,
+	CopyErrorNoSpace: () => CopyErrorNoSpace,
+	CopyErrorNotDirectory: () => CopyErrorNotDirectory,
+	CopyErrorNotFound: () => CopyErrorNotFound,
+	CopyErrorPermissionDenied: () => CopyErrorPermissionDenied,
+	CopyErrorReadOnly: () => CopyErrorReadOnly,
+	CopyErrorTooManyOpenFiles: () => CopyErrorTooManyOpenFiles,
+	EnsureDirectoryError: () => EnsureDirectoryError,
+	EnsureDirectoryErrorBusy: () => EnsureDirectoryErrorBusy,
+	EnsureDirectoryErrorInvalidArgument: () => EnsureDirectoryErrorInvalidArgument,
+	EnsureDirectoryErrorNoSpace: () => EnsureDirectoryErrorNoSpace,
+	EnsureDirectoryErrorNotDirectory: () => EnsureDirectoryErrorNotDirectory,
+	EnsureDirectoryErrorPermissionDenied: () => EnsureDirectoryErrorPermissionDenied,
+	EnsureDirectoryErrorReadOnly: () => EnsureDirectoryErrorReadOnly,
+	EnsureDirectoryErrorTooManyOpenFiles: () => EnsureDirectoryErrorTooManyOpenFiles,
+	EnsureFileError: () => EnsureFileError,
+	EnsureFileErrorBusy: () => EnsureFileErrorBusy,
+	EnsureFileErrorInvalidArgument: () => EnsureFileErrorInvalidArgument,
+	EnsureFileErrorIsDirectory: () => EnsureFileErrorIsDirectory,
+	EnsureFileErrorNoSpace: () => EnsureFileErrorNoSpace,
+	EnsureFileErrorNotDirectory: () => EnsureFileErrorNotDirectory,
+	EnsureFileErrorPermissionDenied: () => EnsureFileErrorPermissionDenied,
+	EnsureFileErrorReadOnly: () => EnsureFileErrorReadOnly,
+	EnsureFileErrorTooManyOpenFiles: () => EnsureFileErrorTooManyOpenFiles,
+	ExistsError: () => ExistsError,
+	ExistsErrorNotDirectory: () => ExistsErrorNotDirectory,
+	ExistsErrorNotFound: () => ExistsErrorNotFound,
+	ExistsErrorPermissionDenied: () => ExistsErrorPermissionDenied,
+	ExistsErrorTooManyOpenFiles: () => ExistsErrorTooManyOpenFiles,
+	LinkError: () => LinkError,
+	LinkErrorAlreadyExists: () => LinkErrorAlreadyExists,
+	LinkErrorBusy: () => LinkErrorBusy,
+	LinkErrorCrossDevice: () => LinkErrorCrossDevice,
+	LinkErrorInvalidArgument: () => LinkErrorInvalidArgument,
+	LinkErrorNoSpace: () => LinkErrorNoSpace,
+	LinkErrorNotDirectory: () => LinkErrorNotDirectory,
+	LinkErrorNotFound: () => LinkErrorNotFound,
+	LinkErrorPermissionDenied: () => LinkErrorPermissionDenied,
+	LinkErrorReadOnly: () => LinkErrorReadOnly,
+	LinkErrorTooManyOpenFiles: () => LinkErrorTooManyOpenFiles,
+	LinkStatError: () => LinkStatError,
+	LinkStatErrorBusy: () => LinkStatErrorBusy,
+	LinkStatErrorNotDirectory: () => LinkStatErrorNotDirectory,
+	LinkStatErrorNotFound: () => LinkStatErrorNotFound,
+	LinkStatErrorPermissionDenied: () => LinkStatErrorPermissionDenied,
+	LinkStatErrorTooManyOpenFiles: () => LinkStatErrorTooManyOpenFiles,
+	MakeDirectoryError: () => MakeDirectoryError,
+	MakeDirectoryErrorAlreadyExists: () => MakeDirectoryErrorAlreadyExists,
+	MakeDirectoryErrorBusy: () => MakeDirectoryErrorBusy,
+	MakeDirectoryErrorInvalidArgument: () => MakeDirectoryErrorInvalidArgument,
+	MakeDirectoryErrorNoSpace: () => MakeDirectoryErrorNoSpace,
+	MakeDirectoryErrorNotDirectory: () => MakeDirectoryErrorNotDirectory,
+	MakeDirectoryErrorNotFound: () => MakeDirectoryErrorNotFound,
+	MakeDirectoryErrorPermissionDenied: () => MakeDirectoryErrorPermissionDenied,
+	MakeDirectoryErrorReadOnly: () => MakeDirectoryErrorReadOnly,
+	MakeDirectoryErrorTooManyOpenFiles: () => MakeDirectoryErrorTooManyOpenFiles,
+	MakeTemporaryDirectoryError: () => MakeTemporaryDirectoryError,
+	MakeTemporaryDirectoryErrorInvalidArgument: () => MakeTemporaryDirectoryErrorInvalidArgument,
+	MakeTemporaryDirectoryErrorNoSpace: () => MakeTemporaryDirectoryErrorNoSpace,
+	MakeTemporaryDirectoryErrorNotDirectory: () => MakeTemporaryDirectoryErrorNotDirectory,
+	MakeTemporaryDirectoryErrorPermissionDenied: () => MakeTemporaryDirectoryErrorPermissionDenied,
+	MakeTemporaryDirectoryErrorReadOnly: () => MakeTemporaryDirectoryErrorReadOnly,
+	MakeTemporaryDirectoryErrorTooManyOpenFiles: () => MakeTemporaryDirectoryErrorTooManyOpenFiles,
+	MakeTemporaryFileError: () => MakeTemporaryFileError,
+	MakeTemporaryFileErrorAlreadyExists: () => MakeTemporaryFileErrorAlreadyExists,
+	MakeTemporaryFileErrorInvalidArgument: () => MakeTemporaryFileErrorInvalidArgument,
+	MakeTemporaryFileErrorNoSpace: () => MakeTemporaryFileErrorNoSpace,
+	MakeTemporaryFileErrorNotDirectory: () => MakeTemporaryFileErrorNotDirectory,
+	MakeTemporaryFileErrorPermissionDenied: () => MakeTemporaryFileErrorPermissionDenied,
+	MakeTemporaryFileErrorReadOnly: () => MakeTemporaryFileErrorReadOnly,
+	MakeTemporaryFileErrorTooManyOpenFiles: () => MakeTemporaryFileErrorTooManyOpenFiles,
+	MoveError: () => MoveError,
+	MoveErrorAlreadyExists: () => MoveErrorAlreadyExists,
+	MoveErrorBusy: () => MoveErrorBusy,
+	MoveErrorCrossDevice: () => MoveErrorCrossDevice,
+	MoveErrorDirectoryNotEmpty: () => MoveErrorDirectoryNotEmpty,
+	MoveErrorInvalidArgument: () => MoveErrorInvalidArgument,
+	MoveErrorIsDirectory: () => MoveErrorIsDirectory,
+	MoveErrorNotDirectory: () => MoveErrorNotDirectory,
+	MoveErrorNotFound: () => MoveErrorNotFound,
+	MoveErrorPermissionDenied: () => MoveErrorPermissionDenied,
+	MoveErrorReadOnly: () => MoveErrorReadOnly,
+	ReadDirectoryError: () => ReadDirectoryError,
+	ReadDirectoryErrorBusy: () => ReadDirectoryErrorBusy,
+	ReadDirectoryErrorNotDirectory: () => ReadDirectoryErrorNotDirectory,
+	ReadDirectoryErrorNotFound: () => ReadDirectoryErrorNotFound,
+	ReadDirectoryErrorPermissionDenied: () => ReadDirectoryErrorPermissionDenied,
+	ReadDirectoryErrorTooManyOpenFiles: () => ReadDirectoryErrorTooManyOpenFiles,
+	ReadFileError: () => ReadFileError,
+	ReadFileErrorBusy: () => ReadFileErrorBusy,
+	ReadFileErrorIsDirectory: () => ReadFileErrorIsDirectory,
+	ReadFileErrorNotDirectory: () => ReadFileErrorNotDirectory,
+	ReadFileErrorNotFound: () => ReadFileErrorNotFound,
+	ReadFileErrorPermissionDenied: () => ReadFileErrorPermissionDenied,
+	ReadFileErrorTooManyOpenFiles: () => ReadFileErrorTooManyOpenFiles,
+	ReadJsonFileError: () => ReadJsonFileError,
+	ReadJsonFileErrorBusy: () => ReadJsonFileErrorBusy,
+	ReadJsonFileErrorIsDirectory: () => ReadJsonFileErrorIsDirectory,
+	ReadJsonFileErrorNotDirectory: () => ReadJsonFileErrorNotDirectory,
+	ReadJsonFileErrorNotFound: () => ReadJsonFileErrorNotFound,
+	ReadJsonFileErrorPermissionDenied: () => ReadJsonFileErrorPermissionDenied,
+	ReadJsonFileErrorTooManyOpenFiles: () => ReadJsonFileErrorTooManyOpenFiles,
+	ReadLinkError: () => ReadLinkError,
+	ReadLinkErrorInvalidArgument: () => ReadLinkErrorInvalidArgument,
+	ReadLinkErrorNotDirectory: () => ReadLinkErrorNotDirectory,
+	ReadLinkErrorNotFound: () => ReadLinkErrorNotFound,
+	ReadLinkErrorPermissionDenied: () => ReadLinkErrorPermissionDenied,
+	ReadLinkErrorTooManyOpenFiles: () => ReadLinkErrorTooManyOpenFiles,
+	ReadTextFileError: () => ReadTextFileError,
+	ReadTextFileErrorBusy: () => ReadTextFileErrorBusy,
+	ReadTextFileErrorIsDirectory: () => ReadTextFileErrorIsDirectory,
+	ReadTextFileErrorNotDirectory: () => ReadTextFileErrorNotDirectory,
+	ReadTextFileErrorNotFound: () => ReadTextFileErrorNotFound,
+	ReadTextFileErrorPermissionDenied: () => ReadTextFileErrorPermissionDenied,
+	ReadTextFileErrorTooManyOpenFiles: () => ReadTextFileErrorTooManyOpenFiles,
+	RealPathError: () => RealPathError,
+	RealPathErrorNotDirectory: () => RealPathErrorNotDirectory,
+	RealPathErrorNotFound: () => RealPathErrorNotFound,
+	RealPathErrorPermissionDenied: () => RealPathErrorPermissionDenied,
+	RealPathErrorTooManyOpenFiles: () => RealPathErrorTooManyOpenFiles,
+	RelocateError: () => RelocateError,
+	RelocateErrorAlreadyExists: () => RelocateErrorAlreadyExists,
+	RelocateErrorBusy: () => RelocateErrorBusy,
+	RelocateErrorCrossDevice: () => RelocateErrorCrossDevice,
+	RelocateErrorDirectoryNotEmpty: () => RelocateErrorDirectoryNotEmpty,
+	RelocateErrorInvalidArgument: () => RelocateErrorInvalidArgument,
+	RelocateErrorIsDirectory: () => RelocateErrorIsDirectory,
+	RelocateErrorNotDirectory: () => RelocateErrorNotDirectory,
+	RelocateErrorNotFound: () => RelocateErrorNotFound,
+	RelocateErrorPermissionDenied: () => RelocateErrorPermissionDenied,
+	RelocateErrorReadOnly: () => RelocateErrorReadOnly,
+	RemoveError: () => RemoveError,
+	RemoveErrorBusy: () => RemoveErrorBusy,
+	RemoveErrorDirectoryNotEmpty: () => RemoveErrorDirectoryNotEmpty,
+	RemoveErrorInvalidArgument: () => RemoveErrorInvalidArgument,
+	RemoveErrorIsDirectory: () => RemoveErrorIsDirectory,
+	RemoveErrorNotDirectory: () => RemoveErrorNotDirectory,
+	RemoveErrorNotFound: () => RemoveErrorNotFound,
+	RemoveErrorPermissionDenied: () => RemoveErrorPermissionDenied,
+	RemoveErrorReadOnly: () => RemoveErrorReadOnly,
+	RenameError: () => RenameError,
+	RenameErrorAlreadyExists: () => RenameErrorAlreadyExists,
+	RenameErrorBusy: () => RenameErrorBusy,
+	RenameErrorCrossDevice: () => RenameErrorCrossDevice,
+	RenameErrorDirectoryNotEmpty: () => RenameErrorDirectoryNotEmpty,
+	RenameErrorInvalidArgument: () => RenameErrorInvalidArgument,
+	RenameErrorIsDirectory: () => RenameErrorIsDirectory,
+	RenameErrorNotDirectory: () => RenameErrorNotDirectory,
+	RenameErrorNotFound: () => RenameErrorNotFound,
+	RenameErrorPermissionDenied: () => RenameErrorPermissionDenied,
+	RenameErrorReadOnly: () => RenameErrorReadOnly,
+	SetModeError: () => SetModeError,
+	SetModeErrorInvalidArgument: () => SetModeErrorInvalidArgument,
+	SetModeErrorNotDirectory: () => SetModeErrorNotDirectory,
+	SetModeErrorNotFound: () => SetModeErrorNotFound,
+	SetModeErrorPermissionDenied: () => SetModeErrorPermissionDenied,
+	SetModeErrorReadOnly: () => SetModeErrorReadOnly,
+	SetOwnerError: () => SetOwnerError,
+	SetOwnerErrorInvalidArgument: () => SetOwnerErrorInvalidArgument,
+	SetOwnerErrorNotDirectory: () => SetOwnerErrorNotDirectory,
+	SetOwnerErrorNotFound: () => SetOwnerErrorNotFound,
+	SetOwnerErrorPermissionDenied: () => SetOwnerErrorPermissionDenied,
+	SetOwnerErrorReadOnly: () => SetOwnerErrorReadOnly,
+	SetTimeError: () => SetTimeError,
+	SetTimeErrorInvalidArgument: () => SetTimeErrorInvalidArgument,
+	SetTimeErrorNotDirectory: () => SetTimeErrorNotDirectory,
+	SetTimeErrorNotFound: () => SetTimeErrorNotFound,
+	SetTimeErrorPermissionDenied: () => SetTimeErrorPermissionDenied,
+	SetTimeErrorReadOnly: () => SetTimeErrorReadOnly,
+	StatError: () => StatError,
+	StatErrorBusy: () => StatErrorBusy,
+	StatErrorNotDirectory: () => StatErrorNotDirectory,
+	StatErrorNotFound: () => StatErrorNotFound,
+	StatErrorPermissionDenied: () => StatErrorPermissionDenied,
+	StatErrorTooManyOpenFiles: () => StatErrorTooManyOpenFiles,
+	SymlinkError: () => SymlinkError,
+	SymlinkErrorAlreadyExists: () => SymlinkErrorAlreadyExists,
+	SymlinkErrorBusy: () => SymlinkErrorBusy,
+	SymlinkErrorInvalidArgument: () => SymlinkErrorInvalidArgument,
+	SymlinkErrorNotDirectory: () => SymlinkErrorNotDirectory,
+	SymlinkErrorNotFound: () => SymlinkErrorNotFound,
+	SymlinkErrorPermissionDenied: () => SymlinkErrorPermissionDenied,
+	SymlinkErrorReadOnly: () => SymlinkErrorReadOnly,
+	SymlinkErrorTooManyOpenFiles: () => SymlinkErrorTooManyOpenFiles,
+	TruncateError: () => TruncateError,
+	TruncateErrorBusy: () => TruncateErrorBusy,
+	TruncateErrorInvalidArgument: () => TruncateErrorInvalidArgument,
+	TruncateErrorIsDirectory: () => TruncateErrorIsDirectory,
+	TruncateErrorNoSpace: () => TruncateErrorNoSpace,
+	TruncateErrorNotDirectory: () => TruncateErrorNotDirectory,
+	TruncateErrorNotFound: () => TruncateErrorNotFound,
+	TruncateErrorPermissionDenied: () => TruncateErrorPermissionDenied,
+	TruncateErrorReadOnly: () => TruncateErrorReadOnly,
+	TruncateErrorTooManyOpenFiles: () => TruncateErrorTooManyOpenFiles,
+	WalkDirectoryError: () => WalkDirectoryError,
+	WalkDirectoryErrorBusy: () => WalkDirectoryErrorBusy,
+	WalkDirectoryErrorNotDirectory: () => WalkDirectoryErrorNotDirectory,
+	WalkDirectoryErrorNotFound: () => WalkDirectoryErrorNotFound,
+	WalkDirectoryErrorPermissionDenied: () => WalkDirectoryErrorPermissionDenied,
+	WalkDirectoryErrorTooManyOpenFiles: () => WalkDirectoryErrorTooManyOpenFiles,
+	WriteFileError: () => WriteFileError,
+	WriteFileErrorBusy: () => WriteFileErrorBusy,
+	WriteFileErrorInvalidArgument: () => WriteFileErrorInvalidArgument,
+	WriteFileErrorIsDirectory: () => WriteFileErrorIsDirectory,
+	WriteFileErrorNoSpace: () => WriteFileErrorNoSpace,
+	WriteFileErrorNotDirectory: () => WriteFileErrorNotDirectory,
+	WriteFileErrorNotFound: () => WriteFileErrorNotFound,
+	WriteFileErrorPermissionDenied: () => WriteFileErrorPermissionDenied,
+	WriteFileErrorReadOnly: () => WriteFileErrorReadOnly,
+	WriteFileErrorTooManyOpenFiles: () => WriteFileErrorTooManyOpenFiles,
+	WriteJsonFileError: () => WriteJsonFileError,
+	WriteJsonFileErrorBusy: () => WriteJsonFileErrorBusy,
+	WriteJsonFileErrorInvalidArgument: () => WriteJsonFileErrorInvalidArgument,
+	WriteJsonFileErrorIsDirectory: () => WriteJsonFileErrorIsDirectory,
+	WriteJsonFileErrorNoSpace: () => WriteJsonFileErrorNoSpace,
+	WriteJsonFileErrorNotDirectory: () => WriteJsonFileErrorNotDirectory,
+	WriteJsonFileErrorNotFound: () => WriteJsonFileErrorNotFound,
+	WriteJsonFileErrorPermissionDenied: () => WriteJsonFileErrorPermissionDenied,
+	WriteJsonFileErrorReadOnly: () => WriteJsonFileErrorReadOnly,
+	WriteJsonFileErrorTooManyOpenFiles: () => WriteJsonFileErrorTooManyOpenFiles,
+	WriteTextFileError: () => WriteTextFileError,
+	WriteTextFileErrorBusy: () => WriteTextFileErrorBusy,
+	WriteTextFileErrorInvalidArgument: () => WriteTextFileErrorInvalidArgument,
+	WriteTextFileErrorIsDirectory: () => WriteTextFileErrorIsDirectory,
+	WriteTextFileErrorNoSpace: () => WriteTextFileErrorNoSpace,
+	WriteTextFileErrorNotDirectory: () => WriteTextFileErrorNotDirectory,
+	WriteTextFileErrorNotFound: () => WriteTextFileErrorNotFound,
+	WriteTextFileErrorPermissionDenied: () => WriteTextFileErrorPermissionDenied,
+	WriteTextFileErrorReadOnly: () => WriteTextFileErrorReadOnly,
+	WriteTextFileErrorTooManyOpenFiles: () => WriteTextFileErrorTooManyOpenFiles,
+	appendFile: () => appendFile,
+	appendTextFile: () => appendTextFile,
+	copy: () => copy,
+	createEntryInterface: () => createEntryInterface,
+	createFileInterface: () => createFileInterface,
+	createFolderInterface: () => createFolderInterface,
+	createUnknownEntryInterface: () => createUnknownEntryInterface,
+	ensureDirectory: () => ensureDirectory,
+	ensureFile: () => ensureFile,
+	exists: () => exists,
+	isFileInterface: () => isFileInterface,
+	isFileInterfaceFromUnknown: () => isFileInterfaceFromUnknown,
+	isFolderInterface: () => isFolderInterface,
+	isFolderInterfaceFromUnknown: () => isFolderInterfaceFromUnknown,
+	isUnknownEntryInterface: () => isUnknownEntryInterface,
+	isUnknownEntryInterfaceFromUnknown: () => isUnknownEntryInterfaceFromUnknown,
+	link: () => link,
+	linkStat: () => linkStat,
+	makeDirectory: () => makeDirectory,
+	makeTemporaryDirectory: () => makeTemporaryDirectory,
+	makeTemporaryFile: () => makeTemporaryFile,
+	move: () => move,
+	readDirectory: () => readDirectory,
+	readFile: () => readFile,
+	readJsonFile: () => readJsonFile,
+	readLink: () => readLink,
+	readTextFile: () => readTextFile,
+	realPath: () => realPath,
+	relocate: () => relocate,
+	remove: () => remove,
+	rename: () => rename,
+	setMode: () => setMode,
+	setOwner: () => setOwner,
+	setTime: () => setTime,
+	stat: () => stat,
+	symlink: () => symlink,
+	truncate: () => truncate,
+	walkDirectory: () => walkDirectory,
+	writeFile: () => writeFile,
+	writeJsonFile: () => writeJsonFile,
+	writeTextFile: () => writeTextFile
+});
+//#endregion
+export { AppendFileError, AppendFileErrorBusy, AppendFileErrorInvalidArgument, AppendFileErrorIsDirectory, AppendFileErrorNoSpace, AppendFileErrorNotDirectory, AppendFileErrorNotFound, AppendFileErrorPermissionDenied, AppendFileErrorReadOnly, AppendFileErrorTooManyOpenFiles, AppendTextFileError, AppendTextFileErrorBusy, AppendTextFileErrorInvalidArgument, AppendTextFileErrorIsDirectory, AppendTextFileErrorNoSpace, AppendTextFileErrorNotDirectory, AppendTextFileErrorNotFound, AppendTextFileErrorPermissionDenied, AppendTextFileErrorReadOnly, AppendTextFileErrorTooManyOpenFiles, CopyError, CopyErrorAlreadyExists, CopyErrorBusy, CopyErrorInvalidArgument, CopyErrorNoSpace, CopyErrorNotDirectory, CopyErrorNotFound, CopyErrorPermissionDenied, CopyErrorReadOnly, CopyErrorTooManyOpenFiles, EnsureDirectoryError, EnsureDirectoryErrorBusy, EnsureDirectoryErrorInvalidArgument, EnsureDirectoryErrorNoSpace, EnsureDirectoryErrorNotDirectory, EnsureDirectoryErrorPermissionDenied, EnsureDirectoryErrorReadOnly, EnsureDirectoryErrorTooManyOpenFiles, EnsureFileError, EnsureFileErrorBusy, EnsureFileErrorInvalidArgument, EnsureFileErrorIsDirectory, EnsureFileErrorNoSpace, EnsureFileErrorNotDirectory, EnsureFileErrorPermissionDenied, EnsureFileErrorReadOnly, EnsureFileErrorTooManyOpenFiles, ExistsError, ExistsErrorNotDirectory, ExistsErrorNotFound, ExistsErrorPermissionDenied, ExistsErrorTooManyOpenFiles, LinkError, LinkErrorAlreadyExists, LinkErrorBusy, LinkErrorCrossDevice, LinkErrorInvalidArgument, LinkErrorNoSpace, LinkErrorNotDirectory, LinkErrorNotFound, LinkErrorPermissionDenied, LinkErrorReadOnly, LinkErrorTooManyOpenFiles, LinkStatError, LinkStatErrorBusy, LinkStatErrorNotDirectory, LinkStatErrorNotFound, LinkStatErrorPermissionDenied, LinkStatErrorTooManyOpenFiles, MakeDirectoryError, MakeDirectoryErrorAlreadyExists, MakeDirectoryErrorBusy, MakeDirectoryErrorInvalidArgument, MakeDirectoryErrorNoSpace, MakeDirectoryErrorNotDirectory, MakeDirectoryErrorNotFound, MakeDirectoryErrorPermissionDenied, MakeDirectoryErrorReadOnly, MakeDirectoryErrorTooManyOpenFiles, MakeTemporaryDirectoryError, MakeTemporaryDirectoryErrorInvalidArgument, MakeTemporaryDirectoryErrorNoSpace, MakeTemporaryDirectoryErrorNotDirectory, MakeTemporaryDirectoryErrorPermissionDenied, MakeTemporaryDirectoryErrorReadOnly, MakeTemporaryDirectoryErrorTooManyOpenFiles, MakeTemporaryFileError, MakeTemporaryFileErrorAlreadyExists, MakeTemporaryFileErrorInvalidArgument, MakeTemporaryFileErrorNoSpace, MakeTemporaryFileErrorNotDirectory, MakeTemporaryFileErrorPermissionDenied, MakeTemporaryFileErrorReadOnly, MakeTemporaryFileErrorTooManyOpenFiles, MoveError, MoveErrorAlreadyExists, MoveErrorBusy, MoveErrorCrossDevice, MoveErrorDirectoryNotEmpty, MoveErrorInvalidArgument, MoveErrorIsDirectory, MoveErrorNotDirectory, MoveErrorNotFound, MoveErrorPermissionDenied, MoveErrorReadOnly, ReadDirectoryError, ReadDirectoryErrorBusy, ReadDirectoryErrorNotDirectory, ReadDirectoryErrorNotFound, ReadDirectoryErrorPermissionDenied, ReadDirectoryErrorTooManyOpenFiles, ReadFileError, ReadFileErrorBusy, ReadFileErrorIsDirectory, ReadFileErrorNotDirectory, ReadFileErrorNotFound, ReadFileErrorPermissionDenied, ReadFileErrorTooManyOpenFiles, ReadJsonFileError, ReadJsonFileErrorBusy, ReadJsonFileErrorIsDirectory, ReadJsonFileErrorNotDirectory, ReadJsonFileErrorNotFound, ReadJsonFileErrorPermissionDenied, ReadJsonFileErrorTooManyOpenFiles, ReadLinkError, ReadLinkErrorInvalidArgument, ReadLinkErrorNotDirectory, ReadLinkErrorNotFound, ReadLinkErrorPermissionDenied, ReadLinkErrorTooManyOpenFiles, ReadTextFileError, ReadTextFileErrorBusy, ReadTextFileErrorIsDirectory, ReadTextFileErrorNotDirectory, ReadTextFileErrorNotFound, ReadTextFileErrorPermissionDenied, ReadTextFileErrorTooManyOpenFiles, RealPathError, RealPathErrorNotDirectory, RealPathErrorNotFound, RealPathErrorPermissionDenied, RealPathErrorTooManyOpenFiles, RelocateError, RelocateErrorAlreadyExists, RelocateErrorBusy, RelocateErrorCrossDevice, RelocateErrorDirectoryNotEmpty, RelocateErrorInvalidArgument, RelocateErrorIsDirectory, RelocateErrorNotDirectory, RelocateErrorNotFound, RelocateErrorPermissionDenied, RelocateErrorReadOnly, RemoveError, RemoveErrorBusy, RemoveErrorDirectoryNotEmpty, RemoveErrorInvalidArgument, RemoveErrorIsDirectory, RemoveErrorNotDirectory, RemoveErrorNotFound, RemoveErrorPermissionDenied, RemoveErrorReadOnly, RenameError, RenameErrorAlreadyExists, RenameErrorBusy, RenameErrorCrossDevice, RenameErrorDirectoryNotEmpty, RenameErrorInvalidArgument, RenameErrorIsDirectory, RenameErrorNotDirectory, RenameErrorNotFound, RenameErrorPermissionDenied, RenameErrorReadOnly, SetModeError, SetModeErrorInvalidArgument, SetModeErrorNotDirectory, SetModeErrorNotFound, SetModeErrorPermissionDenied, SetModeErrorReadOnly, SetOwnerError, SetOwnerErrorInvalidArgument, SetOwnerErrorNotDirectory, SetOwnerErrorNotFound, SetOwnerErrorPermissionDenied, SetOwnerErrorReadOnly, SetTimeError, SetTimeErrorInvalidArgument, SetTimeErrorNotDirectory, SetTimeErrorNotFound, SetTimeErrorPermissionDenied, SetTimeErrorReadOnly, StatError, StatErrorBusy, StatErrorNotDirectory, StatErrorNotFound, StatErrorPermissionDenied, StatErrorTooManyOpenFiles, SymlinkError, SymlinkErrorAlreadyExists, SymlinkErrorBusy, SymlinkErrorInvalidArgument, SymlinkErrorNotDirectory, SymlinkErrorNotFound, SymlinkErrorPermissionDenied, SymlinkErrorReadOnly, SymlinkErrorTooManyOpenFiles, TruncateError, TruncateErrorBusy, TruncateErrorInvalidArgument, TruncateErrorIsDirectory, TruncateErrorNoSpace, TruncateErrorNotDirectory, TruncateErrorNotFound, TruncateErrorPermissionDenied, TruncateErrorReadOnly, TruncateErrorTooManyOpenFiles, WalkDirectoryError, WalkDirectoryErrorBusy, WalkDirectoryErrorNotDirectory, WalkDirectoryErrorNotFound, WalkDirectoryErrorPermissionDenied, WalkDirectoryErrorTooManyOpenFiles, WriteFileError, WriteFileErrorBusy, WriteFileErrorInvalidArgument, WriteFileErrorIsDirectory, WriteFileErrorNoSpace, WriteFileErrorNotDirectory, WriteFileErrorNotFound, WriteFileErrorPermissionDenied, WriteFileErrorReadOnly, WriteFileErrorTooManyOpenFiles, WriteJsonFileError, WriteJsonFileErrorBusy, WriteJsonFileErrorInvalidArgument, WriteJsonFileErrorIsDirectory, WriteJsonFileErrorNoSpace, WriteJsonFileErrorNotDirectory, WriteJsonFileErrorNotFound, WriteJsonFileErrorPermissionDenied, WriteJsonFileErrorReadOnly, WriteJsonFileErrorTooManyOpenFiles, WriteTextFileError, WriteTextFileErrorBusy, WriteTextFileErrorInvalidArgument, WriteTextFileErrorIsDirectory, WriteTextFileErrorNoSpace, WriteTextFileErrorNotDirectory, WriteTextFileErrorNotFound, WriteTextFileErrorPermissionDenied, WriteTextFileErrorReadOnly, WriteTextFileErrorTooManyOpenFiles, appendFile, appendTextFile, copy, createEntryInterface, createFileInterface, createFolderInterface, createUnknownEntryInterface, ensureDirectory, ensureFile, exists, file_exports, isFileInterface, isFileInterfaceFromUnknown, isFolderInterface, isFolderInterfaceFromUnknown, isUnknownEntryInterface, isUnknownEntryInterfaceFromUnknown, link, linkStat, makeDirectory, makeTemporaryDirectory, makeTemporaryFile, move, readDirectory, readFile, readJsonFile, readLink, readTextFile, realPath, relocate, remove, rename, setMode, setOwner, setTime, stat, symlink, truncate, walkDirectory, writeFile, writeJsonFile, writeTextFile };

package/dist/file/link.cjs

@@ -0,0 +1,70 @@
+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/link.ts
+var LinkErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-not-found", Error) {};
+var LinkErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-permission-denied", Error) {};
+var LinkErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-already-exists", Error) {};
+var LinkErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-not-directory", Error) {};
+var LinkErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-no-space", Error) {};
+var LinkErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-read-only", Error) {};
+var LinkErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-invalid-argument", Error) {};
+var LinkErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-too-many-open-files", Error) {};
+var LinkErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-busy", Error) {};
+var LinkErrorCrossDevice = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-cross-device", Error) {};
+var LinkError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-error", Error) {};
+function handleNodeLinkError(error) {
+	let linkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkError = new LinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkError = new LinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") linkError = new LinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") linkError = new LinkErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") linkError = new LinkErrorNoSpace(error);
+		else if (error.code === "EROFS") linkError = new LinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") linkError = new LinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkError = new LinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkError = new LinkErrorBusy(error);
+		else if (error.code === "EXDEV") linkError = new LinkErrorCrossDevice(error);
+	}
+	if (linkError === void 0) linkError = new LinkError(error);
+	return _duplojs_lang_either.left("file-system-link-error", linkError);
+}
+function handleDenoLinkError(error) {
+	let linkError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkError = new LinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkError = new LinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) linkError = new LinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkError = new LinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) linkError = new LinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) linkError = new LinkErrorBusy(error);
+	if (linkError === void 0) linkError = new LinkError(error);
+	return _duplojs_lang_either.left("file-system-link-error", linkError);
+}
+const linkImplementation = require_implementor.implementFunction("link", {
+	NODE: async (existingPath, newPath) => require_implementor.nodeFileSystem.value.link(existingPath, newPath).then(() => _duplojs_lang_either.right("file-system-link")).catch(handleNodeLinkError),
+	DENO: (existingPath, newPath) => Deno.link(existingPath, newPath).then(() => _duplojs_lang_either.right("file-system-link")).catch(handleDenoLinkError)
+});
+function link(...args) {
+	if (args.length === 1) {
+		const [newPath] = args;
+		return (existingPath) => linkImplementation(existingPath, newPath);
+	}
+	return linkImplementation(...args);
+}
+//#endregion
+exports.LinkError = LinkError;
+exports.LinkErrorAlreadyExists = LinkErrorAlreadyExists;
+exports.LinkErrorBusy = LinkErrorBusy;
+exports.LinkErrorCrossDevice = LinkErrorCrossDevice;
+exports.LinkErrorInvalidArgument = LinkErrorInvalidArgument;
+exports.LinkErrorNoSpace = LinkErrorNoSpace;
+exports.LinkErrorNotDirectory = LinkErrorNotDirectory;
+exports.LinkErrorNotFound = LinkErrorNotFound;
+exports.LinkErrorPermissionDenied = LinkErrorPermissionDenied;
+exports.LinkErrorReadOnly = LinkErrorReadOnly;
+exports.LinkErrorTooManyOpenFiles = LinkErrorTooManyOpenFiles;
+exports.link = link;

package/dist/file/link.d.ts

@@ -0,0 +1,46 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+declare const LinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-not-found", unknown>>, unknown>;
+export declare class LinkErrorNotFound extends LinkErrorNotFound_base {
+}
+declare const LinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-permission-denied", unknown>>, unknown>;
+export declare class LinkErrorPermissionDenied extends LinkErrorPermissionDenied_base {
+}
+declare const LinkErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-already-exists", unknown>>, unknown>;
+export declare class LinkErrorAlreadyExists extends LinkErrorAlreadyExists_base {
+}
+declare const LinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-not-directory", unknown>>, unknown>;
+export declare class LinkErrorNotDirectory extends LinkErrorNotDirectory_base {
+}
+declare const LinkErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-no-space", unknown>>, unknown>;
+export declare class LinkErrorNoSpace extends LinkErrorNoSpace_base {
+}
+declare const LinkErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-read-only", unknown>>, unknown>;
+export declare class LinkErrorReadOnly extends LinkErrorReadOnly_base {
+}
+declare const LinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-invalid-argument", unknown>>, unknown>;
+export declare class LinkErrorInvalidArgument extends LinkErrorInvalidArgument_base {
+}
+declare const LinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-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-link-too-many-open-files", unknown>>, unknown>;
+export declare class LinkErrorTooManyOpenFiles extends LinkErrorTooManyOpenFiles_base {
+}
+declare const LinkErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-busy", unknown>>, unknown>;
+export declare class LinkErrorBusy extends LinkErrorBusy_base {
+}
+declare const LinkErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-cross-device", unknown>>, unknown>;
+export declare class LinkErrorCrossDevice extends LinkErrorCrossDevice_base {
+}
+declare const LinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-error", unknown>>, unknown>;
+export declare class LinkError extends LinkError_base {
+}
+export type LinkErrors = (LinkErrorNotFound | LinkErrorPermissionDenied | LinkErrorAlreadyExists | LinkErrorNotDirectory | LinkErrorNoSpace | LinkErrorReadOnly | LinkErrorInvalidArgument | LinkErrorTooManyOpenFiles | LinkErrorBusy | LinkErrorCrossDevice | LinkError);
+export type LinkResult = (DEither.Right<"file-system-link", void> | DEither.Left<"file-system-link-error", LinkErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        link(existingPath: DPath.AnyPath, newPath: DPath.AnyPath): Promise<LinkResult>;
+    }
+}
+export declare function link(newPath: DPath.AnyPath): (existingPath: DPath.AnyPath) => Promise<LinkResult>;
+export declare function link(existingPath: DPath.AnyPath, newPath: DPath.AnyPath): Promise<LinkResult>;
+export {};

package/dist/file/link.mjs

@@ -0,0 +1,56 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/link.ts
+var LinkErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-link-not-found", Error) {};
+var LinkErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-link-permission-denied", Error) {};
+var LinkErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-link-already-exists", Error) {};
+var LinkErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-link-not-directory", Error) {};
+var LinkErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-link-no-space", Error) {};
+var LinkErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-link-read-only", Error) {};
+var LinkErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-link-invalid-argument", Error) {};
+var LinkErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-link-too-many-open-files", Error) {};
+var LinkErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-link-busy", Error) {};
+var LinkErrorCrossDevice = class extends DCommon.DuploJSError.parentClass("file-system-link-cross-device", Error) {};
+var LinkError = class extends DCommon.DuploJSError.parentClass("file-system-link-error", Error) {};
+function handleNodeLinkError(error) {
+	let linkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkError = new LinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkError = new LinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") linkError = new LinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") linkError = new LinkErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") linkError = new LinkErrorNoSpace(error);
+		else if (error.code === "EROFS") linkError = new LinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") linkError = new LinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkError = new LinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkError = new LinkErrorBusy(error);
+		else if (error.code === "EXDEV") linkError = new LinkErrorCrossDevice(error);
+	}
+	if (linkError === void 0) linkError = new LinkError(error);
+	return DEither.left("file-system-link-error", linkError);
+}
+function handleDenoLinkError(error) {
+	let linkError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkError = new LinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkError = new LinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) linkError = new LinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkError = new LinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) linkError = new LinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) linkError = new LinkErrorBusy(error);
+	if (linkError === void 0) linkError = new LinkError(error);
+	return DEither.left("file-system-link-error", linkError);
+}
+const linkImplementation = implementFunction("link", {
+	NODE: async (existingPath, newPath) => nodeFileSystem.value.link(existingPath, newPath).then(() => DEither.right("file-system-link")).catch(handleNodeLinkError),
+	DENO: (existingPath, newPath) => Deno.link(existingPath, newPath).then(() => DEither.right("file-system-link")).catch(handleDenoLinkError)
+});
+function link(...args) {
+	if (args.length === 1) {
+		const [newPath] = args;
+		return (existingPath) => linkImplementation(existingPath, newPath);
+	}
+	return linkImplementation(...args);
+}
+//#endregion
+export { LinkError, LinkErrorAlreadyExists, LinkErrorBusy, LinkErrorCrossDevice, LinkErrorInvalidArgument, LinkErrorNoSpace, LinkErrorNotDirectory, LinkErrorNotFound, LinkErrorPermissionDenied, LinkErrorReadOnly, LinkErrorTooManyOpenFiles, link };