memfs 4.1.0-next.2 → 4.1.0-next.4

package/lib/fsa-to-node/__tests__/FsaNodeFs.test.js

@@ -1,28 +1,20 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const __1 = require("../..");
 const node_to_fsa_1 = require("../../node-to-fsa");
 const FsaNodeFs_1 = require("../FsaNodeFs");
 const thingies_1 = require("thingies");
 const util_1 = require("../../__tests__/util");
 const setup = (json = null, mode = 'readwrite') => {
-    const mfs = (0, __1.memfs)({ mountpoint: json });
+    const { fs: mfs, vol } = (0, __1.memfs)({ mountpoint: json });
     const dir = (0, node_to_fsa_1.nodeToFsa)(mfs, '/mountpoint', { mode, syncHandleAllowed: true });
     const fs = new FsaNodeFs_1.FsaNodeFs(dir);
-    return { fs, mfs, dir };
+    return { fs, mfs, vol, dir };
 };
 (0, util_1.onlyOnNode20)('FsaNodeFs', () => {
     describe('.mkdir()', () => {
-        test('can create a sub-folder', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can create a sub-folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup();
             yield new Promise((resolve, reject) => fs.mkdir('/test', err => {
                 if (err)
@@ -31,7 +23,16 @@ const setup = (json = null, mode = 'readwrite') => {
             }));
             expect(mfs.statSync('/mountpoint/test').isDirectory()).toBe(true);
         }));
-        test('throws when creating sub-sub-folder', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can create a sub-folder with trailing slash', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, mfs } = setup();
+            yield new Promise((resolve, reject) => fs.mkdir('/test/', err => {
+                if (err)
+                    return reject(err);
+                return resolve();
+            }));
+            expect(mfs.statSync('/mountpoint/test').isDirectory()).toBe(true);
+        }));
+        test('throws when creating sub-sub-folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup();
             try {
                 yield new Promise((resolve, reject) => fs.mkdir('/test/subtest', err => {
@@ -45,7 +46,7 @@ const setup = (json = null, mode = 'readwrite') => {
                 expect(error.code).toBe('ENOENT');
             }
         }));
-        test('can create sub-sub-folder with "recursive" flag', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can create sub-sub-folder with "recursive" flag', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup();
             yield new Promise((resolve, reject) => fs.mkdir('/test/subtest', { recursive: true }, err => {
                 if (err)
@@ -54,12 +55,12 @@ const setup = (json = null, mode = 'readwrite') => {
             }));
             expect(mfs.statSync('/mountpoint/test/subtest').isDirectory()).toBe(true);
         }));
-        test('can create sub-sub-folder with "recursive" flag with Promises API', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can create sub-sub-folder with "recursive" flag with Promises API', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup();
             yield fs.promises.mkdir('/test/subtest', { recursive: true });
             expect(mfs.statSync('/mountpoint/test/subtest').isDirectory()).toBe(true);
         }));
-        test('cannot create a folder over a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('cannot create a folder over a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ file: 'test' });
             try {
                 yield fs.promises.mkdir('/file/folder', { recursive: true });
@@ -71,7 +72,7 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.mkdtemp()', () => {
-        test('can create a temporary folder', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can create a temporary folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup();
             const dirname = (yield fs.promises.mkdtemp('prefix--'));
             expect(dirname.startsWith('prefix--')).toBe(true);
@@ -79,134 +80,134 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.rmdir()', () => {
-        test('can remove an empty folder', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+        test('can remove an empty folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             yield fs.promises.rmdir('/empty-folder');
-            expect(mfs.__vol.toJSON()).toStrictEqual({ '/mountpoint/folder/file': 'test' });
+            expect(vol.toJSON()).toStrictEqual({ '/mountpoint/folder/file': 'test' });
         }));
-        test('throws when attempts to remove non-empty folder', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+        test('throws when attempts to remove non-empty folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             try {
                 yield fs.promises.rmdir('/folder');
                 throw new Error('Expected error');
             }
             catch (error) {
                 expect(error.code).toBe('ENOTEMPTY');
-                expect(mfs.__vol.toJSON()).toStrictEqual({
+                expect(vol.toJSON()).toStrictEqual({
                     '/mountpoint/folder/file': 'test',
                     '/mountpoint/empty-folder': null,
                 });
             }
         }));
-        test('can remove non-empty directory recursively', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
+        test('can remove non-empty directory recursively', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
             yield fs.promises.rmdir('/folder', { recursive: true });
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/empty-folder': null,
             });
         }));
-        test('can remove starting from root folder', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
+        test('can remove starting from root folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
             yield fs.promises.rmdir('/', { recursive: true });
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint': null,
             });
         }));
     });
     describe('.rm()', () => {
-        test('can remove an empty folder', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+        test('can remove an empty folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             yield fs.promises.rm('/empty-folder');
-            expect(mfs.__vol.toJSON()).toStrictEqual({ '/mountpoint/folder/file': 'test' });
+            expect(vol.toJSON()).toStrictEqual({ '/mountpoint/folder/file': 'test' });
         }));
-        test('throws when attempts to remove non-empty folder', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+        test('throws when attempts to remove non-empty folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             try {
                 yield fs.promises.rm('/folder');
                 throw new Error('Expected error');
             }
             catch (error) {
                 expect(error.code).toBe('ENOTEMPTY');
-                expect(mfs.__vol.toJSON()).toStrictEqual({
+                expect(vol.toJSON()).toStrictEqual({
                     '/mountpoint/folder/file': 'test',
                     '/mountpoint/empty-folder': null,
                 });
             }
         }));
-        test('can remove non-empty directory recursively', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
+        test('can remove non-empty directory recursively', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
             yield fs.promises.rm('/folder', { recursive: true });
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/empty-folder': null,
             });
         }));
-        test('throws if path does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
+        test('throws if path does not exist', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
             try {
                 yield fs.promises.rm('/lala/lulu', { recursive: true });
                 throw new Error('Expected error');
             }
             catch (error) {
                 expect(error.code).toBe('ENOENT');
-                expect(mfs.__vol.toJSON()).toStrictEqual({
+                expect(vol.toJSON()).toStrictEqual({
                     '/mountpoint/folder/subfolder/file': 'test',
                     '/mountpoint/empty-folder': null,
                 });
             }
         }));
-        test('does not throw, if path does not exist, but "force" flag set', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
+        test('does not throw, if path does not exist, but "force" flag set', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
             yield fs.promises.rm('/lala/lulu', { recursive: true, force: true });
         }));
-        test('can remove a file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
+        test('can remove a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
             yield fs.promises.rm('/folder/subfolder/file');
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/subfolder': null,
                 '/mountpoint/empty-folder': null,
             });
         }));
-        test('can remove starting from root folder', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
+        test('can remove starting from root folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { subfolder: { file: 'test' } }, 'empty-folder': null });
             yield fs.promises.rm('/', { recursive: true });
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint': null,
             });
         }));
     });
     describe('.unlink()', () => {
-        test('can remove a file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+        test('can remove a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             const res = yield fs.promises.unlink('/folder/file');
             expect(res).toBe(undefined);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder': null,
                 '/mountpoint/empty-folder': null,
             });
         }));
-        test('cannot delete a folder', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+        test('cannot delete a folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             try {
                 yield fs.promises.unlink('/folder');
                 throw new Error('Expected error');
             }
             catch (error) {
                 expect(error.code).toBe('EISDIR');
-                expect(mfs.__vol.toJSON()).toStrictEqual({
+                expect(vol.toJSON()).toStrictEqual({
                     '/mountpoint/folder/file': 'test',
                     '/mountpoint/empty-folder': null,
                 });
             }
         }));
-        test('throws when deleting non-existing file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+        test('throws when deleting non-existing file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             try {
                 yield fs.promises.unlink('/folder/not-a-file');
                 throw new Error('Expected error');
             }
             catch (error) {
                 expect(error.code).toBe('ENOENT');
-                expect(mfs.__vol.toJSON()).toStrictEqual({
+                expect(vol.toJSON()).toStrictEqual({
                     '/mountpoint/folder/file': 'test',
                     '/mountpoint/empty-folder': null,
                 });
@@ -214,19 +215,19 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.readFile()', () => {
-        test('can read file contents', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can read file contents', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             const data = yield fs.promises.readFile('/folder/file');
             expect(data.toString()).toBe('test');
         }));
-        test('can read file by file handle', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can read file by file handle', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             const handle = yield fs.promises.open('/folder/file');
             expect(typeof handle).toBe('object');
             const data = yield fs.promises.readFile(handle);
             expect(data.toString()).toBe('test');
         }));
-        test('can read file by file descriptor', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can read file by file descriptor', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             const fd = yield new Promise(resolve => {
                 fs.open('/folder/file', 'r', (err, fd) => resolve(fd));
@@ -237,7 +238,7 @@ const setup = (json = null, mode = 'readwrite') => {
             });
             expect(data).toBe('test');
         }));
-        test('cannot read from closed file descriptor', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('cannot read from closed file descriptor', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             const fd = yield new Promise(resolve => {
                 fs.open('/folder/file', 'r', (err, fd) => resolve(fd));
@@ -259,7 +260,7 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.truncate()', () => {
-        test('can truncate a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can truncate a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             const res = yield new Promise((resolve, reject) => {
                 fs.truncate('/folder/file', 2, (err, res) => (err ? reject(err) : resolve(res)));
@@ -269,7 +270,7 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.ftruncate()', () => {
-        test('can truncate a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can truncate a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
             const handle = yield fs.promises.open('/folder/file');
             const res = yield new Promise((resolve, reject) => {
@@ -280,7 +281,7 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.readdir()', () => {
-        test('can read directory contents as strings', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can read directory contents as strings', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const res = (yield fs.promises.readdir('/'));
             expect(res.length).toBe(3);
@@ -288,7 +289,7 @@ const setup = (json = null, mode = 'readwrite') => {
             expect(res.includes('empty-folder')).toBe(true);
             expect(res.includes('f.html')).toBe(true);
         }));
-        test('can read directory contents with "withFileTypes" flag set', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can read directory contents with "withFileTypes" flag set', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             var _a, _b, _c, _d;
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const list = (yield fs.promises.readdir('/', { withFileTypes: true }));
@@ -302,23 +303,23 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.appendFile()', () => {
-        test('can create a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can create a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({});
             yield fs.promises.appendFile('/test.txt', 'a');
             expect(mfs.readFileSync('/mountpoint/test.txt', 'utf8')).toBe('a');
         }));
-        test('can append to a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can append to a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({});
             yield fs.promises.appendFile('/test.txt', 'a');
             yield fs.promises.appendFile('/test.txt', 'b');
             expect(mfs.readFileSync('/mountpoint/test.txt', 'utf8')).toBe('ab');
         }));
-        test('can append to a file - 2', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can append to a file - 2', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ file: '123' });
             yield fs.promises.appendFile('file', 'x');
             expect(mfs.readFileSync('/mountpoint/file', 'utf8')).toBe('123x');
         }));
-        test('can append to a file - 2', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can append to a file - 2', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ file: '123' });
             yield fs.promises.writeFile('cool.txt', 'worlds');
             yield fs.promises.appendFile('cool.txt', '!');
@@ -326,7 +327,7 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.write()', () => {
-        test('can write to a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can write to a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({});
             const fd = yield new Promise((resolve, reject) => fs.open('/test.txt', 'w', (err, fd) => {
                 if (err)
@@ -346,7 +347,7 @@ const setup = (json = null, mode = 'readwrite') => {
             expect(data).toBe('a');
             expect(mfs.readFileSync('/mountpoint/test.txt', 'utf8')).toBe('a');
         }));
-        test('can write to a file twice sequentially', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can write to a file twice sequentially', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({});
             const fd = yield new Promise((resolve, reject) => fs.open('/test.txt', 'w', (err, fd) => {
                 if (err)
@@ -378,7 +379,7 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.writev()', () => {
-        test('can write to a file two buffers', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can write to a file two buffers', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({});
             const fd = yield new Promise((resolve, reject) => fs.open('/test.txt', 'w', (err, fd) => {
                 if (err)
@@ -400,9 +401,9 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.exists()', () => {
-        test('can works for folders and files', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can works for folders and files', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
-            const exists = (path) => __awaiter(void 0, void 0, void 0, function* () {
+            const exists = (path) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 return new Promise(resolve => {
                     fs.exists(path, exists => resolve(exists));
                 });
@@ -419,19 +420,19 @@ const setup = (json = null, mode = 'readwrite') => {
     });
     describe('.access()', () => {
         describe('files', () => {
-            test('succeeds on file existence check', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('succeeds on file existence check', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 yield fs.promises.access('/folder/file', 0 /* AMODE.F_OK */);
             }));
-            test('succeeds on file "read" check', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('succeeds on file "read" check', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 yield fs.promises.access('/folder/file', 4 /* AMODE.R_OK */);
             }));
-            test('succeeds on file "write" check, on writable file system', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('succeeds on file "write" check, on writable file system', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 yield fs.promises.access('/folder/file', 2 /* AMODE.W_OK */);
             }));
-            test('fails on file "write" check, on read-only file system', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('fails on file "write" check, on read-only file system', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' }, 'read');
                 try {
                     yield fs.promises.access('/folder/file', 2 /* AMODE.W_OK */);
@@ -441,7 +442,7 @@ const setup = (json = null, mode = 'readwrite') => {
                     expect(error.code).toBe('EACCESS');
                 }
             }));
-            test('fails on file "execute" check', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('fails on file "execute" check', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 try {
                     yield fs.promises.access('/folder/file', 1 /* AMODE.X_OK */);
@@ -453,19 +454,19 @@ const setup = (json = null, mode = 'readwrite') => {
             }));
         });
         describe('directories', () => {
-            test('succeeds on folder existence check', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('succeeds on folder existence check', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 yield fs.promises.access('/folder', 0 /* AMODE.F_OK */);
             }));
-            test('succeeds on folder "read" check', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('succeeds on folder "read" check', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 yield fs.promises.access('/folder', 4 /* AMODE.R_OK */);
             }));
-            test('succeeds on folder "write" check, on writable file system', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('succeeds on folder "write" check, on writable file system', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 yield fs.promises.access('/folder', 2 /* AMODE.W_OK */);
             }));
-            test('fails on folder "write" check, on read-only file system', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('fails on folder "write" check, on read-only file system', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' }, 'read');
                 try {
                     yield fs.promises.access('/folder', 2 /* AMODE.W_OK */);
@@ -475,7 +476,7 @@ const setup = (json = null, mode = 'readwrite') => {
                     expect(error.code).toBe('EACCESS');
                 }
             }));
-            test('fails on folder "execute" check', () => __awaiter(void 0, void 0, void 0, function* () {
+            test('fails on folder "execute" check', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
                 try {
                     yield fs.promises.access('/folder', 1 /* AMODE.X_OK */);
@@ -488,10 +489,10 @@ const setup = (json = null, mode = 'readwrite') => {
         });
     });
     describe('.rename()', () => {
-        test('can rename a file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can rename a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, mfs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             yield fs.promises.rename('/folder/file', '/folder/file2');
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file2': 'test',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
@@ -499,33 +500,33 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.stat()', () => {
-        test('can stat a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can stat a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stats = yield fs.promises.stat('/folder/file');
             expect(stats.isFile()).toBe(true);
         }));
-        test('throws "ENOENT" when path is not found', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('throws "ENOENT" when path is not found', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const [, error] = yield (0, thingies_1.of)(fs.promises.stat('/folder/repo/.git'));
             expect(error.code).toBe('ENOENT');
         }));
-        test('throws "ENOTDIR" when sub-folder is a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('throws "ENOTDIR" when sub-folder is a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const [, error] = yield (0, thingies_1.of)(fs.promises.stat('/folder/file/repo/.git'));
             expect(error.code).toBe('ENOTDIR');
         }));
-        test('can retrieve file size', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can retrieve file size', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stats = yield fs.promises.stat('/folder/file');
             expect(stats.size).toBe(4);
         }));
-        test('can stat a folder', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can stat a folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stats = yield fs.promises.stat('/folder');
             expect(stats.isFile()).toBe(false);
             expect(stats.isDirectory()).toBe(true);
         }));
-        test('throws on non-existing path', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('throws on non-existing path', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             try {
                 const stats = yield fs.promises.stat('/folder/abc');
@@ -537,23 +538,23 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.lstat()', () => {
-        test('can stat a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can stat a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stats = yield fs.promises.lstat('/folder/file');
             expect(stats.isFile()).toBe(true);
         }));
-        test('can retrieve file size', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can retrieve file size', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stats = yield fs.promises.lstat('/folder/file');
             expect(stats.size).toBe(4);
         }));
-        test('can stat a folder', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can stat a folder', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stats = yield fs.promises.lstat('/folder');
             expect(stats.isFile()).toBe(false);
             expect(stats.isDirectory()).toBe(true);
         }));
-        test('throws on non-existing path', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('throws on non-existing path', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             try {
                 yield fs.promises.lstat('/folder/abc');
@@ -565,7 +566,7 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.fstat()', () => {
-        test('can stat a file', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can stat a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const handle = yield fs.promises.open('/folder/file', 'r');
             const stats = yield new Promise((resolve, reject) => {
@@ -580,24 +581,24 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.realpath()', () => {
-        test('returns file path', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('returns file path', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const path = yield fs.promises.realpath('folder/file');
             expect(path).toBe('/folder/file');
         }));
     });
     describe('.realpathSync()', () => {
-        test('returns file path', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('returns file path', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const path = fs.realpathSync('folder/file');
             expect(path).toBe('/folder/file');
         }));
     });
     describe('.copyFile()', () => {
-        test('can copy a file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can copy a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             yield fs.promises.copyFile('/folder/file', '/folder/file2');
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'test',
                 '/mountpoint/folder/file2': 'test',
                 '/mountpoint/empty-folder': null,
@@ -606,8 +607,8 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.writeFile()', () => {
-        test('can create a new file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can create a new file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const res = yield new Promise((resolve, reject) => {
                 fs.writeFile('/folder/foo', 'bar', error => {
                     if (error)
@@ -617,16 +618,28 @@ const setup = (json = null, mode = 'readwrite') => {
                 });
             });
             expect(res).toBe(undefined);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'test',
                 '/mountpoint/folder/foo': 'bar',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
+        test('throws "EEXIST", if file already exists and O_EXCL flag set', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+            const [, err] = yield (0, thingies_1.of)(fs.promises.writeFile('/folder/file', 'bar', { flag: 'wx' }));
+            expect(err).toBeInstanceOf(Error);
+            expect(err.code).toBe('EEXIST');
+        }));
+        test('throws "ENOENT", if file does not exist and O_CREAT flag not set', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+            const [, err] = yield (0, thingies_1.of)(fs.promises.writeFile('/folder/file2', 'bar', { flag: 2 /* FLAG.O_RDWR */ }));
+            expect(err).toBeInstanceOf(Error);
+            expect(err.code).toBe('ENOENT');
+        }));
     });
     describe('.read()', () => {
-        test('can read from a file at offset into Buffer', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can read from a file at offset into Buffer', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const handle = yield fs.promises.open('/folder/file', 'r');
             const [buffer, length] = yield new Promise((resolve, reject) => {
@@ -641,7 +654,7 @@ const setup = (json = null, mode = 'readwrite') => {
             expect(length).toBe(2);
             expect(buffer.slice(0, 2).toString()).toBe('es');
         }));
-        test('can read from a file at offset into Uint8Array', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('can read from a file at offset into Uint8Array', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const handle = yield fs.promises.open('/folder/file', 'r');
             const [buffer, length] = yield new Promise((resolve, reject) => {
@@ -659,8 +672,8 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.createWriteStream()', () => {
-        test('can use stream to write to a new file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can use stream to write to a new file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stream = fs.createWriteStream('/folder/file2');
             stream.write(Buffer.from('A'));
             stream.write(Buffer.from('BC'));
@@ -668,15 +681,15 @@ const setup = (json = null, mode = 'readwrite') => {
             stream.end();
             yield new Promise(resolve => stream.once('close', resolve));
             expect(stream.bytesWritten).toBe(6);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'test',
                 '/mountpoint/folder/file2': 'ABCDEF',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('can use stream to write to a new file using strings', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can use stream to write to a new file using strings', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stream = fs.createWriteStream('/folder/file2');
             stream.write('A');
             stream.write('BC');
@@ -684,47 +697,47 @@ const setup = (json = null, mode = 'readwrite') => {
             stream.end();
             yield new Promise(resolve => stream.once('close', resolve));
             expect(stream.bytesWritten).toBe(6);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'test',
                 '/mountpoint/folder/file2': 'ABCDEF',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('can use stream to overwrite existing file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can use stream to overwrite existing file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stream = fs.createWriteStream('/folder/file');
             stream.write(Buffer.from('A'));
             stream.write(Buffer.from('BC'));
             stream.end();
             yield new Promise(resolve => stream.once('close', resolve));
             expect(stream.bytesWritten).toBe(3);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'ABC',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('can write by file descriptor', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can write by file descriptor', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, mfs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const handle = yield fs.promises.open('/folder/file', 'a');
             const stream = fs.createWriteStream('', { fd: handle.fd, start: 1, flags: 'a' });
             stream.write(Buffer.from('BC'));
             stream.end();
             yield new Promise(resolve => stream.once('close', resolve));
             expect(stream.bytesWritten).toBe(2);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'tBCt',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('closes file once stream ends', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('closes file once stream ends', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const handle = yield fs.promises.open('/folder/file', 'a');
             const stream = fs.createWriteStream('', { fd: handle.fd, start: 1, flags: 'a' });
             stream.write(Buffer.from('BC'));
-            const stat = () => __awaiter(void 0, void 0, void 0, function* () {
+            const stat = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 return yield new Promise((resolve, reject) => fs.fstat(handle.fd, (err, stats) => {
                     if (err)
                         reject(err);
@@ -734,19 +747,19 @@ const setup = (json = null, mode = 'readwrite') => {
             });
             yield stat();
             stream.end();
-            yield (0, thingies_1.until)(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, thingies_1.until)(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 const [, error] = yield (0, thingies_1.of)(stat());
                 return !!error;
             }));
             const [, error] = yield (0, thingies_1.of)(stat());
             expect(error.code).toBe('EBADF');
         }));
-        test('does not close file if "autoClose" is false', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('does not close file if "autoClose" is false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const handle = yield fs.promises.open('/folder/file', 'a');
             const stream = fs.createWriteStream('', { fd: handle.fd, start: 1, flags: 'a', autoClose: false });
             stream.write(Buffer.from('BC'));
-            const stat = () => __awaiter(void 0, void 0, void 0, function* () {
+            const stat = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 return yield new Promise((resolve, reject) => fs.fstat(handle.fd, (err, stats) => {
                     if (err)
                         reject(err);
@@ -759,35 +772,35 @@ const setup = (json = null, mode = 'readwrite') => {
             yield (0, thingies_1.tick)(200);
             yield stat();
         }));
-        test('can use stream to add to existing file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can use stream to add to existing file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stream = fs.createWriteStream('/folder/file', { flags: 'a' });
             stream.write(Buffer.from('A'));
             stream.write(Buffer.from('BC'));
             stream.end();
             yield new Promise(resolve => stream.once('close', resolve));
             expect(stream.bytesWritten).toBe(3);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'ABCt',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('can use stream to add to existing file at specified offset', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can use stream to add to existing file at specified offset', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const stream = fs.createWriteStream('/folder/file', { flags: 'a', start: 1 });
             stream.write(Buffer.from('A'));
             stream.write(Buffer.from('B'));
             stream.end();
             yield new Promise(resolve => stream.once('close', resolve));
             expect(stream.bytesWritten).toBe(2);
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'tABt',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('throws if "start" option is not a number', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('throws if "start" option is not a number', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             try {
                 fs.createWriteStream('/folder/file', { flags: 'a', start: '1' });
@@ -798,7 +811,7 @@ const setup = (json = null, mode = 'readwrite') => {
                 expect(error.message).toBe('"start" option must be a Number');
             }
         }));
-        test('throws if "start" option is negative', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('throws if "start" option is negative', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             try {
                 fs.createWriteStream('/folder/file', { flags: 'a', start: -1 });
@@ -811,58 +824,58 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
     describe('.createReadStream()', () => {
-        test('can pipe fs.ReadStream to fs.WriteStream', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can pipe fs.ReadStream to fs.WriteStream', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const readStream = fs.createReadStream('/folder/file');
             const writeStream = fs.createWriteStream('/folder/file2');
             readStream.pipe(writeStream);
             yield new Promise(resolve => writeStream.once('close', resolve));
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'test',
                 '/mountpoint/folder/file2': 'test',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('emits "open" event', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('emits "open" event', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const readStream = fs.createReadStream('/folder/file');
             const fd = yield new Promise(resolve => readStream.once('open', resolve));
             expect(typeof fd).toBe('number');
         }));
-        test('emits "ready" event', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('emits "ready" event', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const readStream = fs.createReadStream('/folder/file');
             yield new Promise(resolve => readStream.once('ready', resolve));
         }));
-        test('emits "close" event', () => __awaiter(void 0, void 0, void 0, function* () {
+        test('emits "close" event', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const readStream = fs.createReadStream('/folder/file', { emitClose: true });
             const writeStream = fs.createWriteStream('/folder/file2');
             readStream.pipe(writeStream);
             yield new Promise(resolve => readStream.once('close', resolve));
         }));
-        test('can write to already open file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can write to already open file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const handle = yield fs.promises.open('/folder/file');
             const readStream = fs.createReadStream('xyz', { fd: handle.fd });
             const writeStream = fs.createWriteStream('/folder/file2');
             readStream.pipe(writeStream);
             yield new Promise(resolve => writeStream.once('close', resolve));
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'test',
                 '/mountpoint/folder/file2': 'test',
                 '/mountpoint/empty-folder': null,
                 '/mountpoint/f.html': 'test',
             });
         }));
-        test('can read a specified slice of a file', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { fs, mfs } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
+        test('can read a specified slice of a file', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const { fs, vol } = setup({ folder: { file: 'test' }, 'empty-folder': null, 'f.html': 'test' });
             const readStream = fs.createReadStream('/folder/file', { start: 1, end: 2 });
             const writeStream = fs.createWriteStream('/folder/file2');
             readStream.pipe(writeStream);
             yield new Promise(resolve => writeStream.once('close', resolve));
-            expect(mfs.__vol.toJSON()).toStrictEqual({
+            expect(vol.toJSON()).toStrictEqual({
                 '/mountpoint/folder/file': 'test',
                 '/mountpoint/folder/file2': 'es',
                 '/mountpoint/empty-folder': null,
@@ -871,3 +884,4 @@ const setup = (json = null, mode = 'readwrite') => {
         }));
     });
 });
+//# sourceMappingURL=FsaNodeFs.test.js.map