memfs 3.5.2 → 3.6.0

package/lib/Dirent.js

@@ -1,49 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dirent = void 0;
-var constants_1 = require("./constants");
-var encoding_1 = require("./encoding");
-var S_IFMT = constants_1.constants.S_IFMT, S_IFDIR = constants_1.constants.S_IFDIR, S_IFREG = constants_1.constants.S_IFREG, S_IFBLK = constants_1.constants.S_IFBLK, S_IFCHR = constants_1.constants.S_IFCHR, S_IFLNK = constants_1.constants.S_IFLNK, S_IFIFO = constants_1.constants.S_IFIFO, S_IFSOCK = constants_1.constants.S_IFSOCK;
+const constants_1 = require("./constants");
+const encoding_1 = require("./encoding");
+const { S_IFMT, S_IFDIR, S_IFREG, S_IFBLK, S_IFCHR, S_IFLNK, S_IFIFO, S_IFSOCK } = constants_1.constants;
 /**
  * A directory entry, like `fs.Dirent`.
  */
-var Dirent = /** @class */ (function () {
-    function Dirent() {
+class Dirent {
+    constructor() {
         this.name = '';
         this.mode = 0;
     }
-    Dirent.build = function (link, encoding) {
-        var dirent = new Dirent();
-        var mode = link.getNode().mode;
+    static build(link, encoding) {
+        const dirent = new Dirent();
+        const { mode } = link.getNode();
         dirent.name = (0, encoding_1.strToEncoding)(link.getName(), encoding);
         dirent.mode = mode;
         return dirent;
-    };
-    Dirent.prototype._checkModeProperty = function (property) {
+    }
+    _checkModeProperty(property) {
         return (this.mode & S_IFMT) === property;
-    };
-    Dirent.prototype.isDirectory = function () {
+    }
+    isDirectory() {
         return this._checkModeProperty(S_IFDIR);
-    };
-    Dirent.prototype.isFile = function () {
+    }
+    isFile() {
         return this._checkModeProperty(S_IFREG);
-    };
-    Dirent.prototype.isBlockDevice = function () {
+    }
+    isBlockDevice() {
         return this._checkModeProperty(S_IFBLK);
-    };
-    Dirent.prototype.isCharacterDevice = function () {
+    }
+    isCharacterDevice() {
         return this._checkModeProperty(S_IFCHR);
-    };
-    Dirent.prototype.isSymbolicLink = function () {
+    }
+    isSymbolicLink() {
         return this._checkModeProperty(S_IFLNK);
-    };
-    Dirent.prototype.isFIFO = function () {
+    }
+    isFIFO() {
         return this._checkModeProperty(S_IFIFO);
-    };
-    Dirent.prototype.isSocket = function () {
+    }
+    isSocket() {
         return this._checkModeProperty(S_IFSOCK);
-    };
-    return Dirent;
-}());
+    }
+}
 exports.Dirent = Dirent;
 exports.default = Dirent;

package/lib/Stats.js

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stats = void 0;
-var constants_1 = require("./constants");
-var getBigInt_1 = require("./getBigInt");
-var S_IFMT = constants_1.constants.S_IFMT, S_IFDIR = constants_1.constants.S_IFDIR, S_IFREG = constants_1.constants.S_IFREG, S_IFBLK = constants_1.constants.S_IFBLK, S_IFCHR = constants_1.constants.S_IFCHR, S_IFLNK = constants_1.constants.S_IFLNK, S_IFIFO = constants_1.constants.S_IFIFO, S_IFSOCK = constants_1.constants.S_IFSOCK;
+const constants_1 = require("./constants");
+const getBigInt_1 = require("./getBigInt");
+const { S_IFMT, S_IFDIR, S_IFREG, S_IFBLK, S_IFCHR, S_IFLNK, S_IFIFO, S_IFSOCK } = constants_1.constants;
 /**
  * Statistics about a file/directory, like `fs.Stats`.
  */
-var Stats = /** @class */ (function () {
-    function Stats() {
-    }
-    Stats.build = function (node, bigint) {
-        if (bigint === void 0) { bigint = false; }
-        var stats = new Stats();
-        var uid = node.uid, gid = node.gid, atime = node.atime, mtime = node.mtime, ctime = node.ctime;
-        var getStatNumber = !bigint ? function (number) { return number; } : getBigInt_1.default;
+class Stats {
+    static build(node, bigint = false) {
+        const stats = new Stats();
+        const { uid, gid, atime, mtime, ctime } = node;
+        const getStatNumber = !bigint ? number => number : getBigInt_1.default;
         // Copy all values on Stats from Node, so that if Node values
         // change, values on Stats would still be the old ones,
         // just like in Node fs.
@@ -31,39 +28,38 @@ var Stats = /** @class */ (function () {
         stats.birthtime = ctime;
         stats.atimeMs = getStatNumber(atime.getTime());
         stats.mtimeMs = getStatNumber(mtime.getTime());
-        var ctimeMs = getStatNumber(ctime.getTime());
+        const ctimeMs = getStatNumber(ctime.getTime());
         stats.ctimeMs = ctimeMs;
         stats.birthtimeMs = ctimeMs;
         stats.dev = getStatNumber(0);
         stats.mode = getStatNumber(node.mode);
         stats.nlink = getStatNumber(node.nlink);
         return stats;
-    };
-    Stats.prototype._checkModeProperty = function (property) {
+    }
+    _checkModeProperty(property) {
         return (Number(this.mode) & S_IFMT) === property;
-    };
-    Stats.prototype.isDirectory = function () {
+    }
+    isDirectory() {
         return this._checkModeProperty(S_IFDIR);
-    };
-    Stats.prototype.isFile = function () {
+    }
+    isFile() {
         return this._checkModeProperty(S_IFREG);
-    };
-    Stats.prototype.isBlockDevice = function () {
+    }
+    isBlockDevice() {
         return this._checkModeProperty(S_IFBLK);
-    };
-    Stats.prototype.isCharacterDevice = function () {
+    }
+    isCharacterDevice() {
         return this._checkModeProperty(S_IFCHR);
-    };
-    Stats.prototype.isSymbolicLink = function () {
+    }
+    isSymbolicLink() {
         return this._checkModeProperty(S_IFLNK);
-    };
-    Stats.prototype.isFIFO = function () {
+    }
+    isFIFO() {
         return this._checkModeProperty(S_IFIFO);
-    };
-    Stats.prototype.isSocket = function () {
+    }
+    isSocket() {
         return this._checkModeProperty(S_IFSOCK);
-    };
-    return Stats;
-}());
+    }
+}
 exports.Stats = Stats;
 exports.default = Stats;

package/lib/encoding.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.strToEncoding = exports.assertEncoding = exports.ENCODING_UTF8 = void 0;
-var buffer_1 = require("./internal/buffer");
-var errors = require("./internal/errors");
+const buffer_1 = require("./internal/buffer");
+const errors = require("./internal/errors");
 exports.ENCODING_UTF8 = 'utf8';
 function assertEncoding(encoding) {
     if (encoding && !buffer_1.Buffer.isEncoding(encoding))

package/lib/index.d.ts

@@ -1,8 +1,8 @@
 import Stats from './Stats';
 import Dirent from './Dirent';
 import { Volume as _Volume, StatWatcher, FSWatcher, IReadStream, IWriteStream, DirectoryJSON } from './volume';
-import { IPromisesAPI } from './promises';
 import { constants } from './constants';
+import type { FsPromisesApi } from './node/types';
 export { DirectoryJSON };
 export declare const Volume: typeof _Volume;
 export declare const vol: _Volume;
@@ -14,8 +14,22 @@ export interface IFs extends _Volume {
     FSWatcher: new () => FSWatcher;
     ReadStream: new (...args: any[]) => IReadStream;
     WriteStream: new (...args: any[]) => IWriteStream;
-    promises: IPromisesAPI;
+    promises: FsPromisesApi;
     _toUnixTimestamp: any;
 }
 export declare function createFsFromVolume(vol: _Volume): IFs;
 export declare const fs: IFs;
+/**
+ * Creates a new file system instance.
+ *
+ * @param json File system structure expressed as a JSON object.
+ *        Use `null` for empty directories and empty string for empty files.
+ * @param cwd Current working directory. The JSON structure will be created
+ *        relative to this path.
+ * @returns A `memfs` file system instance, which is a drop-in replacement for
+ *          the `fs` module.
+ */
+export declare const memfs: (json?: DirectoryJSON, cwd?: string) => IFs;
+export type IFsWithVolume = IFs & {
+    __vol: _Volume;
+};

package/lib/index.js

@@ -1,48 +1,50 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fs = exports.createFsFromVolume = exports.vol = exports.Volume = void 0;
-var Stats_1 = require("./Stats");
-var Dirent_1 = require("./Dirent");
-var volume_1 = require("./volume");
-var _a = require('fs-monkey/lib/util/lists'), fsSyncMethods = _a.fsSyncMethods, fsAsyncMethods = _a.fsAsyncMethods;
-var constants_1 = require("./constants");
-var F_OK = constants_1.constants.F_OK, R_OK = constants_1.constants.R_OK, W_OK = constants_1.constants.W_OK, X_OK = constants_1.constants.X_OK;
+exports.memfs = exports.fs = exports.createFsFromVolume = exports.vol = exports.Volume = void 0;
+const Stats_1 = require("./Stats");
+const Dirent_1 = require("./Dirent");
+const volume_1 = require("./volume");
+const { fsSyncMethods, fsAsyncMethods } = require('fs-monkey/lib/util/lists');
+const constants_1 = require("./constants");
+const { F_OK, R_OK, W_OK, X_OK } = constants_1.constants;
 exports.Volume = volume_1.Volume;
 // Default volume.
 exports.vol = new volume_1.Volume();
 function createFsFromVolume(vol) {
-    var fs = { F_OK: F_OK, R_OK: R_OK, W_OK: W_OK, X_OK: X_OK, constants: constants_1.constants, Stats: Stats_1.default, Dirent: Dirent_1.default };
+    const fs = { F_OK, R_OK, W_OK, X_OK, constants: constants_1.constants, Stats: Stats_1.default, Dirent: Dirent_1.default };
     // Bind FS methods.
-    for (var _i = 0, fsSyncMethods_1 = fsSyncMethods; _i < fsSyncMethods_1.length; _i++) {
-        var method = fsSyncMethods_1[_i];
+    for (const method of fsSyncMethods)
         if (typeof vol[method] === 'function')
             fs[method] = vol[method].bind(vol);
-    }
-    for (var _a = 0, fsAsyncMethods_1 = fsAsyncMethods; _a < fsAsyncMethods_1.length; _a++) {
-        var method = fsAsyncMethods_1[_a];
+    for (const method of fsAsyncMethods)
         if (typeof vol[method] === 'function')
             fs[method] = vol[method].bind(vol);
-    }
     fs.StatWatcher = vol.StatWatcher;
     fs.FSWatcher = vol.FSWatcher;
     fs.WriteStream = vol.WriteStream;
     fs.ReadStream = vol.ReadStream;
     fs.promises = vol.promises;
     fs._toUnixTimestamp = volume_1.toUnixTimestamp;
+    fs.__vol = vol;
     return fs;
 }
 exports.createFsFromVolume = createFsFromVolume;
 exports.fs = createFsFromVolume(exports.vol);
-module.exports = __assign(__assign({}, module.exports), exports.fs);
+/**
+ * Creates a new file system instance.
+ *
+ * @param json File system structure expressed as a JSON object.
+ *        Use `null` for empty directories and empty string for empty files.
+ * @param cwd Current working directory. The JSON structure will be created
+ *        relative to this path.
+ * @returns A `memfs` file system instance, which is a drop-in replacement for
+ *          the `fs` module.
+ */
+const memfs = (json = {}, cwd = '/') => {
+    const volume = exports.Volume.fromJSON(json, cwd);
+    const fs = createFsFromVolume(volume);
+    return fs;
+};
+exports.memfs = memfs;
+module.exports = Object.assign(Object.assign({}, module.exports), exports.fs);
 module.exports.semantic = true;

package/lib/internal/buffer.js

@@ -1,25 +1,12 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bufferFrom = exports.bufferAllocUnsafe = exports.Buffer = void 0;
-var buffer_1 = require("buffer");
+const buffer_1 = require("buffer");
 Object.defineProperty(exports, "Buffer", { enumerable: true, get: function () { return buffer_1.Buffer; } });
-function bufferV0P12Ponyfill(arg0) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    return new (buffer_1.Buffer.bind.apply(buffer_1.Buffer, __spreadArray([void 0, arg0], args, false)))();
+function bufferV0P12Ponyfill(arg0, ...args) {
+    return new buffer_1.Buffer(arg0, ...args);
 }
-var bufferAllocUnsafe = buffer_1.Buffer.allocUnsafe || bufferV0P12Ponyfill;
+const bufferAllocUnsafe = buffer_1.Buffer.allocUnsafe || bufferV0P12Ponyfill;
 exports.bufferAllocUnsafe = bufferAllocUnsafe;
-var bufferFrom = buffer_1.Buffer.from || bufferV0P12Ponyfill;
+const bufferFrom = buffer_1.Buffer.from || bufferV0P12Ponyfill;
 exports.bufferFrom = bufferFrom;

package/lib/internal/errors.js

@@ -4,77 +4,51 @@
 // change. The NodeError classes here all expose a `code` property whose
 // value statically and permanently identifies the error. While the error
 // message may change, the code should not.
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.E = exports.AssertionError = exports.message = exports.RangeError = exports.TypeError = exports.Error = void 0;
-var assert = require("assert");
-var util = require("util");
-var kCode = typeof Symbol === 'undefined' ? '_kCode' : Symbol('code');
-var messages = {}; // new Map();
+const assert = require("assert");
+const util = require("util");
+const kCode = typeof Symbol === 'undefined' ? '_kCode' : Symbol('code');
+const messages = {}; // new Map();
 function makeNodeError(Base) {
-    return /** @class */ (function (_super) {
-        __extends(NodeError, _super);
-        function NodeError(key) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            var _this = _super.call(this, message(key, args)) || this;
-            _this.code = key;
-            _this[kCode] = key;
-            _this.name = "".concat(_super.prototype.name, " [").concat(_this[kCode], "]");
-            return _this;
+    return class NodeError extends Base {
+        constructor(key, ...args) {
+            super(message(key, args));
+            this.code = key;
+            this[kCode] = key;
+            this.name = `${super.name} [${this[kCode]}]`;
         }
-        return NodeError;
-    }(Base));
+    };
 }
-var g = typeof globalThis !== 'undefined' ? globalThis : global;
-var AssertionError = /** @class */ (function (_super) {
-    __extends(AssertionError, _super);
-    function AssertionError(options) {
-        var _this = this;
+const g = typeof globalThis !== 'undefined' ? globalThis : global;
+class AssertionError extends g.Error {
+    constructor(options) {
         if (typeof options !== 'object' || options === null) {
             throw new exports.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'object');
         }
         if (options.message) {
-            _this = _super.call(this, options.message) || this;
+            super(options.message);
         }
         else {
-            _this = _super.call(this, "".concat(util.inspect(options.actual).slice(0, 128), " ") +
-                "".concat(options.operator, " ").concat(util.inspect(options.expected).slice(0, 128))) || this;
+            super(`${util.inspect(options.actual).slice(0, 128)} ` +
+                `${options.operator} ${util.inspect(options.expected).slice(0, 128)}`);
         }
-        _this.generatedMessage = !options.message;
-        _this.name = 'AssertionError [ERR_ASSERTION]';
-        _this.code = 'ERR_ASSERTION';
-        _this.actual = options.actual;
-        _this.expected = options.expected;
-        _this.operator = options.operator;
-        exports.Error.captureStackTrace(_this, options.stackStartFunction);
-        return _this;
+        this.generatedMessage = !options.message;
+        this.name = 'AssertionError [ERR_ASSERTION]';
+        this.code = 'ERR_ASSERTION';
+        this.actual = options.actual;
+        this.expected = options.expected;
+        this.operator = options.operator;
+        exports.Error.captureStackTrace(this, options.stackStartFunction);
     }
-    return AssertionError;
-}(g.Error));
+}
 exports.AssertionError = AssertionError;
 function message(key, args) {
     assert.strictEqual(typeof key, 'string');
     // const msg = messages.get(key);
-    var msg = messages[key];
-    assert(msg, "An invalid error message key was used: ".concat(key, "."));
-    var fmt;
+    const msg = messages[key];
+    assert(msg, `An invalid error message key was used: ${key}.`);
+    let fmt;
     if (typeof msg === 'function') {
         fmt = msg;
     }
@@ -115,18 +89,18 @@ E('ERR_BUFFER_OUT_OF_BOUNDS', bufferOutOfBounds);
 E('ERR_CHILD_CLOSED_BEFORE_REPLY', 'Child closed before reply received');
 E('ERR_CONSOLE_WRITABLE_STREAM', 'Console expects a writable stream instance for %s');
 E('ERR_CPU_USAGE', 'Unable to obtain cpu usage %s');
-E('ERR_DNS_SET_SERVERS_FAILED', function (err, servers) { return "c-ares failed to set servers: \"".concat(err, "\" [").concat(servers, "]"); });
+E('ERR_DNS_SET_SERVERS_FAILED', (err, servers) => `c-ares failed to set servers: "${err}" [${servers}]`);
 E('ERR_FALSY_VALUE_REJECTION', 'Promise was rejected with falsy value');
-E('ERR_ENCODING_NOT_SUPPORTED', function (enc) { return "The \"".concat(enc, "\" encoding is not supported"); });
-E('ERR_ENCODING_INVALID_ENCODED_DATA', function (enc) { return "The encoded data was not valid for encoding ".concat(enc); });
+E('ERR_ENCODING_NOT_SUPPORTED', enc => `The "${enc}" encoding is not supported`);
+E('ERR_ENCODING_INVALID_ENCODED_DATA', enc => `The encoded data was not valid for encoding ${enc}`);
 E('ERR_HTTP_HEADERS_SENT', 'Cannot render headers after they are sent to the client');
 E('ERR_HTTP_INVALID_STATUS_CODE', 'Invalid status code: %s');
 E('ERR_HTTP_TRAILER_INVALID', 'Trailers are invalid with this transfer encoding');
 E('ERR_INDEX_OUT_OF_RANGE', 'Index out of range');
 E('ERR_INVALID_ARG_TYPE', invalidArgType);
-E('ERR_INVALID_ARRAY_LENGTH', function (name, len, actual) {
+E('ERR_INVALID_ARRAY_LENGTH', (name, len, actual) => {
     assert.strictEqual(typeof actual, 'number');
-    return "The array \"".concat(name, "\" (length ").concat(actual, ") must be of length ").concat(len, ".");
+    return `The array "${name}" (length ${actual}) must be of length ${len}.`;
 });
 E('ERR_INVALID_BUFFER_SIZE', 'Buffer size must be a multiple of %s');
 E('ERR_INVALID_CALLBACK', 'Callback must be a function');
@@ -137,16 +111,16 @@ E('ERR_INVALID_FILE_URL_HOST', 'File URL host must be "localhost" or empty on %s
 E('ERR_INVALID_FILE_URL_PATH', 'File URL path %s');
 E('ERR_INVALID_HANDLE_TYPE', 'This handle type cannot be sent');
 E('ERR_INVALID_IP_ADDRESS', 'Invalid IP address: %s');
-E('ERR_INVALID_OPT_VALUE', function (name, value) {
-    return "The value \"".concat(String(value), "\" is invalid for option \"").concat(name, "\"");
+E('ERR_INVALID_OPT_VALUE', (name, value) => {
+    return `The value "${String(value)}" is invalid for option "${name}"`;
 });
-E('ERR_INVALID_OPT_VALUE_ENCODING', function (value) { return "The value \"".concat(String(value), "\" is invalid for option \"encoding\""); });
+E('ERR_INVALID_OPT_VALUE_ENCODING', value => `The value "${String(value)}" is invalid for option "encoding"`);
 E('ERR_INVALID_REPL_EVAL_CONFIG', 'Cannot specify both "breakEvalOnSigint" and "eval" for REPL');
 E('ERR_INVALID_SYNC_FORK_INPUT', 'Asynchronous forks do not support Buffer, Uint8Array or string input: %s');
 E('ERR_INVALID_THIS', 'Value of "this" must be of type %s');
 E('ERR_INVALID_TUPLE', '%s must be an iterable %s tuple');
 E('ERR_INVALID_URL', 'Invalid URL: %s');
-E('ERR_INVALID_URL_SCHEME', function (expected) { return "The URL must be ".concat(oneOf(expected, 'scheme')); });
+E('ERR_INVALID_URL_SCHEME', expected => `The URL must be ${oneOf(expected, 'scheme')}`);
 E('ERR_IPC_CHANNEL_CLOSED', 'Channel closed');
 E('ERR_IPC_DISCONNECTED', 'IPC channel is already disconnected');
 E('ERR_IPC_ONE_PIPE', 'Child process can have only one IPC pipe');
@@ -168,7 +142,7 @@ E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed');
 E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed');
 E('ERR_STREAM_WRAP', 'Stream has StringDecoder set or is in objectMode');
 E('ERR_TLS_CERT_ALTNAME_INVALID', "Hostname/IP does not match certificate's altnames: %s");
-E('ERR_TLS_DH_PARAM_SIZE', function (size) { return "DH parameter size ".concat(size, " is less than 2048"); });
+E('ERR_TLS_DH_PARAM_SIZE', size => `DH parameter size ${size} is less than 2048`);
 E('ERR_TLS_HANDSHAKE_TIMEOUT', 'TLS handshake timeout');
 E('ERR_TLS_RENEGOTIATION_FAILED', 'Failed to renegotiate');
 E('ERR_TLS_REQUIRED_SERVER_NAME', '"servername" is required parameter for Server.addContext');
@@ -183,7 +157,7 @@ E('ERR_V8BREAKITERATOR', 'Full ICU data not installed. ' + 'See https://github.c
 function invalidArgType(name, expected, actual) {
     assert(name, 'name is required');
     // determiner: 'must be' or 'must not be'
-    var determiner;
+    let determiner;
     if (expected.includes('not ')) {
         determiner = 'must not be';
         expected = expected.split('not ')[1];
@@ -191,68 +165,64 @@ function invalidArgType(name, expected, actual) {
     else {
         determiner = 'must be';
     }
-    var msg;
+    let msg;
     if (Array.isArray(name)) {
-        var names = name.map(function (val) { return "\"".concat(val, "\""); }).join(', ');
-        msg = "The ".concat(names, " arguments ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+        const names = name.map(val => `"${val}"`).join(', ');
+        msg = `The ${names} arguments ${determiner} ${oneOf(expected, 'type')}`;
     }
     else if (name.includes(' argument')) {
         // for the case like 'first argument'
-        msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+        msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
     }
     else {
-        var type = name.includes('.') ? 'property' : 'argument';
-        msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+        const type = name.includes('.') ? 'property' : 'argument';
+        msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
     }
     // if actual value received, output it
     if (arguments.length >= 3) {
-        msg += ". Received type ".concat(actual !== null ? typeof actual : 'null');
+        msg += `. Received type ${actual !== null ? typeof actual : 'null'}`;
     }
     return msg;
 }
-function missingArgs() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
+function missingArgs(...args) {
     assert(args.length > 0, 'At least one arg needs to be specified');
-    var msg = 'The ';
-    var len = args.length;
-    args = args.map(function (a) { return "\"".concat(a, "\""); });
+    let msg = 'The ';
+    const len = args.length;
+    args = args.map(a => `"${a}"`);
     switch (len) {
         case 1:
-            msg += "".concat(args[0], " argument");
+            msg += `${args[0]} argument`;
             break;
         case 2:
-            msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+            msg += `${args[0]} and ${args[1]} arguments`;
             break;
         default:
             msg += args.slice(0, len - 1).join(', ');
-            msg += ", and ".concat(args[len - 1], " arguments");
+            msg += `, and ${args[len - 1]} arguments`;
             break;
     }
-    return "".concat(msg, " must be specified");
+    return `${msg} must be specified`;
 }
 function oneOf(expected, thing) {
     assert(expected, 'expected is required');
     assert(typeof thing === 'string', 'thing is required');
     if (Array.isArray(expected)) {
-        var len = expected.length;
+        const len = expected.length;
         assert(len > 0, 'At least one expected value needs to be specified');
         // tslint:disable-next-line
-        expected = expected.map(function (i) { return String(i); });
+        expected = expected.map(i => String(i));
         if (len > 2) {
-            return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
+            return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` + expected[len - 1];
         }
         else if (len === 2) {
-            return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+            return `one of ${thing} ${expected[0]} or ${expected[1]}`;
         }
         else {
-            return "of ".concat(thing, " ").concat(expected[0]);
+            return `of ${thing} ${expected[0]}`;
         }
     }
     else {
-        return "of ".concat(thing, " ").concat(String(expected));
+        return `of ${thing} ${String(expected)}`;
     }
 }
 function bufferOutOfBounds(name, isWriting) {
@@ -260,6 +230,6 @@ function bufferOutOfBounds(name, isWriting) {
         return 'Attempt to write outside buffer bounds';
     }
     else {
-        return "\"".concat(name, "\" is outside of buffer bounds");
+        return `"${name}" is outside of buffer bounds`;
     }
 }

package/lib/node/FileHandle.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import type * as opts from './types/options';
+import type { IFileHandle, IStats, TData, TDataOut, TMode, TTime } from './types/misc';
+import type { FsCallbackApi } from './types';
+export declare class FileHandle implements IFileHandle {
+    private fs;
+    fd: number;
+    constructor(fs: FsCallbackApi, fd: number);
+    appendFile(data: TData, options?: opts.IAppendFileOptions | string): Promise<void>;
+    chmod(mode: TMode): Promise<void>;
+    chown(uid: number, gid: number): Promise<void>;
+    close(): Promise<void>;
+    datasync(): Promise<void>;
+    read(buffer: Buffer | Uint8Array, offset: number, length: number, position: number): Promise<TFileHandleReadResult>;
+    readFile(options?: opts.IReadFileOptions | string): Promise<TDataOut>;
+    stat(options?: opts.IFStatOptions): Promise<IStats>;
+    sync(): Promise<void>;
+    truncate(len?: number): Promise<void>;
+    utimes(atime: TTime, mtime: TTime): Promise<void>;
+    write(buffer: Buffer | Uint8Array, offset?: number, length?: number, position?: number): Promise<TFileHandleWriteResult>;
+    writeFile(data: TData, options?: opts.IWriteFileOptions): Promise<void>;
+}
+export interface TFileHandleReadResult {
+    bytesRead: number;
+    buffer: Buffer | Uint8Array;
+}
+export interface TFileHandleWriteResult {
+    bytesWritten: number;
+    buffer: Buffer | Uint8Array;
+}