Module

std/node/internal/fs/utils.mjs

Deno standard library
Go to Latest
File
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license."use strict";
import { Buffer } from "../../buffer.ts";import { ERR_FS_EISDIR, ERR_FS_INVALID_SYMLINK_TYPE, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, hideStackFrames, uvException,} from "../errors.ts";
import { isArrayBufferView, isBigUint64Array, isDate, isUint8Array,} from "../util/types.ts";import { once } from "../util.mjs";import { toPathIfFileURL } from "../url.ts";import { validateAbortSignal, validateBoolean, validateFunction, validateInt32, validateInteger, validateObject, validateUint32,} from "../validators.mjs";import pathModule from "../../path.ts";const kType = Symbol("type");const kStats = Symbol("stats");import assert from "../assert.mjs";import { lstat, lstatSync } from "../../_fs/_fs_lstat.ts";import { stat, statSync } from "../../_fs/_fs_stat.ts";import { isWindows } from "../../../_util/os.ts";import process from "../../process.ts";
import { fs as fsConstants, os as osConstants,} from "../../internal_binding/constants.ts";const { F_OK = 0, W_OK = 0, R_OK = 0, X_OK = 0, COPYFILE_EXCL, COPYFILE_FICLONE, COPYFILE_FICLONE_FORCE, O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, UV_FS_SYMLINK_DIR, UV_FS_SYMLINK_JUNCTION, UV_DIRENT_UNKNOWN, UV_DIRENT_FILE, UV_DIRENT_DIR, UV_DIRENT_LINK, UV_DIRENT_FIFO, UV_DIRENT_SOCKET, UV_DIRENT_CHAR, UV_DIRENT_BLOCK,} = fsConstants;const { errno: { EISDIR, },} = osConstants;
// The access modes can be any of F_OK, R_OK, W_OK or X_OK. Some might not be// available on specific systems. They can be used in combination as well// (F_OK | R_OK | W_OK | X_OK).const kMinimumAccessMode = Math.min(F_OK, W_OK, R_OK, X_OK);const kMaximumAccessMode = F_OK | W_OK | R_OK | X_OK;
const kDefaultCopyMode = 0;// The copy modes can be any of COPYFILE_EXCL, COPYFILE_FICLONE or// COPYFILE_FICLONE_FORCE. They can be used in combination as well// (COPYFILE_EXCL | COPYFILE_FICLONE | COPYFILE_FICLONE_FORCE).const kMinimumCopyMode = Math.min( kDefaultCopyMode, COPYFILE_EXCL, COPYFILE_FICLONE, COPYFILE_FICLONE_FORCE,);const kMaximumCopyMode = COPYFILE_EXCL | COPYFILE_FICLONE | COPYFILE_FICLONE_FORCE;
// Most platforms don't allow reads or writes >= 2 GB.// See https://github.com/libuv/libuv/pull/1501.const kIoMaxLength = 2 ** 31 - 1;
// Use 64kb in case the file type is not a regular file and thus do not know the// actual file size. Increasing the value further results in more frequent over// allocation for small files and consumes CPU time and memory that should be// used else wise.// Use up to 512kb per read otherwise to partition reading big files to prevent// blocking other threads in case the available threads are all in use.const kReadFileUnknownBufferLength = 64 * 1024;const kReadFileBufferLength = 512 * 1024;
const kWriteFileMaxChunkSize = 512 * 1024;
export const kMaxUserId = 2 ** 32 - 1;
function assertEncoding(encoding) { if (encoding && !Buffer.isEncoding(encoding)) { const reason = "is invalid encoding"; throw new ERR_INVALID_ARG_VALUE(encoding, "encoding", reason); }}
class Dirent { constructor(name, type) { this.name = name; this[kType] = type; }
isDirectory() { return this[kType] === UV_DIRENT_DIR; }
isFile() { return this[kType] === UV_DIRENT_FILE; }
isBlockDevice() { return this[kType] === UV_DIRENT_BLOCK; }
isCharacterDevice() { return this[kType] === UV_DIRENT_CHAR; }
isSymbolicLink() { return this[kType] === UV_DIRENT_LINK; }
isFIFO() { return this[kType] === UV_DIRENT_FIFO; }
isSocket() { return this[kType] === UV_DIRENT_SOCKET; }}
class DirentFromStats extends Dirent { constructor(name, stats) { super(name, null); this[kStats] = stats; }}
for (const name of Reflect.ownKeys(Dirent.prototype)) { if (name === "constructor") { continue; } DirentFromStats.prototype[name] = function () { return this[kStats][name](); };}
export function copyObject(source) { const target = {}; for (const key in source) { target[key] = source[key]; } return target;}
const bufferSep = Buffer.from(pathModule.sep);
function join(path, name) { if ( (typeof path === "string" || isUint8Array(path)) && name === undefined ) { return path; }
if (typeof path === "string" && isUint8Array(name)) { const pathBuffer = Buffer.from(pathModule.join(path, pathModule.sep)); return Buffer.concat([pathBuffer, name]); }
if (typeof path === "string" && typeof name === "string") { return pathModule.join(path, name); }
if (isUint8Array(path) && isUint8Array(name)) { return Buffer.concat([path, bufferSep, name]); }
throw new ERR_INVALID_ARG_TYPE( "path", ["string", "Buffer"], path, );}
function getDirents(path, { 0: names, 1: types }, callback) { let i; if (typeof callback === "function") { const len = names.length; let toFinish = 0; callback = once(callback); for (i = 0; i < len; i++) { const type = types[i]; if (type === UV_DIRENT_UNKNOWN) { const name = names[i]; const idx = i; toFinish++; let filepath; try { filepath = join(path, name); } catch (err) { callback(err); return; } lstat(filepath, (err, stats) => { if (err) { callback(err); return; } names[idx] = new DirentFromStats(name, stats); if (--toFinish === 0) { callback(null, names); } }); } else { names[i] = new Dirent(names[i], types[i]); } } if (toFinish === 0) { callback(null, names); } } else { const len = names.length; for (i = 0; i < len; i++) { names[i] = getDirent(path, names[i], types[i]); } return names; }}
function getDirent(path, name, type, callback) { if (typeof callback === "function") { if (type === UV_DIRENT_UNKNOWN) { let filepath; try { filepath = join(path, name); } catch (err) { callback(err); return; } lstat(filepath, (err, stats) => { if (err) { callback(err); return; } callback(null, new DirentFromStats(name, stats)); }); } else { callback(null, new Dirent(name, type)); } } else if (type === UV_DIRENT_UNKNOWN) { const stats = lstatSync(join(path, name)); return new DirentFromStats(name, stats); } else { return new Dirent(name, type); }}
export function getOptions(options, defaultOptions) { if ( options === null || options === undefined || typeof options === "function" ) { return defaultOptions; }
if (typeof options === "string") { defaultOptions = { ...defaultOptions }; defaultOptions.encoding = options; options = defaultOptions; } else if (typeof options !== "object") { throw new ERR_INVALID_ARG_TYPE("options", ["string", "Object"], options); }
if (options.encoding !== "buffer") { assertEncoding(options.encoding); }
if (options.signal !== undefined) { validateAbortSignal(options.signal, "options.signal"); } return options;}
/** * @param {InternalFSBinding.FSSyncContext} ctx */function handleErrorFromBinding(ctx) { if (ctx.errno !== undefined) { // libuv error numbers const err = uvException(ctx); Error.captureStackTrace(err, handleErrorFromBinding); throw err; } if (ctx.error !== undefined) { // Errors created in C++ land. // TODO(joyeecheung): currently, ctx.error are encoding errors // usually caused by memory problems. We need to figure out proper error // code(s) for this. Error.captureStackTrace(ctx.error, handleErrorFromBinding); throw ctx.error; }}
// Check if the path contains null types if it is a string nor Uint8Array,// otherwise return silently.const nullCheck = hideStackFrames((path, propName, throwError = true) => { const pathIsString = typeof path === "string"; const pathIsUint8Array = isUint8Array(path);
// We can only perform meaningful checks on strings and Uint8Arrays. if ( (!pathIsString && !pathIsUint8Array) || (pathIsString && !path.includes("\u0000")) || (pathIsUint8Array && !path.includes(0)) ) { return; }
const err = new ERR_INVALID_ARG_VALUE( propName, path, "must be a string or Uint8Array without null bytes", ); if (throwError) { throw err; } return err;});
function preprocessSymlinkDestination(path, type, linkPath) { if (!isWindows) { // No preprocessing is needed on Unix. return path; } path = "" + path; if (type === "junction") { // Junctions paths need to be absolute and \\?\-prefixed. // A relative target is relative to the link's parent directory. path = pathModule.resolve(linkPath, "..", path); return pathModule.toNamespacedPath(path); } if (pathModule.isAbsolute(path)) { // If the path is absolute, use the \\?\-prefix to enable long filenames return pathModule.toNamespacedPath(path); } // Windows symlinks don't tolerate forward slashes. return path.replace(/\//g, "\\");}
// Constructor for file stats.function StatsBase( dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks,) { this.dev = dev; this.mode = mode; this.nlink = nlink; this.uid = uid; this.gid = gid; this.rdev = rdev; this.blksize = blksize; this.ino = ino; this.size = size; this.blocks = blocks;}
StatsBase.prototype.isDirectory = function () { return this._checkModeProperty(S_IFDIR);};
StatsBase.prototype.isFile = function () { return this._checkModeProperty(S_IFREG);};
StatsBase.prototype.isBlockDevice = function () { return this._checkModeProperty(S_IFBLK);};
StatsBase.prototype.isCharacterDevice = function () { return this._checkModeProperty(S_IFCHR);};
StatsBase.prototype.isSymbolicLink = function () { return this._checkModeProperty(S_IFLNK);};
StatsBase.prototype.isFIFO = function () { return this._checkModeProperty(S_IFIFO);};
StatsBase.prototype.isSocket = function () { return this._checkModeProperty(S_IFSOCK);};
const kNsPerMsBigInt = 10n ** 6n;const kNsPerSecBigInt = 10n ** 9n;const kMsPerSec = 10 ** 3;const kNsPerMs = 10 ** 6;function msFromTimeSpec(sec, nsec) { return sec * kMsPerSec + nsec / kNsPerMs;}
function nsFromTimeSpecBigInt(sec, nsec) { return sec * kNsPerSecBigInt + nsec;}
// The Date constructor performs Math.floor() to the timestamp.// https://www.ecma-international.org/ecma-262/#sec-timeclip// Since there may be a precision loss when the timestamp is// converted to a floating point number, we manually round// the timestamp here before passing it to Date().// Refs: https://github.com/nodejs/node/pull/12607function dateFromMs(ms) { return new Date(Number(ms) + 0.5);}
function BigIntStats( dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeNs, mtimeNs, ctimeNs, birthtimeNs,) { Reflect.apply(StatsBase, this, [ dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, ]);
this.atimeMs = atimeNs / kNsPerMsBigInt; this.mtimeMs = mtimeNs / kNsPerMsBigInt; this.ctimeMs = ctimeNs / kNsPerMsBigInt; this.birthtimeMs = birthtimeNs / kNsPerMsBigInt; this.atimeNs = atimeNs; this.mtimeNs = mtimeNs; this.ctimeNs = ctimeNs; this.birthtimeNs = birthtimeNs; this.atime = dateFromMs(this.atimeMs); this.mtime = dateFromMs(this.mtimeMs); this.ctime = dateFromMs(this.ctimeMs); this.birthtime = dateFromMs(this.birthtimeMs);}
Object.setPrototypeOf(BigIntStats.prototype, StatsBase.prototype);Object.setPrototypeOf(BigIntStats, StatsBase);
BigIntStats.prototype._checkModeProperty = function (property) { if ( isWindows && (property === S_IFIFO || property === S_IFBLK || property === S_IFSOCK) ) { return false; // Some types are not available on Windows } return (this.mode & BigInt(S_IFMT)) === BigInt(property);};
export function Stats( dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs,) { StatsBase.call( this, dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, ); this.atimeMs = atimeMs; this.mtimeMs = mtimeMs; this.ctimeMs = ctimeMs; this.birthtimeMs = birthtimeMs; this.atime = dateFromMs(atimeMs); this.mtime = dateFromMs(mtimeMs); this.ctime = dateFromMs(ctimeMs); this.birthtime = dateFromMs(birthtimeMs);}
Object.setPrototypeOf(Stats.prototype, StatsBase.prototype);Object.setPrototypeOf(Stats, StatsBase);
// HACK: Workaround for https://github.com/standard-things/esm/issues/821.// TODO(ronag): Remove this as soon as `esm` publishes a fixed version.Stats.prototype.isFile = StatsBase.prototype.isFile;
Stats.prototype._checkModeProperty = function (property) { if ( isWindows && (property === S_IFIFO || property === S_IFBLK || property === S_IFSOCK) ) { return false; // Some types are not available on Windows } return (this.mode & S_IFMT) === property;};
/** * @param {Float64Array | BigUint64Array} stats * @param {number} offset * @returns */function getStatsFromBinding(stats, offset = 0) { if (isBigUint64Array(stats)) { return new BigIntStats( stats[0 + offset], stats[1 + offset], stats[2 + offset], stats[3 + offset], stats[4 + offset], stats[5 + offset], stats[6 + offset], stats[7 + offset], stats[8 + offset], stats[9 + offset], nsFromTimeSpecBigInt(stats[10 + offset], stats[11 + offset]), nsFromTimeSpecBigInt(stats[12 + offset], stats[13 + offset]), nsFromTimeSpecBigInt(stats[14 + offset], stats[15 + offset]), nsFromTimeSpecBigInt(stats[16 + offset], stats[17 + offset]), ); } return new Stats( stats[0 + offset], stats[1 + offset], stats[2 + offset], stats[3 + offset], stats[4 + offset], stats[5 + offset], stats[6 + offset], stats[7 + offset], stats[8 + offset], stats[9 + offset], msFromTimeSpec(stats[10 + offset], stats[11 + offset]), msFromTimeSpec(stats[12 + offset], stats[13 + offset]), msFromTimeSpec(stats[14 + offset], stats[15 + offset]), msFromTimeSpec(stats[16 + offset], stats[17 + offset]), );}
function stringToFlags(flags, name = "flags") { if (typeof flags === "number") { validateInt32(flags, name); return flags; }
if (flags == null) { return O_RDONLY; }
switch (flags) { case "r": return O_RDONLY; case "rs": // Fall through. case "sr": return O_RDONLY | O_SYNC; case "r+": return O_RDWR; case "rs+": // Fall through. case "sr+": return O_RDWR | O_SYNC;
case "w": return O_TRUNC | O_CREAT | O_WRONLY; case "wx": // Fall through. case "xw": return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
case "w+": return O_TRUNC | O_CREAT | O_RDWR; case "wx+": // Fall through. case "xw+": return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
case "a": return O_APPEND | O_CREAT | O_WRONLY; case "ax": // Fall through. case "xa": return O_APPEND | O_CREAT | O_WRONLY | O_EXCL; case "as": // Fall through. case "sa": return O_APPEND | O_CREAT | O_WRONLY | O_SYNC;
case "a+": return O_APPEND | O_CREAT | O_RDWR; case "ax+": // Fall through. case "xa+": return O_APPEND | O_CREAT | O_RDWR | O_EXCL; case "as+": // Fall through. case "sa+": return O_APPEND | O_CREAT | O_RDWR | O_SYNC; }
throw new ERR_INVALID_ARG_VALUE("flags", flags);}
const stringToSymlinkType = hideStackFrames((type) => { let flags = 0; if (typeof type === "string") { switch (type) { case "dir": flags |= UV_FS_SYMLINK_DIR; break; case "junction": flags |= UV_FS_SYMLINK_JUNCTION; break; case "file": break; default: throw new ERR_FS_INVALID_SYMLINK_TYPE(type); } } return flags;});
// converts Date or number to a fractional UNIX timestampfunction toUnixTimestamp(time, name = "time") { // eslint-disable-next-line eqeqeq if (typeof time === "string" && +time == time) { return +time; } if (Number.isFinite(time)) { if (time < 0) { return Date.now() / 1000; } return time; } if (isDate(time)) { // Convert to 123.456 UNIX timestamp return Date.getTime(time) / 1000; } throw new ERR_INVALID_ARG_TYPE(name, ["Date", "Time in seconds"], time);}
export const validateOffsetLengthRead = hideStackFrames( (offset, length, bufferLength) => { if (offset < 0) { throw new ERR_OUT_OF_RANGE("offset", ">= 0", offset); } if (length < 0) { throw new ERR_OUT_OF_RANGE("length", ">= 0", length); } if (offset + length > bufferLength) { throw new ERR_OUT_OF_RANGE( "length", `<= ${bufferLength - offset}`, length, ); } },);
export const validateOffsetLengthWrite = hideStackFrames( (offset, length, byteLength) => { if (offset > byteLength) { throw new ERR_OUT_OF_RANGE("offset", `<= ${byteLength}`, offset); }
if (length > byteLength - offset) { throw new ERR_OUT_OF_RANGE("length", `<= ${byteLength - offset}`, length); }
if (length < 0) { throw new ERR_OUT_OF_RANGE("length", ">= 0", length); }
validateInt32(length, "length", 0); },);
const validatePath = hideStackFrames((path, propName = "path") => { if (typeof path !== "string" && !isUint8Array(path)) { throw new ERR_INVALID_ARG_TYPE(propName, ["string", "Buffer", "URL"], path); }
const err = nullCheck(path, propName, false);
if (err !== undefined) { throw err; }});
export const getValidatedPath = hideStackFrames( (fileURLOrPath, propName = "path") => { const path = toPathIfFileURL(fileURLOrPath); validatePath(path, propName); return path; },);
export const getValidatedFd = hideStackFrames((fd, propName = "fd") => { if (Object.is(fd, -0)) { return 0; }
validateInt32(fd, propName, 0);
return fd;});
export const validateBufferArray = hideStackFrames( (buffers, propName = "buffers") => { if (!Array.isArray(buffers)) { throw new ERR_INVALID_ARG_TYPE(propName, "ArrayBufferView[]", buffers); }
for (let i = 0; i < buffers.length; i++) { if (!isArrayBufferView(buffers[i])) { throw new ERR_INVALID_ARG_TYPE(propName, "ArrayBufferView[]", buffers); } }
return buffers; },);
let nonPortableTemplateWarn = true;
function warnOnNonPortableTemplate(template) { // Template strings passed to the mkdtemp() family of functions should not // end with 'X' because they are handled inconsistently across platforms. if (nonPortableTemplateWarn && template.endsWith("X")) { process.emitWarning( "mkdtemp() templates ending with X are not portable. " + "For details see: https://nodejs.org/api/fs.html", ); nonPortableTemplateWarn = false; }}
const defaultCpOptions = { dereference: false, errorOnExist: false, filter: undefined, force: true, preserveTimestamps: false, recursive: false,};
const defaultRmOptions = { recursive: false, force: false, retryDelay: 100, maxRetries: 0,};
const defaultRmdirOptions = { retryDelay: 100, maxRetries: 0, recursive: false,};
const validateCpOptions = hideStackFrames((options) => { if (options === undefined) { return { ...defaultCpOptions }; } validateObject(options, "options"); options = { ...defaultCpOptions, ...options }; validateBoolean(options.dereference, "options.dereference"); validateBoolean(options.errorOnExist, "options.errorOnExist"); validateBoolean(options.force, "options.force"); validateBoolean(options.preserveTimestamps, "options.preserveTimestamps"); validateBoolean(options.recursive, "options.recursive"); if (options.filter !== undefined) { validateFunction(options.filter, "options.filter"); } return options;});
export const validateRmOptions = hideStackFrames( (path, options, expectDir, cb) => { options = validateRmdirOptions(options, defaultRmOptions); validateBoolean(options.force, "options.force");
stat(path, (err, stats) => { if (err) { if (options.force && err.code === "ENOENT") { return cb(null, options); } return cb(err, options); }
if (expectDir && !stats.isDirectory()) { return cb(false); }
if (stats.isDirectory() && !options.recursive) { return cb( new ERR_FS_EISDIR({ code: "EISDIR", message: "is a directory", path, syscall: "rm", errno: EISDIR, }), ); } return cb(null, options); }); },);
export const validateRmOptionsSync = hideStackFrames( (path, options, expectDir) => { options = validateRmdirOptions(options, defaultRmOptions); validateBoolean(options.force, "options.force");
if (!options.force || expectDir || !options.recursive) { const isDirectory = statSync(path, { throwIfNoEntry: !options.force }) ?.isDirectory();
if (expectDir && !isDirectory) { return false; }
if (isDirectory && !options.recursive) { throw new ERR_FS_EISDIR({ code: "EISDIR", message: "is a directory", path, syscall: "rm", errno: EISDIR, }); } }
return options; },);
let recursiveRmdirWarned = process.noDeprecation;export function emitRecursiveRmdirWarning() { if (!recursiveRmdirWarned) { process.emitWarning( "In future versions of Node.js, fs.rmdir(path, { recursive: true }) " + "will be removed. Use fs.rm(path, { recursive: true }) instead", "DeprecationWarning", "DEP0147", ); recursiveRmdirWarned = true; }}
export const validateRmdirOptions = hideStackFrames( (options, defaults = defaultRmdirOptions) => { if (options === undefined) { return defaults; } validateObject(options, "options");
options = { ...defaults, ...options };
validateBoolean(options.recursive, "options.recursive"); validateInt32(options.retryDelay, "options.retryDelay", 0); validateUint32(options.maxRetries, "options.maxRetries");
return options; },);
export const getValidMode = hideStackFrames((mode, type) => { let min = kMinimumAccessMode; let max = kMaximumAccessMode; let def = F_OK; if (type === "copyFile") { min = kMinimumCopyMode; max = kMaximumCopyMode; def = mode || kDefaultCopyMode; } else { assert(type === "access"); } if (mode == null) { return def; } if (Number.isInteger(mode) && mode >= min && mode <= max) { return mode; } if (typeof mode !== "number") { throw new ERR_INVALID_ARG_TYPE("mode", "integer", mode); } throw new ERR_OUT_OF_RANGE( "mode", `an integer >= ${min} && <= ${max}`, mode, );});
export const validateStringAfterArrayBufferView = hideStackFrames( (buffer, name) => { if (typeof buffer === "string") { return; }
if ( typeof buffer === "object" && buffer !== null && typeof buffer.toString === "function" && Object.prototype.hasOwnProperty.call(buffer, "toString") ) { return; }
throw new ERR_INVALID_ARG_TYPE( name, ["string", "Buffer", "TypedArray", "DataView"], buffer, ); },);
const validatePosition = hideStackFrames((position) => { if (typeof position === "number") { validateInteger(position, "position"); } else if (typeof position === "bigint") { if (!(position >= -(2n ** 63n) && position <= 2n ** 63n - 1n)) { throw new ERR_OUT_OF_RANGE( "position", `>= ${-(2n ** 63n)} && <= ${2n ** 63n - 1n}`, position, ); } } else { throw new ERR_INVALID_ARG_TYPE("position", ["integer", "bigint"], position); }});
export default { constants: { kIoMaxLength, kMaxUserId, kReadFileBufferLength, kReadFileUnknownBufferLength, kWriteFileMaxChunkSize, }, assertEncoding, BigIntStats, // for testing copyObject, Dirent, emitRecursiveRmdirWarning, getDirent, getDirents, getOptions, getValidatedFd, getValidatedPath, getValidMode, handleErrorFromBinding, nullCheck, preprocessSymlinkDestination, realpathCacheKey: Symbol("realpathCacheKey"), getStatsFromBinding, stringToFlags, stringToSymlinkType, Stats, toUnixTimestamp, validateBufferArray, validateCpOptions, validateOffsetLengthRead, validateOffsetLengthWrite, validatePath, validatePosition, validateRmOptions, validateRmOptionsSync, validateRmdirOptions, validateStringAfterArrayBufferView, warnOnNonPortableTemplate,};