// 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';

const {

ArrayPrototypePush,

BigIntPrototypeToString,

Boolean,

MathMax,

Number,

ObjectDefineProperties,

ObjectDefineProperty,

Promise,

PromiseResolve,

ReflectApply,

SafeMap,

SafeSet,

StringPrototypeCharCodeAt,

StringPrototypeIndexOf,

StringPrototypeSlice,

uncurryThis,

} = 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');

const binding = internalBinding('fs');

const { createBlobFromFilePath } = require('internal/blob');

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

const { isBuffer: BufferIsBuffer } = Buffer;

const BufferToString = uncurryThis(Buffer.prototype.toString);

const {

AbortError,

aggregateTwoErrors,

codes: {

ERR_ACCESS_DENIED,

ERR_FS_FILE_TOO_LARGE,

ERR_INVALID_ARG_VALUE,

},

} = require('internal/errors');

const {

FSReqCallback,

statValues,

} = binding;

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

const {

customPromisifyArgs: kCustomPromisifyArgsSymbol,

getLazy,

kEmptyObject,

promisify: {

custom: kCustomPromisifiedSymbol,

},

SideEffectFreeRegExpPrototypeExec,

defineLazyProperties,

isWindows,

isMacOS,

} = require('internal/util');

const {

constants: {

kIoMaxLength,

kMaxUserId,

},

copyObject,

Dirent,

emitRecursiveRmdirWarning,

getDirent,

getDirents,

getOptions,

getValidatedFd,

getValidatedPath,

handleErrorFromBinding,

preprocessSymlinkDestination,

Stats,

getStatFsFromBinding,

getStatsFromBinding,

realpathCacheKey,

stringToFlags,

stringToSymlinkType,

toUnixTimestamp,

validateBufferArray,

validateCpOptions,

validateOffsetLengthRead,

validateOffsetLengthWrite,

validatePath,

validatePosition,

validateRmOptions,

validateRmOptionsSync,

validateRmdirOptions,

validateStringAfterArrayBufferView,

warnOnNonPortableTemplate,

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

const {

CHAR_FORWARD_SLASH,

CHAR_BACKWARD_SLASH,

} = require('internal/constants');

const {

isInt32,

parseFileMode,

validateBoolean,

validateBuffer,

validateEncoding,

validateFunction,

validateInteger,

validateObject,

validateString,

kValidateObjectAllowNullable,

} = require('internal/validators');

const permission = require('internal/process/permission');

let truncateWarn = true;

let fs;

// Lazy loaded

let cpFn;

let cpSyncFn;

let promises = null;

let ReadStream;

let WriteStream;

let rimraf;

let rimrafSync;

let kResistStopPropagation;

let ReadFileContext;

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

// monkeypatching.

let FileReadStream;

let FileWriteStream;

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;

}

}

// 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) {

validateFunction(cb, '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) {

validateFunction(cb, 'cb');

return (err, stats) => {

if (err) return cb(err);

cb(err, getStatsFromBinding(stats));

};

}

const isFd = isInt32;

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;

}

/**

* Tests a user's permissions for the file or directory

* specified by `path`.

* @param {string | Buffer | URL} path

* @param {number} [mode]

* @param {(err?: Error) => any} callback

* @returns {void}

*/

function access(path, mode, callback) {

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

callback = mode;

mode = F_OK;

}

path = getValidatedPath(path);

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.access(path, mode, req);

}

/**

* Synchronously tests a user's permissions for the file or

* directory specified by `path`.

* @param {string | Buffer | URL} path

* @param {number} [mode]

* @returns {void}

*/

function accessSync(path, mode) {

binding.access(getValidatedPath(path), mode);

}

/**

* Tests whether or not the given path exists.

* @param {string | Buffer | URL} path

* @param {(exists?: boolean) => any} callback

* @returns {void}

*/

function exists(path, callback) {

validateFunction(callback, 'cb');

function suppressedCallback(err) {

callback(!err);

}

try {

fs.access(path, F_OK, suppressedCallback);

} catch {

return callback(false);

}

}

ObjectDefineProperty(exists, kCustomPromisifiedSymbol, {

__proto__: null,

value: function exists(path) { // eslint-disable-line func-name-matching

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

/**

* Synchronously tests whether or not the given path exists.

* @param {string | Buffer | URL} path

* @returns {boolean}

*/

function existsSync(path) {

try {

path = getValidatedPath(path);

} catch {

return false;

}

return binding.existsSync(path);

}

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);

// TODO(BridgeAR): Check if allocating a smaller chunk is better performance

// wise, similar to the promise based version (less peak memory and chunked

// stringify operations vs multiple C++/JS boundary crossings).

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) {

// TODO(BridgeAR): If an encoding is set, use the StringDecoder to concat

// the result and reuse the buffer instead of allocating a new one.

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(undefined, { cause: signal.reason }));

return true;

}

return false;

}

/**

* Asynchronously reads the entire contents of a file.

* @param {string | Buffer | URL | number} path

* @param {{

* encoding?: string | null;

* flag?: string;

* signal?: AbortSignal;

* } | string} [options]

* @param {(

* err?: Error,

* data?: string | Buffer

* ) => any} callback

* @returns {void}

*/

function readFile(path, options, callback) {

callback ||= options;

validateFunction(callback, 'cb');

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

ReadFileContext ??= require('internal/fs/read/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');

const req = new FSReqCallback();

req.context = context;

req.oncomplete = readFileAfterOpen;

binding.open(getValidatedPath(path), flagsNumber, 0o666, req);

}

function tryStatSync(fd, isUserFd) {

const stats = binding.fstat(fd, false, undefined, true /* shouldNotThrow */);

if (stats === undefined && !isUserFd) {

fs.closeSync(fd);

}

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;

}

/**

* Synchronously reads the entire contents of a file.

* @param {string | Buffer | URL | number} path

* @param {{

* encoding?: string | null;

* flag?: string;

* }} [options]

* @returns {string | Buffer}

*/

function readFileSync(path, options) {

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

if (options.encoding === 'utf8' || options.encoding === 'utf-8') {

if (!isInt32(path)) {

path = getValidatedPath(path);

}

return binding.readFileUtf8(path, stringToFlags(options.flag));

}

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;

}

/**

* Closes the file descriptor.

* @param {number} fd

* @param {(err?: Error) => any} [callback]

* @returns {void}

*/

function close(fd, callback = defaultCloseCallback) {

if (callback !== defaultCloseCallback)

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.close(fd, req);

}

/**

* Synchronously closes the file descriptor.

* @param {number} fd

* @returns {void}

*/

function closeSync(fd) {

binding.close(fd);

}

/**

* Asynchronously opens a file.

* @param {string | Buffer | URL} path

* @param {string | number} [flags]

* @param {string | number} [mode]

* @param {(

* err?: Error,

* fd?: number

* ) => any} callback

* @returns {void}

*/

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(path, flagsNumber, mode, req);

}

/**

* Synchronously opens a file.

* @param {string | Buffer | URL} path

* @param {string | number} [flags]

* @param {string | number} [mode]

* @returns {number}

*/

function openSync(path, flags, mode) {

return binding.open(

getValidatedPath(path),

stringToFlags(flags),

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

);

}

/**

* @param {string | Buffer | URL } path

* @param {{

* type?: string;

* }} [options]

* @returns {Promise<Blob>}

*/

function openAsBlob(path, options = kEmptyObject) {

validateObject(options, 'options');

const type = options.type || '';

validateString(type, 'options.type');

// The underlying implementation here returns the Blob synchronously for now.

// To give ourselves flexibility to maybe return the Blob asynchronously,

// this API returns a Promise.

path = getValidatedPath(path);

return PromiseResolve(createBlobFromFilePath(path, { type }));

}

/**

* Reads file from the specified `fd` (file descriptor).

* @param {number} fd

* @param {Buffer | TypedArray | DataView} buffer

* @param {number | {

* offset?: number;

* length?: number;

* position?: number | bigint | null;

* }} [offsetOrOptions]

* @param {number} length

* @param {number | bigint | null} position

* @param {(

* err?: Error,

* bytesRead?: number,

* buffer?: Buffer

* ) => any} callback

* @returns {void}

*/

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

fd = getValidatedFd(fd);

let offset = offsetOrOptions;

let params = null;

if (arguments.length <= 4) {

if (arguments.length === 4) {

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

validateObject(offsetOrOptions, 'options', kValidateObjectAllowNullable);

callback = length;

params = offsetOrOptions;

} else if (arguments.length === 3) {

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

if (!isArrayBufferView(buffer)) {

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

params = buffer;

({ buffer = Buffer.alloc(16384) } = params ?? kEmptyObject);

}

callback = offsetOrOptions;

} else {

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

callback = buffer;

buffer = Buffer.alloc(16384);

}

if (params !== undefined) {

validateObject(params, 'options', kValidateObjectAllowNullable);

}

({

offset = 0,

length = buffer?.byteLength - offset,

position = null,

} = params ?? kEmptyObject);

}

validateBuffer(buffer);

validateFunction(callback, 'cb');

if (offset == null) {

offset = 0;

} else {

validateInteger(offset, 'offset', 0);

}

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;

} else {

validatePosition(position, 'position', length);

}

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, kCustomPromisifyArgsSymbol,

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

/**

* Synchronously reads the file from the

* specified `fd` (file descriptor).

* @param {number} fd

* @param {Buffer | TypedArray | DataView} buffer

* @param {number | {

* offset?: number;

* length?: number;

* position?: number | bigint | null;

* }} [offsetOrOptions]

* @param {number} [length]

* @param {number} [position]

* @returns {number}

*/

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

validateBuffer(buffer);

let offset = offsetOrOptions;

if (arguments.length <= 3 || typeof offsetOrOptions === 'object') {

if (offsetOrOptions !== undefined) {

validateObject(offsetOrOptions, 'options', kValidateObjectAllowNullable);

}

({

offset = 0,

length = buffer.byteLength - offset,

position = null,

} = offsetOrOptions ?? kEmptyObject);

}

if (offset === undefined) {

offset = 0;

} else {

validateInteger(offset, 'offset', 0);

}

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;

} else {

validatePosition(position, 'position', length);

}

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

}

/**

* Reads file from the specified `fd` (file descriptor)

* and writes to an array of `ArrayBufferView`s.

* @param {number} fd

* @param {ArrayBufferView[]} buffers

* @param {number | null} [position]

* @param {(

* err?: Error,

* bytesRead?: number,

* buffers?: ArrayBufferView[]

* ) => any} callback

* @returns {void}

*/

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

function wrapper(err, read) {

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

}

fd = getValidatedFd(fd);

validateBufferArray(buffers);

callback ||= position;

validateFunction(callback, 'cb');

const req = new FSReqCallback();

req.oncomplete = wrapper;

if (typeof position !== 'number')

position = null;

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

}

ObjectDefineProperty(readv, kCustomPromisifyArgsSymbol,

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

/**

* Synchronously reads file from the

* specified `fd` (file descriptor) and writes to an array

* of `ArrayBufferView`s.

* @param {number} fd

* @param {ArrayBufferView[]} buffers

* @param {number | null} [position]

* @returns {number}

*/

function readvSync(fd, buffers, position) {

validateBufferArray(buffers);

if (typeof position !== 'number')

position = null;

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

}

/**

* Writes `buffer` to the specified `fd` (file descriptor).

* @param {number} fd

* @param {Buffer | TypedArray | DataView | string} buffer

* @param {number | object} [offsetOrOptions]

* @param {number} [length]

* @param {number | null} [position]

* @param {(

* err?: Error,

* bytesWritten?: number,

* buffer?: Buffer | TypedArray | DataView

* ) => any} callback

* @returns {void}

*/

function write(fd, buffer, offsetOrOptions, 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);

let offset = offsetOrOptions;

if (isArrayBufferView(buffer)) {

callback ||= position || length || offset;

validateFunction(callback, 'cb');

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

({

offset = 0,

length = buffer.byteLength - offset,

position = null,

} = offsetOrOptions ?? kEmptyObject);

}

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

offset = 0;

} else {

validateInteger(offset, 'offset', 0);

}

if (typeof length !== 'number')

length = buffer.byteLength - offset;

if (typeof position !== 'number')

position = null;

validateOffsetLengthWrite(offset, length, buffer.byteLength);

const req = new FSReqCallback();

req.oncomplete = wrapper;

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

return;

}

validateStringAfterArrayBufferView(buffer, 'buffer');

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

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

position = offset;

offset = null;

} else {

position = length;

}

length = 'utf8';

}

const str = buffer;

validateEncoding(str, length);

callback = position;

validateFunction(callback, 'cb');

const req = new FSReqCallback();

req.oncomplete = wrapper;

binding.writeString(fd, str, offset, length, req);

}

ObjectDefineProperty(write, kCustomPromisifyArgsSymbol,

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

/**

* Synchronously writes `buffer` to the

* specified `fd` (file descriptor).

* @param {number} fd

* @param {Buffer | TypedArray | DataView | string} buffer

* @param {{

* offset?: number;

* length?: number;

* position?: number | null;

* }} [offsetOrOptions]

* @param {number} [length]

* @param {number} [position]

* @returns {number}

*/

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

const ctx = {};

let result;

let offset = offsetOrOptions;

if (isArrayBufferView(buffer)) {

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

({

offset = 0,

length = buffer.byteLength - offset,

position = null,

} = offsetOrOptions ?? kEmptyObject);

}

if (position === undefined)

position = null;

if (offset == null) {

offset = 0;

} else {

validateInteger(offset, 'offset', 0);

}

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');

validateEncoding(buffer, length);

if (offset === undefined)

offset = null;

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

undefined, ctx);

}

handleErrorFromBinding(ctx);

return result;

}

/**

* Writes an array of `ArrayBufferView`s to the

* specified `fd` (file descriptor).

* @param {number} fd

* @param {ArrayBufferView[]} buffers

* @param {number | null} [position]

* @param {(

* err?: Error,

* bytesWritten?: number,

* buffers?: ArrayBufferView[]

* ) => any} callback

* @returns {void}

*/

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

function wrapper(err, written) {

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

}

fd = getValidatedFd(fd);

validateBufferArray(buffers);

callback ||= position;

validateFunction(callback, 'cb');

if (buffers.length === 0) {

process.nextTick(callback, null, 0, buffers);

return;

}

const req = new FSReqCallback();

req.oncomplete = wrapper;

if (typeof position !== 'number')

position = null;

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

}

ObjectDefineProperty(writev, kCustomPromisifyArgsSymbol, {

__proto__: null,

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

enumerable: false,

});

/**

* Synchronously writes an array of `ArrayBufferView`s

* to the specified `fd` (file descriptor).

* @param {number} fd

* @param {ArrayBufferView[]} buffers

* @param {number | null} [position]

* @returns {number}

*/

function writevSync(fd, buffers, position) {

validateBufferArray(buffers);

if (buffers.length === 0) {

return 0;

}

if (typeof position !== 'number')

position = null;

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

}

/**

* Asynchronously renames file at `oldPath` to

* the pathname provided as `newPath`.

* @param {string | Buffer | URL} oldPath

* @param {string | Buffer | URL} newPath

* @param {(err?: Error) => any} callback

* @returns {void}

*/

function rename(oldPath, newPath, callback) {

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.rename(

getValidatedPath(oldPath, 'oldPath'),

getValidatedPath(newPath, 'newPath'),

req,

);