const {

ArrayBufferPrototypeGetByteLength,

ArrayFrom,

ArrayIsArray,

ArrayPrototypePush,

ArrayPrototypeSlice,

ArrayPrototypeSort,

Error,

ErrorCaptureStackTrace,

FunctionPrototypeCall,

ObjectDefineProperties,

ObjectDefineProperty,

ObjectGetOwnPropertyDescriptor,

ObjectGetOwnPropertyDescriptors,

ObjectGetPrototypeOf,

ObjectFreeze,

ObjectPrototypeHasOwnProperty,

ObjectSetPrototypeOf,

ObjectValues,

Promise,

ReflectApply,

ReflectConstruct,

RegExpPrototypeExec,

RegExpPrototypeGetDotAll,

RegExpPrototypeGetGlobal,

RegExpPrototypeGetHasIndices,

RegExpPrototypeGetIgnoreCase,

RegExpPrototypeGetMultiline,

RegExpPrototypeGetSticky,

RegExpPrototypeGetUnicode,

RegExpPrototypeGetSource,

SafeMap,

SafeSet,

SafeWeakMap,

SafeWeakRef,

StringPrototypeReplace,

StringPrototypeToLowerCase,

StringPrototypeToUpperCase,

Symbol,

SymbolFor,

SymbolReplace,

SymbolSplit,

} = primordials;

const {

codes: {

ERR_NO_CRYPTO,

ERR_UNKNOWN_SIGNAL,

},

isErrorStackTraceLimitWritable,

uvErrmapGet,

overrideStackTrace,

} = require('internal/errors');

const { signals } = internalBinding('constants').os;

const {

isArrayBufferDetached: _isArrayBufferDetached,

guessHandleType: _guessHandleType,

privateSymbols: {

arrow_message_private_symbol,

decorated_private_symbol,

},

sleep: _sleep,

} = internalBinding('util');

const { isNativeError, isPromise } = internalBinding('types');

const { getOptionValue } = require('internal/options');

const noCrypto = !process.versions.openssl;

const experimentalWarnings = new SafeSet();

const colorRegExp = /\u001b\[\d\d?m/g; // eslint-disable-line no-control-regex

let uvBinding;

function lazyUv() {

uvBinding ??= internalBinding('uv');

return uvBinding;

function removeColors(str) {

return StringPrototypeReplace(str, colorRegExp, '');

function isError(e) {

const codesWarned = new SafeSet();

let validateString;

function getDeprecationWarningEmitter(

function isPendingDeprecation() {

return getOptionValue('--pending-deprecation') &&

!getOptionValue('--no-deprecation');

function pendingDeprecate(fn, msg, code) {

function deprecate(fn, msg, code, useEmitSync) {

function decorateErrorStack(err) {

function assertCrypto() {

if (noCrypto)

throw new ERR_NO_CRYPTO();

function normalizeEncoding(enc) {

if (enc == null || enc === 'utf8' || enc === 'utf-8') return 'utf8';

return slowCases(enc);

function slowCases(enc) {

function emitExperimentalWarning(feature) {

function filterDuplicateStrings(items, low) {

function cachedResult(fn) {

function createClassWrapper(type) {

let signalsToNamesMapping;

function getSignalsToNamesMapping() {

function convertToValidSignal(signal) {

function getConstructorOf(obj) {

let cachedURL;

let cachedCWD;

function getCWDURL() {

function getSystemErrorName(err) {

const entry = uvErrmapGet(err);

return entry ? entry[0] : `Unknown system error ${err}`;

function getSystemErrorMap() {

return lazyUv().getErrorMap();

const kCustomPromisifiedSymbol = SymbolFor('nodejs.util.promisify.custom');

const kCustomPromisifyArgsSymbol = Symbol('customPromisifyArgs');

let validateFunction;

function promisify(original) {

promisify.custom = kCustomPromisifiedSymbol;

function join(output, separator) {

function spliceOne(list, index) {

const kNodeModulesRE = /^(.*)[\\/]node_modules[\\/]/;

let getStructuredStack;

function isInsideNodeModules() {

function once(callback) {

let validateUint32;

function sleep(msec) {

function createDeferredPromise() {

function defineOperation(target, name, method) {

function exposeInterface(target, name, interfaceObject) {

function exposeNamespace(target, name, namespaceObject) {

function exposeGetterAndSetter(target, name, getter, setter = undefined) {

function defineLazyProperties(target, id, keys, enumerable = true) {

function defineReplaceableLazyAttribute(target, id, keys, writable = true, check) {

function exposeLazyInterfaces(target, id, keys) {

defineLazyProperties(target, id, keys, false);

let _DOMException;

const lazyDOMExceptionClass = () => {

_DOMException ??= internalBinding('messaging').DOMException;

return _DOMException;

const lazyDOMException = (message, name) => {

const kEnumerableProperty = { __proto__: null };

kEnumerableProperty.enumerable = true;

const kEmptyObject = ObjectFreeze({ __proto__: null });

function filterOwnProperties(source, keys) {

function setOwnProperty(obj, key, value) {

let internalGlobal;

function getInternalGlobal() {

function SideEffectFreeRegExpPrototypeExec(regex, string) {

const { RegExp: RegExpFromAnotherRealm } = getInternalGlobal();

return FunctionPrototypeCall(RegExpFromAnotherRealm.prototype.exec, regex, string);

const crossRelmRegexes = new SafeWeakMap();

function getCrossRelmRegex(regex) {

function SideEffectFreeRegExpPrototypeSymbolReplace(regex, string, replacement) {

return getCrossRelmRegex(regex)[SymbolReplace](string, replacement);

function SideEffectFreeRegExpPrototypeSymbolSplit(regex, string, limit = undefined) {

return getCrossRelmRegex(regex)[SymbolSplit](string, limit);

function isArrayBufferDetached(value) {

function getLazy(initializer) {

function setupCoverageHooks(dir) {

const handleTypes = ['TCP', 'TTY', 'UDP', 'FILE', 'PIPE', 'UNKNOWN'];

function guessHandleType(fd) {

const type = _guessHandleType(fd);

return handleTypes[type];

class WeakReference {

module.exports = {

getLazy,

assertCrypto,

cachedResult,

convertToValidSignal,

createClassWrapper,

createDeferredPromise,

decorateErrorStack,

defineOperation,

defineLazyProperties,

defineReplaceableLazyAttribute,

deprecate,

emitExperimentalWarning,

exposeInterface,

exposeLazyInterfaces,

exposeNamespace,

exposeGetterAndSetter,

filterDuplicateStrings,

filterOwnProperties,

getConstructorOf,

getCWDURL,

getInternalGlobal,

getSystemErrorMap,

getSystemErrorName,

guessHandleType,

isArrayBufferDetached,

isError,

isInsideNodeModules,

join,

lazyDOMException,

lazyDOMExceptionClass,

normalizeEncoding,

once,

promisify,

SideEffectFreeRegExpPrototypeExec,

SideEffectFreeRegExpPrototypeSymbolReplace,

SideEffectFreeRegExpPrototypeSymbolSplit,

sleep,

spliceOne,

setupCoverageHooks,

removeColors,

// Symbol used to customize promisify conversion

customPromisifyArgs: kCustomPromisifyArgsSymbol,

// Symbol used to provide a custom inspect function for an object as an

// alternative to using 'inspect'

customInspectSymbol: SymbolFor('nodejs.util.inspect.custom'),

// Used by the buffer module to capture an internal reference to the

// default isEncoding implementation, just in case userland overrides it.

kIsEncodingSymbol: Symbol('kIsEncodingSymbol'),

kVmBreakFirstLineSymbol: Symbol('kVmBreakFirstLineSymbol'),

kEmptyObject,

kEnumerableProperty,

setOwnProperty,

pendingDeprecate,

WeakReference,