@gjsify/fs 0.1.15 → 0.2.0

package/lib/esm/callback.js

@@ -6,17 +6,19 @@ import { Buffer } from "node:buffer";
 import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
 import { createNodeError } from "./errors.js";
 import { realpathSync, readdirSync, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, mkdirSync, rmdirSync, readFileSync, writeFileSync } from "./sync.js";
+import { normalizePath } from "./utils.js";
 function parseOptsCb(optionsOrCallback, maybeCallback) {
   return typeof optionsOrCallback === "function" ? { options: {}, callback: optionsOrCallback } : { options: optionsOrCallback ?? {}, callback: maybeCallback };
 }
 function statImpl(path, flags, syscall, options, callback) {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  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);
-      callback(null, options?.bigint ? new BigIntStats(info, path) : new Stats(info, path));
+      callback(null, options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr));
     } catch (err) {
-      callback(createNodeError(err, syscall, path));
+      callback(createNodeError(err, syscall, pathStr));
     }
   });
 }
@@ -53,13 +55,15 @@ function symlink(target, path, typeOrCallback, maybeCallback) {
   if (typeof callback !== "function") {
     throw new TypeError("Callback must be a function. Received " + typeof callback);
   }
-  const file = Gio.File.new_for_path(path.toString());
-  file.make_symbolic_link_async(target.toString(), GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+  const pathStr = normalizePath(path);
+  const targetStr = normalizePath(target);
+  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);
       callback(null);
     } catch (err) {
-      callback(createNodeError(err, "symlink", target, path));
+      callback(createNodeError(err, "symlink", targetStr, pathStr));
     }
   });
 }
@@ -271,10 +275,11 @@ function rmdir(path, optsOrCb, maybeCb) {
 function readFile(path, optsOrCb, maybeCb) {
   const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
   const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
+  const pathStr = normalizePath(path);
   Promise.resolve().then(() => {
     try {
       const readOpts = typeof options === "string" ? { encoding: options, flag: "r" } : { encoding: options?.encoding ?? null, flag: options?.flag ?? "r" };
-      callback(null, readFileSync(path.toString(), readOpts));
+      callback(null, readFileSync(pathStr, readOpts));
     } catch (err) {
       callback(err, null);
     }
@@ -282,9 +287,10 @@ function readFile(path, optsOrCb, maybeCb) {
 }
 function writeFile(path, data, optsOrCb, maybeCb) {
   const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+  const pathStr = normalizePath(path);
   Promise.resolve().then(() => {
     try {
-      writeFileSync(path.toString(), data);
+      writeFileSync(pathStr, data);
       callback(null);
     } catch (err) {
       callback(err);
@@ -292,16 +298,18 @@ function writeFile(path, data, optsOrCb, maybeCb) {
   });
 }
 function link(existingPath, newPath, callback) {
+  const existingStr = normalizePath(existingPath);
+  const newStr = normalizePath(newPath);
   Promise.resolve().then(() => {
     try {
-      const result = GLib.spawn_command_line_sync(`ln ${existingPath.toString()} ${newPath.toString()}`);
+      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}'`), {
+        throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingStr}' -> '${newStr}'`), {
           code: "EPERM",
           errno: -1,
           syscall: "link",
-          path: existingPath.toString(),
-          dest: newPath.toString()
+          path: existingStr,
+          dest: newStr
         });
       }
       callback(null);
@@ -311,9 +319,10 @@ function link(existingPath, newPath, callback) {
   });
 }
 function unlink(path, callback) {
+  const pathStr = normalizePath(path);
   Promise.resolve().then(() => {
     try {
-      GLib.unlink(path.toString());
+      GLib.unlink(pathStr);
       callback(null);
     } catch (err) {
       callback(err);

package/lib/esm/cp.js

@@ -0,0 +1,253 @@
+import Gio from "@girs/gio-2.0";
+import { join } from "node:path";
+import { normalizePath } from "./utils.js";
+import { createNodeError } from "./errors.js";
+function makeEEXIST(destStr) {
+  const e = new Error(`ERR_FS_CP_EEXIST: file already exists, copyfile '${destStr}'`);
+  e.code = "ERR_FS_CP_EEXIST";
+  e.syscall = "copyfile";
+  e.path = destStr;
+  return e;
+}
+function makeEISDIR(srcStr) {
+  const e = new Error(`ERR_FS_EISDIR: illegal operation on a directory, copyfile '${srcStr}'`);
+  e.code = "ERR_FS_EISDIR";
+  e.syscall = "copyfile";
+  e.path = srcStr;
+  return e;
+}
+function makeENOTDIR(srcStr, destStr) {
+  const e = new Error(`ENOTDIR: not a directory, copyfile '${srcStr}' -> '${destStr}'`);
+  e.code = "ENOTDIR";
+  e.syscall = "copyfile";
+  e.path = srcStr;
+  e.dest = destStr;
+  return e;
+}
+function makeSYMLINKLOOP(srcStr, destStr) {
+  const e = new Error(`ELOOP: too many levels of symbolic links, copyfile '${srcStr}' -> '${destStr}'`);
+  e.code = "ELOOP";
+  e.syscall = "copyfile";
+  e.path = srcStr;
+  e.dest = destStr;
+  return e;
+}
+function queryCopyFlags(opts) {
+  const force = opts.force ?? true;
+  let flags = Gio.FileCopyFlags.NONE;
+  if (force) flags |= Gio.FileCopyFlags.OVERWRITE;
+  if (opts.preserveTimestamps) flags |= Gio.FileCopyFlags.TARGET_DEFAULT_MODIFIED_TIME;
+  if (!opts.dereference) flags |= Gio.FileCopyFlags.NOFOLLOW_SYMLINKS;
+  return flags;
+}
+function copyOneSyncFile(srcFile, destFile, srcStr, destStr, opts) {
+  const force = opts.force ?? true;
+  try {
+    const destInfo = destFile.query_info("standard::type", Gio.FileQueryInfoFlags.NONE, null);
+    if (destInfo.get_file_type() === Gio.FileType.DIRECTORY) {
+      throw makeENOTDIR(srcStr, destStr);
+    }
+    if (!force) {
+      if (opts.errorOnExist) throw makeEEXIST(destStr);
+      return;
+    }
+  } catch (e) {
+    if (typeof e.code === "string") throw e;
+  }
+  const flags = queryCopyFlags(opts);
+  try {
+    srcFile.copy(destFile, flags, null, null);
+  } catch (err) {
+    throw createNodeError(err, "copyfile", srcStr, destStr);
+  }
+}
+function cpOneDirSync(srcFile, destFile, srcStr, destStr, opts) {
+  const sep = srcStr.endsWith("/") ? "" : "/";
+  if (destStr.startsWith(srcStr + sep) && destStr !== srcStr) {
+    throw makeSYMLINKLOOP(srcStr, destStr);
+  }
+  if (!destFile.query_exists(null)) {
+    try {
+      destFile.make_directory_with_parents(null);
+    } catch (err) {
+      throw createNodeError(err, "mkdir", destStr);
+    }
+  } else {
+    try {
+      const destInfo = destFile.query_info("standard::type", Gio.FileQueryInfoFlags.NONE, null);
+      if (destInfo.get_file_type() !== Gio.FileType.DIRECTORY) {
+        throw makeENOTDIR(destStr, srcStr);
+      }
+    } catch (e) {
+      if (typeof e.code === "string") throw e;
+    }
+  }
+  let enumerator;
+  try {
+    enumerator = srcFile.enumerate_children(
+      "standard::name,standard::type,standard::is-symlink",
+      opts.dereference ? Gio.FileQueryInfoFlags.NONE : Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      null
+    );
+  } catch (err) {
+    throw createNodeError(err, "scandir", srcStr);
+  }
+  let childInfo = enumerator.next_file(null);
+  while (childInfo !== null) {
+    const name = childInfo.get_name();
+    const childSrc = join(srcStr, name);
+    const childDest = join(destStr, name);
+    const filter = opts.filter;
+    if (filter && !filter(childSrc, childDest)) {
+      childInfo = enumerator.next_file(null);
+      continue;
+    }
+    cpSyncInternal(childSrc, childDest, opts);
+    childInfo = enumerator.next_file(null);
+  }
+}
+function cpSyncInternal(srcStr, destStr, opts) {
+  const srcFile = Gio.File.new_for_path(srcStr);
+  const destFile = Gio.File.new_for_path(destStr);
+  let info;
+  try {
+    info = srcFile.query_info(
+      "standard::type,standard::is-symlink",
+      opts.dereference ? Gio.FileQueryInfoFlags.NONE : Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      null
+    );
+  } catch (err) {
+    throw createNodeError(err, "stat", srcStr);
+  }
+  const type = info.get_file_type();
+  if (type === Gio.FileType.DIRECTORY) {
+    if (!opts.recursive) throw makeEISDIR(srcStr);
+    cpOneDirSync(srcFile, destFile, srcStr, destStr, opts);
+  } else {
+    copyOneSyncFile(srcFile, destFile, srcStr, destStr, opts);
+  }
+}
+function cpSync(src, dest, options) {
+  const srcStr = normalizePath(src);
+  const destStr = normalizePath(dest);
+  const opts = options ?? {};
+  const srcFile = Gio.File.new_for_path(srcStr);
+  const filter = opts.filter;
+  if (filter && !filter(srcStr, destStr)) return;
+  try {
+    const info = srcFile.query_info(
+      "standard::type",
+      opts.dereference ? Gio.FileQueryInfoFlags.NONE : Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      null
+    );
+    if (info.get_file_type() === Gio.FileType.DIRECTORY && !opts.recursive) {
+      throw makeEISDIR(srcStr);
+    }
+  } catch (e) {
+    if (typeof e.code === "string") throw e;
+    throw createNodeError(e, "stat", srcStr);
+  }
+  cpSyncInternal(srcStr, destStr, opts);
+}
+function cp(src, dest, options, callback) {
+  let opts;
+  let cb;
+  if (typeof options === "function") {
+    cb = options;
+    opts = {};
+  } else {
+    cb = callback;
+    opts = options;
+  }
+  const asyncFilter = opts.filter;
+  if (asyncFilter) {
+    Promise.resolve(asyncFilter(normalizePath(src), normalizePath(dest))).then((include) => {
+      if (!include) {
+        cb(null);
+        return;
+      }
+      try {
+        cpPromises(src, dest, opts).then(() => cb(null)).catch(cb);
+      } catch (e) {
+        cb(e);
+      }
+    }).catch(cb);
+    return;
+  }
+  Promise.resolve().then(() => {
+    try {
+      cpSync(src, dest, opts);
+      cb(null);
+    } catch (e) {
+      cb(e);
+    }
+  });
+}
+async function cpPromisesDir(srcStr, destStr, opts) {
+  const sep = srcStr.endsWith("/") ? "" : "/";
+  if (destStr.startsWith(srcStr + sep) && destStr !== srcStr) {
+    throw makeSYMLINKLOOP(srcStr, destStr);
+  }
+  const destFile = Gio.File.new_for_path(destStr);
+  if (!destFile.query_exists(null)) {
+    try {
+      destFile.make_directory_with_parents(null);
+    } catch (err) {
+      throw createNodeError(err, "mkdir", destStr);
+    }
+  }
+  const srcFile = Gio.File.new_for_path(srcStr);
+  let enumerator;
+  try {
+    enumerator = srcFile.enumerate_children(
+      "standard::name,standard::type",
+      opts.dereference ? Gio.FileQueryInfoFlags.NONE : Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      null
+    );
+  } catch (err) {
+    throw createNodeError(err, "scandir", srcStr);
+  }
+  let childInfo = enumerator.next_file(null);
+  while (childInfo !== null) {
+    const name = childInfo.get_name();
+    const childSrc = join(srcStr, name);
+    const childDest = join(destStr, name);
+    const filter = opts.filter;
+    if (filter) {
+      const include = await Promise.resolve(filter(childSrc, childDest));
+      if (!include) {
+        childInfo = enumerator.next_file(null);
+        continue;
+      }
+    }
+    await cpPromises(childSrc, childDest, opts);
+    childInfo = enumerator.next_file(null);
+  }
+}
+async function cpPromises(src, dest, opts = {}) {
+  const srcStr = normalizePath(src);
+  const destStr = normalizePath(dest);
+  const srcFile = Gio.File.new_for_path(srcStr);
+  let info;
+  try {
+    info = srcFile.query_info(
+      "standard::type",
+      opts.dereference ? Gio.FileQueryInfoFlags.NONE : Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      null
+    );
+  } catch (err) {
+    throw createNodeError(err, "stat", srcStr);
+  }
+  if (info.get_file_type() === Gio.FileType.DIRECTORY) {
+    if (!opts.recursive) throw makeEISDIR(srcStr);
+    await cpPromisesDir(srcStr, destStr, opts);
+  } else {
+    const destFile = Gio.File.new_for_path(destStr);
+    copyOneSyncFile(srcFile, destFile, srcStr, destStr, opts);
+  }
+}
+export {
+  cp,
+  cpPromises as cpAsync,
+  cpSync
+};

package/lib/esm/dir.js

@@ -0,0 +1,160 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { normalizePath } from "./utils.js";
+import { Dirent } from "./dirent.js";
+import { createNodeError } from "./errors.js";
+const DIR_ATTRS = "standard::name,standard::type,standard::is-symlink,standard::size,standard::symlink-target,unix::uid,unix::gid,unix::mode,time::modified,time::access,time::created";
+class Dir {
+  path;
+  _enumerator;
+  _closed = false;
+  constructor(path, enumerator) {
+    this.path = path;
+    this._enumerator = enumerator;
+  }
+  _assertOpen() {
+    if (this._closed) {
+      const err = new Error("Directory handle was closed");
+      err.code = "ERR_DIR_CLOSED";
+      throw err;
+    }
+  }
+  readSync() {
+    this._assertOpen();
+    try {
+      const info = this._enumerator.next_file(null);
+      if (info === null) return null;
+      const name = info.get_name();
+      const fileType = info.get_file_type();
+      const childPath = this.path.endsWith("/") ? this.path + name : this.path + "/" + name;
+      return new Dirent(childPath, name, fileType);
+    } catch (err) {
+      throw createNodeError(err, "readdir", this.path);
+    }
+  }
+  read(callback) {
+    if (callback !== void 0) {
+      if (typeof callback !== "function") {
+        throw new TypeError('The "callback" argument must be of type function');
+      }
+      try {
+        this._assertOpen();
+        const dirent = this.readSync();
+        Promise.resolve().then(() => callback(null, dirent));
+      } catch (err) {
+        Promise.resolve().then(() => callback(err, null));
+      }
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this._assertOpen();
+        resolve(this.readSync());
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  closeSync() {
+    this._assertOpen();
+    this._closed = true;
+    try {
+      this._enumerator.close(null);
+    } catch {
+    }
+    this._enumerator = null;
+  }
+  close(callback) {
+    if (callback !== void 0) {
+      if (typeof callback !== "function") {
+        throw new TypeError('The "callback" argument must be of type function');
+      }
+      try {
+        this.closeSync();
+        Promise.resolve().then(() => callback(null));
+      } catch (err) {
+        Promise.resolve().then(() => callback(err));
+      }
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this.closeSync();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    try {
+      while (true) {
+        const dirent = await this.read();
+        if (dirent === null) break;
+        yield dirent;
+      }
+    } finally {
+      if (!this._closed) {
+        await this.close();
+      }
+    }
+  }
+}
+function _openDir(pathStr) {
+  const file = Gio.File.new_for_path(pathStr);
+  let enumerator;
+  try {
+    enumerator = file.enumerate_children(DIR_ATTRS, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+  } catch (err) {
+    throw createNodeError(err, "opendir", pathStr);
+  }
+  return new Dir(pathStr, enumerator);
+}
+function opendirSync(path) {
+  return _openDir(normalizePath(path));
+}
+function opendir(path, optionsOrCallback, callback) {
+  let cb;
+  if (typeof optionsOrCallback === "function") {
+    cb = optionsOrCallback;
+  } else {
+    cb = callback;
+  }
+  if (typeof cb !== "function") {
+    throw new TypeError('The "callback" argument must be of type function');
+  }
+  Promise.resolve().then(() => {
+    try {
+      const dir = opendirSync(path);
+      cb(null, dir);
+    } catch (err) {
+      cb(err, null);
+    }
+  });
+}
+async function opendirAsync(path, _options) {
+  return new Promise((resolve, reject) => {
+    const pathStr = normalizePath(path);
+    const file = Gio.File.new_for_path(pathStr);
+    file.enumerate_children_async(
+      DIR_ATTRS,
+      Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      GLib.PRIORITY_DEFAULT,
+      null,
+      (_source, result) => {
+        try {
+          const enumerator = file.enumerate_children_finish(result);
+          resolve(new Dir(pathStr, enumerator));
+        } catch (err) {
+          reject(createNodeError(err, "opendir", pathStr));
+        }
+      }
+    );
+  });
+}
+export {
+  Dir,
+  opendir,
+  opendirAsync,
+  opendirSync
+};

package/lib/esm/fd-ops.js

@@ -0,0 +1,189 @@
+import { FileHandle } from "./file-handle.js";
+import { statSync, truncateSync, chmodSync, chownSync, readFileSync } from "./sync.js";
+import { utimesSync } from "./utimes.js";
+import { normalizePath } from "./utils.js";
+function getFH(fd) {
+  if (fd instanceof FileHandle) return FileHandle.getInstance(fd.fd);
+  return FileHandle.getInstance(fd);
+}
+function fstatSync(fd, options) {
+  return statSync(normalizePath(getFH(fd).options.path), options);
+}
+function fstat(fd, optionsOrCb, callback) {
+  if (typeof optionsOrCb === "function") {
+    callback = optionsOrCb;
+    optionsOrCb = {};
+  }
+  Promise.resolve().then(() => fstatSync(fd, optionsOrCb)).then((s) => callback(null, s), callback);
+}
+async function fstatAsync(fd, options) {
+  return fstatSync(fd, options);
+}
+function ftruncateSync(fd, len = 0) {
+  truncateSync(normalizePath(getFH(fd).options.path), len);
+}
+function ftruncate(fd, lenOrCb, callback) {
+  if (typeof lenOrCb === "function") {
+    callback = lenOrCb;
+    lenOrCb = 0;
+  }
+  Promise.resolve().then(() => ftruncateSync(fd, lenOrCb)).then(() => callback(null), callback);
+}
+async function ftruncateAsync(fd, len = 0) {
+  ftruncateSync(fd, len);
+}
+function fdatasyncSync(fd) {
+  getFH(fd)._flushSync();
+}
+function fdatasync(fd, callback) {
+  Promise.resolve().then(() => fdatasyncSync(fd)).then(() => callback(null), callback);
+}
+async function fdatasyncAsync(fd) {
+  fdatasyncSync(fd);
+}
+function fsyncSync(fd) {
+  getFH(fd)._flushSync();
+}
+function fsync(fd, callback) {
+  Promise.resolve().then(() => fsyncSync(fd)).then(() => callback(null), callback);
+}
+async function fsyncAsync(fd) {
+  fsyncSync(fd);
+}
+function fchmodSync(fd, mode) {
+  chmodSync(normalizePath(getFH(fd).options.path), mode);
+}
+function fchmod(fd, mode, callback) {
+  Promise.resolve().then(() => fchmodSync(fd, mode)).then(() => callback(null), callback);
+}
+async function fchmodAsync(fd, mode) {
+  fchmodSync(fd, mode);
+}
+function fchownSync(fd, uid, gid) {
+  chownSync(normalizePath(getFH(fd).options.path), uid, gid);
+}
+function fchown(fd, uid, gid, callback) {
+  Promise.resolve().then(() => fchownSync(fd, uid, gid)).then(() => callback(null), callback);
+}
+async function fchownAsync(fd, uid, gid) {
+  fchownSync(fd, uid, gid);
+}
+function futimesSync(fd, atime, mtime) {
+  utimesSync(normalizePath(getFH(fd).options.path), atime, mtime);
+}
+function futimes(fd, atime, mtime, callback) {
+  Promise.resolve().then(() => futimesSync(fd, atime, mtime)).then(() => callback(null), callback);
+}
+async function futimesAsync(fd, atime, mtime) {
+  futimesSync(fd, atime, mtime);
+}
+function closeSync(fd) {
+  getFH(fd)._closeSync();
+}
+function readSync(fd, buffer, offsetOrOptions, length, position) {
+  let offset = 0;
+  if (offsetOrOptions !== null && typeof offsetOrOptions === "object") {
+    offset = offsetOrOptions.offset ?? 0;
+    length = offsetOrOptions.length ?? buffer.byteLength;
+    position = offsetOrOptions.position ?? null;
+  } else {
+    offset = offsetOrOptions ?? 0;
+    length = length ?? buffer.byteLength - offset;
+  }
+  return getFH(fd)._readSync(buffer, offset, length, position ?? null);
+}
+function writeSync(fd, bufferOrString, offsetOrPosition, lengthOrEncoding, position) {
+  let data;
+  if (typeof bufferOrString === "string") {
+    data = new TextEncoder().encode(bufferOrString);
+    if (typeof offsetOrPosition === "number") position = offsetOrPosition;
+  } else {
+    const offset = typeof offsetOrPosition === "number" ? offsetOrPosition : 0;
+    const len = typeof lengthOrEncoding === "number" ? lengthOrEncoding : bufferOrString.byteLength - offset;
+    data = new Uint8Array(bufferOrString.buffer, bufferOrString.byteOffset + offset, len);
+  }
+  return getFH(fd)._writeSync(data, position ?? null);
+}
+function readvSync(fd, buffers, position) {
+  let bytesRead = 0;
+  for (const buf of buffers) {
+    const n = readSync(fd, buf, 0, buf.byteLength, position != null ? position + bytesRead : null);
+    bytesRead += n;
+    if (n < buf.byteLength) break;
+  }
+  return bytesRead;
+}
+function readv(fd, buffers, positionOrCb, callback) {
+  if (typeof positionOrCb === "function") {
+    callback = positionOrCb;
+    positionOrCb = null;
+  }
+  Promise.resolve().then(() => ({ bytesRead: readvSync(fd, buffers, positionOrCb), buffers })).then((r) => callback(null, r.bytesRead, r.buffers), callback);
+}
+async function readvAsync(fd, buffers, position) {
+  return { bytesRead: readvSync(fd, buffers, position), buffers };
+}
+function writevSync(fd, buffers, position) {
+  let bytesWritten = 0;
+  for (const buf of buffers) {
+    const n = writeSync(fd, buf, 0, buf.byteLength, position != null ? position + bytesWritten : null);
+    bytesWritten += n;
+  }
+  return bytesWritten;
+}
+function writev(fd, buffers, positionOrCb, callback) {
+  if (typeof positionOrCb === "function") {
+    callback = positionOrCb;
+    positionOrCb = null;
+  }
+  Promise.resolve().then(() => ({ bytesWritten: writevSync(fd, buffers, positionOrCb), buffers })).then((r) => callback(null, r.bytesWritten, r.buffers), callback);
+}
+async function writevAsync(fd, buffers, position) {
+  return { bytesWritten: writevSync(fd, buffers, position), buffers };
+}
+function exists(path, callback) {
+  try {
+    statSync(normalizePath(path));
+    callback(true);
+  } catch {
+    callback(false);
+  }
+}
+async function openAsBlob(path, options) {
+  const data = readFileSync(normalizePath(path));
+  return new Blob([data], { type: options?.type ?? "" });
+}
+export {
+  closeSync,
+  exists,
+  fchmod,
+  fchmodAsync,
+  fchmodSync,
+  fchown,
+  fchownAsync,
+  fchownSync,
+  fdatasync,
+  fdatasyncAsync,
+  fdatasyncSync,
+  fstat,
+  fstatAsync,
+  fstatSync,
+  fsync,
+  fsyncAsync,
+  fsyncSync,
+  ftruncate,
+  ftruncateAsync,
+  ftruncateSync,
+  futimes,
+  futimesAsync,
+  futimesSync,
+  openAsBlob,
+  readSync,
+  readv,
+  readvAsync,
+  readvSync,
+  writeSync,
+  writev,
+  writevAsync,
+  writevSync
+};