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

package/dist/file/symlink.d.ts

@@ -0,0 +1,48 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export interface SymlinkParams {
+    /**
+     * @remarks
+     * Specify the symbolic link type as file, directory or NTFS junction.
+     * This option only applies to Windows and is ignored on other operating systems.
+     */
+    type: "file" | "dir" | "junction";
+}
+declare const SymlinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-found", unknown>>, unknown>;
+export declare class SymlinkErrorNotFound extends SymlinkErrorNotFound_base {
+}
+declare const SymlinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-permission-denied", unknown>>, unknown>;
+export declare class SymlinkErrorPermissionDenied extends SymlinkErrorPermissionDenied_base {
+}
+declare const SymlinkErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-already-exists", unknown>>, unknown>;
+export declare class SymlinkErrorAlreadyExists extends SymlinkErrorAlreadyExists_base {
+}
+declare const SymlinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-directory", unknown>>, unknown>;
+export declare class SymlinkErrorNotDirectory extends SymlinkErrorNotDirectory_base {
+}
+declare const SymlinkErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-read-only", unknown>>, unknown>;
+export declare class SymlinkErrorReadOnly extends SymlinkErrorReadOnly_base {
+}
+declare const SymlinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-invalid-argument", unknown>>, unknown>;
+export declare class SymlinkErrorInvalidArgument extends SymlinkErrorInvalidArgument_base {
+}
+declare const SymlinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-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-symlink-too-many-open-files", unknown>>, unknown>;
+export declare class SymlinkErrorTooManyOpenFiles extends SymlinkErrorTooManyOpenFiles_base {
+}
+declare const SymlinkErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-busy", unknown>>, unknown>;
+export declare class SymlinkErrorBusy extends SymlinkErrorBusy_base {
+}
+declare const SymlinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-error", unknown>>, unknown>;
+export declare class SymlinkError extends SymlinkError_base {
+}
+export type SymlinkErrors = (SymlinkErrorNotFound | SymlinkErrorPermissionDenied | SymlinkErrorAlreadyExists | SymlinkErrorNotDirectory | SymlinkErrorReadOnly | SymlinkErrorInvalidArgument | SymlinkErrorTooManyOpenFiles | SymlinkErrorBusy | SymlinkError);
+export type SymlinkResult = (DEither.Right<"file-system-symlink", void> | DEither.Left<"file-system-symlink-error", SymlinkErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        symlink(oldPath: DPath.AnyPath, newPath: DPath.AnyPath, params?: SymlinkParams): Promise<SymlinkResult>;
+    }
+}
+export declare function symlink(newPath: DPath.AnyPath): (oldPath: DPath.AnyPath) => Promise<SymlinkResult>;
+export declare function symlink(oldPath: DPath.AnyPath, newPath: DPath.AnyPath, params?: SymlinkParams): Promise<SymlinkResult>;
+export {};

package/dist/file/symlink.mjs

@@ -0,0 +1,52 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/symlink.ts
+var SymlinkErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-symlink-not-found", Error) {};
+var SymlinkErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-symlink-permission-denied", Error) {};
+var SymlinkErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-symlink-already-exists", Error) {};
+var SymlinkErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-symlink-not-directory", Error) {};
+var SymlinkErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-symlink-read-only", Error) {};
+var SymlinkErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-symlink-invalid-argument", Error) {};
+var SymlinkErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-symlink-too-many-open-files", Error) {};
+var SymlinkErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-symlink-busy", Error) {};
+var SymlinkError = class extends DCommon.DuploJSError.parentClass("file-system-symlink-error", Error) {};
+function handleNodeSymlinkError(error) {
+	let symlinkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") symlinkError = new SymlinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") symlinkError = new SymlinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") symlinkError = new SymlinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") symlinkError = new SymlinkErrorNotDirectory(error);
+		else if (error.code === "EROFS") symlinkError = new SymlinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") symlinkError = new SymlinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") symlinkError = new SymlinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") symlinkError = new SymlinkErrorBusy(error);
+	}
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return DEither.left("file-system-symlink-error", symlinkError);
+}
+function handleDenoSymlinkError(error) {
+	let symlinkError = void 0;
+	if (error instanceof Deno.errors.NotFound) symlinkError = new SymlinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) symlinkError = new SymlinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) symlinkError = new SymlinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) symlinkError = new SymlinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) symlinkError = new SymlinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) symlinkError = new SymlinkErrorBusy(error);
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return DEither.left("file-system-symlink-error", symlinkError);
+}
+const symlinkImplementation = implementFunction("symlink", {
+	NODE: async (oldPath, newPath, params) => nodeFileSystem.value.symlink(oldPath, newPath, params?.type).then(() => DEither.right("file-system-symlink")).catch(handleNodeSymlinkError),
+	DENO: (oldPath, newPath, params) => Deno.symlink(oldPath, newPath, params).then(() => DEither.right("file-system-symlink")).catch(handleDenoSymlinkError)
+});
+function symlink(...args) {
+	if (args.length === 1) {
+		const [newPath] = args;
+		return (oldPath) => symlinkImplementation(oldPath, newPath);
+	}
+	return symlinkImplementation(...args);
+}
+//#endregion
+export { SymlinkError, SymlinkErrorAlreadyExists, SymlinkErrorBusy, SymlinkErrorInvalidArgument, SymlinkErrorNotDirectory, SymlinkErrorNotFound, SymlinkErrorPermissionDenied, SymlinkErrorReadOnly, SymlinkErrorTooManyOpenFiles, symlink };

package/dist/file/truncate.cjs

@@ -0,0 +1,60 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/truncate.ts
+var TruncateErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-not-found", Error) {};
+var TruncateErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-permission-denied", Error) {};
+var TruncateErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-is-directory", Error) {};
+var TruncateErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-not-directory", Error) {};
+var TruncateErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-no-space", Error) {};
+var TruncateErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-read-only", Error) {};
+var TruncateErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-invalid-argument", Error) {};
+var TruncateErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-too-many-open-files", Error) {};
+var TruncateErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-busy", Error) {};
+var TruncateError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-error", Error) {};
+function handleNodeTruncateError(error) {
+	let truncateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") truncateError = new TruncateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") truncateError = new TruncateErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") truncateError = new TruncateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") truncateError = new TruncateErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") truncateError = new TruncateErrorNoSpace(error);
+		else if (error.code === "EROFS") truncateError = new TruncateErrorReadOnly(error);
+		else if (error.code === "EINVAL") truncateError = new TruncateErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") truncateError = new TruncateErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") truncateError = new TruncateErrorBusy(error);
+	}
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return _duplojs_lang_either.left("file-system-truncate-error", truncateError);
+}
+function handleDenoTruncateError(error) {
+	let truncateError = void 0;
+	if (error instanceof Deno.errors.NotFound) truncateError = new TruncateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) truncateError = new TruncateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) truncateError = new TruncateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) truncateError = new TruncateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) truncateError = new TruncateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) truncateError = new TruncateErrorBusy(error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return _duplojs_lang_either.left("file-system-truncate-error", truncateError);
+}
+const truncate = require_implementor.implementFunction("truncate", {
+	NODE: async (path, size) => require_implementor.nodeFileSystem.value.truncate(path, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleNodeTruncateError),
+	DENO: (path, size) => _duplojs_lang_common.pipe(path, _duplojs_lang_common.when(_duplojs_lang_common.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleDenoTruncateError))
+});
+//#endregion
+exports.TruncateError = TruncateError;
+exports.TruncateErrorBusy = TruncateErrorBusy;
+exports.TruncateErrorInvalidArgument = TruncateErrorInvalidArgument;
+exports.TruncateErrorIsDirectory = TruncateErrorIsDirectory;
+exports.TruncateErrorNoSpace = TruncateErrorNoSpace;
+exports.TruncateErrorNotDirectory = TruncateErrorNotDirectory;
+exports.TruncateErrorNotFound = TruncateErrorNotFound;
+exports.TruncateErrorPermissionDenied = TruncateErrorPermissionDenied;
+exports.TruncateErrorReadOnly = TruncateErrorReadOnly;
+exports.TruncateErrorTooManyOpenFiles = TruncateErrorTooManyOpenFiles;
+exports.truncate = truncate;

package/dist/file/truncate.d.ts

@@ -0,0 +1,42 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+declare const TruncateErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-found", unknown>>, unknown>;
+export declare class TruncateErrorNotFound extends TruncateErrorNotFound_base {
+}
+declare const TruncateErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-permission-denied", unknown>>, unknown>;
+export declare class TruncateErrorPermissionDenied extends TruncateErrorPermissionDenied_base {
+}
+declare const TruncateErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-is-directory", unknown>>, unknown>;
+export declare class TruncateErrorIsDirectory extends TruncateErrorIsDirectory_base {
+}
+declare const TruncateErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-directory", unknown>>, unknown>;
+export declare class TruncateErrorNotDirectory extends TruncateErrorNotDirectory_base {
+}
+declare const TruncateErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-no-space", unknown>>, unknown>;
+export declare class TruncateErrorNoSpace extends TruncateErrorNoSpace_base {
+}
+declare const TruncateErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-read-only", unknown>>, unknown>;
+export declare class TruncateErrorReadOnly extends TruncateErrorReadOnly_base {
+}
+declare const TruncateErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-invalid-argument", unknown>>, unknown>;
+export declare class TruncateErrorInvalidArgument extends TruncateErrorInvalidArgument_base {
+}
+declare const TruncateErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-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-truncate-too-many-open-files", unknown>>, unknown>;
+export declare class TruncateErrorTooManyOpenFiles extends TruncateErrorTooManyOpenFiles_base {
+}
+declare const TruncateErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-busy", unknown>>, unknown>;
+export declare class TruncateErrorBusy extends TruncateErrorBusy_base {
+}
+declare const TruncateError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-error", unknown>>, unknown>;
+export declare class TruncateError extends TruncateError_base {
+}
+export type TruncateErrors = (TruncateErrorNotFound | TruncateErrorPermissionDenied | TruncateErrorIsDirectory | TruncateErrorNotDirectory | TruncateErrorNoSpace | TruncateErrorReadOnly | TruncateErrorInvalidArgument | TruncateErrorTooManyOpenFiles | TruncateErrorBusy | TruncateError);
+export type TruncateResult = (DEither.Right<"file-system-truncate", void> | DEither.Left<"file-system-truncate-error", TruncateErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        truncate(path: DPath.AnyPath, size?: number): Promise<TruncateResult>;
+    }
+}
+export declare const truncate: (path: DPath.AnyPath, size?: number) => Promise<TruncateResult>;
+export {};

package/dist/file/truncate.mjs

@@ -0,0 +1,47 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/truncate.ts
+var TruncateErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-truncate-not-found", Error) {};
+var TruncateErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-truncate-permission-denied", Error) {};
+var TruncateErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-truncate-is-directory", Error) {};
+var TruncateErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-truncate-not-directory", Error) {};
+var TruncateErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-truncate-no-space", Error) {};
+var TruncateErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-truncate-read-only", Error) {};
+var TruncateErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-truncate-invalid-argument", Error) {};
+var TruncateErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-truncate-too-many-open-files", Error) {};
+var TruncateErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-truncate-busy", Error) {};
+var TruncateError = class extends DCommon.DuploJSError.parentClass("file-system-truncate-error", Error) {};
+function handleNodeTruncateError(error) {
+	let truncateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") truncateError = new TruncateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") truncateError = new TruncateErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") truncateError = new TruncateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") truncateError = new TruncateErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") truncateError = new TruncateErrorNoSpace(error);
+		else if (error.code === "EROFS") truncateError = new TruncateErrorReadOnly(error);
+		else if (error.code === "EINVAL") truncateError = new TruncateErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") truncateError = new TruncateErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") truncateError = new TruncateErrorBusy(error);
+	}
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return DEither.left("file-system-truncate-error", truncateError);
+}
+function handleDenoTruncateError(error) {
+	let truncateError = void 0;
+	if (error instanceof Deno.errors.NotFound) truncateError = new TruncateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) truncateError = new TruncateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) truncateError = new TruncateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) truncateError = new TruncateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) truncateError = new TruncateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) truncateError = new TruncateErrorBusy(error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return DEither.left("file-system-truncate-error", truncateError);
+}
+const truncate = implementFunction("truncate", {
+	NODE: async (path, size) => nodeFileSystem.value.truncate(path, size).then(() => DEither.right("file-system-truncate")).catch(handleNodeTruncateError),
+	DENO: (path, size) => DCommon.pipe(path, DCommon.when(DCommon.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => DEither.right("file-system-truncate")).catch(handleDenoTruncateError))
+});
+//#endregion
+export { TruncateError, TruncateErrorBusy, TruncateErrorInvalidArgument, TruncateErrorIsDirectory, TruncateErrorNoSpace, TruncateErrorNotDirectory, TruncateErrorNotFound, TruncateErrorPermissionDenied, TruncateErrorReadOnly, TruncateErrorTooManyOpenFiles, truncate };

package/dist/file/unknownEntryInterface.cjs

@@ -0,0 +1,40 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_stat = require("./stat.cjs");
+const require_exists = require("./exists.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/file/unknownEntryInterface.ts
+const unknownInterfaceKind = require_kind.createKind("unknownInterface");
+function createUnknownEntryInterface(path) {
+	function getName() {
+		return _duplojs_lang_path.getBaseName(path);
+	}
+	function getParentPath() {
+		return _duplojs_lang_path.getParentFolderPath(path);
+	}
+	function localStat() {
+		return require_stat.stat(path);
+	}
+	function exist() {
+		return require_exists.exists(path);
+	}
+	return {
+		path: _duplojs_lang_common.cast(path),
+		getName,
+		getParentPath,
+		stat: localStat,
+		exist,
+		[unknownInterfaceKind.runTimeKey]: null
+	};
+}
+function isUnknownEntryInterface(input) {
+	return unknownInterfaceKind.has(input);
+}
+const isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterface;
+//#endregion
+exports.createUnknownEntryInterface = createUnknownEntryInterface;
+exports.isUnknownEntryInterface = isUnknownEntryInterface;
+exports.isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterfaceFromUnknown;

package/dist/file/unknownEntryInterface.d.ts

@@ -0,0 +1,17 @@
+import { StatResult } from './stat';
+import { ExistsResult } from './exists';
+import type * as DKind from "@duplojs/lang/kind";
+import * as DPath from "@duplojs/lang/path";
+declare const unknownInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/unknownInterface", unknown>>;
+export type EntryPath = DPath.AnyPath;
+export interface UnknownEntryInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath> extends DKind.Kind<typeof unknownInterfaceKind> {
+    path: GenericPath & DPath.Path;
+    getName(): (string & DPath.Segment & DPath.Path) | null;
+    getParentPath(): ReturnType<typeof DPath.getParentFolderPath<GenericPath>>;
+    stat(): Promise<StatResult>;
+    exist(): Promise<ExistsResult>;
+}
+export declare function createUnknownEntryInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath>(path: GenericPath): UnknownEntryInterface<GenericPath>;
+export declare function isUnknownEntryInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, UnknownEntryInterface>;
+export declare const isUnknownEntryInterfaceFromUnknown: (input: unknown) => input is UnknownEntryInterface;
+export {};

package/dist/file/unknownEntryInterface.mjs

@@ -0,0 +1,35 @@
+import { createKind } from "../kind.mjs";
+import { stat } from "./stat.mjs";
+import { exists } from "./exists.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/unknownEntryInterface.ts
+const unknownInterfaceKind = createKind("unknownInterface");
+function createUnknownEntryInterface(path) {
+	function getName() {
+		return DPath.getBaseName(path);
+	}
+	function getParentPath() {
+		return DPath.getParentFolderPath(path);
+	}
+	function localStat() {
+		return stat(path);
+	}
+	function exist() {
+		return exists(path);
+	}
+	return {
+		path: DCommon.cast(path),
+		getName,
+		getParentPath,
+		stat: localStat,
+		exist,
+		[unknownInterfaceKind.runTimeKey]: null
+	};
+}
+function isUnknownEntryInterface(input) {
+	return unknownInterfaceKind.has(input);
+}
+const isUnknownEntryInterfaceFromUnknown = isUnknownEntryInterface;
+//#endregion
+export { createUnknownEntryInterface, isUnknownEntryInterface, isUnknownEntryInterfaceFromUnknown };

package/dist/file/walkDirectory.cjs

@@ -0,0 +1,57 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+const require_getCurrentWorkDirectoryOrThrow = require("../common/getCurrentWorkDirectoryOrThrow.cjs");
+const require_fileInterface = require("./fileInterface.cjs");
+const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
+const require_folderInterface = require("./folderInterface.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+let _duplojs_lang_generator = require("@duplojs/lang/generator");
+_duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
+//#region scripts/file/walkDirectory.ts
+var WalkDirectoryErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-not-found", Error) {};
+var WalkDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-permission-denied", Error) {};
+var WalkDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-not-directory", Error) {};
+var WalkDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-too-many-open-files", Error) {};
+var WalkDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-busy", Error) {};
+var WalkDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-walk-directory-error", Error) {};
+function handleNodeWalkDirectoryError(error) {
+	let walkDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") walkDirectoryError = new WalkDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") walkDirectoryError = new WalkDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") walkDirectoryError = new WalkDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") walkDirectoryError = new WalkDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") walkDirectoryError = new WalkDirectoryErrorBusy(error);
+	}
+	if (walkDirectoryError === void 0) walkDirectoryError = new WalkDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-walk-directory-error", walkDirectoryError);
+}
+const walkDirectory = require_implementor.implementFunction("walkDirectory", { NODE: async (path, params) => require_implementor.nodeFileSystem.value.readdir(path, {
+	recursive: params?.recursive ?? false,
+	withFileTypes: true
+}).then((result) => {
+	const currentWorkDirectory = require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow();
+	return _duplojs_lang_common.pipe(result, _duplojs_lang_generator.map((dirent) => ({
+		dirent,
+		path: _duplojs_lang_path.resolveFrom(currentWorkDirectory, [_duplojs_lang_path.normalize(`${dirent.parentPath}/${dirent.name}`)])
+	})), (generator) => {
+		const matcher = params?.matcher;
+		if (!matcher) return generator;
+		return _duplojs_lang_generator.filter(generator, ({ path }) => matcher(path));
+	}, _duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when(({ dirent }) => dirent.isFile(), ({ path }) => require_fileInterface.createFileInterface(path)), _duplojs_lang_pattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => require_folderInterface.createFolderInterface(path)), _duplojs_lang_pattern.otherwise(({ path }) => require_unknownEntryInterface.createUnknownEntryInterface(path)))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value));
+}).catch(handleNodeWalkDirectoryError) });
+//#endregion
+exports.WalkDirectoryError = WalkDirectoryError;
+exports.WalkDirectoryErrorBusy = WalkDirectoryErrorBusy;
+exports.WalkDirectoryErrorNotDirectory = WalkDirectoryErrorNotDirectory;
+exports.WalkDirectoryErrorNotFound = WalkDirectoryErrorNotFound;
+exports.WalkDirectoryErrorPermissionDenied = WalkDirectoryErrorPermissionDenied;
+exports.WalkDirectoryErrorTooManyOpenFiles = WalkDirectoryErrorTooManyOpenFiles;
+exports.walkDirectory = walkDirectory;

package/dist/file/walkDirectory.d.ts

@@ -0,0 +1,37 @@
+import { FileInterface } from './fileInterface';
+import { FolderInterface } from './folderInterface';
+import { UnknownEntryInterface } from './unknownEntryInterface';
+import * as DCommon from "@duplojs/lang/common";
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+declare const WalkDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-not-found", unknown>>, unknown>;
+export declare class WalkDirectoryErrorNotFound extends WalkDirectoryErrorNotFound_base {
+}
+declare const WalkDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-permission-denied", unknown>>, unknown>;
+export declare class WalkDirectoryErrorPermissionDenied extends WalkDirectoryErrorPermissionDenied_base {
+}
+declare const WalkDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-not-directory", unknown>>, unknown>;
+export declare class WalkDirectoryErrorNotDirectory extends WalkDirectoryErrorNotDirectory_base {
+}
+declare const WalkDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-too-many-open-files", unknown>>, unknown>;
+export declare class WalkDirectoryErrorTooManyOpenFiles extends WalkDirectoryErrorTooManyOpenFiles_base {
+}
+declare const WalkDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-busy", unknown>>, unknown>;
+export declare class WalkDirectoryErrorBusy extends WalkDirectoryErrorBusy_base {
+}
+declare const WalkDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-walk-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-walk-directory-error", unknown>>, unknown>;
+export declare class WalkDirectoryError extends WalkDirectoryError_base {
+}
+export type WalkDirectoryErrors = (WalkDirectoryErrorNotFound | WalkDirectoryErrorPermissionDenied | WalkDirectoryErrorNotDirectory | WalkDirectoryErrorTooManyOpenFiles | WalkDirectoryErrorBusy | WalkDirectoryError);
+export interface WalkDirectoryParams {
+    recursive?: boolean;
+    matcher?: DPath.PathMatcher<string & DPath.Absolute>;
+}
+export type WalkDirectoryResult = (DEither.Right<"file-system-walk-directory", Generator<FileInterface<string & DPath.Absolute> | FolderInterface<string & DPath.Absolute> | UnknownEntryInterface<string & DPath.Absolute>>> | DEither.Left<"file-system-walk-directory-error", WalkDirectoryErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        walkDirectory(path: DPath.AnyPath, params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
+    }
+}
+export declare const walkDirectory: (path: DPath.AnyPath, params?: WalkDirectoryParams) => Promise<WalkDirectoryResult>;
+export {};

package/dist/file/walkDirectory.mjs

@@ -0,0 +1,45 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import { getCurrentWorkDirectoryOrThrow } from "../common/getCurrentWorkDirectoryOrThrow.mjs";
+import { createFileInterface } from "./fileInterface.mjs";
+import { createUnknownEntryInterface } from "./unknownEntryInterface.mjs";
+import { createFolderInterface } from "./folderInterface.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+import * as DGenerator from "@duplojs/lang/generator";
+//#region scripts/file/walkDirectory.ts
+var WalkDirectoryErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-not-found", Error) {};
+var WalkDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-permission-denied", Error) {};
+var WalkDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-not-directory", Error) {};
+var WalkDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-too-many-open-files", Error) {};
+var WalkDirectoryErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-busy", Error) {};
+var WalkDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-walk-directory-error", Error) {};
+function handleNodeWalkDirectoryError(error) {
+	let walkDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") walkDirectoryError = new WalkDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") walkDirectoryError = new WalkDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") walkDirectoryError = new WalkDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") walkDirectoryError = new WalkDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") walkDirectoryError = new WalkDirectoryErrorBusy(error);
+	}
+	if (walkDirectoryError === void 0) walkDirectoryError = new WalkDirectoryError(error);
+	return DEither.left("file-system-walk-directory-error", walkDirectoryError);
+}
+const walkDirectory = implementFunction("walkDirectory", { NODE: async (path, params) => nodeFileSystem.value.readdir(path, {
+	recursive: params?.recursive ?? false,
+	withFileTypes: true
+}).then((result) => {
+	const currentWorkDirectory = getCurrentWorkDirectoryOrThrow();
+	return DCommon.pipe(result, DGenerator.map((dirent) => ({
+		dirent,
+		path: DPath.resolveFrom(currentWorkDirectory, [DPath.normalize(`${dirent.parentPath}/${dirent.name}`)])
+	})), (generator) => {
+		const matcher = params?.matcher;
+		if (!matcher) return generator;
+		return DGenerator.filter(generator, ({ path }) => matcher(path));
+	}, DGenerator.map(DCommon.innerPipe(DPattern.when(({ dirent }) => dirent.isFile(), ({ path }) => createFileInterface(path)), DPattern.when(({ dirent }) => dirent.isDirectory(), ({ path }) => createFolderInterface(path)), DPattern.otherwise(({ path }) => createUnknownEntryInterface(path)))), (value) => DEither.right("file-system-walk-directory", value));
+}).catch(handleNodeWalkDirectoryError) });
+//#endregion
+export { WalkDirectoryError, WalkDirectoryErrorBusy, WalkDirectoryErrorNotDirectory, WalkDirectoryErrorNotFound, WalkDirectoryErrorPermissionDenied, WalkDirectoryErrorTooManyOpenFiles, walkDirectory };

package/dist/file/writeFile.cjs

@@ -0,0 +1,68 @@
+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/writeFile.ts
+var WriteFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-not-found", Error) {};
+var WriteFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-permission-denied", Error) {};
+var WriteFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-is-directory", Error) {};
+var WriteFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-not-directory", Error) {};
+var WriteFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-no-space", Error) {};
+var WriteFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-read-only", Error) {};
+var WriteFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-invalid-argument", Error) {};
+var WriteFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-too-many-open-files", Error) {};
+var WriteFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-busy", Error) {};
+var WriteFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-file-error", Error) {};
+function handleNodeWriteFileError(error) {
+	let writeFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeFileError = new WriteFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeFileError = new WriteFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeFileError = new WriteFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeFileError = new WriteFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeFileError = new WriteFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeFileError = new WriteFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeFileError = new WriteFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeFileError = new WriteFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeFileError = new WriteFileErrorBusy(error);
+	}
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return _duplojs_lang_either.left("file-system-write-file-error", writeFileError);
+}
+function handleDenoWriteFileError(error) {
+	let writeFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeFileError = new WriteFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeFileError = new WriteFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeFileError = new WriteFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeFileError = new WriteFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeFileError = new WriteFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeFileError = new WriteFileErrorBusy(error);
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return _duplojs_lang_either.left("file-system-write-file-error", writeFileError);
+}
+const writeFileImplementation = require_implementor.implementFunction("writeFile", {
+	NODE: async (path, data) => require_implementor.nodeFileSystem.value.writeFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleNodeWriteFileError),
+	DENO: (path, data) => Deno.writeFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleDenoWriteFileError),
+	BUN: (path, data) => Bun.file(path).write(data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleNodeWriteFileError)
+});
+function writeFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => writeFileImplementation(path, data);
+	}
+	return writeFileImplementation(...args);
+}
+//#endregion
+exports.WriteFileError = WriteFileError;
+exports.WriteFileErrorBusy = WriteFileErrorBusy;
+exports.WriteFileErrorInvalidArgument = WriteFileErrorInvalidArgument;
+exports.WriteFileErrorIsDirectory = WriteFileErrorIsDirectory;
+exports.WriteFileErrorNoSpace = WriteFileErrorNoSpace;
+exports.WriteFileErrorNotDirectory = WriteFileErrorNotDirectory;
+exports.WriteFileErrorNotFound = WriteFileErrorNotFound;
+exports.WriteFileErrorPermissionDenied = WriteFileErrorPermissionDenied;
+exports.WriteFileErrorReadOnly = WriteFileErrorReadOnly;
+exports.WriteFileErrorTooManyOpenFiles = WriteFileErrorTooManyOpenFiles;
+exports.writeFile = writeFile;