// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

// Maintainers, keep in mind that ES1-style octal literals (`0666`) are not

// allowed in strict mode. Use ES6-style octal literals instead (`0o666`).

'use strict';

// Most platforms don't allow reads or writes >= 2 GB.

// See https://github.com/libuv/libuv/pull/1501.

const kIoMaxLength = 2 ** 31 - 1;

// When using FSReqCallback, make sure to create the object only *after* all

// parameter validation has happened, so that the objects are not kept in memory

// in case they are created but never used due to an exception.

const {

ArrayPrototypePush,

BigIntPrototypeToString,

MathMax,

Number,

ObjectCreate,

ObjectDefineProperties,

ObjectDefineProperty,

Promise,

ReflectApply,

RegExpPrototypeExec,

SafeMap,

String,

StringPrototypeCharCodeAt,

StringPrototypeIndexOf,

StringPrototypeSlice,

} = primordials;

const { fs: constants } = internalBinding('constants');

const {

S_IFIFO,

S_IFLNK,

S_IFMT,

S_IFREG,

S_IFSOCK,

F_OK,

R_OK,

W_OK,

X_OK,

O_WRONLY,

O_SYMLINK

} = constants;

const pathModule = require('path');

const { isArrayBufferView } = require('internal/util/types');

// We need to get the statValues from the binding at the callsite since

// it's re-initialized after deserialization.

const binding = internalBinding('fs');

const { Buffer } = require('buffer');

const {

aggregateTwoErrors,

codes: {

ERR_FS_FILE_TOO_LARGE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_ARG_TYPE,

ERR_FEATURE_UNAVAILABLE_ON_PLATFORM,

},

AbortError,

uvErrmapGet,

uvException

} = require('internal/errors');

const { FSReqCallback } = binding;

const { toPathIfFileURL } = require('internal/url');

const internalUtil = require('internal/util');

const {

copyObject,

Dirent,

emitRecursiveRmdirWarning,

getDirents,

getOptions,

getValidatedFd,

getValidatedPath,

getValidMode,

handleErrorFromBinding,

nullCheck,

preprocessSymlinkDestination,

Stats,

getStatsFromBinding,

realpathCacheKey,

stringToFlags,

stringToSymlinkType,

toUnixTimestamp,

validateBufferArray,

validateOffsetLengthRead,

validateOffsetLengthWrite,

validatePath,

validatePosition,

validateRmOptions,

validateRmOptionsSync,

validateRmdirOptions,

validateStringAfterArrayBufferView,

warnOnNonPortableTemplate

} = require('internal/fs/utils');

const {

Dir,

opendir,

opendirSync

} = require('internal/fs/dir');

const {

CHAR_FORWARD_SLASH,

CHAR_BACKWARD_SLASH,

} = require('internal/constants');

const {

isUint32,

parseFileMode,

validateBoolean,

validateBuffer,

validateCallback,

validateFunction,

validateInteger,

} = require('internal/validators');

// 2 ** 32 - 1

const kMaxUserId = 4294967295;

let truncateWarn = true;

let fs;

// Lazy loaded

let promises = null;

let watchers;

let ReadFileContext;

let ReadStream;

let WriteStream;

let rimraf;

let rimrafSync;

// These have to be separate because of how graceful-fs happens to do it's

// monkeypatching.

let FileReadStream;

let FileWriteStream;

const isWindows = process.platform === 'win32';

const isOSX = process.platform === 'darwin';

function showTruncateDeprecation() {

if (truncateWarn) {

process.emitWarning(

'Using fs.truncate with a file descriptor is deprecated. Please use ' +

'fs.ftruncate with a file descriptor instead.',

'DeprecationWarning', 'DEP0081');

truncateWarn = false;

}

}

function maybeCallback(cb) {

validateCallback(cb);

return cb;

}

// Ensure that callbacks run in the global context. Only use this function

// for callbacks that are passed to the binding layer, callbacks that are

// invoked from JS already run in the proper scope.

function makeCallback(cb) {

validateCallback(cb);

return (...args) => ReflectApply(cb, this, args);

}

// Special case of `makeCallback()` that is specific to async `*stat()` calls as

// an optimization, since the data passed back to the callback needs to be

// transformed anyway.

function makeStatsCallback(cb) {

validateCallback(cb);

return (err, stats) => {

if (err) return cb(err);

cb(err, getStatsFromBinding(stats));

};

}

const isFd = isUint32;

function isFileType(stats, fileType) {

// Use stats array directly to avoid creating an fs.Stats instance just for

// our internal use.

let mode = stats[1];

if (typeof mode === 'bigint')

mode = Number(mode);

return (mode & S_IFMT) === fileType;

}

function access(path, mode, callback) {

if (typeof mode === 'function') {

callback = mode;

mode = F_OK;

}

path = getValidatedPath(path);

mode = getValidMode(mode, 'access');

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.access(pathModule.toNamespacedPath(path), mode, req);

}

function accessSync(path, mode) {

path = getValidatedPath(path);

mode = getValidMode(mode, 'access');

const ctx = { path };

binding.access(pathModule.toNamespacedPath(path), mode, undefined, ctx);

handleErrorFromBinding(ctx);

}

function exists(path, callback) {

maybeCallback(callback);

function suppressedCallback(err) {

callback(err ? false : true);

}

try {

fs.access(path, F_OK, suppressedCallback);

} catch {

return callback(false);

}

}

ObjectDefineProperty(exists, internalUtil.promisify.custom, {

value: (path) => {

return new Promise((resolve) => fs.exists(path, resolve));

}

});

// fs.existsSync never throws, it only returns true or false.

// Since fs.existsSync never throws, users have established

// the expectation that passing invalid arguments to it, even like

// fs.existsSync(), would only get a false in return, so we cannot signal

// validation errors to users properly out of compatibility concerns.

// TODO(joyeecheung): deprecate the never-throw-on-invalid-arguments behavior

function existsSync(path) {

try {

path = getValidatedPath(path);

} catch {

return false;

}

const ctx = { path };

const nPath = pathModule.toNamespacedPath(path);

binding.access(nPath, F_OK, undefined, ctx);

// In case of an invalid symlink, `binding.access()` on win32

// will **not** return an error and is therefore not enough.

// Double check with `binding.stat()`.

if (isWindows && ctx.errno === undefined) {

binding.stat(nPath, false, undefined, ctx);

}

return ctx.errno === undefined;

}

function readFileAfterOpen(err, fd) {

const context = this.context;

if (err) {

context.callback(err);

return;

}

context.fd = fd;

const req = new FSReqCallback();

req.oncomplete = readFileAfterStat;

req.context = context;

binding.fstat(fd, false, req);

}

function readFileAfterStat(err, stats) {

const context = this.context;

if (err)

return context.close(err);

const size = context.size = isFileType(stats, S_IFREG) ? stats[8] : 0;

if (size > kIoMaxLength) {

err = new ERR_FS_FILE_TOO_LARGE(size);

return context.close(err);

}

try {

if (size === 0) {

context.buffers = [];

} else {

context.buffer = Buffer.allocUnsafeSlow(size);

}

} catch (err) {

return context.close(err);

}

context.read();

}

function checkAborted(signal, callback) {

if (signal?.aborted) {

callback(new AbortError());

return true;

}

return false;

}

function readFile(path, options, callback) {

callback = maybeCallback(callback || options);

options = getOptions(options, { flag: 'r' });

if (!ReadFileContext)

ReadFileContext = require('internal/fs/read_file_context');

const context = new ReadFileContext(callback, options.encoding);

context.isUserFd = isFd(path); // File descriptor ownership

if (options.signal) {

context.signal = options.signal;

}

if (context.isUserFd) {

process.nextTick(function tick(context) {

ReflectApply(readFileAfterOpen, { context }, [null, path]);

}, context);

return;

}

if (checkAborted(options.signal, callback))

return;

const flagsNumber = stringToFlags(options.flag, 'options.flag');

path = getValidatedPath(path);

const req = new FSReqCallback();

req.context = context;

req.oncomplete = readFileAfterOpen;

binding.open(pathModule.toNamespacedPath(path),

flagsNumber,

0o666,

req);

}

function tryStatSync(fd, isUserFd) {

const ctx = {};

const stats = binding.fstat(fd, false, undefined, ctx);

if (ctx.errno !== undefined && !isUserFd) {

fs.closeSync(fd);

throw uvException(ctx);

}

return stats;

}

function tryCreateBuffer(size, fd, isUserFd) {

let threw = true;

let buffer;

try {

if (size > kIoMaxLength) {

throw new ERR_FS_FILE_TOO_LARGE(size);

}

buffer = Buffer.allocUnsafe(size);

threw = false;

} finally {

if (threw && !isUserFd) fs.closeSync(fd);

}

return buffer;

}

function tryReadSync(fd, isUserFd, buffer, pos, len) {

let threw = true;

let bytesRead;

try {

bytesRead = fs.readSync(fd, buffer, pos, len);

threw = false;

} finally {

if (threw && !isUserFd) fs.closeSync(fd);

}

return bytesRead;

}

function readFileSync(path, options) {

options = getOptions(options, { flag: 'r' });

const isUserFd = isFd(path); // File descriptor ownership

const fd = isUserFd ? path : fs.openSync(path, options.flag, 0o666);

const stats = tryStatSync(fd, isUserFd);

const size = isFileType(stats, S_IFREG) ? stats[8] : 0;

let pos = 0;

let buffer; // Single buffer with file data

let buffers; // List for when size is unknown

if (size === 0) {

buffers = [];

} else {

buffer = tryCreateBuffer(size, fd, isUserFd);

}

let bytesRead;

if (size !== 0) {

do {

bytesRead = tryReadSync(fd, isUserFd, buffer, pos, size - pos);

pos += bytesRead;

} while (bytesRead !== 0 && pos < size);

} else {

do {

// The kernel lies about many files.

// Go ahead and try to read some bytes.

buffer = Buffer.allocUnsafe(8192);

bytesRead = tryReadSync(fd, isUserFd, buffer, 0, 8192);

if (bytesRead !== 0) {

ArrayPrototypePush(buffers, buffer.slice(0, bytesRead));

}

pos += bytesRead;

} while (bytesRead !== 0);

}

if (!isUserFd)

fs.closeSync(fd);

if (size === 0) {

// Data was collected into the buffers list.

buffer = Buffer.concat(buffers, pos);

} else if (pos < size) {

buffer = buffer.slice(0, pos);

}

if (options.encoding) buffer = buffer.toString(options.encoding);

return buffer;

}

function defaultCloseCallback(err) {

if (err != null) throw err;

}

function close(fd, callback = defaultCloseCallback) {

fd = getValidatedFd(fd);

if (callback !== defaultCloseCallback)

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.close(fd, req);

}

function closeSync(fd) {

fd = getValidatedFd(fd);

const ctx = {};

binding.close(fd, undefined, ctx);

handleErrorFromBinding(ctx);

}

function open(path, flags, mode, callback) {

path = getValidatedPath(path);

if (arguments.length < 3) {

callback = flags;

flags = 'r';

mode = 0o666;

} else if (typeof mode === 'function') {

callback = mode;

mode = 0o666;

} else {

mode = parseFileMode(mode, 'mode', 0o666);

}

const flagsNumber = stringToFlags(flags);

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.open(pathModule.toNamespacedPath(path),

flagsNumber,

mode,

req);

}

function openSync(path, flags, mode) {

path = getValidatedPath(path);

const flagsNumber = stringToFlags(flags);

mode = parseFileMode(mode, 'mode', 0o666);

const ctx = { path };

const result = binding.open(pathModule.toNamespacedPath(path),

flagsNumber, mode,

undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

// usage:

// fs.read(fd, buffer, offset, length, position, callback);

// OR

// fs.read(fd, {}, callback)

function read(fd, buffer, offset, length, position, callback) {

fd = getValidatedFd(fd);

if (arguments.length <= 3) {

// Assume fs.read(fd, options, callback)

let options = {};

if (arguments.length < 3) {

// This is fs.read(fd, callback)

// buffer will be the callback

callback = buffer;

} else {

// This is fs.read(fd, {}, callback)

// buffer will be the options object

// offset is the callback

options = buffer;

callback = offset;

}

({

buffer = Buffer.alloc(16384),

offset = 0,

length = buffer.length,

position

} = options);

}

validateBuffer(buffer);

callback = maybeCallback(callback);

if (offset == null) {

offset = 0;

} else {

validateInteger(offset, 'offset');

}

length |= 0;

if (length === 0) {

return process.nextTick(function tick() {

callback(null, 0, buffer);

});

}

if (buffer.byteLength === 0) {

throw new ERR_INVALID_ARG_VALUE('buffer', buffer,

'is empty and cannot be written');

}

validateOffsetLengthRead(offset, length, buffer.byteLength);

if (position == null)

position = -1;

validatePosition(position, 'position');

function wrapper(err, bytesRead) {

// Retain a reference to buffer so that it can't be GC'ed too soon.

callback(err, bytesRead || 0, buffer);

}

const req = new FSReqCallback();

req.oncomplete = wrapper;

binding.read(fd, buffer, offset, length, position, req);

}

ObjectDefineProperty(read, internalUtil.customPromisifyArgs,

{ value: ['bytesRead', 'buffer'], enumerable: false });

// usage:

// fs.readSync(fd, buffer, offset, length, position);

// OR

// fs.readSync(fd, buffer, {}) or fs.readSync(fd, buffer)

function readSync(fd, buffer, offset, length, position) {

fd = getValidatedFd(fd);

if (arguments.length <= 3) {

// Assume fs.read(fd, buffer, options)

const options = offset || {};

({ offset = 0, length = buffer.length, position } = options);

}

validateBuffer(buffer);

if (offset == null) {

offset = 0;

} else {

validateInteger(offset, 'offset');

}

length |= 0;

if (length === 0) {

return 0;

}

if (buffer.byteLength === 0) {

throw new ERR_INVALID_ARG_VALUE('buffer', buffer,

'is empty and cannot be written');

}

validateOffsetLengthRead(offset, length, buffer.byteLength);

if (position == null)

position = -1;

validatePosition(position, 'position');

const ctx = {};

const result = binding.read(fd, buffer, offset, length, position,

undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

function readv(fd, buffers, position, callback) {

function wrapper(err, read) {

callback(err, read || 0, buffers);

}

fd = getValidatedFd(fd);

validateBufferArray(buffers);

callback = maybeCallback(callback || position);

const req = new FSReqCallback();

req.oncomplete = wrapper;

if (typeof position !== 'number')

position = null;

return binding.readBuffers(fd, buffers, position, req);

}

ObjectDefineProperty(readv, internalUtil.customPromisifyArgs,

{ value: ['bytesRead', 'buffers'], enumerable: false });

function readvSync(fd, buffers, position) {

fd = getValidatedFd(fd);

validateBufferArray(buffers);

const ctx = {};

if (typeof position !== 'number')

position = null;

const result = binding.readBuffers(fd, buffers, position, undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

// usage:

// fs.write(fd, buffer[, offset[, length[, position]]], callback);

// OR

// fs.write(fd, string[, position[, encoding]], callback);

function write(fd, buffer, offset, length, position, callback) {

function wrapper(err, written) {

// Retain a reference to buffer so that it can't be GC'ed too soon.

callback(err, written || 0, buffer);

}

fd = getValidatedFd(fd);

if (isArrayBufferView(buffer)) {

callback = maybeCallback(callback || position || length || offset);

if (offset == null || typeof offset === 'function') {

offset = 0;

} else {

validateInteger(offset, 'offset');

}

if (typeof length !== 'number')

length = buffer.length - offset;

if (typeof position !== 'number')

position = null;

validateOffsetLengthWrite(offset, length, buffer.byteLength);

const req = new FSReqCallback();

req.oncomplete = wrapper;

return binding.writeBuffer(fd, buffer, offset, length, position, req);

}

validateStringAfterArrayBufferView(buffer, 'buffer');

if (typeof position !== 'function') {

if (typeof offset === 'function') {

position = offset;

offset = null;

} else {

position = length;

}

length = 'utf8';

}

callback = maybeCallback(position);

const req = new FSReqCallback();

req.oncomplete = wrapper;

return binding.writeString(fd, String(buffer), offset, length, req);

}

ObjectDefineProperty(write, internalUtil.customPromisifyArgs,

{ value: ['bytesWritten', 'buffer'], enumerable: false });

// Usage:

// fs.writeSync(fd, buffer[, offset[, length[, position]]]);

// OR

// fs.writeSync(fd, string[, position[, encoding]]);

function writeSync(fd, buffer, offset, length, position) {

fd = getValidatedFd(fd);

const ctx = {};

let result;

if (isArrayBufferView(buffer)) {

if (position === undefined)

position = null;

if (offset == null) {

offset = 0;

} else {

validateInteger(offset, 'offset');

}

if (typeof length !== 'number')

length = buffer.byteLength - offset;

validateOffsetLengthWrite(offset, length, buffer.byteLength);

result = binding.writeBuffer(fd, buffer, offset, length, position,

undefined, ctx);

} else {

validateStringAfterArrayBufferView(buffer, 'buffer');

if (offset === undefined)

offset = null;

result = binding.writeString(fd, buffer, offset, length,

undefined, ctx);

}

handleErrorFromBinding(ctx);

return result;

}

// usage:

// fs.writev(fd, buffers[, position], callback);

function writev(fd, buffers, position, callback) {

function wrapper(err, written) {

callback(err, written || 0, buffers);

}

fd = getValidatedFd(fd);

validateBufferArray(buffers);

callback = maybeCallback(callback || position);

const req = new FSReqCallback();

req.oncomplete = wrapper;

if (typeof position !== 'number')

position = null;

return binding.writeBuffers(fd, buffers, position, req);

}

ObjectDefineProperty(writev, internalUtil.customPromisifyArgs, {

value: ['bytesWritten', 'buffer'],

enumerable: false

});

function writevSync(fd, buffers, position) {

fd = getValidatedFd(fd);

validateBufferArray(buffers);

const ctx = {};

if (typeof position !== 'number')

position = null;

const result = binding.writeBuffers(fd, buffers, position, undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

function rename(oldPath, newPath, callback) {

callback = makeCallback(callback);

oldPath = getValidatedPath(oldPath, 'oldPath');

newPath = getValidatedPath(newPath, 'newPath');

const req = new FSReqCallback();

req.oncomplete = callback;

binding.rename(pathModule.toNamespacedPath(oldPath),

pathModule.toNamespacedPath(newPath),

req);

}

function renameSync(oldPath, newPath) {

oldPath = getValidatedPath(oldPath, 'oldPath');

newPath = getValidatedPath(newPath, 'newPath');

const ctx = { path: oldPath, dest: newPath };

binding.rename(pathModule.toNamespacedPath(oldPath),

pathModule.toNamespacedPath(newPath), undefined, ctx);

handleErrorFromBinding(ctx);

}

function truncate(path, len, callback) {

if (typeof path === 'number') {

showTruncateDeprecation();

return fs.ftruncate(path, len, callback);

}

if (typeof len === 'function') {

callback = len;

len = 0;

} else if (len === undefined) {

len = 0;

}

validateInteger(len, 'len');

len = MathMax(0, len);

callback = maybeCallback(callback);

fs.open(path, 'r+', (er, fd) => {

if (er) return callback(er);

const req = new FSReqCallback();

req.oncomplete = function oncomplete(er) {

fs.close(fd, (er2) => {

callback(aggregateTwoErrors(er2, er));

});

};

binding.ftruncate(fd, len, req);

});

}

function truncateSync(path, len) {

if (typeof path === 'number') {

// legacy

showTruncateDeprecation();

return fs.ftruncateSync(path, len);

}

if (len === undefined) {

len = 0;

}

// Allow error to be thrown, but still close fd.

const fd = fs.openSync(path, 'r+');

let ret;

try {

ret = fs.ftruncateSync(fd, len);

} finally {

fs.closeSync(fd);

}

return ret;

}

function ftruncate(fd, len = 0, callback) {

if (typeof len === 'function') {

callback = len;

len = 0;

}

fd = getValidatedFd(fd);

validateInteger(len, 'len');

len = MathMax(0, len);

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.ftruncate(fd, len, req);

}

function ftruncateSync(fd, len = 0) {

fd = getValidatedFd(fd);

validateInteger(len, 'len');

len = MathMax(0, len);

const ctx = {};

binding.ftruncate(fd, len, undefined, ctx);

handleErrorFromBinding(ctx);

}

function lazyLoadRimraf() {

if (rimraf === undefined)

({ rimraf, rimrafSync } = require('internal/fs/rimraf'));

}

function rmdir(path, options, callback) {

if (typeof options === 'function') {

callback = options;

options = undefined;

}

callback = makeCallback(callback);

path = pathModule.toNamespacedPath(getValidatedPath(path));

if (options?.recursive) {

emitRecursiveRmdirWarning();

validateRmOptions(

path,

{ ...options, force: false },

true,

(err, options) => {

if (err === false) {

const req = new FSReqCallback();

req.oncomplete = callback;

return binding.rmdir(path, req);

}

if (err) {

return callback(err);

}

lazyLoadRimraf();

rimraf(path, options, callback);

});

} else {

validateRmdirOptions(options);

const req = new FSReqCallback();

req.oncomplete = callback;

return binding.rmdir(path, req);

}

}

function rmdirSync(path, options) {

path = getValidatedPath(path);

if (options?.recursive) {

emitRecursiveRmdirWarning();

options = validateRmOptionsSync(path, { ...options, force: false }, true);

if (options !== false) {

lazyLoadRimraf();

return rimrafSync(pathModule.toNamespacedPath(path), options);

}

} else {

validateRmdirOptions(options);

}

const ctx = { path };

binding.rmdir(pathModule.toNamespacedPath(path), undefined, ctx);

return handleErrorFromBinding(ctx);

}

function rm(path, options, callback) {

if (typeof options === 'function') {

callback = options;

options = undefined;

}

validateRmOptions(path, options, false, (err, options) => {

if (err) {

return callback(err);

}

lazyLoadRimraf();

return rimraf(pathModule.toNamespacedPath(path), options, callback);

});

}

function rmSync(path, options) {

options = validateRmOptionsSync(path, options, false);

lazyLoadRimraf();

return rimrafSync(pathModule.toNamespacedPath(path), options);

}

function fdatasync(fd, callback) {

fd = getValidatedFd(fd);

const req = new FSReqCallback();

req.oncomplete = makeCallback(callback);

binding.fdatasync(fd, req);

}

function fdatasyncSync(fd) {

fd = getValidatedFd(fd);

const ctx = {};

binding.fdatasync(fd, undefined, ctx);

handleErrorFromBinding(ctx);

}

function fsync(fd, callback) {

fd = getValidatedFd(fd);

const req = new FSReqCallback();

req.oncomplete = makeCallback(callback);

binding.fsync(fd, req);

}

function fsyncSync(fd) {

fd = getValidatedFd(fd);

const ctx = {};

binding.fsync(fd, undefined, ctx);

handleErrorFromBinding(ctx);

}

function mkdir(path, options, callback) {

let mode = 0o777;

let recursive = false;

if (typeof options === 'function') {

callback = options;

} else if (typeof options === 'number' || typeof options === 'string') {

mode = options;

} else if (options) {