node_modules/bare-fs/README.md

# bare-fs

Native file system operations for Bare. The API closely follows that of the Node.js `fs` module.

```
npm i bare-fs
```

## Usage

```js
const fs = require('bare-fs')

const fd = await fs.open('hello.txt')

const buffer = Buffer.alloc(1024)

try {
  const length = await fs.read(fd, buffer)

  console.log('Read', length, 'bytes')
} finally {
  await fs.close(fd)
}
```

## API

#### `const fd = await fs.open(filepath[, flags[, mode]])`

Open a file, returning a file descriptor. `flags` defaults to `'r'` and `mode` defaults to `0o666`. `flags` may be a string such as `'r'`, `'w'`, `'a'`, `'r+'`, etc., or a numeric combination of `fs.constants` flags.

#### `fs.open(filepath[, flags[, mode]], callback)`

Callback version of `fs.open()`.

#### `const fd = fs.openSync(filepath[, flags[, mode]])`

Synchronous version of `fs.open()`.

#### `await fs.close(fd)`

Close a file descriptor.

#### `fs.close(fd, callback)`

Callback version of `fs.close()`.

#### `fs.closeSync(fd)`

Synchronous version of `fs.close()`.

#### `await fs.access(filepath[, mode])`

Check whether the file at `filepath` is accessible. `mode` defaults to `fs.constants.F_OK`.

#### `fs.access(filepath[, mode], callback)`

Callback version of `fs.access()`.

#### `fs.accessSync(filepath[, mode])`

Synchronous version of `fs.access()`.

#### `const exists = await fs.exists(filepath)`

Check whether a file exists at `filepath`. Returns `true` if the file is accessible, `false` otherwise.

#### `fs.exists(filepath, callback)`

Callback version of `fs.exists()`.

#### `const exists = fs.existsSync(filepath)`

Synchronous version of `fs.exists()`.

#### `const bytesRead = await fs.read(fd, buffer[, offset[, len[, pos]]])`

Read from a file descriptor into `buffer`. `offset` defaults to `0`, `len` defaults to `buffer.byteLength - offset`, and `pos` defaults to `-1` (current position). Returns the number of bytes read.

#### `fs.read(fd, buffer[, offset[, len[, pos]]], callback)`

Callback version of `fs.read()`.

#### `const bytesRead = fs.readSync(fd, buffer[, offset[, len[, pos]]])`

Synchronous version of `fs.read()`.

#### `const bytesRead = await fs.readv(fd, buffers[, pos])`

Read from a file descriptor into an array of `buffers`. `pos` defaults to `-1`.

#### `fs.readv(fd, buffers[, pos], callback)`

Callback version of `fs.readv()`.

#### `const bytesRead = fs.readvSync(fd, buffers[, pos])`

Synchronous version of `fs.readv()`.

#### `const bytesWritten = await fs.write(fd, data[, offset[, len[, pos]]])`

Write `data` to a file descriptor. When `data` is a string, the signature is `fs.write(fd, data[, pos[, encoding]])` where `encoding` defaults to `'utf8'`. Returns the number of bytes written.

#### `fs.write(fd, data[, offset[, len[, pos]]], callback)`

Callback version of `fs.write()`.

#### `const bytesWritten = fs.writeSync(fd, data[, offset[, len[, pos]]])`

Synchronous version of `fs.write()`.

#### `const bytesWritten = await fs.writev(fd, buffers[, pos])`

Write an array of `buffers` to a file descriptor. `pos` defaults to `-1`.

#### `fs.writev(fd, buffers[, pos], callback)`

Callback version of `fs.writev()`.

#### `const bytesWritten = fs.writevSync(fd, buffers[, pos])`

Synchronous version of `fs.writev()`.

#### `const stats = await fs.stat(filepath)`

Get the status of a file. Returns a `Stats` object.

#### `fs.stat(filepath, callback)`

Callback version of `fs.stat()`.

#### `const stats = fs.statSync(filepath)`

Synchronous version of `fs.stat()`.

#### `const stats = await fs.lstat(filepath)`

Like `fs.stat()`, but if `filepath` is a symbolic link, the link itself is statted, not the file it refers to.

#### `fs.lstat(filepath, callback)`

Callback version of `fs.lstat()`.

#### `const stats = fs.lstatSync(filepath)`

Synchronous version of `fs.lstat()`.

#### `const stats = await fs.fstat(fd)`

Get the status of a file by its file descriptor. Returns a `Stats` object.

#### `fs.fstat(fd, callback)`

Callback version of `fs.fstat()`.

#### `const stats = fs.fstatSync(fd)`

Synchronous version of `fs.fstat()`.

#### `const stats = await fs.statfs(filepath)`

Get filesystem statistics. Returns a `StatFs` object.

#### `fs.statfs(filepath, callback)`

Callback version of `fs.statfs()`.

#### `const stats = fs.statfsSync(filepath)`

Synchronous version of `fs.statfs()`.

#### `await fs.ftruncate(fd[, len])`

Truncate a file to `len` bytes. `len` defaults to `0`.

#### `fs.ftruncate(fd[, len], callback)`

Callback version of `fs.ftruncate()`.

#### `fs.ftruncateSync(fd[, len])`

Synchronous version of `fs.ftruncate()`.

#### `await fs.chmod(filepath, mode)`

Change the permissions of a file. `mode` may be a numeric mode or a string that will be parsed as octal.

#### `fs.chmod(filepath, mode, callback)`

Callback version of `fs.chmod()`.

#### `fs.chmodSync(filepath, mode)`

Synchronous version of `fs.chmod()`.

#### `await fs.fchmod(fd, mode)`

Change the permissions of a file by its file descriptor.

#### `fs.fchmod(fd, mode, callback)`

Callback version of `fs.fchmod()`.

#### `fs.fchmodSync(fd, mode)`

Synchronous version of `fs.fchmod()`.

#### `await fs.chown(filepath, uid, gid)`

Change the owner and group of a file.

**NOTE**: The `chown` functions are not implemented on Windows.

#### `fs.chown(filepath,  uid, gid, callback)`

Callback version of `fs.chown()`.

#### `await fs.chownSync(filepath, uid, gid)`

Synchronous version of `fs.chown()`.

#### `await fs.lchown(filepath, uid, gid)`

Change the owner and group of a file, but if `filepath` is a symbolic link, the changes are applied only to the link, not the file it refers to.

#### `fs.lchown(filepath,  uid, gid, callback)`

Callback version of `fs.lchown()`.

#### `fs.lchownSync(filepath, uid, gid)`

Synchronous version of `fs.lchown()`.

#### `await fs.fchown(filepath, uid, gid)`

Change the owner and group of a file by its file descriptor.

#### `fs.fchown(filepath,  uid, gid, callback)`

Callback version of `fs.fchown()`.

#### `fs.fchownSync(filepath, uid, gid)`

Synchronous version of `fs.fchown()`.

#### `await fs.utimes(filepath, atime, mtime)`

Change the access and modification times of a file. Times may be numbers (seconds since epoch) or `Date` objects.

#### `fs.utimes(filepath, atime, mtime, callback)`

Callback version of `fs.utimes()`.

#### `fs.utimesSync(filepath, atime, mtime)`

Synchronous version of `fs.utimes()`.

#### `await fs.lutimes(filepath, atime, mtime)`

Like `fs.utimes()`, but if `filepath` is a symbolic link, the timestamps of the link is changed, not the file it refers to.

#### `fs.lutimes(filepath, atime, mtime, callback)`

Callback version of `fs.lutimes()`.

#### `fs.lutimesSync(filepath, atime, mtime)`

Synchronous version of `fs.lutimes()`.

#### `await fs.futimes(fd, atime, mtime)`

Change the access and modification times of a file by its file descriptor. Times may be numbers (seconds since epoch) or `Date` objects.

#### `fs.futimes(fd, atime, mtime, callback)`

Callback version of `fs.futimes()`.

#### `fs.futimesSync(fd, atime, mtime)`

Synchronous version of `fs.futimes()`.

#### `await fs.link(src, dst)`

Creates a new link (also known as a hard link) to an existing file.

#### `fs.link(src, dst, callback)`

Callback version of `fs.link()`.

#### `fs.linkSync(src, dst)`

Synchronous version of `fs.link()`.

#### `await fs.mkdir(filepath[, opts])`

Create a directory at `filepath`.

Options include:

```js
options = {
  mode: 0o777,
  recursive: false
}
```

If `opts` is a number, it is treated as the `mode`. When `recursive` is `true`, parent directories are created as needed.

#### `fs.mkdir(filepath[, opts], callback)`

Callback version of `fs.mkdir()`.

#### `fs.mkdirSync(filepath[, opts])`

Synchronous version of `fs.mkdir()`.

#### `const path = await fs.mkdtemp(prefix)`

Create a unique temporary directory.

#### `fs.mkdtemp(prefix, callback)`

Callback version of `fs.mkdtemp()`.

#### `const path = fs.mkdtempSync(prefix)`

Synchronous version of `fs.mkdtemp()`.

#### `await fs.rmdir(filepath)`

Remove an empty directory.

#### `fs.rmdir(filepath, callback)`

Callback version of `fs.rmdir()`.

#### `fs.rmdirSync(filepath)`

Synchronous version of `fs.rmdir()`.

#### `await fs.rm(filepath[, opts])`

Remove a file or directory at `filepath`.

Options include:

```js
options = {
  force: false,
  recursive: false
}
```

When `recursive` is `true`, directories are removed along with their contents. When `force` is `true`, no error is thrown if `filepath` does not exist.

#### `fs.rm(filepath[, opts], callback)`

Callback version of `fs.rm()`.

#### `fs.rmSync(filepath[, opts])`

Synchronous version of `fs.rm()`.

#### `await fs.unlink(filepath)`

Remove a file.

#### `fs.unlink(filepath, callback)`

Callback version of `fs.unlink()`.

#### `fs.unlinkSync(filepath)`

Synchronous version of `fs.unlink()`.

#### `await fs.rename(src, dst)`

Rename a file from `src` to `dst`.

#### `fs.rename(src, dst, callback)`

Callback version of `fs.rename()`.

#### `fs.renameSync(src, dst)`

Synchronous version of `fs.rename()`.

#### `await fs.copyFile(src, dst[, mode])`

Copy a file from `src` to `dst`. `mode` is an optional bitmask created from `fs.constants.COPYFILE_EXCL`, `fs.constants.COPYFILE_FICLONE`, or `fs.constants.COPYFILE_FICLONE_FORCE`.

#### `fs.copyFile(src, dst[, mode], callback)`

Callback version of `fs.copyFile()`.

#### `fs.copyFileSync(src, dst[, mode])`

Synchronous version of `fs.copyFile()`.

#### `await fs.cp(src, dst[, opts])`

Copy a file or directory from `src` to `dst`.

Options include:

```js
options = {
  recursive: false
}
```

Set `recursive` to `true` to copy directories and their contents. Files are copied preserving their permissions.

#### `fs.cp(src, dst[, opts], callback)`

Callback version of `fs.cp()`.

#### `fs.cpSync(src, dst[, opts])`

Synchronous version of `fs.cp()`.

#### `const resolved = await fs.realpath(filepath[, opts])`

Resolve the real path of `filepath`, expanding all symbolic links.

Options include:

```js
options = {
  encoding: 'utf8'
}
```

Set `encoding` to `'buffer'` to receive the result as a `Buffer`.

#### `fs.realpath(filepath[, opts], callback)`

Callback version of `fs.realpath()`.

#### `const resolved = fs.realpathSync(filepath[, opts])`

Synchronous version of `fs.realpath()`.

#### `const target = await fs.readlink(filepath[, opts])`

Read the target of a symbolic link.

Options include:

```js
options = {
  encoding: 'utf8'
}
```

#### `fs.readlink(filepath[, opts], callback)`

Callback version of `fs.readlink()`.

#### `const target = fs.readlinkSync(filepath[, opts])`

Synchronous version of `fs.readlink()`.

#### `await fs.truncate(filename[, len])`

Truncate the file at `filename` to `len` bytes. `len` defaults to `0`.

#### `fs.truncate(filename[, len], callback)`

Callback version of `fs.truncate()`.

#### `fs.truncateSync(filename[, len])`

Synchronous version of `fs.truncate()`.

#### `await fs.symlink(target, filepath[, type])`

Create a symbolic link at `filepath` pointing to `target`. `type` may be `'file'`, `'dir'`, or `'junction'` (Windows only) or a numeric flag. On Windows, if `type` is not provided, it is inferred from the target.

#### `fs.symlink(target, filepath[, type], callback)`

Callback version of `fs.symlink()`.

#### `fs.symlinkSync(target, filepath[, type])`

Synchronous version of `fs.symlink()`.

#### `await fs.fsync(fd)`

Flush all modified in-core data of the file referred by its file descriptor to the disk device.

#### `fs.fsync(fs, callback)`

Callback version of `fs.fsync()`.

#### `fs.fsyncSync(fd)`

Synchronous version of `fs.fsync()`.

#### `await fs.fdatasync(fd)`

Similar to `fsync`, but does not flush modified metadata unless necessary.

#### `fs.fdatasync(fs, callback)`

Callback version of `fs.fdatasync()`.

#### `fs.fdatasyncSync(fd)`

Synchronous version of `fs.fdatasync()`.

#### `const dir = await fs.opendir(filepath[, opts])`

Open a directory for iteration. Returns a `Dir` object.

Options include:

```js
options = {
  encoding: 'utf8',
  bufferSize: 32
}
```

#### `fs.opendir(filepath[, opts], callback)`

Callback version of `fs.opendir()`.

#### `const dir = fs.opendirSync(filepath[, opts])`

Synchronous version of `fs.opendir()`.

#### `const entries = await fs.readdir(filepath[, opts])`

Read the contents of a directory. Returns an array of filenames or, if `withFileTypes` is `true`, an array of `Dirent` objects.

Options include:

```js
options = {
  encoding: 'utf8',
  withFileTypes: false,
  recursive: false
}
```

#### `fs.readdir(filepath[, opts], callback)`

Callback version of `fs.readdir()`.

#### `const entries = fs.readdirSync(filepath[, opts])`

Synchronous version of `fs.readdir()`.

#### `const data = await fs.readFile(filepath[, opts])`

Read the entire contents of a file. Returns a `Buffer` by default, or a string if an `encoding` is specified.

Options include:

```js
options = {
  encoding: 'buffer',
  flag: 'r'
}
```

#### `fs.readFile(filepath[, opts], callback)`

Callback version of `fs.readFile()`.

#### `const data = fs.readFileSync(filepath[, opts])`

Synchronous version of `fs.readFile()`.

#### `await fs.writeFile(filepath, data[, opts])`

Write `data` to a file, replacing it if it already exists.

Options include:

```js
options = {
  encoding: 'utf8',
  flag: 'w',
  mode: 0o666
}
```

#### `fs.writeFile(filepath, data[, opts], callback)`

Callback version of `fs.writeFile()`.

#### `fs.writeFileSync(filepath, data[, opts])`

Synchronous version of `fs.writeFile()`.

#### `await fs.appendFile(filepath, data[, opts])`

Append `data` to a file, creating it if it does not exist. Accepts the same options as `fs.writeFile()` but defaults to the `'a'` flag.

#### `fs.appendFile(filepath, data[, opts], callback)`

Callback version of `fs.appendFile()`.

#### `fs.appendFileSync(filepath, data[, opts])`

Synchronous version of `fs.appendFile()`.

#### `const watcher = fs.watch(filepath[, opts], callback)`

Watch a file or directory for changes. Returns a `Watcher` object. The `callback`, if provided, is called with `(eventType, filename)` on each change.

Options include:

```js
options = {
  persistent: true,
  recursive: false,
  encoding: 'utf8'
}
```

#### `const stream = fs.createReadStream(path[, opts])`

Create a readable stream for a file. Returns a `ReadStream`.

Options include:

```js
options = {
  fd: -1,
  flags: 'r',
  mode: 0o666,
  start: 0,
  end: Infinity
}
```

If `fd` is provided, `path` may be `null` and the stream reads from the given file descriptor.

#### `const stream = fs.createWriteStream(path[, opts])`

Create a writable stream for a file. Returns a `WriteStream`.

Options include:

```js
options = {
  fd: -1,
  flags: 'w',
  mode: 0o666
}
```

If `fd` is provided, `path` may be `null` and the stream writes to the given file descriptor.

#### `fs.constants`

An object containing file system constants. See `fs/constants` for the full list. Commonly used constants include:

- `fs.constants.O_RDONLY`, `fs.constants.O_WRONLY`, `fs.constants.O_RDWR` — file access flags
- `fs.constants.O_CREAT`, `fs.constants.O_TRUNC`, `fs.constants.O_APPEND` — file creation flags
- `fs.constants.F_OK`, `fs.constants.R_OK`, `fs.constants.W_OK`, `fs.constants.X_OK` — file accessibility flags
- `fs.constants.S_IFMT`, `fs.constants.S_IFREG`, `fs.constants.S_IFDIR`, `fs.constants.S_IFLNK` — file type flags
- `fs.constants.COPYFILE_EXCL`, `fs.constants.COPYFILE_FICLONE`, `fs.constants.COPYFILE_FICLONE_FORCE` — copy flags

### `Stats`

Returned by `fs.stat()`, `fs.lstat()`, and `fs.fstat()`.

#### `stats.dev`

The device identifier.

#### `stats.mode`

The file mode (type and permissions).

#### `stats.nlink`

The number of hard links.

#### `stats.uid`

The user identifier of the file owner.

#### `stats.gid`

The group identifier of the file owner.

#### `stats.rdev`

The device identifier for special files.

#### `stats.blksize`

The file system block size for I/O operations.

#### `stats.ino`

The inode number.

#### `stats.size`

The size of the file in bytes.

#### `stats.blocks`

The number of 512-byte blocks allocated.

#### `stats.atimeMs`

The access time in milliseconds since the epoch.

#### `stats.mtimeMs`

The modification time in milliseconds since the epoch.

#### `stats.ctimeMs`

The change time in milliseconds since the epoch.

#### `stats.birthtimeMs`

The creation time in milliseconds since the epoch.

#### `stats.atime`

The access time as a `Date` object.

#### `stats.mtime`

The modification time as a `Date` object.

#### `stats.ctime`

The change time as a `Date` object.

#### `stats.birthtime`

The creation time as a `Date` object.

#### `stats.isDirectory()`

Returns `true` if the file is a directory.

#### `stats.isFile()`

Returns `true` if the file is a regular file.

#### `stats.isBlockDevice()`

Returns `true` if the file is a block device.

#### `stats.isCharacterDevice()`

Returns `true` if the file is a character device.

#### `stats.isFIFO()`

Returns `true` if the file is a FIFO (named pipe).

#### `stats.isSymbolicLink()`

Returns `true` if the file is a symbolic link. Only meaningful when using `fs.lstat()`.

#### `stats.isSocket()`

Returns `true` if the file is a socket.

### `Dir`

Returned by `fs.opendir()`. Supports both synchronous and asynchronous iteration.

#### `dir.path`

The path of the directory.

#### `const dirent = await dir.read()`

Read the next directory entry. Returns a `Dirent` or `null` when all entries have been read.

#### `dir.read(callback)`

Callback version of `dir.read()`.

#### `const dirent = dir.readSync()`

Synchronous version of `dir.read()`.

#### `await dir.close()`

Close the directory handle.

#### `dir.close(callback)`

Callback version of `dir.close()`.

#### `dir.closeSync()`

Synchronous version of `dir.close()`.

### `Dirent`

Represents a directory entry, returned when iterating a `Dir` or using `fs.readdir()` with `withFileTypes: true`.

#### `dirent.parentPath`

The path of the parent directory.

#### `dirent.name`

The name of the directory entry, as a string or `Buffer` depending on the encoding.

#### `dirent.type`

The numeric type of the directory entry.

#### `dirent.isFile()`

Returns `true` if the entry is a regular file.

#### `dirent.isDirectory()`

Returns `true` if the entry is a directory.

#### `dirent.isSymbolicLink()`

Returns `true` if the entry is a symbolic link.

#### `dirent.isFIFO()`

Returns `true` if the entry is a FIFO.

#### `dirent.isSocket()`

Returns `true` if the entry is a socket.

#### `dirent.isCharacterDevice()`

Returns `true` if the entry is a character device.

#### `dirent.isBlockDevice()`

Returns `true` if the entry is a block device.

### `ReadStream`

A readable stream for file data, created by `fs.createReadStream()`. Extends `Readable` from <https://github.com/holepunchto/bare-stream>.

#### `stream.path`

The file path, or `null` if opened by file descriptor.

#### `stream.fd`

The underlying file descriptor.

#### `stream.flags`

The flags the file was opened with.

#### `stream.mode`

The mode the file was opened with.

### `WriteStream`

A writable stream for file data, created by `fs.createWriteStream()`. Extends `Writable` from <https://github.com/holepunchto/bare-stream>.

#### `stream.path`

The file path, or `null` if opened by file descriptor.

#### `stream.fd`

The underlying file descriptor.

#### `stream.flags`

The flags the file was opened with.

#### `stream.mode`

The mode the file was opened with.

### `Watcher`

Watches for file system changes, created by `fs.watch()`. Extends `EventEmitter` from <https://github.com/holepunchto/bare-events>.

#### `watcher.close()`

Stop watching for changes.

#### `watcher.ref()`

Prevent the event loop from exiting while the watcher is active.

#### `watcher.unref()`

Allow the event loop to exit even if the watcher is still active.

#### `event: 'change'`

Emitted with `(eventType, filename)` when a change is detected. `eventType` is either `'rename'` or `'change'`.

#### `event: 'error'`

Emitted with `(err)` when an error occurs.

#### `event: 'close'`

Emitted when the watcher is closed.

### `FileHandle`

Returned by `require('bare-fs/promises').open()`. Provides an object-oriented API for working with file descriptors.

#### `await handle.close()`

Close the file handle.

#### `const { bytesRead, buffer } = await handle.read(buffer[, offset[, len[, pos]]])`

Read from the file into `buffer`.

#### `const { bytesRead, buffers } = await handle.readv(buffers[, pos])`

Read from the file into an array of `buffers`.

#### `const { bytesWritten, buffer } = await handle.write(data[, offset[, len[, pos]]])`

Write `data` to the file.

#### `const { bytesWritten, buffers } = await handle.writev(buffers[, pos])`

Write an array of `buffers` to the file.

#### `const stats = await handle.stat()`

Get the status of the file.

#### `await handle.chmod(mode)`

Change the permissions of the file.

#### `await handle.chown(uid, gid)`

Change the owner and group of the file.

**NOTE**: This function is not implemented on Windows.

#### `await handle.datasync()`

Similar to `fsync`, but does not flush modified metadata unless necessary.

#### `await handle.sync()`

Flush all modified in-core data of the file.

#### `await handle.truncate(len)`

Truncate the file.

#### `await handle.utimes(mode)`

Change the access and modification times of the file.

#### `const stream = handle.createReadStream([opts])`

Create a readable stream for the file.

#### `const stream = handle.createWriteStream([opts])`

Create a writable stream for the file.

#### `handle.fd`

The file descriptor number.

#### `event: 'close'`

Emitted when the file handle is closed.

## License

Apache-2.0