@gjsify/fs 0.3.12 → 0.3.14

package/lib/esm/promises.js

@@ -1,444 +1,471 @@
-import Gio from "@girs/gio-2.0";
-import GLib from "@girs/glib-2.0";
-import { join, dirname } from "node:path";
-import { getEncodingFromOptions, encodeUint8Array, decode } from "./encoding.js";
-import { realpathSync, readdirSync as readdirSyncFn, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, linkSync } from "./sync.js";
-import { cpAsync } from "./cp.js";
-import { opendirAsync } from "./dir.js";
-import { globAsync } from "./glob.js";
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { decode, encodeUint8Array, getEncodingFromOptions } from "./encoding.js";
+import { normalizePath, tempDirPath } from "./utils.js";
 import { watchAsync } from "./fs-watcher.js";
-import { statfsAsync } from "./statfs.js";
-import { utimesAsync, lutimesAsync, lchownAsync, lchmodAsync } from "./utimes.js";
-import {
-  fstatAsync,
-  ftruncateAsync,
-  fdatasyncAsync,
-  fsyncAsync,
-  fchmodAsync,
-  fchownAsync,
-  futimesAsync,
-  readvAsync,
-  writevAsync,
-  openAsBlob
-} from "./fd-ops.js";
-import { FileHandle } from "./file-handle.js";
-import { tempDirPath, normalizePath } from "./utils.js";
 import { Dirent } from "./dirent.js";
-import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
+import { BigIntStats, STAT_ATTRIBUTES, Stats } from "./stats.js";
+import { FileHandle } from "./file-handle.js";
 import { createNodeError } from "./errors.js";
+import { accessSync, appendFileSync, chmodSync, chownSync, copyFileSync, linkSync, readdirSync, readlinkSync, realpathSync, renameSync, truncateSync } from "./sync.js";
+import { cpAsync as cpPromises } from "./cp.js";
+import { opendirAsync } from "./dir.js";
+import { globAsync } from "./glob.js";
+import { statfsAsync } from "./statfs.js";
+import { lchmodAsync, lchownAsync, lutimesAsync, utimesAsync } from "./utimes.js";
+import { fchmodAsync, fchownAsync, fdatasyncAsync, fstatAsync, fsyncAsync, ftruncateAsync, futimesAsync, openAsBlob, readvAsync, writevAsync } from "./fd-ops.js";
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
+import { dirname, join } from "node:path";
+
+//#region src/promises.ts
+var promises_exports = /* @__PURE__ */ __exportAll({
+	access: () => access,
+	appendFile: () => appendFile,
+	chmod: () => chmod,
+	chown: () => chown,
+	copyFile: () => copyFile,
+	cp: () => cpPromises,
+	default: () => promises_default,
+	fchmod: () => fchmodAsync,
+	fchown: () => fchownAsync,
+	fdatasync: () => fdatasyncAsync,
+	fstat: () => fstatAsync,
+	fsync: () => fsyncAsync,
+	ftruncate: () => ftruncateAsync,
+	futimes: () => futimesAsync,
+	glob: () => globAsync,
+	lchmod: () => lchmodAsync,
+	lchown: () => lchownAsync,
+	link: () => link,
+	lstat: () => lstat,
+	lutimes: () => lutimesAsync,
+	mkdir: () => mkdir,
+	mkdtemp: () => mkdtemp,
+	open: () => open,
+	openAsBlob: () => openAsBlob,
+	opendir: () => opendirAsync,
+	readFile: () => readFile,
+	readdir: () => readdir,
+	readlink: () => readlink,
+	readv: () => readvAsync,
+	realpath: () => realpath,
+	rename: () => rename,
+	rm: () => rm,
+	rmdir: () => rmdir,
+	stat: () => stat,
+	statfs: () => statfsAsync,
+	symlink: () => symlink,
+	truncate: () => truncate,
+	unlink: () => unlink,
+	utimes: () => utimesAsync,
+	watch: () => watchAsync,
+	write: () => write,
+	writeFile: () => writeFile,
+	writev: () => writevAsync
+});
 async function mkdir(path, options) {
-  let recursive;
-  let _mode = 511;
-  if (typeof options === "object") {
-    if (options.recursive) recursive = options.recursive;
-    if (options.mode) _mode = options.mode;
-  } else {
-    _mode = options;
-  }
-  const pathStr = normalizePath(path);
-  if (recursive) {
-    return mkdirRecursiveAsync(pathStr);
-  }
-  const file = Gio.File.new_for_path(pathStr);
-  return new Promise((resolve, reject) => {
-    file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        file.make_directory_finish(res);
-        resolve(void 0);
-      } catch (err) {
-        reject(createNodeError(err, "mkdir", pathStr));
-      }
-    });
-  });
+	let recursive;
+	let _mode = 511;
+	if (typeof options === "object") {
+		if (options.recursive) recursive = options.recursive;
+		if (options.mode) _mode = options.mode;
+	} else {
+		_mode = options;
+	}
+	const pathStr = normalizePath(path);
+	if (recursive) {
+		return mkdirRecursiveAsync(pathStr);
+	}
+	const file = Gio.File.new_for_path(pathStr);
+	return new Promise((resolve, reject) => {
+		file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				file.make_directory_finish(res);
+				resolve(undefined);
+			} catch (err) {
+				reject(createNodeError(err, "mkdir", pathStr));
+			}
+		});
+	});
 }
+/**
+* Recursively creates directories, similar to `mkdir -p`.
+* Returns the first directory path created, or undefined if all directories already existed.
+*/
 async function mkdirRecursiveAsync(pathStr) {
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    await new Promise((resolve, reject) => {
-      file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-        try {
-          file.make_directory_finish(res);
-          resolve();
-        } catch (err) {
-          reject(err);
-        }
-      });
-    });
-    return pathStr;
-  } catch (err) {
-    const gErr = err;
-    if (gErr.code === Gio.IOErrorEnum.EXISTS) {
-      return void 0;
-    }
-    if (gErr.code === Gio.IOErrorEnum.NOT_FOUND) {
-      const parentPath = dirname(pathStr);
-      if (parentPath === pathStr) {
-        throw createNodeError(err, "mkdir", pathStr);
-      }
-      const firstCreated = await mkdirRecursiveAsync(parentPath);
-      const retryFile = Gio.File.new_for_path(pathStr);
-      await new Promise((resolve, reject) => {
-        retryFile.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-          try {
-            retryFile.make_directory_finish(res);
-            resolve();
-          } catch (retryErr) {
-            reject(createNodeError(retryErr, "mkdir", pathStr));
-          }
-        });
-      });
-      return firstCreated ?? pathStr;
-    }
-    throw createNodeError(err, "mkdir", pathStr);
-  }
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		await new Promise((resolve, reject) => {
+			file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+				try {
+					file.make_directory_finish(res);
+					resolve();
+				} catch (err) {
+					reject(err);
+				}
+			});
+		});
+		return pathStr;
+	} catch (err) {
+		const gErr = err;
+		if (gErr.code === Gio.IOErrorEnum.EXISTS) {
+			return undefined;
+		}
+		if (gErr.code === Gio.IOErrorEnum.NOT_FOUND) {
+			const parentPath = dirname(pathStr);
+			if (parentPath === pathStr) {
+				throw createNodeError(err, "mkdir", pathStr);
+			}
+			const firstCreated = await mkdirRecursiveAsync(parentPath);
+			const retryFile = Gio.File.new_for_path(pathStr);
+			await new Promise((resolve, reject) => {
+				retryFile.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+					try {
+						retryFile.make_directory_finish(res);
+						resolve();
+					} catch (retryErr) {
+						reject(createNodeError(retryErr, "mkdir", pathStr));
+					}
+				});
+			});
+			return firstCreated ?? pathStr;
+		}
+		throw createNodeError(err, "mkdir", pathStr);
+	}
 }
-async function readFile(path, options = { encoding: null, flag: "r" }) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  let ok;
-  let data;
-  try {
-    [ok, data] = await new Promise((resolve, reject) => {
-      file.load_contents_async(null, (self, res) => {
-        try {
-          resolve(file.load_contents_finish(res));
-        } catch (error) {
-          reject(error);
-        }
-      });
-    });
-  } catch (error) {
-    throw createNodeError(error, "open", pathStr);
-  }
-  if (!ok) {
-    throw createNodeError(new Error("failed to read file"), "open", pathStr);
-  }
-  return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+async function readFile(path, options = {
+	encoding: null,
+	flag: "r"
+}) {
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	let ok;
+	let data;
+	try {
+		[ok, data] = await new Promise((resolve, reject) => {
+			file.load_contents_async(null, (self, res) => {
+				try {
+					resolve(file.load_contents_finish(res));
+				} catch (error) {
+					reject(error);
+				}
+			});
+		});
+	} catch (error) {
+		throw createNodeError(error, "open", pathStr);
+	}
+	if (!ok) {
+		throw createNodeError(new Error("failed to read file"), "open", pathStr);
+	}
+	return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
 }
 async function mkdtemp(prefix, options) {
-  const encoding = getEncodingFromOptions(options);
-  const path = tempDirPath(prefix);
-  await mkdir(
-    path,
-    { recursive: false, mode: 448 }
-  );
-  return decode(path, encoding);
+	const encoding = getEncodingFromOptions(options);
+	const path = tempDirPath(prefix);
+	await mkdir(path, {
+		recursive: false,
+		mode: 448
+	});
+	return decode(path, encoding);
 }
 async function writeFile(path, data) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  let bytes;
-  if (typeof data === "string") {
-    bytes = new TextEncoder().encode(data);
-  } else if (data instanceof Uint8Array) {
-    bytes = data;
-  } else {
-    bytes = new TextEncoder().encode(String(data));
-  }
-  const outputStream = await new Promise((resolve, reject) => {
-    file.replace_async(null, false, Gio.FileCreateFlags.REPLACE_DESTINATION, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        resolve(file.replace_finish(res));
-      } catch (err) {
-        reject(createNodeError(err, "open", pathStr));
-      }
-    });
-  });
-  if (bytes.length > 0) {
-    const glibBytes = new GLib.Bytes(bytes);
-    await new Promise((resolve, reject) => {
-      outputStream.write_bytes_async(glibBytes, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-        try {
-          outputStream.write_bytes_finish(res);
-          resolve();
-        } catch (err) {
-          reject(createNodeError(err, "write", pathStr));
-        }
-      });
-    });
-  }
-  await new Promise((resolve, reject) => {
-    outputStream.close_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        outputStream.close_finish(res);
-        resolve();
-      } catch (err) {
-        reject(createNodeError(err, "close", pathStr));
-      }
-    });
-  });
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	let bytes;
+	if (typeof data === "string") {
+		bytes = new TextEncoder().encode(data);
+	} else if (data instanceof Uint8Array) {
+		bytes = data;
+	} else {
+		bytes = new TextEncoder().encode(String(data));
+	}
+	const outputStream = await new Promise((resolve, reject) => {
+		file.replace_async(null, false, Gio.FileCreateFlags.REPLACE_DESTINATION, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				resolve(file.replace_finish(res));
+			} catch (err) {
+				reject(createNodeError(err, "open", pathStr));
+			}
+		});
+	});
+	if (bytes.length > 0) {
+		const glibBytes = new GLib.Bytes(bytes);
+		await new Promise((resolve, reject) => {
+			outputStream.write_bytes_async(glibBytes, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+				try {
+					outputStream.write_bytes_finish(res);
+					resolve();
+				} catch (err) {
+					reject(createNodeError(err, "write", pathStr));
+				}
+			});
+		});
+	}
+	await new Promise((resolve, reject) => {
+		outputStream.close_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				outputStream.close_finish(res);
+				resolve();
+			} catch (err) {
+				reject(createNodeError(err, "close", pathStr));
+			}
+		});
+	});
 }
+/**
+* Removes the directory identified by `path`.
+*
+* Using `fsPromises.rmdir()` on a file (not a directory) results in the
+* promise being rejected with an `ENOENT` error on Windows and an `ENOTDIR`error on POSIX.
+*
+* To get a behavior similar to the `rm -rf` Unix command, use `fsPromises.rm()` with options `{ recursive: true, force: true }`.
+* @since v10.0.0
+* @return Fulfills with `undefined` upon success.
+*/
 async function rmdir(path, _options) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  const info = await new Promise((resolve, reject) => {
-    file.query_info_async("standard::type", Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        resolve(file.query_info_finish(res));
-      } catch (err) {
-        reject(createNodeError(err, "rmdir", pathStr));
-      }
-    });
-  });
-  if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
-    const err = Object.assign(new Error(), { code: 4 });
-    throw createNodeError(err, "rmdir", pathStr);
-  }
-  const children = await new Promise((resolve, reject) => {
-    file.enumerate_children_async("standard::name", Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        resolve(file.enumerate_children_finish(res));
-      } catch (err) {
-        reject(createNodeError(err, "rmdir", pathStr));
-      }
-    });
-  });
-  const firstChild = children.next_file(null);
-  if (firstChild !== null) {
-    const err = Object.assign(new Error(), { code: 5 });
-    throw createNodeError(err, "rmdir", pathStr);
-  }
-  await new Promise((resolve, reject) => {
-    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        file.delete_finish(res);
-        resolve();
-      } catch (err) {
-        reject(createNodeError(err, "rmdir", pathStr));
-      }
-    });
-  });
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	const info = await new Promise((resolve, reject) => {
+		file.query_info_async("standard::type", Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				resolve(file.query_info_finish(res));
+			} catch (err) {
+				reject(createNodeError(err, "rmdir", pathStr));
+			}
+		});
+	});
+	if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
+		const err = Object.assign(new Error(), { code: 4 });
+		throw createNodeError(err, "rmdir", pathStr);
+	}
+	const children = await new Promise((resolve, reject) => {
+		file.enumerate_children_async("standard::name", Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				resolve(file.enumerate_children_finish(res));
+			} catch (err) {
+				reject(createNodeError(err, "rmdir", pathStr));
+			}
+		});
+	});
+	const firstChild = children.next_file(null);
+	if (firstChild !== null) {
+		const err = Object.assign(new Error(), { code: 5 });
+		throw createNodeError(err, "rmdir", pathStr);
+	}
+	await new Promise((resolve, reject) => {
+		file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				file.delete_finish(res);
+				resolve();
+			} catch (err) {
+				reject(createNodeError(err, "rmdir", pathStr));
+			}
+		});
+	});
 }
 async function unlink(path) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  await new Promise((resolve, reject) => {
-    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        file.delete_finish(res);
-        resolve();
-      } catch (err) {
-        reject(createNodeError(err, "unlink", pathStr));
-      }
-    });
-  });
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	await new Promise((resolve, reject) => {
+		file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				file.delete_finish(res);
+				resolve();
+			} catch (err) {
+				reject(createNodeError(err, "unlink", pathStr));
+			}
+		});
+	});
 }
 async function open(path, flags, mode) {
-  return new FileHandle({ path, flags, mode });
+	return new FileHandle({
+		path,
+		flags,
+		mode
+	});
 }
 async function write(fd, data, positionOrOffset, encodingOrLength, position) {
-  if (typeof data === "string") {
-    return _writeStr(fd, data, positionOrOffset, encodingOrLength);
-  }
-  return _writeBuf(fd, data, positionOrOffset, encodingOrLength, position);
+	if (typeof data === "string") {
+		return _writeStr(fd, data, positionOrOffset, encodingOrLength);
+	}
+	return _writeBuf(fd, data, positionOrOffset, encodingOrLength, position);
 }
 async function _writeBuf(fd, buffer, offset, length, position) {
-  const fileHandle = FileHandle.getInstance(fd);
-  const result = await fileHandle.write(buffer, offset, length, position);
-  return { bytesWritten: result.bytesWritten, buffer };
+	const fileHandle = FileHandle.getInstance(fd);
+	const result = await fileHandle.write(buffer, offset, length, position);
+	return {
+		bytesWritten: result.bytesWritten,
+		buffer
+	};
 }
 async function _writeStr(fd, data, position, encoding) {
-  const fileHandle = FileHandle.getInstance(fd);
-  const result = await fileHandle.write(data, position, encoding);
-  return { bytesWritten: result.bytesWritten, buffer: data };
+	const fileHandle = FileHandle.getInstance(fd);
+	const result = await fileHandle.write(data, position, encoding);
+	return {
+		bytesWritten: result.bytesWritten,
+		buffer: data
+	};
 }
 function queryInfoAsync(path, flags, syscall, options) {
-  const pathStr = normalizePath(path);
-  return new Promise((resolve, reject) => {
-    const file = Gio.File.new_for_path(pathStr);
-    file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        const info = file.query_info_finish(res);
-        resolve(options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr));
-      } catch (err) {
-        reject(createNodeError(err, syscall, pathStr));
-      }
-    });
-  });
+	const pathStr = normalizePath(path);
+	return new Promise((resolve, reject) => {
+		const file = Gio.File.new_for_path(pathStr);
+		file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				const info = file.query_info_finish(res);
+				resolve(options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr));
+			} catch (err) {
+				reject(createNodeError(err, syscall, pathStr));
+			}
+		});
+	});
 }
 async function stat(path, options) {
-  return queryInfoAsync(path, Gio.FileQueryInfoFlags.NONE, "stat", options);
+	return queryInfoAsync(path, Gio.FileQueryInfoFlags.NONE, "stat", options);
 }
 async function lstat(path, options) {
-  return queryInfoAsync(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, "lstat", options);
+	return queryInfoAsync(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, "lstat", options);
 }
 async function readdir(path, options) {
-  try {
-    return readdirSyncFn(path, options);
-  } catch (error) {
-    throw createNodeError(error, "scandir", path);
-  }
+	try {
+		return readdirSync(path, options);
+	} catch (error) {
+		throw createNodeError(error, "scandir", path);
+	}
 }
 async function realpath(path) {
-  return realpathSync(path);
+	return realpathSync(path);
 }
 async function symlink(target, path, _type) {
-  const pathStr = normalizePath(path);
-  const targetStr = normalizePath(target);
-  return new Promise((resolve, reject) => {
-    const file = Gio.File.new_for_path(pathStr);
-    file.make_symbolic_link_async(targetStr, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        file.make_symbolic_link_finish(res);
-        resolve();
-      } catch (err) {
-        reject(createNodeError(err, "symlink", targetStr, pathStr));
-      }
-    });
-  });
+	const pathStr = normalizePath(path);
+	const targetStr = normalizePath(target);
+	return new Promise((resolve, reject) => {
+		const file = Gio.File.new_for_path(pathStr);
+		file.make_symbolic_link_async(targetStr, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				file.make_symbolic_link_finish(res);
+				resolve();
+			} catch (err) {
+				reject(createNodeError(err, "symlink", targetStr, pathStr));
+			}
+		});
+	});
 }
+/**
+* Removes files and directories (modeled on the standard POSIX `rm` utility).
+* @since v14.14.0
+* @return Fulfills with `undefined` upon success.
+*/
 async function rm(path, options) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  const recursive = options?.recursive || false;
-  const force = options?.force || false;
-  let dirent;
-  try {
-    dirent = new Dirent(pathStr);
-  } catch (err) {
-    if (force) return;
-    throw createNodeError(err, "rm", path);
-  }
-  if (dirent.isDirectory()) {
-    const childFiles = await readdir(path, { withFileTypes: true });
-    if (!recursive && childFiles.length) {
-      const err = Object.assign(new Error(), { code: 5 });
-      throw createNodeError(err, "rm", path);
-    }
-    for (const childFile of childFiles) {
-      if (typeof childFile !== "string") {
-        await rm(join(pathStr, childFile.name), options);
-      }
-    }
-  }
-  await new Promise((resolve, reject) => {
-    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_self, res) => {
-      try {
-        file.delete_finish(res);
-        resolve();
-      } catch (err) {
-        if (force) {
-          resolve();
-          return;
-        }
-        reject(createNodeError(err, "rm", path));
-      }
-    });
-  });
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	const recursive = options?.recursive || false;
+	const force = options?.force || false;
+	let dirent;
+	try {
+		dirent = new Dirent(pathStr);
+	} catch (err) {
+		if (force) return;
+		throw createNodeError(err, "rm", path);
+	}
+	if (dirent.isDirectory()) {
+		const childFiles = await readdir(path, { withFileTypes: true });
+		if (!recursive && childFiles.length) {
+			const err = Object.assign(new Error(), { code: 5 });
+			throw createNodeError(err, "rm", path);
+		}
+		for (const childFile of childFiles) {
+			if (typeof childFile !== "string") {
+				await rm(join(pathStr, childFile.name), options);
+			}
+		}
+	}
+	await new Promise((resolve, reject) => {
+		file.delete_async(GLib.PRIORITY_DEFAULT, null, (_self, res) => {
+			try {
+				file.delete_finish(res);
+				resolve();
+			} catch (err) {
+				if (force) {
+					resolve();
+					return;
+				}
+				reject(createNodeError(err, "rm", path));
+			}
+		});
+	});
 }
 async function rename(oldPath, newPath) {
-  renameSync(oldPath, newPath);
+	renameSync(oldPath, newPath);
 }
 async function copyFile(src, dest, mode) {
-  copyFileSync(src, dest, mode);
+	copyFileSync(src, dest, mode);
 }
 async function access(path, mode) {
-  accessSync(path, mode);
+	accessSync(path, mode);
 }
 async function appendFile(path, data, options) {
-  appendFileSync(path, data, options);
+	appendFileSync(path, data, options);
 }
 async function readlink(path, options) {
-  return readlinkSync(path, options);
+	return readlinkSync(path, options);
 }
 async function truncate(path, len) {
-  truncateSync(path, len);
+	truncateSync(path, len);
 }
 async function chmod(path, mode) {
-  chmodSync(path, mode);
+	chmodSync(path, mode);
 }
 async function chown(path, uid, gid) {
-  chownSync(path, uid, gid);
+	chownSync(path, uid, gid);
 }
 async function link(existingPath, newPath) {
-  linkSync(existingPath, newPath);
+	linkSync(existingPath, newPath);
 }
 var promises_default = {
-  readFile,
-  mkdir,
-  mkdtemp,
-  realpath,
-  readdir,
-  writeFile,
-  rmdir,
-  unlink,
-  open,
-  write,
-  rm,
-  lstat,
-  symlink,
-  stat,
-  rename,
-  copyFile,
-  access,
-  appendFile,
-  readlink,
-  truncate,
-  chmod,
-  chown,
-  link,
-  cp: cpAsync,
-  opendir: opendirAsync,
-  glob: globAsync,
-  watch: watchAsync,
-  statfs: statfsAsync,
-  utimes: utimesAsync,
-  lutimes: lutimesAsync,
-  lchown: lchownAsync,
-  lchmod: lchmodAsync,
-  fstat: fstatAsync,
-  ftruncate: ftruncateAsync,
-  fdatasync: fdatasyncAsync,
-  fsync: fsyncAsync,
-  fchmod: fchmodAsync,
-  fchown: fchownAsync,
-  futimes: futimesAsync,
-  readv: readvAsync,
-  writev: writevAsync,
-  openAsBlob
-};
-export {
-  access,
-  appendFile,
-  chmod,
-  chown,
-  copyFile,
-  cpAsync as cp,
-  promises_default as default,
-  fchmodAsync as fchmod,
-  fchownAsync as fchown,
-  fdatasyncAsync as fdatasync,
-  fstatAsync as fstat,
-  fsyncAsync as fsync,
-  ftruncateAsync as ftruncate,
-  futimesAsync as futimes,
-  globAsync as glob,
-  lchmodAsync as lchmod,
-  lchownAsync as lchown,
-  link,
-  lstat,
-  lutimesAsync as lutimes,
-  mkdir,
-  mkdtemp,
-  open,
-  openAsBlob,
-  opendirAsync as opendir,
-  readFile,
-  readdir,
-  readlink,
-  readvAsync as readv,
-  realpath,
-  rename,
-  rm,
-  rmdir,
-  stat,
-  statfsAsync as statfs,
-  symlink,
-  truncate,
-  unlink,
-  utimesAsync as utimes,
-  watchAsync as watch,
-  write,
-  writeFile,
-  writevAsync as writev
+	readFile,
+	mkdir,
+	mkdtemp,
+	realpath,
+	readdir,
+	writeFile,
+	rmdir,
+	unlink,
+	open,
+	write,
+	rm,
+	lstat,
+	symlink,
+	stat,
+	rename,
+	copyFile,
+	access,
+	appendFile,
+	readlink,
+	truncate,
+	chmod,
+	chown,
+	link,
+	cp: cpPromises,
+	opendir: opendirAsync,
+	glob: globAsync,
+	watch: watchAsync,
+	statfs: statfsAsync,
+	utimes: utimesAsync,
+	lutimes: lutimesAsync,
+	lchown: lchownAsync,
+	lchmod: lchmodAsync,
+	fstat: fstatAsync,
+	ftruncate: ftruncateAsync,
+	fdatasync: fdatasyncAsync,
+	fsync: fsyncAsync,
+	fchmod: fchmodAsync,
+	fchown: fchownAsync,
+	futimes: futimesAsync,
+	readv: readvAsync,
+	writev: writevAsync,
+	openAsBlob
 };
+
+//#endregion
+export { access, appendFile, chmod, chown, copyFile, cpPromises as cp, promises_default as default, fchmodAsync as fchmod, fchownAsync as fchown, fdatasyncAsync as fdatasync, fstatAsync as fstat, fsyncAsync as fsync, ftruncateAsync as ftruncate, futimesAsync as futimes, globAsync as glob, lchmodAsync as lchmod, lchownAsync as lchown, link, lstat, lutimesAsync as lutimes, mkdir, mkdtemp, open, openAsBlob, opendirAsync as opendir, promises_exports, readFile, readdir, readlink, readvAsync as readv, realpath, rename, rm, rmdir, stat, statfsAsync as statfs, symlink, truncate, unlink, utimesAsync as utimes, watchAsync as watch, write, writeFile, writevAsync as writev };