memfs 4.0.0 → 4.1.0

package/lib/volume.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FSWatcher = exports.StatWatcher = exports.Volume = exports.toUnixTimestamp = exports.bufferToEncoding = exports.dataToBuffer = exports.dataToStr = exports.pathToSteps = exports.filenameToSteps = exports.pathToFilename = exports.flagsToNumber = exports.FLAGS = void 0;
+exports.FSWatcher = exports.StatWatcher = exports.Volume = exports.toUnixTimestamp = exports.dataToStr = exports.pathToSteps = exports.filenameToSteps = void 0;
 const pathModule = require("path");
 const node_1 = require("./node");
 const Stats_1 = require("./Stats");
@@ -13,41 +13,20 @@ const stream_1 = require("stream");
 const constants_1 = require("./constants");
 const events_1 = require("events");
 const encoding_1 = require("./encoding");
-const errors = require("./internal/errors");
 const util = require("util");
 const promises_1 = require("./node/promises");
+const constants_2 = require("./node/constants");
+const options_1 = require("./node/options");
+const util_1 = require("./node/util");
 const resolveCrossPlatform = pathModule.resolve;
-const { O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC, O_APPEND, O_SYNC, O_DIRECTORY, F_OK, COPYFILE_EXCL, COPYFILE_FICLONE_FORCE, } = constants_1.constants;
+const { O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC, O_APPEND, O_DIRECTORY, F_OK, COPYFILE_EXCL, COPYFILE_FICLONE_FORCE, } = constants_1.constants;
 const { sep, relative, join, dirname } = pathModule.posix ? pathModule.posix : pathModule;
-const isWin = process_1.default.platform === 'win32';
+// ---------------------------------------- Constants
 const kMinPoolSpace = 128;
-// const kMaxLength = require('buffer').kMaxLength;
 // ---------------------------------------- Error messages
-// TODO: Use `internal/errors.js` in the future.
-const ERRSTR = {
-    PATH_STR: 'path must be a string or Buffer',
-    // FD:             'file descriptor must be a unsigned 32-bit integer',
-    FD: 'fd must be a file descriptor',
-    MODE_INT: 'mode must be an int',
-    CB: 'callback must be a function',
-    UID: 'uid must be an unsigned int',
-    GID: 'gid must be an unsigned int',
-    LEN: 'len must be an integer',
-    ATIME: 'atime must be an integer',
-    MTIME: 'mtime must be an integer',
-    PREFIX: 'filename prefix is required',
-    BUFFER: 'buffer must be an instance of Buffer or StaticBuffer',
-    OFFSET: 'offset must be an integer',
-    LENGTH: 'length must be an integer',
-    POSITION: 'position must be an integer',
-};
-const ERRSTR_OPTS = tipeof => `Expected options to be either an object or a string, but got ${tipeof} instead`;
-// const ERRSTR_FLAG = flag => `Unknown file open flag: ${flag}`;
 const ENOENT = 'ENOENT';
 const EBADF = 'EBADF';
 const EINVAL = 'EINVAL';
-const EPERM = 'EPERM';
-const EPROTO = 'EPROTO';
 const EEXIST = 'EEXIST';
 const ENOTDIR = 'ENOTDIR';
 const EMFILE = 'EMFILE';
@@ -56,219 +35,8 @@ const EISDIR = 'EISDIR';
 const ENOTEMPTY = 'ENOTEMPTY';
 const ENOSYS = 'ENOSYS';
 const ERR_FS_EISDIR = 'ERR_FS_EISDIR';
-function formatError(errorCode, func = '', path = '', path2 = '') {
-    let pathFormatted = '';
-    if (path)
-        pathFormatted = ` '${path}'`;
-    if (path2)
-        pathFormatted += ` -> '${path2}'`;
-    switch (errorCode) {
-        case ENOENT:
-            return `ENOENT: no such file or directory, ${func}${pathFormatted}`;
-        case EBADF:
-            return `EBADF: bad file descriptor, ${func}${pathFormatted}`;
-        case EINVAL:
-            return `EINVAL: invalid argument, ${func}${pathFormatted}`;
-        case EPERM:
-            return `EPERM: operation not permitted, ${func}${pathFormatted}`;
-        case EPROTO:
-            return `EPROTO: protocol error, ${func}${pathFormatted}`;
-        case EEXIST:
-            return `EEXIST: file already exists, ${func}${pathFormatted}`;
-        case ENOTDIR:
-            return `ENOTDIR: not a directory, ${func}${pathFormatted}`;
-        case EISDIR:
-            return `EISDIR: illegal operation on a directory, ${func}${pathFormatted}`;
-        case EACCES:
-            return `EACCES: permission denied, ${func}${pathFormatted}`;
-        case ENOTEMPTY:
-            return `ENOTEMPTY: directory not empty, ${func}${pathFormatted}`;
-        case EMFILE:
-            return `EMFILE: too many open files, ${func}${pathFormatted}`;
-        case ENOSYS:
-            return `ENOSYS: function not implemented, ${func}${pathFormatted}`;
-        case ERR_FS_EISDIR:
-            return `[ERR_FS_EISDIR]: Path is a directory: ${func} returned EISDIR (is a directory) ${path}`;
-        default:
-            return `${errorCode}: error occurred, ${func}${pathFormatted}`;
-    }
-}
-function createError(errorCode, func = '', path = '', path2 = '', Constructor = Error) {
-    const error = new Constructor(formatError(errorCode, func, path, path2));
-    error.code = errorCode;
-    if (path) {
-        error.path = path;
-    }
-    return error;
-}
-// ---------------------------------------- Flags
-// List of file `flags` as defined by Node.
-var FLAGS;
-(function (FLAGS) {
-    // Open file for reading. An exception occurs if the file does not exist.
-    FLAGS[FLAGS["r"] = O_RDONLY] = "r";
-    // Open file for reading and writing. An exception occurs if the file does not exist.
-    FLAGS[FLAGS["r+"] = O_RDWR] = "r+";
-    // Open file for reading in synchronous mode. Instructs the operating system to bypass the local file system cache.
-    FLAGS[FLAGS["rs"] = O_RDONLY | O_SYNC] = "rs";
-    FLAGS[FLAGS["sr"] = FLAGS.rs] = "sr";
-    // Open file for reading and writing, telling the OS to open it synchronously. See notes for 'rs' about using this with caution.
-    FLAGS[FLAGS["rs+"] = O_RDWR | O_SYNC] = "rs+";
-    FLAGS[FLAGS["sr+"] = FLAGS['rs+']] = "sr+";
-    // Open file for writing. The file is created (if it does not exist) or truncated (if it exists).
-    FLAGS[FLAGS["w"] = O_WRONLY | O_CREAT | O_TRUNC] = "w";
-    // Like 'w' but fails if path exists.
-    FLAGS[FLAGS["wx"] = O_WRONLY | O_CREAT | O_TRUNC | O_EXCL] = "wx";
-    FLAGS[FLAGS["xw"] = FLAGS.wx] = "xw";
-    // Open file for reading and writing. The file is created (if it does not exist) or truncated (if it exists).
-    FLAGS[FLAGS["w+"] = O_RDWR | O_CREAT | O_TRUNC] = "w+";
-    // Like 'w+' but fails if path exists.
-    FLAGS[FLAGS["wx+"] = O_RDWR | O_CREAT | O_TRUNC | O_EXCL] = "wx+";
-    FLAGS[FLAGS["xw+"] = FLAGS['wx+']] = "xw+";
-    // Open file for appending. The file is created if it does not exist.
-    FLAGS[FLAGS["a"] = O_WRONLY | O_APPEND | O_CREAT] = "a";
-    // Like 'a' but fails if path exists.
-    FLAGS[FLAGS["ax"] = O_WRONLY | O_APPEND | O_CREAT | O_EXCL] = "ax";
-    FLAGS[FLAGS["xa"] = FLAGS.ax] = "xa";
-    // Open file for reading and appending. The file is created if it does not exist.
-    FLAGS[FLAGS["a+"] = O_RDWR | O_APPEND | O_CREAT] = "a+";
-    // Like 'a+' but fails if path exists.
-    FLAGS[FLAGS["ax+"] = O_RDWR | O_APPEND | O_CREAT | O_EXCL] = "ax+";
-    FLAGS[FLAGS["xa+"] = FLAGS['ax+']] = "xa+";
-})(FLAGS = exports.FLAGS || (exports.FLAGS = {}));
-function flagsToNumber(flags) {
-    if (typeof flags === 'number')
-        return flags;
-    if (typeof flags === 'string') {
-        const flagsNum = FLAGS[flags];
-        if (typeof flagsNum !== 'undefined')
-            return flagsNum;
-    }
-    // throw new TypeError(formatError(ERRSTR_FLAG(flags)));
-    throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'flags', flags);
-}
-exports.flagsToNumber = flagsToNumber;
-// ---------------------------------------- Options
-function getOptions(defaults, options) {
-    let opts;
-    if (!options)
-        return defaults;
-    else {
-        const tipeof = typeof options;
-        switch (tipeof) {
-            case 'string':
-                opts = Object.assign({}, defaults, { encoding: options });
-                break;
-            case 'object':
-                opts = Object.assign({}, defaults, options);
-                break;
-            default:
-                throw TypeError(ERRSTR_OPTS(tipeof));
-        }
-    }
-    if (opts.encoding !== 'buffer')
-        (0, encoding_1.assertEncoding)(opts.encoding);
-    return opts;
-}
-function optsGenerator(defaults) {
-    return options => getOptions(defaults, options);
-}
-function validateCallback(callback) {
-    if (typeof callback !== 'function')
-        throw TypeError(ERRSTR.CB);
-    return callback;
-}
-function optsAndCbGenerator(getOpts) {
-    return (options, callback) => typeof options === 'function' ? [getOpts(), options] : [getOpts(options), validateCallback(callback)];
-}
-const optsDefaults = {
-    encoding: 'utf8',
-};
-const getDefaultOpts = optsGenerator(optsDefaults);
-const getDefaultOptsAndCb = optsAndCbGenerator(getDefaultOpts);
-const readFileOptsDefaults = {
-    flag: 'r',
-};
-const getReadFileOptions = optsGenerator(readFileOptsDefaults);
-const writeFileDefaults = {
-    encoding: 'utf8',
-    mode: 438 /* MODE.DEFAULT */,
-    flag: FLAGS[FLAGS.w],
-};
-const getWriteFileOptions = optsGenerator(writeFileDefaults);
-const appendFileDefaults = {
-    encoding: 'utf8',
-    mode: 438 /* MODE.DEFAULT */,
-    flag: FLAGS[FLAGS.a],
-};
-const getAppendFileOpts = optsGenerator(appendFileDefaults);
-const getAppendFileOptsAndCb = optsAndCbGenerator(getAppendFileOpts);
-const realpathDefaults = optsDefaults;
-const getRealpathOptions = optsGenerator(realpathDefaults);
-const getRealpathOptsAndCb = optsAndCbGenerator(getRealpathOptions);
-const mkdirDefaults = {
-    mode: 511 /* MODE.DIR */,
-    recursive: false,
-};
-const getMkdirOptions = (options) => {
-    if (typeof options === 'number')
-        return Object.assign({}, mkdirDefaults, { mode: options });
-    return Object.assign({}, mkdirDefaults, options);
-};
-const rmdirDefaults = {
-    recursive: false,
-};
-const getRmdirOptions = (options) => {
-    return Object.assign({}, rmdirDefaults, options);
-};
-const getRmOpts = optsGenerator(optsDefaults);
-const getRmOptsAndCb = optsAndCbGenerator(getRmOpts);
-const readdirDefaults = {
-    encoding: 'utf8',
-    withFileTypes: false,
-};
-const getReaddirOptions = optsGenerator(readdirDefaults);
-const getReaddirOptsAndCb = optsAndCbGenerator(getReaddirOptions);
-const statDefaults = {
-    bigint: false,
-};
-const getStatOptions = (options = {}) => Object.assign({}, statDefaults, options);
-const getStatOptsAndCb = (options, callback) => typeof options === 'function' ? [getStatOptions(), options] : [getStatOptions(options), validateCallback(callback)];
-// ---------------------------------------- Utility functions
-function getPathFromURLPosix(url) {
-    if (url.hostname !== '') {
-        throw new errors.TypeError('ERR_INVALID_FILE_URL_HOST', process_1.default.platform);
-    }
-    const pathname = url.pathname;
-    for (let n = 0; n < pathname.length; n++) {
-        if (pathname[n] === '%') {
-            const third = pathname.codePointAt(n + 2) | 0x20;
-            if (pathname[n + 1] === '2' && third === 102) {
-                throw new errors.TypeError('ERR_INVALID_FILE_URL_PATH', 'must not include encoded / characters');
-            }
-        }
-    }
-    return decodeURIComponent(pathname);
-}
-function pathToFilename(path) {
-    if (typeof path !== 'string' && !buffer_1.Buffer.isBuffer(path)) {
-        try {
-            if (!(path instanceof require('url').URL))
-                throw new TypeError(ERRSTR.PATH_STR);
-        }
-        catch (err) {
-            throw new TypeError(ERRSTR.PATH_STR);
-        }
-        path = getPathFromURLPosix(path);
-    }
-    const pathString = String(path);
-    nullCheck(pathString);
-    // return slash(pathString);
-    return pathString;
-}
-exports.pathToFilename = pathToFilename;
 let resolve = (filename, base = process_1.default.cwd()) => resolveCrossPlatform(base, filename);
-if (isWin) {
+if (util_1.isWin) {
     const _resolve = resolve;
     const { unixify } = require('fs-monkey/lib/correctPath');
     resolve = (filename, base) => unixify(_resolve(filename, base));
@@ -282,7 +50,7 @@ function filenameToSteps(filename, base) {
 }
 exports.filenameToSteps = filenameToSteps;
 function pathToSteps(path) {
-    return filenameToSteps(pathToFilename(path));
+    return filenameToSteps((0, util_1.pathToFilename)(path));
 }
 exports.pathToSteps = pathToSteps;
 function dataToStr(data, encoding = encoding_1.ENCODING_UTF8) {
@@ -294,55 +62,6 @@ function dataToStr(data, encoding = encoding_1.ENCODING_UTF8) {
         return String(data);
 }
 exports.dataToStr = dataToStr;
-function dataToBuffer(data, encoding = encoding_1.ENCODING_UTF8) {
-    if (buffer_1.Buffer.isBuffer(data))
-        return data;
-    else if (data instanceof Uint8Array)
-        return (0, buffer_1.bufferFrom)(data);
-    else
-        return (0, buffer_1.bufferFrom)(String(data), encoding);
-}
-exports.dataToBuffer = dataToBuffer;
-function bufferToEncoding(buffer, encoding) {
-    if (!encoding || encoding === 'buffer')
-        return buffer;
-    else
-        return buffer.toString(encoding);
-}
-exports.bufferToEncoding = bufferToEncoding;
-function nullCheck(path, callback) {
-    if (('' + path).indexOf('\u0000') !== -1) {
-        const er = new Error('Path must be a string without null bytes');
-        er.code = ENOENT;
-        if (typeof callback !== 'function')
-            throw er;
-        process_1.default.nextTick(callback, er);
-        return false;
-    }
-    return true;
-}
-function _modeToNumber(mode, def) {
-    if (typeof mode === 'number')
-        return mode;
-    if (typeof mode === 'string')
-        return parseInt(mode, 8);
-    if (def)
-        return modeToNumber(def);
-    return undefined;
-}
-function modeToNumber(mode, def) {
-    const result = _modeToNumber(mode, def);
-    if (typeof result !== 'number' || isNaN(result))
-        throw new TypeError(ERRSTR.MODE_INT);
-    return result;
-}
-function isFd(path) {
-    return path >>> 0 === path;
-}
-function validateFd(fd) {
-    if (!isFd(fd))
-        throw TypeError(ERRSTR.FD);
-}
 // converts Date or number to a fractional UNIX timestamp
 function toUnixTimestamp(time) {
     // tslint:disable-next-line triple-equals
@@ -363,11 +82,11 @@ function toUnixTimestamp(time) {
 exports.toUnixTimestamp = toUnixTimestamp;
 function validateUid(uid) {
     if (typeof uid !== 'number')
-        throw TypeError(ERRSTR.UID);
+        throw TypeError(constants_2.ERRSTR.UID);
 }
 function validateGid(gid) {
     if (typeof gid !== 'number')
-        throw TypeError(ERRSTR.GID);
+        throw TypeError(constants_2.ERRSTR.GID);
 }
 function flattenJSON(nestedJSON) {
     const flatJSON = {};
@@ -498,22 +217,11 @@ class Volume {
         this.inodes[node.ino] = node;
         return node;
     }
-    getNode(ino) {
-        return this.inodes[ino];
-    }
     deleteNode(node) {
         node.del();
         delete this.inodes[node.ino];
         this.releasedInos.push(node.ino);
     }
-    // Generates 6 character long random string, used by `mkdtemp`.
-    genRndStr() {
-        const str = (Math.random() + 1).toString(36).substring(2, 8);
-        if (str.length === 6)
-            return str;
-        else
-            return this.genRndStr();
-    }
     // Returns a `Link` (hard link) referenced by path "split" into steps.
     getLink(steps) {
         return this.root.walk(steps);
@@ -523,7 +231,7 @@ class Volume {
         const steps = filenameToSteps(filename);
         const link = this.getLink(steps);
         if (!link)
-            throw createError(ENOENT, funcName, filename);
+            throw (0, util_1.createError)(ENOENT, funcName, filename);
         return link;
     }
     // Just like `getLink`, but also dereference/resolves symbolic links.
@@ -551,7 +259,7 @@ class Volume {
     getResolvedLinkOrThrow(filename, funcName) {
         const link = this.getResolvedLink(filename);
         if (!link)
-            throw createError(ENOENT, funcName, filename);
+            throw (0, util_1.createError)(ENOENT, funcName, filename);
         return link;
     }
     resolveSymlinks(link) {
@@ -568,7 +276,7 @@ class Volume {
     getLinkAsDirOrThrow(filename, funcName) {
         const link = this.getLinkOrThrow(filename, funcName);
         if (!link.getNode().isDirectory())
-            throw createError(ENOTDIR, funcName, filename);
+            throw (0, util_1.createError)(ENOTDIR, funcName, filename);
         return link;
     }
     // Get the immediate parent directory of the link.
@@ -579,20 +287,20 @@ class Volume {
         const steps = filenameOrSteps instanceof Array ? filenameOrSteps : filenameToSteps(filenameOrSteps);
         const link = this.getLinkParent(steps);
         if (!link)
-            throw createError(ENOENT, funcName, sep + steps.join(sep));
+            throw (0, util_1.createError)(ENOENT, funcName, sep + steps.join(sep));
         if (!link.getNode().isDirectory())
-            throw createError(ENOTDIR, funcName, sep + steps.join(sep));
+            throw (0, util_1.createError)(ENOTDIR, funcName, sep + steps.join(sep));
         return link;
     }
     getFileByFd(fd) {
         return this.fds[String(fd)];
     }
     getFileByFdOrThrow(fd, funcName) {
-        if (!isFd(fd))
-            throw TypeError(ERRSTR.FD);
+        if (!(0, util_1.isFd)(fd))
+            throw TypeError(constants_2.ERRSTR.FD);
         const file = this.getFileByFd(fd);
         if (!file)
-            throw createError(EBADF, funcName);
+            throw (0, util_1.createError)(EBADF, funcName);
         return file;
     }
     /**
@@ -624,7 +332,7 @@ class Volume {
     }
     */
     wrapAsync(method, args, callback) {
-        validateCallback(callback);
+        (0, util_1.validateCallback)(callback);
         (0, setImmediate_1.default)(() => {
             let result;
             try {
@@ -678,7 +386,7 @@ class Volume {
             if (!(paths instanceof Array))
                 paths = [paths];
             for (const path of paths) {
-                const filename = pathToFilename(path);
+                const filename = (0, util_1.pathToFilename)(path);
                 const link = this.getResolvedLink(filename);
                 if (!link)
                     continue;
@@ -729,28 +437,28 @@ class Volume {
     openLink(link, flagsNum, resolveSymlinks = true) {
         if (this.openFiles >= this.maxFiles) {
             // Too many open files.
-            throw createError(EMFILE, 'open', link.getPath());
+            throw (0, util_1.createError)(EMFILE, 'open', link.getPath());
         }
         // Resolve symlinks.
         let realLink = link;
         if (resolveSymlinks)
             realLink = this.resolveSymlinks(link);
         if (!realLink)
-            throw createError(ENOENT, 'open', link.getPath());
+            throw (0, util_1.createError)(ENOENT, 'open', link.getPath());
         const node = realLink.getNode();
         // Check whether node is a directory
         if (node.isDirectory()) {
             if ((flagsNum & (O_RDONLY | O_RDWR | O_WRONLY)) !== O_RDONLY)
-                throw createError(EISDIR, 'open', link.getPath());
+                throw (0, util_1.createError)(EISDIR, 'open', link.getPath());
         }
         else {
             if (flagsNum & O_DIRECTORY)
-                throw createError(ENOTDIR, 'open', link.getPath());
+                throw (0, util_1.createError)(ENOTDIR, 'open', link.getPath());
         }
         // Check node permissions
         if (!(flagsNum & O_WRONLY)) {
             if (!node.canRead()) {
-                throw createError(EACCES, 'open', link.getPath());
+                throw (0, util_1.createError)(EACCES, 'open', link.getPath());
             }
         }
         if (flagsNum & O_RDWR) {
@@ -766,33 +474,33 @@ class Volume {
         const steps = filenameToSteps(filename);
         let link = resolveSymlinks ? this.getResolvedLink(steps) : this.getLink(steps);
         if (link && flagsNum & O_EXCL)
-            throw createError(EEXIST, 'open', filename);
+            throw (0, util_1.createError)(EEXIST, 'open', filename);
         // Try creating a new file, if it does not exist.
         if (!link && flagsNum & O_CREAT) {
             // const dirLink: Link = this.getLinkParent(steps);
             const dirLink = this.getResolvedLink(steps.slice(0, steps.length - 1));
             // if(!dirLink) throw createError(ENOENT, 'open', filename);
             if (!dirLink)
-                throw createError(ENOENT, 'open', sep + steps.join(sep));
+                throw (0, util_1.createError)(ENOENT, 'open', sep + steps.join(sep));
             if (flagsNum & O_CREAT && typeof modeNum === 'number') {
                 link = this.createLink(dirLink, steps[steps.length - 1], false, modeNum);
             }
         }
         if (link)
             return this.openLink(link, flagsNum, resolveSymlinks);
-        throw createError(ENOENT, 'open', filename);
+        throw (0, util_1.createError)(ENOENT, 'open', filename);
     }
     openBase(filename, flagsNum, modeNum, resolveSymlinks = true) {
         const file = this.openFile(filename, flagsNum, modeNum, resolveSymlinks);
         if (!file)
-            throw createError(ENOENT, 'open', filename);
+            throw (0, util_1.createError)(ENOENT, 'open', filename);
         return file.fd;
     }
     openSync(path, flags, mode = 438 /* MODE.DEFAULT */) {
         // Validate (1) mode; (2) path; (3) flags - in that order.
-        const modeNum = modeToNumber(mode);
-        const fileName = pathToFilename(path);
-        const flagsNum = flagsToNumber(flags);
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const fileName = (0, util_1.pathToFilename)(path);
+        const flagsNum = (0, util_1.flagsToNumber)(flags);
         return this.openBase(fileName, flagsNum, modeNum);
     }
     open(path, flags, a, b) {
@@ -803,9 +511,9 @@ class Volume {
             callback = a;
         }
         mode = mode || 438 /* MODE.DEFAULT */;
-        const modeNum = modeToNumber(mode);
-        const fileName = pathToFilename(path);
-        const flagsNum = flagsToNumber(flags);
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const fileName = (0, util_1.pathToFilename)(path);
+        const flagsNum = (0, util_1.flagsToNumber)(flags);
         this.wrapAsync(this.openBase, [fileName, flagsNum, modeNum], callback);
     }
     closeFile(file) {
@@ -816,23 +524,23 @@ class Volume {
         this.releasedFds.push(file.fd);
     }
     closeSync(fd) {
-        validateFd(fd);
+        (0, util_1.validateFd)(fd);
         const file = this.getFileByFdOrThrow(fd, 'close');
         this.closeFile(file);
     }
     close(fd, callback) {
-        validateFd(fd);
+        (0, util_1.validateFd)(fd);
         this.wrapAsync(this.closeSync, [fd], callback);
     }
     openFileOrGetById(id, flagsNum, modeNum) {
         if (typeof id === 'number') {
             const file = this.fds[id];
             if (!file)
-                throw createError(ENOENT);
+                throw (0, util_1.createError)(ENOENT);
             return file;
         }
         else {
-            return this.openFile(pathToFilename(id), flagsNum, modeNum);
+            return this.openFile((0, util_1.pathToFilename)(id), flagsNum, modeNum);
         }
     }
     readBase(fd, buffer, offset, length, position) {
@@ -840,11 +548,11 @@ class Volume {
         return file.read(buffer, Number(offset), Number(length), position);
     }
     readSync(fd, buffer, offset, length, position) {
-        validateFd(fd);
+        (0, util_1.validateFd)(fd);
         return this.readBase(fd, buffer, offset, length, position);
     }
     read(fd, buffer, offset, length, position, callback) {
-        validateCallback(callback);
+        (0, util_1.validateCallback)(callback);
         // This `if` branch is from Node.js
         if (length === 0) {
             return process_1.default.nextTick(() => {
@@ -865,23 +573,23 @@ class Volume {
     readFileBase(id, flagsNum, encoding) {
         let result;
         const isUserFd = typeof id === 'number';
-        const userOwnsFd = isUserFd && isFd(id);
+        const userOwnsFd = isUserFd && (0, util_1.isFd)(id);
         let fd;
         if (userOwnsFd)
             fd = id;
         else {
-            const filename = pathToFilename(id);
+            const filename = (0, util_1.pathToFilename)(id);
             const steps = filenameToSteps(filename);
             const link = this.getResolvedLink(steps);
             if (link) {
                 const node = link.getNode();
                 if (node.isDirectory())
-                    throw createError(EISDIR, 'open', link.getPath());
+                    throw (0, util_1.createError)(EISDIR, 'open', link.getPath());
             }
             fd = this.openSync(id, flagsNum);
         }
         try {
-            result = bufferToEncoding(this.getFileByFdOrThrow(fd).getBuffer(), encoding);
+            result = (0, util_1.bufferToEncoding)(this.getFileByFdOrThrow(fd).getBuffer(), encoding);
         }
         finally {
             if (!userOwnsFd) {
@@ -891,13 +599,13 @@ class Volume {
         return result;
     }
     readFileSync(file, options) {
-        const opts = getReadFileOptions(options);
-        const flagsNum = flagsToNumber(opts.flag);
+        const opts = (0, options_1.getReadFileOptions)(options);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
         return this.readFileBase(file, flagsNum, opts.encoding);
     }
     readFile(id, a, b) {
-        const [opts, callback] = optsAndCbGenerator(getReadFileOptions)(a, b);
-        const flagsNum = flagsToNumber(opts.flag);
+        const [opts, callback] = (0, options_1.optsAndCbGenerator)(options_1.getReadFileOptions)(a, b);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
         this.wrapAsync(this.readFileBase, [id, flagsNum, opts.encoding], callback);
     }
     writeBase(fd, buf, offset, length, position) {
@@ -905,92 +613,15 @@ class Volume {
         return file.write(buf, offset, length, position);
     }
     writeSync(fd, a, b, c, d) {
-        validateFd(fd);
-        let encoding;
-        let offset;
-        let length;
-        let position;
-        const isBuffer = typeof a !== 'string';
-        if (isBuffer) {
-            offset = (b || 0) | 0;
-            length = c;
-            position = d;
-        }
-        else {
-            position = b;
-            encoding = c;
-        }
-        const buf = dataToBuffer(a, encoding);
-        if (isBuffer) {
-            if (typeof length === 'undefined') {
-                length = buf.length;
-            }
-        }
-        else {
-            offset = 0;
-            length = buf.length;
-        }
+        const [, buf, offset, length, position] = (0, util_1.getWriteSyncArgs)(fd, a, b, c, d);
         return this.writeBase(fd, buf, offset, length, position);
     }
     write(fd, a, b, c, d, e) {
-        validateFd(fd);
-        let offset;
-        let length;
-        let position;
-        let encoding;
-        let callback;
-        const tipa = typeof a;
-        const tipb = typeof b;
-        const tipc = typeof c;
-        const tipd = typeof d;
-        if (tipa !== 'string') {
-            if (tipb === 'function') {
-                callback = b;
-            }
-            else if (tipc === 'function') {
-                offset = b | 0;
-                callback = c;
-            }
-            else if (tipd === 'function') {
-                offset = b | 0;
-                length = c;
-                callback = d;
-            }
-            else {
-                offset = b | 0;
-                length = c;
-                position = d;
-                callback = e;
-            }
-        }
-        else {
-            if (tipb === 'function') {
-                callback = b;
-            }
-            else if (tipc === 'function') {
-                position = b;
-                callback = c;
-            }
-            else if (tipd === 'function') {
-                position = b;
-                encoding = c;
-                callback = d;
-            }
-        }
-        const buf = dataToBuffer(a, encoding);
-        if (tipa !== 'string') {
-            if (typeof length === 'undefined')
-                length = buf.length;
-        }
-        else {
-            offset = 0;
-            length = buf.length;
-        }
-        const cb = validateCallback(callback);
+        const [, asStr, buf, offset, length, position, cb] = (0, util_1.getWriteArgs)(fd, a, b, c, d, e);
         (0, setImmediate_1.default)(() => {
             try {
                 const bytes = this.writeBase(fd, buf, offset, length, position);
-                if (tipa !== 'string') {
+                if (!asStr) {
                     cb(null, bytes, buf);
                 }
                 else {
@@ -1002,6 +633,9 @@ class Volume {
             }
         });
     }
+    writev(fd, buffers, a, b) {
+        throw new Error('not implemented');
+    }
     writeFileBase(id, buf, flagsNum, modeNum) {
         // console.log('writeFileBase', id, buf, flagsNum, modeNum);
         // const node = this.getNodeByIdOrCreate(id, flagsNum, modeNum);
@@ -1011,7 +645,7 @@ class Volume {
         if (isUserFd)
             fd = id;
         else {
-            fd = this.openBase(pathToFilename(id), flagsNum, modeNum);
+            fd = this.openBase((0, util_1.pathToFilename)(id), flagsNum, modeNum);
             // fd = this.openSync(id as PathLike, flagsNum, modeNum);
         }
         let offset = 0;
@@ -1032,40 +666,40 @@ class Volume {
         }
     }
     writeFileSync(id, data, options) {
-        const opts = getWriteFileOptions(options);
-        const flagsNum = flagsToNumber(opts.flag);
-        const modeNum = modeToNumber(opts.mode);
-        const buf = dataToBuffer(data, opts.encoding);
+        const opts = (0, options_1.getWriteFileOptions)(options);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
+        const modeNum = (0, util_1.modeToNumber)(opts.mode);
+        const buf = (0, util_1.dataToBuffer)(data, opts.encoding);
         this.writeFileBase(id, buf, flagsNum, modeNum);
     }
     writeFile(id, data, a, b) {
         let options = a;
         let callback = b;
         if (typeof a === 'function') {
-            options = writeFileDefaults;
+            options = options_1.writeFileDefaults;
             callback = a;
         }
-        const cb = validateCallback(callback);
-        const opts = getWriteFileOptions(options);
-        const flagsNum = flagsToNumber(opts.flag);
-        const modeNum = modeToNumber(opts.mode);
-        const buf = dataToBuffer(data, opts.encoding);
+        const cb = (0, util_1.validateCallback)(callback);
+        const opts = (0, options_1.getWriteFileOptions)(options);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
+        const modeNum = (0, util_1.modeToNumber)(opts.mode);
+        const buf = (0, util_1.dataToBuffer)(data, opts.encoding);
         this.wrapAsync(this.writeFileBase, [id, buf, flagsNum, modeNum], cb);
     }
     linkBase(filename1, filename2) {
         const steps1 = filenameToSteps(filename1);
         const link1 = this.getLink(steps1);
         if (!link1)
-            throw createError(ENOENT, 'link', filename1, filename2);
+            throw (0, util_1.createError)(ENOENT, 'link', filename1, filename2);
         const steps2 = filenameToSteps(filename2);
         // Check new link directory exists.
         const dir2 = this.getLinkParent(steps2);
         if (!dir2)
-            throw createError(ENOENT, 'link', filename1, filename2);
+            throw (0, util_1.createError)(ENOENT, 'link', filename1, filename2);
         const name = steps2[steps2.length - 1];
         // Check if new file already exists.
         if (dir2.getChild(name))
-            throw createError(EEXIST, 'link', filename1, filename2);
+            throw (0, util_1.createError)(EEXIST, 'link', filename1, filename2);
         const node = link1.getNode();
         node.nlink++;
         dir2.createChild(name, node);
@@ -1074,22 +708,22 @@ class Volume {
         const buf = this.readFileSync(src);
         if (flags & COPYFILE_EXCL) {
             if (this.existsSync(dest)) {
-                throw createError(EEXIST, 'copyFile', src, dest);
+                throw (0, util_1.createError)(EEXIST, 'copyFile', src, dest);
             }
         }
         if (flags & COPYFILE_FICLONE_FORCE) {
-            throw createError(ENOSYS, 'copyFile', src, dest);
+            throw (0, util_1.createError)(ENOSYS, 'copyFile', src, dest);
         }
-        this.writeFileBase(dest, buf, FLAGS.w, 438 /* MODE.DEFAULT */);
+        this.writeFileBase(dest, buf, constants_2.FLAGS.w, 438 /* MODE.DEFAULT */);
     }
     copyFileSync(src, dest, flags) {
-        const srcFilename = pathToFilename(src);
-        const destFilename = pathToFilename(dest);
+        const srcFilename = (0, util_1.pathToFilename)(src);
+        const destFilename = (0, util_1.pathToFilename)(dest);
         return this.copyFileBase(srcFilename, destFilename, (flags || 0) | 0);
     }
     copyFile(src, dest, a, b) {
-        const srcFilename = pathToFilename(src);
-        const destFilename = pathToFilename(dest);
+        const srcFilename = (0, util_1.pathToFilename)(src);
+        const destFilename = (0, util_1.pathToFilename)(dest);
         let flags;
         let callback;
         if (typeof a === 'function') {
@@ -1100,24 +734,24 @@ class Volume {
             flags = a;
             callback = b;
         }
-        validateCallback(callback);
+        (0, util_1.validateCallback)(callback);
         this.wrapAsync(this.copyFileBase, [srcFilename, destFilename, flags], callback);
     }
     linkSync(existingPath, newPath) {
-        const existingPathFilename = pathToFilename(existingPath);
-        const newPathFilename = pathToFilename(newPath);
+        const existingPathFilename = (0, util_1.pathToFilename)(existingPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
         this.linkBase(existingPathFilename, newPathFilename);
     }
     link(existingPath, newPath, callback) {
-        const existingPathFilename = pathToFilename(existingPath);
-        const newPathFilename = pathToFilename(newPath);
+        const existingPathFilename = (0, util_1.pathToFilename)(existingPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
         this.wrapAsync(this.linkBase, [existingPathFilename, newPathFilename], callback);
     }
     unlinkBase(filename) {
         const steps = filenameToSteps(filename);
         const link = this.getLink(steps);
         if (!link)
-            throw createError(ENOENT, 'unlink', filename);
+            throw (0, util_1.createError)(ENOENT, 'unlink', filename);
         // TODO: Check if it is file, dir, other...
         if (link.length)
             throw Error('Dir not empty...');
@@ -1130,11 +764,11 @@ class Volume {
         }
     }
     unlinkSync(path) {
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         this.unlinkBase(filename);
     }
     unlink(path, callback) {
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.unlinkBase, [filename], callback);
     }
     symlinkBase(targetFilename, pathFilename) {
@@ -1142,11 +776,11 @@ class Volume {
         // Check if directory exists, where we about to create a symlink.
         const dirLink = this.getLinkParent(pathSteps);
         if (!dirLink)
-            throw createError(ENOENT, 'symlink', targetFilename, pathFilename);
+            throw (0, util_1.createError)(ENOENT, 'symlink', targetFilename, pathFilename);
         const name = pathSteps[pathSteps.length - 1];
         // Check if new file already exists.
         if (dirLink.getChild(name))
-            throw createError(EEXIST, 'symlink', targetFilename, pathFilename);
+            throw (0, util_1.createError)(EEXIST, 'symlink', targetFilename, pathFilename);
         // Create symlink.
         const symlink = dirLink.createChild(name);
         symlink.getNode().makeSymlink(filenameToSteps(targetFilename));
@@ -1154,29 +788,29 @@ class Volume {
     }
     // `type` argument works only on Windows.
     symlinkSync(target, path, type) {
-        const targetFilename = pathToFilename(target);
-        const pathFilename = pathToFilename(path);
+        const targetFilename = (0, util_1.pathToFilename)(target);
+        const pathFilename = (0, util_1.pathToFilename)(path);
         this.symlinkBase(targetFilename, pathFilename);
     }
     symlink(target, path, a, b) {
-        const callback = validateCallback(typeof a === 'function' ? a : b);
-        const targetFilename = pathToFilename(target);
-        const pathFilename = pathToFilename(path);
+        const callback = (0, util_1.validateCallback)(typeof a === 'function' ? a : b);
+        const targetFilename = (0, util_1.pathToFilename)(target);
+        const pathFilename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.symlinkBase, [targetFilename, pathFilename], callback);
     }
     realpathBase(filename, encoding) {
         const steps = filenameToSteps(filename);
         const realLink = this.getResolvedLink(steps);
         if (!realLink)
-            throw createError(ENOENT, 'realpath', filename);
+            throw (0, util_1.createError)(ENOENT, 'realpath', filename);
         return (0, encoding_1.strToEncoding)(realLink.getPath() || '/', encoding);
     }
     realpathSync(path, options) {
-        return this.realpathBase(pathToFilename(path), getRealpathOptions(options).encoding);
+        return this.realpathBase((0, util_1.pathToFilename)(path), (0, options_1.getRealpathOptions)(options).encoding);
     }
     realpath(path, a, b) {
-        const [opts, callback] = getRealpathOptsAndCb(a, b);
-        const pathFilename = pathToFilename(path);
+        const [opts, callback] = (0, options_1.getRealpathOptsAndCb)(a, b);
+        const pathFilename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.realpathBase, [pathFilename, opts.encoding], callback);
     }
     lstatBase(filename, bigint = false, throwIfNoEntry = false) {
@@ -1188,16 +822,16 @@ class Volume {
             return undefined;
         }
         else {
-            throw createError(ENOENT, 'lstat', filename);
+            throw (0, util_1.createError)(ENOENT, 'lstat', filename);
         }
     }
     lstatSync(path, options) {
-        const { throwIfNoEntry = true, bigint = false } = getStatOptions(options);
-        return this.lstatBase(pathToFilename(path), bigint, throwIfNoEntry);
+        const { throwIfNoEntry = true, bigint = false } = (0, options_1.getStatOptions)(options);
+        return this.lstatBase((0, util_1.pathToFilename)(path), bigint, throwIfNoEntry);
     }
     lstat(path, a, b) {
-        const [{ throwIfNoEntry = true, bigint = false }, callback] = getStatOptsAndCb(a, b);
-        this.wrapAsync(this.lstatBase, [pathToFilename(path), bigint, throwIfNoEntry], callback);
+        const [{ throwIfNoEntry = true, bigint = false }, callback] = (0, options_1.getStatOptsAndCb)(a, b);
+        this.wrapAsync(this.lstatBase, [(0, util_1.pathToFilename)(path), bigint, throwIfNoEntry], callback);
     }
     statBase(filename, bigint = false, throwIfNoEntry = true) {
         const link = this.getResolvedLink(filenameToSteps(filename));
@@ -1208,40 +842,40 @@ class Volume {
             return undefined;
         }
         else {
-            throw createError(ENOENT, 'stat', filename);
+            throw (0, util_1.createError)(ENOENT, 'stat', filename);
         }
     }
     statSync(path, options) {
-        const { bigint = true, throwIfNoEntry = true } = getStatOptions(options);
-        return this.statBase(pathToFilename(path), bigint, throwIfNoEntry);
+        const { bigint = true, throwIfNoEntry = true } = (0, options_1.getStatOptions)(options);
+        return this.statBase((0, util_1.pathToFilename)(path), bigint, throwIfNoEntry);
     }
     stat(path, a, b) {
-        const [{ bigint = false, throwIfNoEntry = true }, callback] = getStatOptsAndCb(a, b);
-        this.wrapAsync(this.statBase, [pathToFilename(path), bigint, throwIfNoEntry], callback);
+        const [{ bigint = false, throwIfNoEntry = true }, callback] = (0, options_1.getStatOptsAndCb)(a, b);
+        this.wrapAsync(this.statBase, [(0, util_1.pathToFilename)(path), bigint, throwIfNoEntry], callback);
     }
     fstatBase(fd, bigint = false) {
         const file = this.getFileByFd(fd);
         if (!file)
-            throw createError(EBADF, 'fstat');
+            throw (0, util_1.createError)(EBADF, 'fstat');
         return Stats_1.default.build(file.node, bigint);
     }
     fstatSync(fd, options) {
-        return this.fstatBase(fd, getStatOptions(options).bigint);
+        return this.fstatBase(fd, (0, options_1.getStatOptions)(options).bigint);
     }
     fstat(fd, a, b) {
-        const [opts, callback] = getStatOptsAndCb(a, b);
+        const [opts, callback] = (0, options_1.getStatOptsAndCb)(a, b);
         this.wrapAsync(this.fstatBase, [fd, opts.bigint], callback);
     }
     renameBase(oldPathFilename, newPathFilename) {
         const link = this.getLink(filenameToSteps(oldPathFilename));
         if (!link)
-            throw createError(ENOENT, 'rename', oldPathFilename, newPathFilename);
+            throw (0, util_1.createError)(ENOENT, 'rename', oldPathFilename, newPathFilename);
         // TODO: Check if it is directory, if non-empty, we cannot move it, right?
         const newPathSteps = filenameToSteps(newPathFilename);
         // Check directory exists for the new location.
         const newPathDirLink = this.getLinkParent(newPathSteps);
         if (!newPathDirLink)
-            throw createError(ENOENT, 'rename', oldPathFilename, newPathFilename);
+            throw (0, util_1.createError)(ENOENT, 'rename', oldPathFilename, newPathFilename);
         // TODO: Also treat cases with directories and symbolic links.
         // TODO: See: http://man7.org/linux/man-pages/man2/rename.2.html
         // Remove hard link from old folder.
@@ -1256,13 +890,13 @@ class Volume {
         newPathDirLink.setChild(link.getName(), link);
     }
     renameSync(oldPath, newPath) {
-        const oldPathFilename = pathToFilename(oldPath);
-        const newPathFilename = pathToFilename(newPath);
+        const oldPathFilename = (0, util_1.pathToFilename)(oldPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
         this.renameBase(oldPathFilename, newPathFilename);
     }
     rename(oldPath, newPath, callback) {
-        const oldPathFilename = pathToFilename(oldPath);
-        const newPathFilename = pathToFilename(newPath);
+        const oldPathFilename = (0, util_1.pathToFilename)(oldPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
         this.wrapAsync(this.renameBase, [oldPathFilename, newPathFilename], callback);
     }
     existsBase(filename) {
@@ -1270,16 +904,16 @@ class Volume {
     }
     existsSync(path) {
         try {
-            return this.existsBase(pathToFilename(path));
+            return this.existsBase((0, util_1.pathToFilename)(path));
         }
         catch (err) {
             return false;
         }
     }
     exists(path, callback) {
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         if (typeof callback !== 'function')
-            throw Error(ERRSTR.CB);
+            throw Error(constants_2.ERRSTR.CB);
         (0, setImmediate_1.default)(() => {
             try {
                 callback(this.existsBase(filename));
@@ -1294,7 +928,7 @@ class Volume {
         // TODO: Verify permissions
     }
     accessSync(path, mode = F_OK) {
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         mode = mode | 0;
         this.accessBase(filename, mode);
     }
@@ -1303,25 +937,25 @@ class Volume {
         let callback;
         if (typeof a !== 'function') {
             mode = a | 0; // cast to number
-            callback = validateCallback(b);
+            callback = (0, util_1.validateCallback)(b);
         }
         else {
             callback = a;
         }
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.accessBase, [filename, mode], callback);
     }
-    appendFileSync(id, data, options = appendFileDefaults) {
-        const opts = getAppendFileOpts(options);
+    appendFileSync(id, data, options) {
+        const opts = (0, options_1.getAppendFileOpts)(options);
         // force append behavior when using a supplied file descriptor
-        if (!opts.flag || isFd(id))
+        if (!opts.flag || (0, util_1.isFd)(id))
             opts.flag = 'a';
         this.writeFileSync(id, data, opts);
     }
     appendFile(id, data, a, b) {
-        const [opts, callback] = getAppendFileOptsAndCb(a, b);
+        const [opts, callback] = (0, options_1.getAppendFileOptsAndCb)(a, b);
         // force append behavior when using a supplied file descriptor
-        if (!opts.flag || isFd(id))
+        if (!opts.flag || (0, util_1.isFd)(id))
             opts.flag = 'a';
         this.writeFile(id, data, opts, callback);
     }
@@ -1329,10 +963,10 @@ class Volume {
         const steps = filenameToSteps(filename);
         const link = this.getResolvedLink(steps);
         if (!link)
-            throw createError(ENOENT, 'readdir', filename);
+            throw (0, util_1.createError)(ENOENT, 'readdir', filename);
         const node = link.getNode();
         if (!node.isDirectory())
-            throw createError(ENOTDIR, 'scandir', filename);
+            throw (0, util_1.createError)(ENOTDIR, 'scandir', filename);
         if (options.withFileTypes) {
             const list = [];
             for (const name in link.children) {
@@ -1342,7 +976,7 @@ class Volume {
                 }
                 list.push(Dirent_1.default.build(child, options.encoding));
             }
-            if (!isWin && options.encoding !== 'buffer')
+            if (!util_1.isWin && options.encoding !== 'buffer')
                 list.sort((a, b) => {
                     if (a.name < b.name)
                         return -1;
@@ -1359,36 +993,36 @@ class Volume {
             }
             list.push((0, encoding_1.strToEncoding)(name, options.encoding));
         }
-        if (!isWin && options.encoding !== 'buffer')
+        if (!util_1.isWin && options.encoding !== 'buffer')
             list.sort();
         return list;
     }
     readdirSync(path, options) {
-        const opts = getReaddirOptions(options);
-        const filename = pathToFilename(path);
+        const opts = (0, options_1.getReaddirOptions)(options);
+        const filename = (0, util_1.pathToFilename)(path);
         return this.readdirBase(filename, opts);
     }
     readdir(path, a, b) {
-        const [options, callback] = getReaddirOptsAndCb(a, b);
-        const filename = pathToFilename(path);
+        const [options, callback] = (0, options_1.getReaddirOptsAndCb)(a, b);
+        const filename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.readdirBase, [filename, options], callback);
     }
     readlinkBase(filename, encoding) {
         const link = this.getLinkOrThrow(filename, 'readlink');
         const node = link.getNode();
         if (!node.isSymlink())
-            throw createError(EINVAL, 'readlink', filename);
+            throw (0, util_1.createError)(EINVAL, 'readlink', filename);
         const str = sep + node.symlink.join(sep);
         return (0, encoding_1.strToEncoding)(str, encoding);
     }
     readlinkSync(path, options) {
-        const opts = getDefaultOpts(options);
-        const filename = pathToFilename(path);
+        const opts = (0, options_1.getDefaultOpts)(options);
+        const filename = (0, util_1.pathToFilename)(path);
         return this.readlinkBase(filename, opts.encoding);
     }
     readlink(path, a, b) {
-        const [opts, callback] = getDefaultOptsAndCb(a, b);
-        const filename = pathToFilename(path);
+        const [opts, callback] = (0, options_1.getDefaultOptsAndCb)(a, b);
+        const filename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.readlinkBase, [filename, opts.encoding], callback);
     }
     fsyncBase(fd) {
@@ -1418,7 +1052,7 @@ class Volume {
     }
     ftruncate(fd, a, b) {
         const len = typeof a === 'number' ? a : 0;
-        const callback = validateCallback(typeof a === 'number' ? b : a);
+        const callback = (0, util_1.validateCallback)(typeof a === 'number' ? b : a);
         this.wrapAsync(this.ftruncateBase, [fd, len], callback);
     }
     truncateBase(path, len) {
@@ -1430,15 +1064,19 @@ class Volume {
             this.closeSync(fd);
         }
     }
+    /**
+     * `id` should be a file descriptor or a path. `id` as file descriptor will
+     * not be supported soon.
+     */
     truncateSync(id, len) {
-        if (isFd(id))
+        if ((0, util_1.isFd)(id))
             return this.ftruncateSync(id, len);
         this.truncateBase(id, len);
     }
     truncate(id, a, b) {
         const len = typeof a === 'number' ? a : 0;
-        const callback = validateCallback(typeof a === 'number' ? b : a);
-        if (isFd(id))
+        const callback = (0, util_1.validateCallback)(typeof a === 'number' ? b : a);
+        if ((0, util_1.isFd)(id))
             return this.ftruncate(id, len, callback);
         this.wrapAsync(this.truncateBase, [id, len], callback);
     }
@@ -1464,22 +1102,22 @@ class Volume {
         }
     }
     utimesSync(path, atime, mtime) {
-        this.utimesBase(pathToFilename(path), toUnixTimestamp(atime), toUnixTimestamp(mtime));
+        this.utimesBase((0, util_1.pathToFilename)(path), toUnixTimestamp(atime), toUnixTimestamp(mtime));
     }
     utimes(path, atime, mtime, callback) {
-        this.wrapAsync(this.utimesBase, [pathToFilename(path), toUnixTimestamp(atime), toUnixTimestamp(mtime)], callback);
+        this.wrapAsync(this.utimesBase, [(0, util_1.pathToFilename)(path), toUnixTimestamp(atime), toUnixTimestamp(mtime)], callback);
     }
     mkdirBase(filename, modeNum) {
         const steps = filenameToSteps(filename);
         // This will throw if user tries to create root dir `fs.mkdirSync('/')`.
         if (!steps.length) {
-            throw createError(EEXIST, 'mkdir', filename);
+            throw (0, util_1.createError)(EEXIST, 'mkdir', filename);
         }
         const dir = this.getLinkParentAsDirOrThrow(filename, 'mkdir');
         // Check path already exists.
         const name = steps[steps.length - 1];
         if (dir.getChild(name))
-            throw createError(EEXIST, 'mkdir', filename);
+            throw (0, util_1.createError)(EEXIST, 'mkdir', filename);
         dir.createChild(name, this.createNode(true, modeNum));
     }
     /**
@@ -1496,13 +1134,13 @@ class Volume {
         for (let i = 0; i < steps.length; i++) {
             const step = steps[i];
             if (!link.getNode().isDirectory())
-                throw createError(ENOTDIR, 'mkdir', link.getPath());
+                throw (0, util_1.createError)(ENOTDIR, 'mkdir', link.getPath());
             const child = link.getChild(step);
             if (child) {
                 if (child.getNode().isDirectory())
                     link = child;
                 else
-                    throw createError(ENOTDIR, 'mkdir', child.getPath());
+                    throw (0, util_1.createError)(ENOTDIR, 'mkdir', child.getPath());
             }
             else {
                 link = link.createChild(step, this.createNode(true, modeNum));
@@ -1512,18 +1150,18 @@ class Volume {
         return created ? fullPath : undefined;
     }
     mkdirSync(path, options) {
-        const opts = getMkdirOptions(options);
-        const modeNum = modeToNumber(opts.mode, 0o777);
-        const filename = pathToFilename(path);
+        const opts = (0, options_1.getMkdirOptions)(options);
+        const modeNum = (0, util_1.modeToNumber)(opts.mode, 0o777);
+        const filename = (0, util_1.pathToFilename)(path);
         if (opts.recursive)
             return this.mkdirpBase(filename, modeNum);
         this.mkdirBase(filename, modeNum);
     }
     mkdir(path, a, b) {
-        const opts = getMkdirOptions(a);
-        const callback = validateCallback(typeof a === 'function' ? a : b);
-        const modeNum = modeToNumber(opts.mode, 0o777);
-        const filename = pathToFilename(path);
+        const opts = (0, options_1.getMkdirOptions)(a);
+        const callback = (0, util_1.validateCallback)(typeof a === 'function' ? a : b);
+        const modeNum = (0, util_1.modeToNumber)(opts.mode, 0o777);
+        const filename = (0, util_1.pathToFilename)(path);
         if (opts.recursive)
             this.wrapAsync(this.mkdirpBase, [filename, modeNum], callback);
         else
@@ -1535,11 +1173,11 @@ class Volume {
     }
     mkdirp(path, a, b) {
         const mode = typeof a === 'function' ? undefined : a;
-        const callback = validateCallback(typeof a === 'function' ? a : b);
+        const callback = (0, util_1.validateCallback)(typeof a === 'function' ? a : b);
         this.mkdir(path, { mode, recursive: true }, callback);
     }
     mkdtempBase(prefix, encoding, retry = 5) {
-        const filename = prefix + this.genRndStr();
+        const filename = prefix + (0, util_1.genRndStr6)();
         try {
             this.mkdirBase(filename, 511 /* MODE.DIR */);
             return (0, encoding_1.strToEncoding)(filename, encoding);
@@ -1556,67 +1194,67 @@ class Volume {
         }
     }
     mkdtempSync(prefix, options) {
-        const { encoding } = getDefaultOpts(options);
+        const { encoding } = (0, options_1.getDefaultOpts)(options);
         if (!prefix || typeof prefix !== 'string')
             throw new TypeError('filename prefix is required');
-        nullCheck(prefix);
+        (0, util_1.nullCheck)(prefix);
         return this.mkdtempBase(prefix, encoding);
     }
     mkdtemp(prefix, a, b) {
-        const [{ encoding }, callback] = getDefaultOptsAndCb(a, b);
+        const [{ encoding }, callback] = (0, options_1.getDefaultOptsAndCb)(a, b);
         if (!prefix || typeof prefix !== 'string')
             throw new TypeError('filename prefix is required');
-        if (!nullCheck(prefix))
+        if (!(0, util_1.nullCheck)(prefix))
             return;
         this.wrapAsync(this.mkdtempBase, [prefix, encoding], callback);
     }
     rmdirBase(filename, options) {
-        const opts = getRmdirOptions(options);
+        const opts = (0, options_1.getRmdirOptions)(options);
         const link = this.getLinkAsDirOrThrow(filename, 'rmdir');
         // Check directory is empty.
         if (link.length && !opts.recursive)
-            throw createError(ENOTEMPTY, 'rmdir', filename);
+            throw (0, util_1.createError)(ENOTEMPTY, 'rmdir', filename);
         this.deleteLink(link);
     }
     rmdirSync(path, options) {
-        this.rmdirBase(pathToFilename(path), options);
+        this.rmdirBase((0, util_1.pathToFilename)(path), options);
     }
     rmdir(path, a, b) {
-        const opts = getRmdirOptions(a);
-        const callback = validateCallback(typeof a === 'function' ? a : b);
-        this.wrapAsync(this.rmdirBase, [pathToFilename(path), opts], callback);
+        const opts = (0, options_1.getRmdirOptions)(a);
+        const callback = (0, util_1.validateCallback)(typeof a === 'function' ? a : b);
+        this.wrapAsync(this.rmdirBase, [(0, util_1.pathToFilename)(path), opts], callback);
     }
     rmBase(filename, options = {}) {
         const link = this.getResolvedLink(filename);
         if (!link) {
             // "stat" is used to match Node's native error message.
             if (!options.force)
-                throw createError(ENOENT, 'stat', filename);
+                throw (0, util_1.createError)(ENOENT, 'stat', filename);
             return;
         }
         if (link.getNode().isDirectory()) {
             if (!options.recursive) {
-                throw createError(ERR_FS_EISDIR, 'rm', filename);
+                throw (0, util_1.createError)(ERR_FS_EISDIR, 'rm', filename);
             }
         }
         this.deleteLink(link);
     }
     rmSync(path, options) {
-        this.rmBase(pathToFilename(path), options);
+        this.rmBase((0, util_1.pathToFilename)(path), options);
     }
     rm(path, a, b) {
-        const [opts, callback] = getRmOptsAndCb(a, b);
-        this.wrapAsync(this.rmBase, [pathToFilename(path), opts], callback);
+        const [opts, callback] = (0, options_1.getRmOptsAndCb)(a, b);
+        this.wrapAsync(this.rmBase, [(0, util_1.pathToFilename)(path), opts], callback);
     }
     fchmodBase(fd, modeNum) {
         const file = this.getFileByFdOrThrow(fd, 'fchmod');
         file.chmod(modeNum);
     }
     fchmodSync(fd, mode) {
-        this.fchmodBase(fd, modeToNumber(mode));
+        this.fchmodBase(fd, (0, util_1.modeToNumber)(mode));
     }
     fchmod(fd, mode, callback) {
-        this.wrapAsync(this.fchmodBase, [fd, modeToNumber(mode)], callback);
+        this.wrapAsync(this.fchmodBase, [fd, (0, util_1.modeToNumber)(mode)], callback);
     }
     chmodBase(filename, modeNum) {
         const fd = this.openSync(filename, 'r');
@@ -1628,13 +1266,13 @@ class Volume {
         }
     }
     chmodSync(path, mode) {
-        const modeNum = modeToNumber(mode);
-        const filename = pathToFilename(path);
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
         this.chmodBase(filename, modeNum);
     }
     chmod(path, mode, callback) {
-        const modeNum = modeToNumber(mode);
-        const filename = pathToFilename(path);
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.chmodBase, [filename, modeNum], callback);
     }
     lchmodBase(filename, modeNum) {
@@ -1647,13 +1285,13 @@ class Volume {
         }
     }
     lchmodSync(path, mode) {
-        const modeNum = modeToNumber(mode);
-        const filename = pathToFilename(path);
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
         this.lchmodBase(filename, modeNum);
     }
     lchmod(path, mode, callback) {
-        const modeNum = modeToNumber(mode);
-        const filename = pathToFilename(path);
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
         this.wrapAsync(this.lchmodBase, [filename, modeNum], callback);
     }
     fchownBase(fd, uid, gid) {
@@ -1684,12 +1322,12 @@ class Volume {
     chownSync(path, uid, gid) {
         validateUid(uid);
         validateGid(gid);
-        this.chownBase(pathToFilename(path), uid, gid);
+        this.chownBase((0, util_1.pathToFilename)(path), uid, gid);
     }
     chown(path, uid, gid, callback) {
         validateUid(uid);
         validateGid(gid);
-        this.wrapAsync(this.chownBase, [pathToFilename(path), uid, gid], callback);
+        this.wrapAsync(this.chownBase, [(0, util_1.pathToFilename)(path), uid, gid], callback);
     }
     lchownBase(filename, uid, gid) {
         this.getLinkOrThrow(filename, 'lchown').getNode().chown(uid, gid);
@@ -1697,15 +1335,15 @@ class Volume {
     lchownSync(path, uid, gid) {
         validateUid(uid);
         validateGid(gid);
-        this.lchownBase(pathToFilename(path), uid, gid);
+        this.lchownBase((0, util_1.pathToFilename)(path), uid, gid);
     }
     lchown(path, uid, gid, callback) {
         validateUid(uid);
         validateGid(gid);
-        this.wrapAsync(this.lchownBase, [pathToFilename(path), uid, gid], callback);
+        this.wrapAsync(this.lchownBase, [(0, util_1.pathToFilename)(path), uid, gid], callback);
     }
     watchFile(path, a, b) {
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         let options = a;
         let listener = b;
         if (typeof options === 'function') {
@@ -1733,7 +1371,7 @@ class Volume {
         return watcher;
     }
     unwatchFile(path, listener) {
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         const watcher = this.statWatchers[filename];
         if (!watcher)
             return;
@@ -1757,14 +1395,14 @@ class Volume {
     // watch(path: PathLike): FSWatcher;
     // watch(path: PathLike, options?: IWatchOptions | string): FSWatcher;
     watch(path, options, listener) {
-        const filename = pathToFilename(path);
+        const filename = (0, util_1.pathToFilename)(path);
         let givenOptions = options;
         if (typeof options === 'function') {
             listener = options;
             givenOptions = null;
         }
         // tslint:disable-next-line prefer-const
-        let { persistent, recursive, encoding } = getDefaultOpts(givenOptions);
+        let { persistent, recursive, encoding } = (0, options_1.getDefaultOpts)(givenOptions);
         if (persistent === undefined)
             persistent = true;
         if (recursive === undefined)
@@ -1818,7 +1456,7 @@ class StatWatcher extends events_1.EventEmitter {
         return false;
     }
     start(path, persistent = true, interval = 5007) {
-        this.filename = pathToFilename(path);
+        this.filename = (0, util_1.pathToFilename)(path);
         this.setTimeout = persistent
             ? setTimeout.bind(typeof globalThis !== 'undefined' ? globalThis : global)
             : setTimeoutUnref_1.default;
@@ -1832,6 +1470,8 @@ class StatWatcher extends events_1.EventEmitter {
     }
 }
 exports.StatWatcher = StatWatcher;
+/* tslint:disable no-var-keyword prefer-const */
+// ---------------------------------------- ReadStream
 var pool;
 function allocNewPool(poolSize) {
     pool = (0, buffer_1.bufferAllocUnsafe)(poolSize);
@@ -1844,11 +1484,11 @@ function FsReadStream(vol, path, options) {
         return new FsReadStream(vol, path, options);
     this._vol = vol;
     // a little bit bigger buffer and water marks by default
-    options = Object.assign({}, getOptions(options, {}));
+    options = Object.assign({}, (0, options_1.getOptions)(options, {}));
     if (options.highWaterMark === undefined)
         options.highWaterMark = 64 * 1024;
     stream_1.Readable.call(this, options);
-    this.path = pathToFilename(path);
+    this.path = (0, util_1.pathToFilename)(path);
     this.fd = options.fd === undefined ? null : options.fd;
     this.flags = options.flags === undefined ? 'r' : options.flags;
     this.mode = options.mode === undefined ? 0o666 : options.mode;
@@ -1990,9 +1630,9 @@ function FsWriteStream(vol, path, options) {
     if (!(this instanceof FsWriteStream))
         return new FsWriteStream(vol, path, options);
     this._vol = vol;
-    options = Object.assign({}, getOptions(options, {}));
+    options = Object.assign({}, (0, options_1.getOptions)(options, {}));
     stream_1.Writable.call(this, options);
-    this.path = pathToFilename(path);
+    this.path = (0, util_1.pathToFilename)(path);
     this.fd = options.fd === undefined ? null : options.fd;
     this.flags = options.flags === undefined ? 'w' : options.flags;
     this.mode = options.mode === undefined ? 0o666 : options.mode;
@@ -2000,6 +1640,7 @@ function FsWriteStream(vol, path, options) {
     this.autoClose = options.autoClose === undefined ? true : !!options.autoClose;
     this.pos = undefined;
     this.bytesWritten = 0;
+    this.pending = true;
     if (this.start !== undefined) {
         if (typeof this.start !== 'number') {
             throw new TypeError('"start" option must be a Number');
@@ -2030,6 +1671,7 @@ FsWriteStream.prototype.open = function () {
             return;
         }
         this.fd = fd;
+        this.pending = false;
         this.emit('open', fd);
     }.bind(this));
 };
@@ -2155,7 +1797,7 @@ class FSWatcher extends events_1.EventEmitter {
         return this._steps[this._steps.length - 1];
     }
     start(path, persistent = true, recursive = false, encoding = encoding_1.ENCODING_UTF8) {
-        this._filename = pathToFilename(path);
+        this._filename = (0, util_1.pathToFilename)(path);
         this._steps = filenameToSteps(this._filename);
         this._filenameEncoded = (0, encoding_1.strToEncoding)(this._filename);
         // this._persistent = persistent;