extra-fs/index.js

Useful additions to inbuilt fs module.

'use strict';

var os = require('os');
var path = require('path');
var F = require('fs');
var P = require('fs/promises');

function _interopNamespaceDefault(e) {
    var n = Object.create(null);
    if (e) {
        Object.keys(e).forEach(function (k) {
            if (k !== 'default') {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () { return e[k]; }
                });
            }
        });
    }
    n.default = e;
    return Object.freeze(n);
}

var F__namespace = /*#__PURE__*/_interopNamespaceDefault(F);
var P__namespace = /*#__PURE__*/_interopNamespaceDefault(P);

class FsError extends Error {
    constructor(code, message) {
        super(message);
        this.code = code;
        this.name = this.constructor.name;
    }
}
function open(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.open.apply(null, args);
    else
        return P__namespace.open.apply(null, args);
}
function closeAsync(fd) {
    return new Promise((resolve, reject) => {
        F__namespace.close(fd, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function close(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.close.apply(null, args);
    else
        return closeAsync.apply(null, args);
}
function readAsync(...args) {
    return new Promise((resolve, reject) => {
        F__namespace.read(...args, (err, bytesRead, buffer) => {
            if (err)
                reject(err);
            else
                resolve({ bytesRead, buffer });
        });
    });
}
function read(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.read.apply(null, args);
    else
        return readAsync.apply(null, args);
}
function writeAsync(...args) {
    return new Promise((resolve, reject) => {
        F__namespace.write(...args, (err, bytesWritten, buffer) => {
            if (err)
                reject(err);
            else
                resolve({ bytesWritten, buffer });
        });
    });
}
function write(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.write.apply(null, args);
    else
        return writeAsync.apply(null, args);
}
function readvAsync(fd, buffers, position) {
    return new Promise((resolve, reject) => {
        F__namespace.readv(fd, buffers, position, (err, bytesRead, buffers) => {
            if (err)
                reject(err);
            else
                resolve({ bytesRead, buffers });
        });
    });
}
function readv(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.readv.apply(null, args);
    else
        return readvAsync.apply(null, args);
}
function writevAsync(fd, buffers, position) {
    return new Promise((resolve, reject) => {
        F__namespace.writev(fd, buffers, position, (err, bytesWritten) => {
            if (err)
                reject(err);
            else
                resolve({ bytesWritten, buffers: buffers });
        });
    });
}
function writev(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.writev.apply(null, args);
    else
        return writevAsync.apply(null, args);
}
function fdatasyncAsync(fd) {
    return new Promise((resolve, reject) => {
        F__namespace.fdatasync(fd, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fdatasync(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.fdatasync.apply(null, args);
    else
        return fdatasyncAsync.apply(null, args);
}
function fsyncAsync(fd) {
    return new Promise((resolve, reject) => {
        F__namespace.fsync(fd, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fsync(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.fsync.apply(null, args);
    else
        return fsyncAsync.apply(null, args);
}
function ftruncateAsync(fd, len) {
    return new Promise((resolve, reject) => {
        F__namespace.ftruncate(fd, len, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function ftruncate(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.ftruncate.apply(null, args);
    else
        return ftruncateAsync.apply(null, args);
}
function futimesAsync(fd, atime, mtime) {
    return new Promise((resolve, reject) => {
        F__namespace.futimes(fd, atime, mtime, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function futimes(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.futimes.apply(null, args);
    else
        return futimesAsync.apply(null, args);
}
function fstatAsync(fd, options) {
    return new Promise((resolve, reject) => {
        F__namespace.fstat(fd, options, (err, stats) => {
            if (err)
                reject(err);
            else
                resolve(stats);
        });
    });
}
function fstat(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.fstat.apply(null, args);
    else
        return fstatAsync.apply(null, args);
}
function fchmodAsync(fd, mode) {
    return new Promise((resolve, reject) => {
        F__namespace.fchmod(fd, mode, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fchmod(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.fchmod.apply(null, args);
    else
        return fchmodAsync.apply(null, args);
}
function fchownAsync(fd, uid, gid) {
    return new Promise((resolve, reject) => {
        F__namespace.fchown(fd, uid, gid, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fchown(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.fchown.apply(null, args);
    else
        return fchownAsync.apply(null, args);
}
function link(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.link.apply(null, args);
    else
        return P__namespace.link.apply(null, args);
}
function symlink(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.symlink.apply(null, args);
    else
        return P__namespace.symlink.apply(null, args);
}
function readlink(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.readlink.apply(null, args);
    else
        return P__namespace.readlink.apply(null, args);
}
function realpath(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.realpath.apply(null, args);
    else
        return P__namespace.realpath.apply(null, args);
}
function lutimes(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.lutimes.apply(null, args);
    else
        return P__namespace.lutimes.apply(null, args);
}
function lstat(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.lstat.apply(null, args);
    else
        return P__namespace.lstat.apply(null, args);
}
function lchown(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.lchown.apply(null, args);
    else
        return P__namespace.lchown.apply(null, args);
}
function readFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.readFile.apply(null, args);
    else
        return P__namespace.readFile.apply(null, args);
}
function writeFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.writeFile.apply(null, args);
    else
        return P__namespace.writeFile.apply(null, args);
}
function appendFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.appendFile.apply(null, args);
    else
        return P__namespace.appendFile.apply(null, args);
}
function truncate(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.truncate.apply(null, args);
    else
        return P__namespace.truncate.apply(null, args);
}
function unlink(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.unlink.apply(null, args);
    else
        return P__namespace.unlink.apply(null, args);
}
function utimes(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.utimes.apply(null, args);
    else
        return P__namespace.utimes.apply(null, args);
}
function stat(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.stat.apply(null, args);
    else
        return P__namespace.stat.apply(null, args);
}
function copyFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.copyFile.apply(null, args);
    else
        return P__namespace.copyFile.apply(null, args);
}
function mkdir(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.mkdir.apply(null, args);
    else
        return P__namespace.mkdir.apply(null, args);
}
function mkdtemp(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.mkdtemp.apply(null, args);
    else
        return P__namespace.mkdtemp.apply(null, args);
}
function opendir(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.opendir.apply(null, args);
    else
        return P__namespace.opendir.apply(null, args);
}
function readdir(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.readdir.apply(null, args);
    else
        return P__namespace.readdir.apply(null, args);
}
function rmdir(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.rm.apply(null, args);
    else
        return P__namespace.rm.apply(null, args);
}
function access(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.access.apply(null, args);
    else
        return P__namespace.access.apply(null, args);
}
function chmod(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.chmod.apply(null, args);
    else
        return P__namespace.chmod.apply(null, args);
}
function chown(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.chown.apply(null, args);
    else
        return P__namespace.chown.apply(null, args);
}
function rename(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.rename.apply(null, args);
    else
        return P__namespace.rename.apply(null, args);
}
function cp(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.cp.apply(null, args);
    else
        return P__namespace.cp.apply(null, args);
}
function rm(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.rm.apply(null, args);
    else
        return P__namespace.rm.apply(null, args);
}
async function readFileTextAsync(path) {
    var text = await P__namespace.readFile(path, "utf8");
    return text.replace(/\r?\n/g, "\n");
}
function readFileTextSync(path) {
    var text = F__namespace.readFileSync(path, "utf8");
    return text.replace(/\r?\n/g, "\n");
}
function readFileTextCb(path, fn) {
    F__namespace.readFile(path, "utf8", (err, text) => {
        if (err)
            return fn(err);
        fn(null, text.replace(/\r?\n/g, "\n"));
    });
}
function readFileText(...args) {
    if (typeof args[args.length - 1] === "function")
        readFileTextCb.apply(null, args);
    else
        return readFileTextAsync.apply(null, args);
}
function writeFileTextAsync(path, text) {
    var text = text.replace(/\r?\n/g, os.EOL);
    return P__namespace.writeFile(path, text);
}
function writeFileTextSync(path, text) {
    var text = text.replace(/\r?\n/g, os.EOL);
    return F__namespace.writeFileSync(path, text);
}
function writeFileTextCb(path, text, fn) {
    var text = text.replace(/\r?\n/g, os.EOL);
    F__namespace.writeFile(path, text, fn);
}
function writeFileText(...args) {
    if (typeof args[args.length - 1] === "function")
        writeFileTextCb.apply(null, args);
    else
        return writeFileTextAsync.apply(null, args);
}
async function readJsonAsync(path) {
    return JSON.parse(await readFileTextAsync(path));
}
function readJsonSync(path) {
    return JSON.parse(readFileTextSync(path));
}
function readJsonCb(path, fn) {
    readFileTextCb(path, (err, text) => {
        if (err != null)
            return fn(err);
        fn(null, JSON.parse(text));
    });
}
function readJson(...args) {
    if (typeof args[args.length - 1] === "function")
        readJsonCb.apply(null, args);
    else
        return readJsonAsync.apply(null, args);
}
function writeJsonAsync(path, json) {
    return writeFileTextAsync(path, JSON.stringify(json, null, 2) + "\n");
}
function writeJsonSync(path, json) {
    writeFileTextSync(path, JSON.stringify(json, null, 2) + "\n");
}
function writeJsonCb(path, json, fn) {
    writeFileText(path, JSON.stringify(json, null, 2) + "\n", fn);
}
function writeJson(...args) {
    if (typeof args[args.length - 1] === "function")
        writeJsonCb.apply(null, args);
    else
        return writeJsonAsync.apply(null, args);
}
function dehuskdirSync(dir, depth = -1) {
    for (var seed = dir; depth > 0; depth--) {
        var es = F__namespace.readdirSync(seed, { withFileTypes: true });
        if (es.length === 0 || es.length > 1 || !es[0].isDirectory())
            break;
        seed = path.join(seed, es[0].name);
    }
    if (seed === dir)
        return seed;
    var tmp = dir + Math.random();
    F__namespace.renameSync(seed, tmp);
    F__namespace.rmdirSync(dir);
    F__namespace.renameSync(tmp, dir);
    return seed;
}
async function dehuskdirAsync(dir, depth = -1) {
    for (var seed = dir; depth > 0; depth--) {
        var es = await P__namespace.readdir(seed, { withFileTypes: true });
        if (es.length === 0 || es.length > 1 || !es[0].isDirectory())
            break;
        seed = path.join(seed, es[0].name);
    }
    if (seed === dir)
        return seed;
    var tmp = dir + Math.random();
    await P__namespace.rename(seed, tmp);
    await P__namespace.rmdir(dir);
    await P__namespace.rename(tmp, dir);
    return seed;
}
function dehuskdirCb(...args) {
    var dir = args[0];
    var depth = typeof args[1] === "number" ? args[1] : 0;
    var fn = args[args.length - 1];
    dehuskdirAsync(dir, depth).then(seed => fn(seed), fn);
}
function dehuskdir(...args) {
    if (typeof args[args.length - 1] === "function")
        dehuskdirCb.apply(null, args);
    else
        return dehuskdirAsync.apply(null, args);
}
async function existsAsync(path) {
    try {
        await P__namespace.access(path);
        return true;
    }
    catch (_a) {
        return false;
    }
}
function exists(path, fn) {
    if (typeof fn === "function")
        existsAsync(path).then(a => fn(null, a), fn);
    else
        return existsAsync(path);
}
async function assertExistsAsync(path) {
    await P__namespace.access(path);
}
function assertExistsSync(path) {
    F__namespace.accessSync(path);
}
function assertExists(...args) {
    if (typeof args[args.length - 1] === "function")
        F__namespace.access.apply(null, args);
    else
        return assertExistsAsync.apply(null, args);
}
async function assertNotExistsAsync(path, err) {
    try {
        await P__namespace.access(path);
    }
    catch (_a) {
        return;
    }
    var message = `file or directory already exists, path "${path}"`;
    throw new FsError(err || "ERR_FS_ENSURE_NOT_EXISTS", message);
}
function assertNotExistsSync(path, err) {
    try {
        F__namespace.accessSync(path);
    }
    catch (_a) {
        return;
    }
    var message = `file or directory already exists, path "${path}"`;
    throw new FsError(err || "ERR_FS_ENSURE_NOT_EXISTS", message);
}
function assertNotExistsCb(path, err, fn) {
    var _fn = arguments.length === 3 ? fn : err;
    var _err = arguments.length === 3 ? err : null;
    F__namespace.access(path, e => {
        if (e != null)
            return _fn(null);
        var message = `file or directory already exists, path "${path}"`;
        _fn(new FsError(_err || "ERR_FS_ENSURE_NOT_EXISTS", message));
    });
}
function assertNotExists(...args) {
    if (typeof args[args.length - 1] === "function")
        assertNotExistsCb.apply(null, args);
    else
        return assertNotExistsAsync.apply(null, args);
}

Object.defineProperty(exports, 'Dir', {
    enumerable: true,
    get: function () { return F.Dir; }
});
Object.defineProperty(exports, 'Dirent', {
    enumerable: true,
    get: function () { return F.Dirent; }
});
Object.defineProperty(exports, 'ReadStream', {
    enumerable: true,
    get: function () { return F.ReadStream; }
});
Object.defineProperty(exports, 'Stats', {
    enumerable: true,
    get: function () { return F.Stats; }
});
Object.defineProperty(exports, 'WriteStream', {
    enumerable: true,
    get: function () { return F.WriteStream; }
});
Object.defineProperty(exports, 'accessSync', {
    enumerable: true,
    get: function () { return F.accessSync; }
});
Object.defineProperty(exports, 'appendFileSync', {
    enumerable: true,
    get: function () { return F.appendFileSync; }
});
Object.defineProperty(exports, 'chmodSync', {
    enumerable: true,
    get: function () { return F.chmodSync; }
});
Object.defineProperty(exports, 'chownSync', {
    enumerable: true,
    get: function () { return F.chownSync; }
});
Object.defineProperty(exports, 'closeSync', {
    enumerable: true,
    get: function () { return F.closeSync; }
});
Object.defineProperty(exports, 'constants', {
    enumerable: true,
    get: function () { return F.constants; }
});
Object.defineProperty(exports, 'copyFileSync', {
    enumerable: true,
    get: function () { return F.copyFileSync; }
});
Object.defineProperty(exports, 'cpSync', {
    enumerable: true,
    get: function () { return F.cpSync; }
});
Object.defineProperty(exports, 'createReadStream', {
    enumerable: true,
    get: function () { return F.createReadStream; }
});
Object.defineProperty(exports, 'createWriteStream', {
    enumerable: true,
    get: function () { return F.createWriteStream; }
});
Object.defineProperty(exports, 'existsSync', {
    enumerable: true,
    get: function () { return F.existsSync; }
});
Object.defineProperty(exports, 'fchmodSync', {
    enumerable: true,
    get: function () { return F.fchmodSync; }
});
Object.defineProperty(exports, 'fchownSync', {
    enumerable: true,
    get: function () { return F.fchownSync; }
});
Object.defineProperty(exports, 'fdatasyncSync', {
    enumerable: true,
    get: function () { return F.fdatasyncSync; }
});
Object.defineProperty(exports, 'fstatSync', {
    enumerable: true,
    get: function () { return F.fstatSync; }
});
Object.defineProperty(exports, 'fsyncSync', {
    enumerable: true,
    get: function () { return F.fsyncSync; }
});
Object.defineProperty(exports, 'ftruncateSync', {
    enumerable: true,
    get: function () { return F.ftruncateSync; }
});
Object.defineProperty(exports, 'futimesSync', {
    enumerable: true,
    get: function () { return F.futimesSync; }
});
Object.defineProperty(exports, 'lchownSync', {
    enumerable: true,
    get: function () { return F.lchownSync; }
});
Object.defineProperty(exports, 'linkSync', {
    enumerable: true,
    get: function () { return F.linkSync; }
});
Object.defineProperty(exports, 'lstatSync', {
    enumerable: true,
    get: function () { return F.lstatSync; }
});
Object.defineProperty(exports, 'lutimesSync', {
    enumerable: true,
    get: function () { return F.lutimesSync; }
});
Object.defineProperty(exports, 'mkdirSync', {
    enumerable: true,
    get: function () { return F.mkdirSync; }
});
Object.defineProperty(exports, 'mkdtempSync', {
    enumerable: true,
    get: function () { return F.mkdtempSync; }
});
Object.defineProperty(exports, 'openSync', {
    enumerable: true,
    get: function () { return F.openSync; }
});
Object.defineProperty(exports, 'opendirSync', {
    enumerable: true,
    get: function () { return F.opendirSync; }
});
Object.defineProperty(exports, 'readFileSync', {
    enumerable: true,
    get: function () { return F.readFileSync; }
});
Object.defineProperty(exports, 'readSync', {
    enumerable: true,
    get: function () { return F.readSync; }
});
Object.defineProperty(exports, 'readdirSync', {
    enumerable: true,
    get: function () { return F.readdirSync; }
});
Object.defineProperty(exports, 'readlinkSync', {
    enumerable: true,
    get: function () { return F.readlinkSync; }
});
Object.defineProperty(exports, 'readvSync', {
    enumerable: true,
    get: function () { return F.readvSync; }
});
Object.defineProperty(exports, 'realpathSync', {
    enumerable: true,
    get: function () { return F.realpathSync; }
});
Object.defineProperty(exports, 'renameSync', {
    enumerable: true,
    get: function () { return F.renameSync; }
});
Object.defineProperty(exports, 'rmSync', {
    enumerable: true,
    get: function () { return F.rmSync; }
});
Object.defineProperty(exports, 'rmdirSync', {
    enumerable: true,
    get: function () { return F.rmdirSync; }
});
Object.defineProperty(exports, 'statSync', {
    enumerable: true,
    get: function () { return F.statSync; }
});
Object.defineProperty(exports, 'symlinkSync', {
    enumerable: true,
    get: function () { return F.symlinkSync; }
});
Object.defineProperty(exports, 'truncateSync', {
    enumerable: true,
    get: function () { return F.truncateSync; }
});
Object.defineProperty(exports, 'unlinkSync', {
    enumerable: true,
    get: function () { return F.unlinkSync; }
});
Object.defineProperty(exports, 'unwatchFile', {
    enumerable: true,
    get: function () { return F.unwatchFile; }
});
Object.defineProperty(exports, 'utimesSync', {
    enumerable: true,
    get: function () { return F.utimesSync; }
});
Object.defineProperty(exports, 'watch', {
    enumerable: true,
    get: function () { return F.watch; }
});
Object.defineProperty(exports, 'watchFile', {
    enumerable: true,
    get: function () { return F.watchFile; }
});
Object.defineProperty(exports, 'writeFileSync', {
    enumerable: true,
    get: function () { return F.writeFileSync; }
});
Object.defineProperty(exports, 'writeSync', {
    enumerable: true,
    get: function () { return F.writeSync; }
});
Object.defineProperty(exports, 'writevSync', {
    enumerable: true,
    get: function () { return F.writevSync; }
});
Object.defineProperty(exports, 'accessAsync', {
    enumerable: true,
    get: function () { return P.access; }
});
Object.defineProperty(exports, 'appendFileAsync', {
    enumerable: true,
    get: function () { return P.appendFile; }
});
Object.defineProperty(exports, 'chmodAsync', {
    enumerable: true,
    get: function () { return P.chmod; }
});
Object.defineProperty(exports, 'chownAsync', {
    enumerable: true,
    get: function () { return P.chown; }
});
Object.defineProperty(exports, 'copyFileAsync', {
    enumerable: true,
    get: function () { return P.copyFile; }
});
Object.defineProperty(exports, 'cpAsync', {
    enumerable: true,
    get: function () { return P.cp; }
});
Object.defineProperty(exports, 'lchownAsync', {
    enumerable: true,
    get: function () { return P.lchown; }
});
Object.defineProperty(exports, 'linkAsync', {
    enumerable: true,
    get: function () { return P.link; }
});
Object.defineProperty(exports, 'lstatAsync', {
    enumerable: true,
    get: function () { return P.lstat; }
});
Object.defineProperty(exports, 'lutimesAsync', {
    enumerable: true,
    get: function () { return P.lutimes; }
});
Object.defineProperty(exports, 'mkdirAsync', {
    enumerable: true,
    get: function () { return P.mkdir; }
});
Object.defineProperty(exports, 'mkdtempAsync', {
    enumerable: true,
    get: function () { return P.mkdtemp; }
});
Object.defineProperty(exports, 'openAsync', {
    enumerable: true,
    get: function () { return P.open; }
});
Object.defineProperty(exports, 'opendirAsync', {
    enumerable: true,
    get: function () { return P.opendir; }
});
exports.promises = P__namespace;
Object.defineProperty(exports, 'readFileAsync', {
    enumerable: true,
    get: function () { return P.readFile; }
});
Object.defineProperty(exports, 'readdirAsync', {
    enumerable: true,
    get: function () { return P.readdir; }
});
Object.defineProperty(exports, 'readlinkAsync', {
    enumerable: true,
    get: function () { return P.readlink; }
});
Object.defineProperty(exports, 'realpathAsync', {
    enumerable: true,
    get: function () { return P.realpath; }
});
Object.defineProperty(exports, 'renameAsync', {
    enumerable: true,
    get: function () { return P.rename; }
});
Object.defineProperty(exports, 'rmAsync', {
    enumerable: true,
    get: function () { return P.rm; }
});
Object.defineProperty(exports, 'rmdirAsync', {
    enumerable: true,
    get: function () { return P.rmdir; }
});
Object.defineProperty(exports, 'statAsync', {
    enumerable: true,
    get: function () { return P.stat; }
});
Object.defineProperty(exports, 'symlinkAsync', {
    enumerable: true,
    get: function () { return P.symlink; }
});
Object.defineProperty(exports, 'truncateAsync', {
    enumerable: true,
    get: function () { return P.truncate; }
});
Object.defineProperty(exports, 'unlinkAsync', {
    enumerable: true,
    get: function () { return P.unlink; }
});
Object.defineProperty(exports, 'utimesAsync', {
    enumerable: true,
    get: function () { return P.utimes; }
});
Object.defineProperty(exports, 'writeFileAsync', {
    enumerable: true,
    get: function () { return P.writeFile; }
});
exports.FsError = FsError;
exports.access = access;
exports.appendFile = appendFile;
exports.assertExists = assertExists;
exports.assertExistsAsync = assertExistsAsync;
exports.assertExistsSync = assertExistsSync;
exports.assertNotExists = assertNotExists;
exports.assertNotExistsAsync = assertNotExistsAsync;
exports.assertNotExistsSync = assertNotExistsSync;
exports.chmod = chmod;
exports.chown = chown;
exports.close = close;
exports.closeAsync = closeAsync;
exports.copyFile = copyFile;
exports.cp = cp;
exports.dehuskdir = dehuskdir;
exports.dehuskdirAsync = dehuskdirAsync;
exports.dehuskdirSync = dehuskdirSync;
exports.exists = exists;
exports.existsAsync = existsAsync;
exports.fchmod = fchmod;
exports.fchmodAsync = fchmodAsync;
exports.fchown = fchown;
exports.fchownAsync = fchownAsync;
exports.fdatasync = fdatasync;
exports.fdatasyncAsync = fdatasyncAsync;
exports.fstat = fstat;
exports.fstatAsync = fstatAsync;
exports.fsync = fsync;
exports.fsyncAsync = fsyncAsync;
exports.ftruncate = ftruncate;
exports.ftruncateAsync = ftruncateAsync;
exports.futimes = futimes;
exports.futimesAsync = futimesAsync;
exports.lchown = lchown;
exports.link = link;
exports.lstat = lstat;
exports.lutimes = lutimes;
exports.mkdir = mkdir;
exports.mkdtemp = mkdtemp;
exports.open = open;
exports.opendir = opendir;
exports.read = read;
exports.readAsync = readAsync;
exports.readFile = readFile;
exports.readFileText = readFileText;
exports.readFileTextAsync = readFileTextAsync;
exports.readFileTextSync = readFileTextSync;
exports.readJson = readJson;
exports.readJsonAsync = readJsonAsync;
exports.readJsonSync = readJsonSync;
exports.readdir = readdir;
exports.readlink = readlink;
exports.readv = readv;
exports.readvAsync = readvAsync;
exports.realpath = realpath;
exports.rename = rename;
exports.rm = rm;
exports.rmdir = rmdir;
exports.stat = stat;
exports.symlink = symlink;
exports.truncate = truncate;
exports.unlink = unlink;
exports.utimes = utimes;
exports.write = write;
exports.writeAsync = writeAsync;
exports.writeFile = writeFile;
exports.writeFileText = writeFileText;
exports.writeFileTextAsync = writeFileTextAsync;
exports.writeFileTextSync = writeFileTextSync;
exports.writeJson = writeJson;
exports.writeJsonAsync = writeJsonAsync;
exports.writeJsonSync = writeJsonSync;
exports.writev = writev;
exports.writevAsync = writevAsync;