@gjsify/fs 0.1.13 → 0.2.0

package/lib/esm/read-stream.js

@@ -2,7 +2,7 @@ import Gio from "@girs/gio-2.0";
 import GLib from "@girs/glib-2.0";
 import { Buffer } from "node:buffer";
 import { Readable } from "node:stream";
-import { URL, fileURLToPath } from "node:url";
+import { normalizePath } from "./utils.js";
 class ReadStream extends Readable {
   bytesRead = 0;
   path;
@@ -10,56 +10,62 @@ class ReadStream extends Readable {
   fd = null;
   _gioFile;
   _inputStream = null;
+  _cancellable = new Gio.Cancellable();
   _start;
   _end;
   _pos;
   close(callback) {
+    this._cancellable.cancel();
     if (this._inputStream) {
-      try {
-        this._inputStream.close(null);
-      } catch {
-      }
+      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {
+      });
       this._inputStream = null;
     }
     this.destroy();
     if (callback) callback(null);
   }
   constructor(path, opts) {
-    if (path instanceof URL) {
-      path = fileURLToPath(path);
-    }
+    const pathStr = normalizePath(path);
     super({
       highWaterMark: opts?.highWaterMark ?? 64 * 1024,
       encoding: opts?.encoding,
       objectMode: false
     });
-    this.path = path.toString();
-    this._gioFile = Gio.File.new_for_path(this.path.toString());
+    this.path = pathStr;
+    this._gioFile = Gio.File.new_for_path(pathStr);
     this._start = opts?.start ?? 0;
     this._end = opts?.end ?? Infinity;
     this._pos = this._start;
-    Promise.resolve().then(() => {
-      if (!this._inputStream && !this.destroyed) {
-        try {
-          this._inputStream = this._gioFile.read(null);
-          this.pending = false;
-          this.emit("open", 0);
-          this.emit("ready");
-          if (this._start > 0 && this._inputStream.can_seek()) {
-            this._inputStream.seek(this._start, GLib.SeekType.SET, null);
-          }
-        } catch (err) {
-          this.destroy(err);
+  }
+  // Use _construct() for async file opening so the stream machinery defers
+  // _read() until the file is open. This avoids the fragile _pendingReadSize
+  // pattern and correctly handles backpressure via the constructed flag.
+  _construct(callback) {
+    this._gioFile.read_async(GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
+      if (this.destroyed) {
+        callback();
+        return;
+      }
+      try {
+        this._inputStream = this._gioFile.read_finish(asyncResult);
+        this.pending = false;
+        this.emit("open", 0);
+        this.emit("ready");
+        if (this._start > 0 && this._inputStream.can_seek()) {
+          this._inputStream.seek(this._start, GLib.SeekType.SET, null);
+        }
+        callback();
+      } catch (err) {
+        if (!this._cancellable.is_cancelled()) {
+          callback(err);
         }
       }
     });
   }
   _read(size) {
-    if (!this._inputStream) {
-      if (this.destroyed) return;
-      Promise.resolve().then(() => this._read(size));
-      return;
-    }
+    this._doRead(size);
+  }
+  _doRead(size) {
     let toRead = size;
     if (this._end !== Infinity) {
       const remaining = this._end - this._pos + 1;
@@ -69,26 +75,30 @@ class ReadStream extends Readable {
       }
       toRead = Math.min(size, remaining);
     }
-    try {
-      const gbytes = this._inputStream.read_bytes(toRead, null);
-      const data = gbytes.get_data();
-      if (!data || data.length === 0) {
-        this.push(null);
-        return;
+    const stream = this._inputStream;
+    stream.read_bytes_async(toRead, GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
+      try {
+        const gbytes = stream.read_bytes_finish(asyncResult);
+        const data = gbytes.get_data();
+        if (!data || data.length === 0) {
+          this.push(null);
+          return;
+        }
+        this.bytesRead += data.length;
+        this._pos += data.length;
+        this.push(Buffer.from(data));
+      } catch (err) {
+        if (!this._cancellable.is_cancelled()) {
+          this.destroy(err);
+        }
       }
-      this.bytesRead += data.length;
-      this._pos += data.length;
-      this.push(Buffer.from(data));
-    } catch (err) {
-      this.destroy(err);
-    }
+    });
   }
   _destroy(error, callback) {
+    this._cancellable.cancel();
     if (this._inputStream) {
-      try {
-        this._inputStream.close(null);
-      } catch {
-      }
+      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {
+      });
       this._inputStream = null;
     }
     callback(error);

package/lib/esm/stat-watcher.js

@@ -0,0 +1,121 @@
+import { EventEmitter } from "node:events";
+import { statSync } from "./sync.js";
+function zeroedStat() {
+  return {
+    dev: 0,
+    ino: 0,
+    mode: 0,
+    nlink: 0,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    size: 0,
+    blksize: 0,
+    blocks: 0,
+    atimeMs: 0,
+    mtimeMs: 0,
+    ctimeMs: 0,
+    birthtimeMs: 0,
+    atime: /* @__PURE__ */ new Date(0),
+    mtime: /* @__PURE__ */ new Date(0),
+    ctime: /* @__PURE__ */ new Date(0),
+    birthtime: /* @__PURE__ */ new Date(0),
+    isFile: () => false,
+    isDirectory: () => false,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+class StatWatcher extends EventEmitter {
+  _path;
+  _interval;
+  _timerId = null;
+  _prev;
+  _changeCount = 0;
+  constructor(path, interval) {
+    super();
+    this._path = path;
+    this._interval = interval;
+    this._prev = zeroedStat();
+  }
+  start() {
+    try {
+      this._prev = statSync(this._path);
+    } catch {
+    }
+    this._timerId = setInterval(() => {
+      let curr;
+      try {
+        curr = statSync(this._path);
+      } catch {
+        curr = zeroedStat();
+      }
+      const prev = this._prev;
+      if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size || curr.ino !== prev.ino) {
+        this._prev = curr;
+        this.emit("change", curr, prev);
+      }
+    }, this._interval);
+  }
+  stop() {
+    if (this._timerId !== null) {
+      clearInterval(this._timerId);
+      this._timerId = null;
+    }
+    this.emit("stop");
+  }
+  addChangeListener(listener) {
+    this._changeCount++;
+    this.on("change", listener);
+  }
+  removeChangeListener(listener) {
+    this._changeCount--;
+    this.removeListener("change", listener);
+  }
+  removeAllChangeListeners() {
+    this._changeCount = 0;
+    this.removeAllListeners("change");
+  }
+  get changeListenerCount() {
+    return this._changeCount;
+  }
+}
+const statWatchers = /* @__PURE__ */ new Map();
+function watchFile(filename, options, listener) {
+  if (typeof options === "function") {
+    listener = options;
+    options = {};
+  }
+  const interval = options.interval ?? 5007;
+  const resolved = filename.toString();
+  let watcher = statWatchers.get(resolved);
+  if (!watcher) {
+    watcher = new StatWatcher(resolved, interval);
+    watcher.start();
+    statWatchers.set(resolved, watcher);
+  }
+  if (listener) watcher.addChangeListener(listener);
+  return watcher;
+}
+function unwatchFile(filename, listener) {
+  const resolved = filename.toString();
+  const watcher = statWatchers.get(resolved);
+  if (!watcher) return;
+  if (listener) {
+    watcher.removeChangeListener(listener);
+  } else {
+    watcher.removeAllChangeListeners();
+  }
+  if (watcher.changeListenerCount === 0) {
+    watcher.stop();
+    statWatchers.delete(resolved);
+  }
+}
+export {
+  StatWatcher,
+  unwatchFile,
+  watchFile
+};

package/lib/esm/statfs.js

@@ -0,0 +1,57 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { normalizePath } from "./utils.js";
+const FS_INFO_ATTRS = [
+  "filesystem::size",
+  "filesystem::free"
+].join(",");
+const BSIZE = 4096;
+function buildStatFs(info) {
+  const totalBytes = Number(info.get_attribute_uint64("filesystem::size") ?? 0);
+  const freeBytes = Number(info.get_attribute_uint64("filesystem::free") ?? 0);
+  const blocks = Math.floor(totalBytes / BSIZE);
+  const bfree = Math.floor(freeBytes / BSIZE);
+  return { type: 0, bsize: BSIZE, blocks, bfree, bavail: bfree, files: 0, ffree: 0 };
+}
+function buildBigIntStatFs(info) {
+  const totalBytes = BigInt(info.get_attribute_uint64("filesystem::size") ?? 0);
+  const freeBytes = BigInt(info.get_attribute_uint64("filesystem::free") ?? 0);
+  const bsize = BigInt(BSIZE);
+  const blocks = totalBytes / bsize;
+  const bfree = freeBytes / bsize;
+  return { type: 0n, bsize, blocks, bfree, bavail: bfree, files: 0n, ffree: 0n };
+}
+function statfsSync(path, options) {
+  const file = Gio.File.new_for_path(normalizePath(path));
+  const info = file.query_filesystem_info(FS_INFO_ATTRS, null);
+  return options?.bigint === true ? buildBigIntStatFs(info) : buildStatFs(info);
+}
+function queryFsInfoAsync(path, useBigInt) {
+  return new Promise((resolve, reject) => {
+    const file = Gio.File.new_for_path(normalizePath(path));
+    file.query_filesystem_info_async(FS_INFO_ATTRS, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        const info = file.query_filesystem_info_finish(res);
+        resolve(useBigInt ? buildBigIntStatFs(info) : buildStatFs(info));
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+}
+function statfs(path, optionsOrCb, callback) {
+  if (typeof optionsOrCb === "function") {
+    callback = optionsOrCb;
+    optionsOrCb = {};
+  }
+  const useBigInt = optionsOrCb?.bigint === true;
+  queryFsInfoAsync(path, useBigInt).then((result) => callback(null, result), (err) => callback(err, null));
+}
+async function statfsAsync(path, options) {
+  return queryFsInfoAsync(path, options?.bigint === true);
+}
+export {
+  statfs,
+  statfsAsync,
+  statfsSync
+};

package/lib/esm/sync.js

@@ -9,29 +9,31 @@ 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 } from "./utils.js";
+import { tempDirPath, normalizePath } from "./utils.js";
 function statSync(path, options) {
+  const pathStr = normalizePath(path);
   try {
-    const file = Gio.File.new_for_path(path.toString());
+    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, path) : new Stats(info, path);
+    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", path);
+    throw createNodeError(err, "stat", pathStr);
   }
 }
 function lstatSync(path, options) {
+  const pathStr = normalizePath(path);
   try {
-    const file = Gio.File.new_for_path(path.toString());
+    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, path) : new Stats(info, path);
+    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", path);
+    throw createNodeError(err, "lstat", pathStr);
   }
 }
 function readdirSync(path, options) {
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
   const file = Gio.File.new_for_path(pathStr);
   const enumerator = file.enumerate_children(
     "standard::name,standard::type",
@@ -64,7 +66,8 @@ function readdirSync(path, options) {
 }
 const MAX_SYMLINK_DEPTH = 40;
 function realpathSync(path) {
-  let current = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  let current = Gio.File.new_for_path(pathStr);
   let depth = 0;
   while (true) {
     const info = current.query_info(
@@ -79,26 +82,29 @@ function realpathSync(path) {
     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 '${path}'`);
+      throw new Error(`ELOOP: too many levels of symbolic links, realpath '${pathStr}'`);
     }
   }
 }
 realpathSync.native = realpathSync;
 function symlinkSync(target, path, _type) {
-  const file = Gio.File.new_for_path(path.toString());
-  file.make_symbolic_link(target.toString(), 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 file = Gio.File.new_for_path(path);
+  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", path);
+      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", path);
+    throw createNodeError(err, "read", pathStr);
   }
 }
 function mkdirSync(path, options) {
@@ -110,9 +116,7 @@ function mkdirSync(path, options) {
   } else {
     mode = options || 511;
   }
-  if (typeof path !== "string") {
-    path = path.toString();
-  }
+  path = normalizePath(path);
   if (typeof mode === "string") {
     throw new TypeError("mode as string is currently not supported!");
   }
@@ -156,47 +160,53 @@ function mkdirSyncRecursive(pathStr, mode) {
   }
 }
 function rmdirSync(path, _options) {
-  const file = Gio.File.new_for_path(path.toString());
+  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", path);
+      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", path);
+      throw createNodeError(err, "rmdir", pathStr);
     }
     file.delete(null);
   } catch (err) {
     if (err.code && typeof err.code === "string") throw err;
-    throw createNodeError(err, "rmdir", path);
+    throw createNodeError(err, "rmdir", pathStr);
   }
 }
 function unlinkSync(path) {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   try {
     file.delete(null);
   } catch (err) {
-    throw createNodeError(err, "unlink", path);
+    throw createNodeError(err, "unlink", pathStr);
   }
 }
 function writeFileSync(path, data) {
-  GLib.file_set_contents(path, data);
+  GLib.file_set_contents(normalizePath(path), data);
 }
 function renameSync(oldPath, newPath) {
-  const src = Gio.File.new_for_path(oldPath.toString());
-  const dest = Gio.File.new_for_path(newPath.toString());
+  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", oldPath, newPath);
+    throw createNodeError(err, "rename", oldStr, newStr);
   }
 }
 function copyFileSync(src, dest, mode) {
-  const srcFile = Gio.File.new_for_path(src.toString());
-  const destFile = Gio.File.new_for_path(dest.toString());
+  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;
@@ -206,32 +216,34 @@ function copyFileSync(src, dest, mode) {
   try {
     srcFile.copy(destFile, flags, null, null);
   } catch (err) {
-    throw createNodeError(err, "copyfile", src, dest);
+    throw createNodeError(err, "copyfile", srcStr, destStr);
   }
 }
 function accessSync(path, mode) {
-  const file = Gio.File.new_for_path(path.toString());
+  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 '${path}'` };
+      const permErr = { code: 14, message: `permission denied, access '${pathStr}'` };
       if (mode & 4 && !info.get_attribute_boolean("access::can-read")) {
-        throw createNodeError(permErr, "access", path);
+        throw createNodeError(permErr, "access", pathStr);
       }
       if (mode & 2 && !info.get_attribute_boolean("access::can-write")) {
-        throw createNodeError(permErr, "access", path);
+        throw createNodeError(permErr, "access", pathStr);
       }
       if (mode & 1 && !info.get_attribute_boolean("access::can-execute")) {
-        throw createNodeError(permErr, "access", path);
+        throw createNodeError(permErr, "access", pathStr);
       }
     }
   } catch (err) {
     if (err.code && typeof err.code === "string") throw err;
-    throw createNodeError(err, "access", path);
+    throw createNodeError(err, "access", pathStr);
   }
 }
 function appendFileSync(path, data, options) {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   let bytes;
   if (typeof data === "string") {
     bytes = new TextEncoder().encode(data);
@@ -245,16 +257,17 @@ function appendFileSync(path, data, options) {
     }
     stream.close(null);
   } catch (err) {
-    throw createNodeError(err, "appendfile", path);
+    throw createNodeError(err, "appendfile", pathStr);
   }
 }
 function readlinkSync(path, options) {
-  const file = Gio.File.new_for_path(path.toString());
+  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 '${path}'`), { code: "EINVAL", errno: -22, syscall: "readlink", path: path.toString() });
+      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") {
@@ -263,17 +276,20 @@ function readlinkSync(path, options) {
     return target;
   } catch (err) {
     if (typeof err.code === "string") throw err;
-    throw createNodeError(err, "readlink", path);
+    throw createNodeError(err, "readlink", pathStr);
   }
 }
 function linkSync(existingPath, newPath) {
-  const result = GLib.spawn_command_line_sync(`ln ${existingPath.toString()} ${newPath.toString()}`);
+  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 '${existingPath}' -> '${newPath}'`), { code: "EPERM", errno: -1, syscall: "link", path: existingPath.toString(), dest: newPath.toString() });
+    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 file = Gio.File.new_for_path(path.toString());
+  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) {
@@ -285,24 +301,26 @@ function truncateSync(path, len) {
     }
     stream.close(null);
   } catch (err) {
-    throw createNodeError(err, "truncate", path);
+    throw createNodeError(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)} ${path.toString()}`);
+  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 '${path}'`), { code: "EPERM", errno: -1, syscall: "chmod", path: path.toString() });
+    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 result = GLib.spawn_command_line_sync(`chown ${uid}:${gid} ${path.toString()}`);
+  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 '${path}'`), { code: "EPERM", errno: -1, syscall: "chown", path: path.toString() });
+    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(filename, options, listener);
+  return new FSWatcher(normalizePath(filename), options, listener);
 }
 function openSync(path, flags, mode) {
   return new FileHandle({ path, flags, mode });
@@ -317,7 +335,7 @@ function mkdtempSync(prefix, options) {
   return decode(path, encoding);
 }
 function rmSync(path, options) {
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
   const file = Gio.File.new_for_path(pathStr);
   const recursive = options?.recursive || false;
   const force = options?.force || false;

package/lib/esm/utils.js

@@ -1,4 +1,10 @@
 import { existsSync } from "./sync.js";
+import { fileURLToPath, URL as NodeURL } from "node:url";
+function normalizePath(path) {
+  if (path instanceof URL || path instanceof NodeURL) return fileURLToPath(path);
+  if (typeof path === "string") return path;
+  return path.toString();
+}
 const CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 function randomName() {
   return [...Array(6)].map(
@@ -13,6 +19,7 @@ function tempDirPath(prefix) {
   return path;
 }
 export {
+  normalizePath,
   randomName,
   tempDirPath
 };