@gjsify/fs 0.3.13 → 0.3.14

package/lib/esm/sync.js

@@ -1,393 +1,418 @@
+import { decode, encodeUint8Array, getEncodingFromOptions } from "./encoding.js";
+import { normalizePath, tempDirPath } from "./utils.js";
+import { FSWatcher } from "./fs-watcher.js";
+import { Dirent } from "./dirent.js";
+import { BigIntStats, STAT_ATTRIBUTES, Stats } from "./stats.js";
+import { FileHandle } from "./file-handle.js";
+import { createNodeError as createNodeError$1, isNotFoundError } from "./errors.js";
 import GLib from "@girs/glib-2.0";
 import Gio from "@girs/gio-2.0";
-import { existsSync } from "@gjsify/utils";
-import { Buffer } from "node:buffer";
 import { join } from "node:path";
-import FSWatcher from "./fs-watcher.js";
-import { getEncodingFromOptions, encodeUint8Array, decode } from "./encoding.js";
-import { FileHandle } from "./file-handle.js";
-import { Dirent } from "./dirent.js";
-import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
-import { createNodeError, isNotFoundError } from "./errors.js";
-import { tempDirPath, normalizePath } from "./utils.js";
+import { Buffer } from "node:buffer";
+import { existsSync } from "@gjsify/utils";
+
+//#region src/sync.ts
 function statSync(path, options) {
-  const pathStr = normalizePath(path);
-  try {
-    const file = Gio.File.new_for_path(pathStr);
-    const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NONE, null);
-    return options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr);
-  } catch (err) {
-    if (options?.throwIfNoEntry === false && isNotFoundError(err)) return void 0;
-    throw createNodeError(err, "stat", pathStr);
-  }
+	const pathStr = normalizePath(path);
+	try {
+		const file = Gio.File.new_for_path(pathStr);
+		const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NONE, null);
+		return options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr);
+	} catch (err) {
+		if (options?.throwIfNoEntry === false && isNotFoundError(err)) return undefined;
+		throw createNodeError$1(err, "stat", pathStr);
+	}
 }
 function lstatSync(path, options) {
-  const pathStr = normalizePath(path);
-  try {
-    const file = Gio.File.new_for_path(pathStr);
-    const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-    return options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr);
-  } catch (err) {
-    if (options?.throwIfNoEntry === false && isNotFoundError(err)) return void 0;
-    throw createNodeError(err, "lstat", pathStr);
-  }
+	const pathStr = normalizePath(path);
+	try {
+		const file = Gio.File.new_for_path(pathStr);
+		const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+		return options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr);
+	} catch (err) {
+		if (options?.throwIfNoEntry === false && isNotFoundError(err)) return undefined;
+		throw createNodeError$1(err, "lstat", pathStr);
+	}
 }
 function readdirSync(path, options) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  const enumerator = file.enumerate_children(
-    "standard::name,standard::type",
-    Gio.FileQueryInfoFlags.NONE,
-    null
-  );
-  const result = [];
-  let info = enumerator.next_file(null);
-  while (info !== null) {
-    const childName = info.get_name();
-    const childPath = join(pathStr, childName);
-    if (options?.withFileTypes) {
-      result.push(new Dirent(childPath, childName));
-    } else {
-      result.push(childName);
-    }
-    if (options?.recursive && info.get_file_type() === Gio.FileType.DIRECTORY) {
-      const subEntries = readdirSync(childPath, options);
-      for (const entry of subEntries) {
-        if (typeof entry === "string") {
-          result.push(join(childName, entry));
-        } else {
-          result.push(entry);
-        }
-      }
-    }
-    info = enumerator.next_file(null);
-  }
-  return result;
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	const enumerator = file.enumerate_children("standard::name,standard::type", Gio.FileQueryInfoFlags.NONE, null);
+	const result = [];
+	let info = enumerator.next_file(null);
+	while (info !== null) {
+		const childName = info.get_name();
+		const childPath = join(pathStr, childName);
+		if (options?.withFileTypes) {
+			result.push(new Dirent(childPath, childName));
+		} else {
+			result.push(childName);
+		}
+		if (options?.recursive && info.get_file_type() === Gio.FileType.DIRECTORY) {
+			const subEntries = readdirSync(childPath, options);
+			for (const entry of subEntries) {
+				if (typeof entry === "string") {
+					result.push(join(childName, entry));
+				} else {
+					result.push(entry);
+				}
+			}
+		}
+		info = enumerator.next_file(null);
+	}
+	return result;
 }
 const MAX_SYMLINK_DEPTH = 40;
 function realpathSync(path) {
-  const pathStr = normalizePath(path);
-  let current = Gio.File.new_for_path(pathStr);
-  let depth = 0;
-  while (true) {
-    const info = current.query_info(
-      "standard::is-symlink,standard::symlink-target",
-      Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
-      null
-    );
-    if (!info.get_is_symlink()) {
-      return current.get_path();
-    }
-    const target = info.get_symlink_target();
-    const parent = current.get_parent();
-    current = parent ? parent.resolve_relative_path(target) : Gio.File.new_for_path(target);
-    if (++depth > MAX_SYMLINK_DEPTH) {
-      throw new Error(`ELOOP: too many levels of symbolic links, realpath '${pathStr}'`);
-    }
-  }
+	const pathStr = normalizePath(path);
+	let current = Gio.File.new_for_path(pathStr);
+	let depth = 0;
+	while (true) {
+		const info = current.query_info("standard::is-symlink,standard::symlink-target", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+		if (!info.get_is_symlink()) {
+			return current.get_path();
+		}
+		const target = info.get_symlink_target();
+		const parent = current.get_parent();
+		current = parent ? parent.resolve_relative_path(target) : Gio.File.new_for_path(target);
+		if (++depth > MAX_SYMLINK_DEPTH) {
+			throw new Error(`ELOOP: too many levels of symbolic links, realpath '${pathStr}'`);
+		}
+	}
 }
 realpathSync.native = realpathSync;
 function symlinkSync(target, path, _type) {
-  const pathStr = normalizePath(path);
-  const targetStr = normalizePath(target);
-  const file = Gio.File.new_for_path(pathStr);
-  file.make_symbolic_link(targetStr, null);
+	const pathStr = normalizePath(path);
+	const targetStr = normalizePath(target);
+	const file = Gio.File.new_for_path(pathStr);
+	file.make_symbolic_link(targetStr, null);
 }
-function readFileSync(path, options = { encoding: null, flag: "r" }) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    const [ok, data] = file.load_contents(null);
-    if (!ok) {
-      throw createNodeError(new Error("failed to read file"), "read", pathStr);
-    }
-    return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
-  } catch (err) {
-    if (err.code && typeof err.code === "string") throw err;
-    throw createNodeError(err, "read", pathStr);
-  }
+function readFileSync(path, options = {
+	encoding: null,
+	flag: "r"
+}) {
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		const [ok, data] = file.load_contents(null);
+		if (!ok) {
+			throw createNodeError$1(new Error("failed to read file"), "read", pathStr);
+		}
+		return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+	} catch (err) {
+		if (err.code && typeof err.code === "string") throw err;
+		throw createNodeError$1(err, "read", pathStr);
+	}
 }
+/**
+* Synchronous mkdir(2) - create a directory.
+* @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+* @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
+* should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
+*/
 function mkdirSync(path, options) {
-  let recursive = false;
-  let mode = 511;
-  if (typeof options === "object") {
-    if (options?.recursive) recursive = options.recursive;
-    if (options?.mode) mode = options.mode;
-  } else {
-    mode = options || 511;
-  }
-  path = normalizePath(path);
-  if (typeof mode === "string") {
-    throw new TypeError("mode as string is currently not supported!");
-  }
-  if (recursive) {
-    return mkdirSyncRecursive(path, mode);
-  }
-  const file = Gio.File.new_for_path(path);
-  try {
-    file.make_directory(null);
-  } catch (err) {
-    throw createNodeError(err, "mkdir", path);
-  }
-  return void 0;
+	let recursive = false;
+	let mode = 511;
+	if (typeof options === "object") {
+		if (options?.recursive) recursive = options.recursive;
+		if (options?.mode) mode = options.mode;
+	} else {
+		mode = options || 511;
+	}
+	path = normalizePath(path);
+	if (typeof mode === "string") {
+		throw new TypeError("mode as string is currently not supported!");
+	}
+	if (recursive) {
+		return mkdirSyncRecursive(path, mode);
+	}
+	const file = Gio.File.new_for_path(path);
+	try {
+		file.make_directory(null);
+	} catch (err) {
+		throw createNodeError$1(err, "mkdir", path);
+	}
+	return undefined;
 }
+/**
+* Recursively creates directories, similar to `mkdir -p`.
+* Returns the first directory path created, or undefined if all directories already existed.
+*/
 function mkdirSyncRecursive(pathStr, mode) {
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    file.make_directory(null);
-    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 = join(pathStr, "..");
-      const resolvedParent = Gio.File.new_for_path(parentPath).get_path();
-      if (resolvedParent === pathStr) {
-        throw createNodeError(err, "mkdir", pathStr);
-      }
-      const firstCreated = mkdirSyncRecursive(resolvedParent, mode);
-      const retryFile = Gio.File.new_for_path(pathStr);
-      try {
-        retryFile.make_directory(null);
-      } catch (retryErr) {
-        throw createNodeError(retryErr, "mkdir", pathStr);
-      }
-      return firstCreated ?? pathStr;
-    }
-    throw createNodeError(err, "mkdir", pathStr);
-  }
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		file.make_directory(null);
+		return pathStr;
+	} catch (err) {
+		const gErr = err;
+		if (gErr.code === Gio.IOErrorEnum.EXISTS) {
+			return undefined;
+		}
+		if (gErr.code === Gio.IOErrorEnum.NOT_FOUND) {
+			const parentPath = join(pathStr, "..");
+			const resolvedParent = Gio.File.new_for_path(parentPath).get_path();
+			if (resolvedParent === pathStr) {
+				throw createNodeError$1(err, "mkdir", pathStr);
+			}
+			const firstCreated = mkdirSyncRecursive(resolvedParent, mode);
+			const retryFile = Gio.File.new_for_path(pathStr);
+			try {
+				retryFile.make_directory(null);
+			} catch (retryErr) {
+				throw createNodeError$1(retryErr, "mkdir", pathStr);
+			}
+			return firstCreated ?? pathStr;
+		}
+		throw createNodeError$1(err, "mkdir", pathStr);
+	}
 }
+/**
+* Synchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). Returns `undefined`.
+*
+* Using `fs.rmdirSync()` on a file (not a directory) results in an `ENOENT` error
+* on Windows and an `ENOTDIR` error on POSIX.
+*
+* To get a behavior similar to the `rm -rf` Unix command, use {@link rmSync} with options `{ recursive: true, force: true }`.
+* @since v0.1.21
+*/
 function rmdirSync(path, _options) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    const info = file.query_info("standard::type", Gio.FileQueryInfoFlags.NONE, null);
-    if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
-      const err = Object.assign(new Error(), { code: 4 });
-      throw createNodeError(err, "rmdir", pathStr);
-    }
-    const enumerator = file.enumerate_children("standard::name", Gio.FileQueryInfoFlags.NONE, null);
-    if (enumerator.next_file(null) !== null) {
-      const err = Object.assign(new Error(), { code: 5 });
-      throw createNodeError(err, "rmdir", pathStr);
-    }
-    file.delete(null);
-  } catch (err) {
-    if (err.code && typeof err.code === "string") throw err;
-    throw createNodeError(err, "rmdir", pathStr);
-  }
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		const info = file.query_info("standard::type", Gio.FileQueryInfoFlags.NONE, null);
+		if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
+			const err = Object.assign(new Error(), { code: 4 });
+			throw createNodeError$1(err, "rmdir", pathStr);
+		}
+		const enumerator = file.enumerate_children("standard::name", Gio.FileQueryInfoFlags.NONE, null);
+		if (enumerator.next_file(null) !== null) {
+			const err = Object.assign(new Error(), { code: 5 });
+			throw createNodeError$1(err, "rmdir", pathStr);
+		}
+		file.delete(null);
+	} catch (err) {
+		if (err.code && typeof err.code === "string") throw err;
+		throw createNodeError$1(err, "rmdir", pathStr);
+	}
 }
 function unlinkSync(path) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    file.delete(null);
-  } catch (err) {
-    throw createNodeError(err, "unlink", pathStr);
-  }
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		file.delete(null);
+	} catch (err) {
+		throw createNodeError$1(err, "unlink", pathStr);
+	}
 }
 function writeFileSync(path, data) {
-  GLib.file_set_contents(normalizePath(path), data);
+	GLib.file_set_contents(normalizePath(path), data);
 }
 function renameSync(oldPath, newPath) {
-  const oldStr = normalizePath(oldPath);
-  const newStr = normalizePath(newPath);
-  const src = Gio.File.new_for_path(oldStr);
-  const dest = Gio.File.new_for_path(newStr);
-  try {
-    src.move(dest, Gio.FileCopyFlags.OVERWRITE, null, null);
-  } catch (err) {
-    throw createNodeError(err, "rename", oldStr, newStr);
-  }
+	const oldStr = normalizePath(oldPath);
+	const newStr = normalizePath(newPath);
+	const src = Gio.File.new_for_path(oldStr);
+	const dest = Gio.File.new_for_path(newStr);
+	try {
+		src.move(dest, Gio.FileCopyFlags.OVERWRITE, null, null);
+	} catch (err) {
+		throw createNodeError$1(err, "rename", oldStr, newStr);
+	}
 }
 function copyFileSync(src, dest, mode) {
-  const srcStr = normalizePath(src);
-  const destStr = normalizePath(dest);
-  const srcFile = Gio.File.new_for_path(srcStr);
-  const destFile = Gio.File.new_for_path(destStr);
-  let flags = Gio.FileCopyFlags.NONE;
-  if (mode && (mode & 1) === 0) {
-    flags = Gio.FileCopyFlags.OVERWRITE;
-  } else if (!mode) {
-    flags = Gio.FileCopyFlags.OVERWRITE;
-  }
-  try {
-    srcFile.copy(destFile, flags, null, null);
-  } catch (err) {
-    throw createNodeError(err, "copyfile", srcStr, destStr);
-  }
+	const srcStr = normalizePath(src);
+	const destStr = normalizePath(dest);
+	const srcFile = Gio.File.new_for_path(srcStr);
+	const destFile = Gio.File.new_for_path(destStr);
+	let flags = Gio.FileCopyFlags.NONE;
+	if (mode && (mode & 1) === 0) {
+		flags = Gio.FileCopyFlags.OVERWRITE;
+	} else if (!mode) {
+		flags = Gio.FileCopyFlags.OVERWRITE;
+	}
+	try {
+		srcFile.copy(destFile, flags, null, null);
+	} catch (err) {
+		throw createNodeError$1(err, "copyfile", srcStr, destStr);
+	}
 }
 function accessSync(path, mode) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    const info = file.query_info("access::*", Gio.FileQueryInfoFlags.NONE, null);
-    if (mode !== void 0 && mode !== 0) {
-      const permErr = { code: 14, message: `permission denied, access '${pathStr}'` };
-      if (mode & 4 && !info.get_attribute_boolean("access::can-read")) {
-        throw createNodeError(permErr, "access", pathStr);
-      }
-      if (mode & 2 && !info.get_attribute_boolean("access::can-write")) {
-        throw createNodeError(permErr, "access", pathStr);
-      }
-      if (mode & 1 && !info.get_attribute_boolean("access::can-execute")) {
-        throw createNodeError(permErr, "access", pathStr);
-      }
-    }
-  } catch (err) {
-    if (err.code && typeof err.code === "string") throw err;
-    throw createNodeError(err, "access", pathStr);
-  }
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		const info = file.query_info("access::*", Gio.FileQueryInfoFlags.NONE, null);
+		if (mode !== undefined && mode !== 0) {
+			const permErr = {
+				code: 14,
+				message: `permission denied, access '${pathStr}'`
+			};
+			if (mode & 4 && !info.get_attribute_boolean("access::can-read")) {
+				throw createNodeError$1(permErr, "access", pathStr);
+			}
+			if (mode & 2 && !info.get_attribute_boolean("access::can-write")) {
+				throw createNodeError$1(permErr, "access", pathStr);
+			}
+			if (mode & 1 && !info.get_attribute_boolean("access::can-execute")) {
+				throw createNodeError$1(permErr, "access", pathStr);
+			}
+		}
+	} catch (err) {
+		if (err.code && typeof err.code === "string") throw err;
+		throw createNodeError$1(err, "access", pathStr);
+	}
 }
 function appendFileSync(path, data, options) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  let bytes;
-  if (typeof data === "string") {
-    bytes = new TextEncoder().encode(data);
-  } else {
-    bytes = data;
-  }
-  try {
-    const stream = file.append_to(Gio.FileCreateFlags.NONE, null);
-    if (bytes.length > 0) {
-      stream.write_bytes(new GLib.Bytes(bytes), null);
-    }
-    stream.close(null);
-  } catch (err) {
-    throw createNodeError(err, "appendfile", 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 {
+		bytes = data;
+	}
+	try {
+		const stream = file.append_to(Gio.FileCreateFlags.NONE, null);
+		if (bytes.length > 0) {
+			stream.write_bytes(new GLib.Bytes(bytes), null);
+		}
+		stream.close(null);
+	} catch (err) {
+		throw createNodeError$1(err, "appendfile", pathStr);
+	}
 }
 function readlinkSync(path, options) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    const info = file.query_info("standard::symlink-target", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-    const target = info.get_symlink_target();
-    if (!target) {
-      throw Object.assign(new Error(`EINVAL: invalid argument, readlink '${pathStr}'`), { code: "EINVAL", errno: -22, syscall: "readlink", path: pathStr });
-    }
-    const encoding = typeof options === "string" ? options : options?.encoding;
-    if (encoding === "buffer") {
-      return Buffer.from(target);
-    }
-    return target;
-  } catch (err) {
-    if (typeof err.code === "string") throw err;
-    throw createNodeError(err, "readlink", pathStr);
-  }
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		const info = file.query_info("standard::symlink-target", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+		const target = info.get_symlink_target();
+		if (!target) {
+			throw Object.assign(new Error(`EINVAL: invalid argument, readlink '${pathStr}'`), {
+				code: "EINVAL",
+				errno: -22,
+				syscall: "readlink",
+				path: pathStr
+			});
+		}
+		const encoding = typeof options === "string" ? options : options?.encoding;
+		if (encoding === "buffer") {
+			return Buffer.from(target);
+		}
+		return target;
+	} catch (err) {
+		if (typeof err.code === "string") throw err;
+		throw createNodeError$1(err, "readlink", pathStr);
+	}
 }
 function linkSync(existingPath, newPath) {
-  const existingStr = normalizePath(existingPath);
-  const newStr = normalizePath(newPath);
-  const result = GLib.spawn_command_line_sync(`ln ${existingStr} ${newStr}`);
-  if (!result[0]) {
-    throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingStr}' -> '${newStr}'`), { code: "EPERM", errno: -1, syscall: "link", path: existingStr, dest: newStr });
-  }
+	const existingStr = normalizePath(existingPath);
+	const newStr = normalizePath(newPath);
+	const result = GLib.spawn_command_line_sync(`ln ${existingStr} ${newStr}`);
+	if (!result[0]) {
+		throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingStr}' -> '${newStr}'`), {
+			code: "EPERM",
+			errno: -1,
+			syscall: "link",
+			path: existingStr,
+			dest: newStr
+		});
+	}
 }
 function truncateSync(path, len) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  try {
-    const stream = file.replace(null, false, Gio.FileCreateFlags.NONE, null);
-    if (len && len > 0) {
-      const [, data] = file.load_contents(null);
-      const truncated = data.slice(0, len);
-      if (truncated.length > 0) {
-        stream.write_bytes(new GLib.Bytes(truncated), null);
-      }
-    }
-    stream.close(null);
-  } catch (err) {
-    throw createNodeError(err, "truncate", pathStr);
-  }
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	try {
+		const stream = file.replace(null, false, Gio.FileCreateFlags.NONE, null);
+		if (len && len > 0) {
+			const [, data] = file.load_contents(null);
+			const truncated = data.slice(0, len);
+			if (truncated.length > 0) {
+				stream.write_bytes(new GLib.Bytes(truncated), null);
+			}
+		}
+		stream.close(null);
+	} catch (err) {
+		throw createNodeError$1(err, "truncate", pathStr);
+	}
 }
 function chmodSync(path, mode) {
-  const pathStr = normalizePath(path);
-  const modeNum = typeof mode === "string" ? parseInt(mode, 8) : mode;
-  const result = GLib.spawn_command_line_sync(`chmod ${modeNum.toString(8)} ${pathStr}`);
-  if (!result[0]) {
-    throw Object.assign(new Error(`EPERM: operation not permitted, chmod '${pathStr}'`), { code: "EPERM", errno: -1, syscall: "chmod", path: pathStr });
-  }
+	const pathStr = normalizePath(path);
+	const modeNum = typeof mode === "string" ? parseInt(mode, 8) : mode;
+	const result = GLib.spawn_command_line_sync(`chmod ${modeNum.toString(8)} ${pathStr}`);
+	if (!result[0]) {
+		throw Object.assign(new Error(`EPERM: operation not permitted, chmod '${pathStr}'`), {
+			code: "EPERM",
+			errno: -1,
+			syscall: "chmod",
+			path: pathStr
+		});
+	}
 }
 function chownSync(path, uid, gid) {
-  const pathStr = normalizePath(path);
-  const result = GLib.spawn_command_line_sync(`chown ${uid}:${gid} ${pathStr}`);
-  if (!result[0]) {
-    throw Object.assign(new Error(`EPERM: operation not permitted, chown '${pathStr}'`), { code: "EPERM", errno: -1, syscall: "chown", path: pathStr });
-  }
+	const pathStr = normalizePath(path);
+	const result = GLib.spawn_command_line_sync(`chown ${uid}:${gid} ${pathStr}`);
+	if (!result[0]) {
+		throw Object.assign(new Error(`EPERM: operation not permitted, chown '${pathStr}'`), {
+			code: "EPERM",
+			errno: -1,
+			syscall: "chown",
+			path: pathStr
+		});
+	}
 }
 function watch(filename, options, listener) {
-  return new FSWatcher(normalizePath(filename), options, listener);
+	return new FSWatcher(normalizePath(filename), options, listener);
 }
 function openSync(path, flags, mode) {
-  return new FileHandle({ path, flags, mode });
+	return new FileHandle({
+		path,
+		flags,
+		mode
+	});
 }
 function mkdtempSync(prefix, options) {
-  const encoding = getEncodingFromOptions(options);
-  const path = tempDirPath(prefix);
-  mkdirSync(
-    path,
-    { recursive: false, mode: 511 }
-  );
-  return decode(path, encoding);
+	const encoding = getEncodingFromOptions(options);
+	const path = tempDirPath(prefix);
+	mkdirSync(path, {
+		recursive: false,
+		mode: 511
+	});
+	return decode(path, encoding);
 }
+/**
+* Synchronously removes files and directories (modeled on the standard POSIX `rm`utility). Returns `undefined`.
+* @since v14.14.0
+*/
 function rmSync(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 && isNotFoundError(err)) return;
-    throw createNodeError(err, "rm", path);
-  }
-  if (dirent.isDirectory()) {
-    const childFiles = readdirSync(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") {
-        rmSync(join(pathStr, childFile.name), options);
-      }
-    }
-  }
-  try {
-    file.delete(null);
-  } catch (err) {
-    if (force && isNotFoundError(err)) return;
-    throw 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 && isNotFoundError(err)) return;
+		throw createNodeError$1(err, "rm", path);
+	}
+	if (dirent.isDirectory()) {
+		const childFiles = readdirSync(path, { withFileTypes: true });
+		if (!recursive && childFiles.length) {
+			const err = Object.assign(new Error(), { code: 5 });
+			throw createNodeError$1(err, "rm", path);
+		}
+		for (const childFile of childFiles) {
+			if (typeof childFile !== "string") {
+				rmSync(join(pathStr, childFile.name), options);
+			}
+		}
+	}
+	try {
+		file.delete(null);
+	} catch (err) {
+		if (force && isNotFoundError(err)) return;
+		throw createNodeError$1(err, "rm", path);
+	}
 }
-export {
-  accessSync,
-  appendFileSync,
-  chmodSync,
-  chownSync,
-  copyFileSync,
-  existsSync,
-  linkSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  openSync,
-  readFileSync,
-  readdirSync,
-  readlinkSync,
-  realpathSync,
-  renameSync,
-  rmSync,
-  rmdirSync,
-  statSync,
-  symlinkSync,
-  truncateSync,
-  unlinkSync,
-  watch,
-  writeFileSync
-};
+
+//#endregion
+export { accessSync, appendFileSync, chmodSync, chownSync, copyFileSync, existsSync, linkSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, symlinkSync, truncateSync, unlinkSync, watch, writeFileSync };