diff --git a/src/fsa-to-node/FsaNodeFs.ts b/src/fsa-to-node/FsaNodeFs.ts
index 67ab938a6..4835d7eb0 100644
--- a/src/fsa-to-node/FsaNodeFs.ts
+++ b/src/fsa-to-node/FsaNodeFs.ts
@@ -1,13 +1,13 @@
 import { createPromisesApi } from '../node/promises';
 import { getMkdirOptions } from '../node/options';
-import {createError, modeToNumber, pathToFilename, validateCallback} from '../node/util';
-import {pathToLocation} from './util';
-import type {FsCallbackApi, FsPromisesApi} from '../node/types';
+import { createError, modeToNumber, pathToFilename, validateCallback } from '../node/util';
+import { pathToLocation } from './util';
+import type { FsCallbackApi, FsPromisesApi } from '../node/types';
 import type * as misc from '../node/types/misc';
 import type * as opts from '../node/types/options';
 import type * as fsa from '../fsa/types';
 
-const notImplemented: ((...args: unknown[]) => unknown) = () => {
+const notImplemented: (...args: unknown[]) => unknown = () => {
   throw new Error('Not implemented');
 };
 
@@ -18,9 +18,14 @@ const notImplemented: ((...args: unknown[]) => unknown) = () => {
 export class FsaNodeFs implements FsCallbackApi {
   public readonly promises: FsPromisesApi = createPromisesApi(this);
 
-  public constructor (protected readonly root: fsa.IFileSystemDirectoryHandle) {}
+  public constructor(protected readonly root: fsa.IFileSystemDirectoryHandle) {}
 
-  public readonly open: FsCallbackApi['open'] = (path: misc.PathLike, flags: misc.TFlags, a?: misc.TMode | misc.TCallback<number>, b?: misc.TCallback<number> | string) => {
+  public readonly open: FsCallbackApi['open'] = (
+    path: misc.PathLike,
+    flags: misc.TFlags,
+    a?: misc.TMode | misc.TCallback<number>,
+    b?: misc.TCallback<number> | string,
+  ) => {
     throw new Error('Not implemented');
   };
 
@@ -39,7 +44,11 @@ export class FsaNodeFs implements FsCallbackApi {
     throw new Error('Not implemented');
   };
 
-  public readonly readFile: FsCallbackApi['readFile'] = (id: misc.TFileId, a?: opts.IReadFileOptions | string | misc.TCallback<misc.TDataOut>, b?: misc.TCallback<misc.TDataOut>) => {
+  public readonly readFile: FsCallbackApi['readFile'] = (
+    id: misc.TFileId,
+    a?: opts.IReadFileOptions | string | misc.TCallback<misc.TDataOut>,
+    b?: misc.TCallback<misc.TDataOut>,
+  ) => {
     throw new Error('Not implemented');
   };
 
@@ -54,7 +63,12 @@ export class FsaNodeFs implements FsCallbackApi {
     options: opts.IWriteFileOptions | string,
     callback: misc.TCallback<void>,
   );
-  writeFile(id: misc.TFileId, data: misc.TData, a: misc.TCallback<void> | opts.IWriteFileOptions | string, b?: misc.TCallback<void>) {
+  writeFile(
+    id: misc.TFileId,
+    data: misc.TData,
+    a: misc.TCallback<void> | opts.IWriteFileOptions | string,
+    b?: misc.TCallback<void>,
+  ) {
     throw new Error('Not implemented');
   }
 
@@ -74,19 +88,32 @@ export class FsaNodeFs implements FsCallbackApi {
 
   symlink(target: misc.PathLike, path: misc.PathLike, callback: misc.TCallback<void>);
   symlink(target: misc.PathLike, path: misc.PathLike, type: misc.symlink.Type, callback: misc.TCallback<void>);
-  symlink(target: misc.PathLike, path: misc.PathLike, a: misc.symlink.Type | misc.TCallback<void>, b?: misc.TCallback<void>) {
+  symlink(
+    target: misc.PathLike,
+    path: misc.PathLike,
+    a: misc.symlink.Type | misc.TCallback<void>,
+    b?: misc.TCallback<void>,
+  ) {
     throw new Error('Not implemented');
   }
 
   realpath(path: misc.PathLike, callback: misc.TCallback<misc.TDataOut>);
   realpath(path: misc.PathLike, options: opts.IRealpathOptions | string, callback: misc.TCallback<misc.TDataOut>);
-  realpath(path: misc.PathLike, a: misc.TCallback<misc.TDataOut> | opts.IRealpathOptions | string, b?: misc.TCallback<misc.TDataOut>) {
+  realpath(
+    path: misc.PathLike,
+    a: misc.TCallback<misc.TDataOut> | opts.IRealpathOptions | string,
+    b?: misc.TCallback<misc.TDataOut>,
+  ) {
     throw new Error('Not implemented');
   }
 
   lstat(path: misc.PathLike, callback: misc.TCallback<misc.IStats>): void;
   lstat(path: misc.PathLike, options: opts.IStatOptions, callback: misc.TCallback<misc.IStats>): void;
-  lstat(path: misc.PathLike, a: misc.TCallback<misc.IStats> | opts.IStatOptions, b?: misc.TCallback<misc.IStats>): void {
+  lstat(
+    path: misc.PathLike,
+    a: misc.TCallback<misc.IStats> | opts.IStatOptions,
+    b?: misc.TCallback<misc.IStats>,
+  ): void {
     throw new Error('Not implemented');
   }
 
@@ -160,7 +187,7 @@ export class FsaNodeFs implements FsCallbackApi {
   ftruncate(fd: number, a: misc.TCallback<void> | number, b?: misc.TCallback<void>) {
     throw new Error('Not implemented');
   }
-  
+
   truncate(id: misc.TFileId, callback: misc.TCallback<void>);
   truncate(id: misc.TFileId, len: number, callback: misc.TCallback<void>);
   truncate(id: misc.TFileId, a: misc.TCallback<void> | number, b?: misc.TCallback<void>) {
@@ -181,13 +208,16 @@ export class FsaNodeFs implements FsCallbackApi {
    */
   private async getDir(path: string[], create: boolean): Promise<fsa.IFileSystemDirectoryHandle> {
     let curr: fsa.IFileSystemDirectoryHandle = this.root;
-    const options: fsa.GetDirectoryHandleOptions = {create};
-    for (const name of path)
-      curr = await curr.getDirectoryHandle(name, options);
+    const options: fsa.GetDirectoryHandleOptions = { create };
+    for (const name of path) curr = await curr.getDirectoryHandle(name, options);
     return curr;
   }
 
-  public readonly mkdir: FsCallbackApi['mkdir'] = (path: misc.PathLike, a: misc.TCallback<void> | misc.TMode | opts.IMkdirOptions, b?: misc.TCallback<string> | misc.TCallback<void>) => {
+  public readonly mkdir: FsCallbackApi['mkdir'] = (
+    path: misc.PathLike,
+    a: misc.TCallback<void> | misc.TMode | opts.IMkdirOptions,
+    b?: misc.TCallback<string> | misc.TCallback<void>,
+  ) => {
     const opts: misc.TMode | opts.IMkdirOptions = getMkdirOptions(a);
     const callback = validateCallback(typeof a === 'function' ? a : b!);
     // const modeNum = modeToNumber(opts.mode, 0o777);
@@ -195,22 +225,25 @@ export class FsaNodeFs implements FsCallbackApi {
     const [folder, name] = pathToLocation(filename);
     // TODO: need to throw if directory already exists
     this.getDir(folder, opts.recursive ?? false)
-      .then(dir => dir.getDirectoryHandle(name, {create: true}))
-      .then(() => callback(null), error => {
-        if (!error || typeof error !== 'object') {
-          callback(createError('', 'mkdir'));
-          return;
-        }
-        switch (error.name) {
-          case 'NotFoundError': {
-            const err = createError('ENOTDIR', 'mkdir', folder.join('/'));
-            callback(err);
-          }
-          default: {
+      .then(dir => dir.getDirectoryHandle(name, { create: true }))
+      .then(
+        () => callback(null),
+        error => {
+          if (!error || typeof error !== 'object') {
             callback(createError('', 'mkdir'));
+            return;
+          }
+          switch (error.name) {
+            case 'NotFoundError': {
+              const err = createError('ENOTDIR', 'mkdir', folder.join('/'));
+              callback(err);
+            }
+            default: {
+              callback(createError('', 'mkdir'));
+            }
           }
-        }
-      });
+        },
+      );
   };
 
   mkdirp(path: misc.PathLike, callback: misc.TCallback<string>);
diff --git a/src/fsa-to-node/__tests__/FsaNodeFs.test.ts b/src/fsa-to-node/__tests__/FsaNodeFs.test.ts
index 115db67f2..ec2152806 100644
--- a/src/fsa-to-node/__tests__/FsaNodeFs.test.ts
+++ b/src/fsa-to-node/__tests__/FsaNodeFs.test.ts
@@ -1,10 +1,10 @@
-import {IFsWithVolume, memfs} from '../..';
-import {nodeToFsa} from '../../node-to-fsa';
-import {FsaNodeFs} from '../FsaNodeFs';
+import { IFsWithVolume, memfs } from '../..';
+import { nodeToFsa } from '../../node-to-fsa';
+import { FsaNodeFs } from '../FsaNodeFs';
 
 const setup = () => {
   const mfs = memfs({ mountpoint: null }) as IFsWithVolume;
-  const dir = nodeToFsa(mfs, '/mountpoint', {mode: 'readwrite'});
+  const dir = nodeToFsa(mfs, '/mountpoint', { mode: 'readwrite' });
   const fs = new FsaNodeFs(dir);
   return { fs, mfs, dir };
 };
@@ -12,20 +12,24 @@ const setup = () => {
 describe('.mkdir()', () => {
   test('can create a sub-folder', async () => {
     const { fs, mfs } = setup();
-    await new Promise<void>((resolve, reject) => fs.mkdir('/test', (err) => {
-      if (err) return reject(err);
-      return resolve();
-    }));
+    await new Promise<void>((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', async () => {
     const { fs } = setup();
     try {
-      await new Promise<void>((resolve, reject) => fs.mkdir('/test/subtest', (err) => {
-        if (err) return reject(err);
-        return resolve();
-      }));
+      await new Promise<void>((resolve, reject) =>
+        fs.mkdir('/test/subtest', err => {
+          if (err) return reject(err);
+          return resolve();
+        }),
+      );
       throw new Error('Expected error');
     } catch (error) {
       expect(error.code).toBe('ENOTDIR');
@@ -34,16 +38,18 @@ describe('.mkdir()', () => {
 
   test('can create sub-sub-folder with "recursive" flag', async () => {
     const { fs, mfs } = setup();
-    await new Promise<void>((resolve, reject) => fs.mkdir('/test/subtest', {recursive: true}, (err) => {
-      if (err) return reject(err);
-      return resolve();
-    }));
+    await new Promise<void>((resolve, reject) =>
+      fs.mkdir('/test/subtest', { recursive: true }, err => {
+        if (err) return reject(err);
+        return resolve();
+      }),
+    );
     expect(mfs.statSync('/mountpoint/test/subtest').isDirectory()).toBe(true);
   });
 
   test('can create sub-sub-folder with "recursive" flag with Promises API', async () => {
     const { fs, mfs } = setup();
-    await fs.promises.mkdir('/test/subtest', {recursive: true});
+    await fs.promises.mkdir('/test/subtest', { recursive: true });
     expect(mfs.statSync('/mountpoint/test/subtest').isDirectory()).toBe(true);
   });
 });
diff --git a/src/fsa-to-node/util.ts b/src/fsa-to-node/util.ts
index 61f4e2d9a..a74794274 100644
--- a/src/fsa-to-node/util.ts
+++ b/src/fsa-to-node/util.ts
@@ -1,5 +1,5 @@
-import {FsaToNodeConstants} from "./constants";;
-import type {FsLocation} from "./types";
+import { FsaToNodeConstants } from './constants';
+import type { FsLocation } from './types';
 
 export const pathToLocation = (path: string): FsLocation => {
   if (path[0] === FsaToNodeConstants.Separator) path = path.slice(1);
diff --git a/src/node/options.ts b/src/node/options.ts
index 34102c496..87d618b54 100644
--- a/src/node/options.ts
+++ b/src/node/options.ts
@@ -1,4 +1,4 @@
-import type * as opts from "./types/options";
+import type * as opts from './types/options';
 import { MODE } from './constants';
 
 const mkdirDefaults: opts.IMkdirOptions = {
diff --git a/src/node/util.ts b/src/node/util.ts
index 4e45278bd..f1a8ba196 100644
--- a/src/node/util.ts
+++ b/src/node/util.ts
@@ -1,7 +1,7 @@
-import {ERRSTR} from './constants';
+import { ERRSTR } from './constants';
 import * as errors from '../internal/errors';
 import type { FsCallbackApi } from './types';
-import type * as misc from "./types/misc";
+import type * as misc from './types/misc';
 
 export function promisify(
   fs: FsCallbackApi,
diff --git a/src/volume.ts b/src/volume.ts
index a02ba561a..c6bb55012 100644
--- a/src/volume.ts
+++ b/src/volume.ts
@@ -15,7 +15,7 @@ import * as util from 'util';
 import { createPromisesApi } from './node/promises';
 import { ERRSTR, MODE } from './node/constants';
 import { getMkdirOptions } from './node/options';
-import {validateCallback, modeToNumber, pathToFilename, nullCheck, createError} from './node/util';
+import { validateCallback, modeToNumber, pathToFilename, nullCheck, createError } from './node/util';
 import type { PathLike, symlink } from 'fs';
 
 const resolveCrossPlatform = pathModule.resolve;