'use strict'; const { Array, ArrayIsArray, BigIntPrototypeValueOf, BooleanPrototypeValueOf, DatePrototypeGetTime, DatePrototypeToISOString, DatePrototypeToString, ErrorPrototypeToString, JSONStringify, MapPrototypeEntries, MathFloor, MathMax, MathMin, MathRound, MathSqrt, Number, NumberIsNaN, NumberPrototypeValueOf, ObjectAssign, ObjectCreate, ObjectDefineProperties, ObjectDefineProperty, ObjectGetOwnPropertyDescriptor, ObjectGetOwnPropertyDescriptors, ObjectGetOwnPropertyNames, ObjectGetOwnPropertySymbols, ObjectGetPrototypeOf, ObjectIs, ObjectKeys, ObjectPrototypeHasOwnProperty, ObjectPrototypePropertyIsEnumerable, ObjectSeal, RegExpPrototypeToString, SetPrototypeValues, StringPrototypeValueOf, SymbolPrototypeToString, SymbolPrototypeValueOf, SymbolIterator, SymbolToStringTag, uncurryThis, } = primordials; const { getOwnNonIndexProperties, getPromiseDetails, getProxyDetails, kPending, kRejected, previewEntries, getConstructorName: internalGetConstructorName, propertyFilter: { ALL_PROPERTIES, ONLY_ENUMERABLE } } = internalBinding('util'); const { customInspectSymbol, isError, join, removeColors } = require('internal/util'); const { codes: { ERR_INVALID_ARG_TYPE }, isStackOverflowError } = require('internal/errors'); const { isAsyncFunction, isGeneratorFunction, isAnyArrayBuffer, isArrayBuffer, isArgumentsObject, isBoxedPrimitive, isDataView, isExternal, isMap, isMapIterator, isModuleNamespaceObject, isNativeError, isPromise, isSet, isSetIterator, isWeakMap, isWeakSet, isRegExp, isDate, isTypedArray, isStringObject, isNumberObject, isBooleanObject, isBigIntObject, isUint8Array, isUint8ClampedArray, isUint16Array, isUint32Array, isInt8Array, isInt16Array, isInt32Array, isFloat32Array, isFloat64Array, isBigInt64Array, isBigUint64Array } = require('internal/util/types'); const assert = require('internal/assert'); const { NativeModule } = require('internal/bootstrap/loaders'); let hexSlice; const builtInObjects = new Set( ObjectGetOwnPropertyNames(global).filter((e) => /^([A-Z][a-z]+)+$/.test(e)) ); // These options must stay in sync with `getUserOptions`. So if any option will // be added or removed, `getUserOptions` must also be updated accordingly. const inspectDefaultOptions = ObjectSeal({ showHidden: false, depth: 2, colors: false, customInspect: true, showProxy: false, maxArrayLength: 100, breakLength: 80, compact: 3, sorted: false, getters: false }); const kObjectType = 0; const kArrayType = 1; const kArrayExtrasType = 2; /* eslint-disable no-control-regex */ const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c\x7f-\x9f]/; const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c\x7f-\x9f]/g; const strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c\x7f-\x9f]/; const strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]/g; /* eslint-enable no-control-regex */ const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/; const numberRegExp = /^(0|[1-9][0-9]*)$/; const coreModuleRegExp = /^ at (?:[^/\\(]+ \(|)((? 1) { // Legacy... if (arguments.length > 2) { if (arguments[2] !== undefined) { ctx.depth = arguments[2]; } if (arguments.length > 3 && arguments[3] !== undefined) { ctx.colors = arguments[3]; } } // Set user-specified options if (typeof opts === 'boolean') { ctx.showHidden = opts; } else if (opts) { const optKeys = ObjectKeys(opts); for (const key of optKeys) { // TODO(BridgeAR): Find a solution what to do about stylize. Either make // this function public or add a new API with a similar or better // functionality. if ( ObjectPrototypeHasOwnProperty(inspectDefaultOptions, key) || key === 'stylize') { ctx[key] = opts[key]; } else if (ctx.userOptions === undefined) { // This is required to pass through the actual user input. ctx.userOptions = opts; } } } } if (ctx.colors) ctx.stylize = stylizeWithColor; if (ctx.maxArrayLength === null) ctx.maxArrayLength = Infinity; return formatValue(ctx, value, 0); } inspect.custom = customInspectSymbol; ObjectDefineProperty(inspect, 'defaultOptions', { get() { return inspectDefaultOptions; }, set(options) { if (options === null || typeof options !== 'object') { throw new ERR_INVALID_ARG_TYPE('options', 'Object', options); } return ObjectAssign(inspectDefaultOptions, options); } }); // Set Graphics Rendition http://en.wikipedia.org/wiki/ANSI_escape_code#graphics // Each color consists of an array with the color code as first entry and the // reset code as second entry. const defaultFG = 39; const defaultBG = 49; inspect.colors = ObjectAssign(ObjectCreate(null), { reset: [0, 0], bold: [1, 22], dim: [2, 22], // Alias: faint italic: [3, 23], underline: [4, 24], blink: [5, 25], // Swap forground and background colors inverse: [7, 27], // Alias: swapcolors, swapColors hidden: [8, 28], // Alias: conceal strikethrough: [9, 29], // Alias: strikeThrough, crossedout, crossedOut doubleunderline: [21, 24], // Alias: doubleUnderline black: [30, defaultFG], red: [31, defaultFG], green: [32, defaultFG], yellow: [33, defaultFG], blue: [34, defaultFG], magenta: [35, defaultFG], cyan: [36, defaultFG], white: [37, defaultFG], bgBlack: [40, defaultBG], bgRed: [41, defaultBG], bgGreen: [42, defaultBG], bgYellow: [43, defaultBG], bgBlue: [44, defaultBG], bgMagenta: [45, defaultBG], bgCyan: [46, defaultBG], bgWhite: [47, defaultBG], framed: [51, 54], overlined: [53, 55], gray: [90, defaultFG], // Alias: grey, blackBright redBright: [91, defaultFG], greenBright: [92, defaultFG], yellowBright: [93, defaultFG], blueBright: [94, defaultFG], magentaBright: [95, defaultFG], cyanBright: [96, defaultFG], whiteBright: [97, defaultFG], bgGray: [100, defaultBG], // Alias: bgGrey, bgBlackBright bgRedBright: [101, defaultBG], bgGreenBright: [102, defaultBG], bgYellowBright: [103, defaultBG], bgBlueBright: [104, defaultBG], bgMagentaBright: [105, defaultBG], bgCyanBright: [106, defaultBG], bgWhiteBright: [107, defaultBG], }); function defineColorAlias(target, alias) { ObjectDefineProperty(inspect.colors, alias, { get() { return this[target]; }, set(value) { this[target] = value; }, configurable: true, enumerable: false }); } defineColorAlias('gray', 'grey'); defineColorAlias('gray', 'blackBright'); defineColorAlias('bgGray', 'bgGrey'); defineColorAlias('bgGray', 'bgBlackBright'); defineColorAlias('dim', 'faint'); defineColorAlias('strikethrough', 'crossedout'); defineColorAlias('strikethrough', 'strikeThrough'); defineColorAlias('strikethrough', 'crossedOut'); defineColorAlias('hidden', 'conceal'); defineColorAlias('inverse', 'swapColors'); defineColorAlias('inverse', 'swapcolors'); defineColorAlias('doubleunderline', 'doubleUnderline'); // TODO(BridgeAR): Add function style support for more complex styles. // Don't use 'blue' not visible on cmd.exe inspect.styles = ObjectAssign(ObjectCreate(null), { special: 'cyan', number: 'yellow', bigint: 'yellow', boolean: 'yellow', undefined: 'grey', null: 'bold', string: 'green', symbol: 'green', date: 'magenta', // "name": intentionally not styling // TODO(BridgeAR): Highlight regular expressions properly. regexp: 'red', module: 'underline' }); function addQuotes(str, quotes) { if (quotes === -1) { return `"${str}"`; } if (quotes === -2) { return `\`${str}\``; } return `'${str}'`; } const escapeFn = (str) => meta[str.charCodeAt(0)]; // Escape control characters, single quotes and the backslash. // This is similar to JSON stringify escaping. function strEscape(str) { let escapeTest = strEscapeSequencesRegExp; let escapeReplace = strEscapeSequencesReplacer; let singleQuote = 39; // Check for double quotes. If not present, do not escape single quotes and // instead wrap the text in double quotes. If double quotes exist, check for // backticks. If they do not exist, use those as fallback instead of the // double quotes. if (str.includes("'")) { // This invalidates the charCode and therefore can not be matched for // anymore. if (!str.includes('"')) { singleQuote = -1; } else if (!str.includes('`') && !str.includes('${')) { singleQuote = -2; } if (singleQuote !== 39) { escapeTest = strEscapeSequencesRegExpSingle; escapeReplace = strEscapeSequencesReplacerSingle; } } // Some magic numbers that worked out fine while benchmarking with v8 6.0 if (str.length < 5000 && !escapeTest.test(str)) return addQuotes(str, singleQuote); if (str.length > 100) { str = str.replace(escapeReplace, escapeFn); return addQuotes(str, singleQuote); } let result = ''; let last = 0; const lastIndex = str.length; for (let i = 0; i < lastIndex; i++) { const point = str.charCodeAt(i); if (point === singleQuote || point === 92 || point < 32 || (point > 126 && point < 160)) { if (last === i) { result += meta[point]; } else { result += `${str.slice(last, i)}${meta[point]}`; } last = i + 1; } } if (last !== lastIndex) { result += str.slice(last); } return addQuotes(result, singleQuote); } function stylizeWithColor(str, styleType) { const style = inspect.styles[styleType]; if (style !== undefined) { const color = inspect.colors[style]; return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`; } return str; } function stylizeNoColor(str) { return str; } // Return a new empty array to push in the results of the default formatter. function getEmptyFormatArray() { return []; } function getConstructorName(obj, ctx, recurseTimes) { let firstProto; const tmp = obj; while (obj) { const descriptor = ObjectGetOwnPropertyDescriptor(obj, 'constructor'); if (descriptor !== undefined && typeof descriptor.value === 'function' && descriptor.value.name !== '') { return descriptor.value.name; } obj = ObjectGetPrototypeOf(obj); if (firstProto === undefined) { firstProto = obj; } } if (firstProto === null) { return null; } const res = internalGetConstructorName(tmp); if (recurseTimes > ctx.depth && ctx.depth !== null) { return `${res} `; } const protoConstr = getConstructorName(firstProto, ctx, recurseTimes + 1); if (protoConstr === null) { return `${res} <${inspect(firstProto, { ...ctx, customInspect: false, depth: -1 })}>`; } return `${res} <${protoConstr}>`; } function getPrefix(constructor, tag, fallback) { if (constructor === null) { if (tag !== '') { return `[${fallback}: null prototype] [${tag}] `; } return `[${fallback}: null prototype] `; } if (tag !== '' && constructor !== tag) { return `${constructor} [${tag}] `; } return `${constructor} `; } // Look up the keys of the object. function getKeys(value, showHidden) { let keys; const symbols = ObjectGetOwnPropertySymbols(value); if (showHidden) { keys = ObjectGetOwnPropertyNames(value); if (symbols.length !== 0) keys.push(...symbols); } else { // This might throw if `value` is a Module Namespace Object from an // unevaluated module, but we don't want to perform the actual type // check because it's expensive. // TODO(devsnek): track https://github.com/tc39/ecma262/issues/1209 // and modify this logic as needed. try { keys = ObjectKeys(value); } catch (err) { assert(isNativeError(err) && err.name === 'ReferenceError' && isModuleNamespaceObject(value)); keys = ObjectGetOwnPropertyNames(value); } if (symbols.length !== 0) { const filter = (key) => ObjectPrototypePropertyIsEnumerable(value, key); keys.push(...symbols.filter(filter)); } } return keys; } function getCtxStyle(value, constructor, tag) { let fallback = ''; if (constructor === null) { fallback = internalGetConstructorName(value); if (fallback === tag) { fallback = 'Object'; } } return getPrefix(constructor, tag, fallback); } function formatProxy(ctx, proxy, recurseTimes) { if (recurseTimes > ctx.depth && ctx.depth !== null) { return ctx.stylize('Proxy [Array]', 'special'); } recurseTimes += 1; ctx.indentationLvl += 2; const res = [ formatValue(ctx, proxy[0], recurseTimes), formatValue(ctx, proxy[1], recurseTimes) ]; ctx.indentationLvl -= 2; return reduceToSingleString( ctx, res, '', ['Proxy [', ']'], kArrayExtrasType, recurseTimes); } function findTypedConstructor(value) { for (const [check, clazz] of [ [isUint8Array, Uint8Array], [isUint8ClampedArray, Uint8ClampedArray], [isUint16Array, Uint16Array], [isUint32Array, Uint32Array], [isInt8Array, Int8Array], [isInt16Array, Int16Array], [isInt32Array, Int32Array], [isFloat32Array, Float32Array], [isFloat64Array, Float64Array], [isBigInt64Array, BigInt64Array], [isBigUint64Array, BigUint64Array] ]) { if (check(value)) { return clazz; } } } let lazyNullPrototypeCache; // Creates a subclass and name // the constructor as `${clazz} : null prototype` function clazzWithNullPrototype(clazz, name) { if (lazyNullPrototypeCache === undefined) { lazyNullPrototypeCache = new Map(); } else { const cachedClass = lazyNullPrototypeCache.get(clazz); if (cachedClass !== undefined) { return cachedClass; } } class NullPrototype extends clazz { get [SymbolToStringTag]() { return ''; } } ObjectDefineProperty(NullPrototype.prototype.constructor, 'name', { value: `[${name}: null prototype]` }); lazyNullPrototypeCache.set(clazz, NullPrototype); return NullPrototype; } function noPrototypeIterator(ctx, value, recurseTimes) { let newVal; if (isSet(value)) { const clazz = clazzWithNullPrototype(Set, 'Set'); newVal = new clazz(SetPrototypeValues(value)); } else if (isMap(value)) { const clazz = clazzWithNullPrototype(Map, 'Map'); newVal = new clazz(MapPrototypeEntries(value)); } else if (ArrayIsArray(value)) { const clazz = clazzWithNullPrototype(Array, 'Array'); newVal = new clazz(value.length); } else if (isTypedArray(value)) { const constructor = findTypedConstructor(value); const clazz = clazzWithNullPrototype(constructor, constructor.name); newVal = new clazz(value); } if (newVal !== undefined) { ObjectDefineProperties(newVal, ObjectGetOwnPropertyDescriptors(value)); return formatRaw(ctx, newVal, recurseTimes); } } // Note: using `formatValue` directly requires the indentation level to be // corrected by setting `ctx.indentationLvL += diff` and then to decrease the // value afterwards again. function formatValue(ctx, value, recurseTimes, typedArray) { // Primitive types cannot have properties. if (typeof value !== 'object' && typeof value !== 'function') { return formatPrimitive(ctx.stylize, value, ctx); } if (value === null) { return ctx.stylize('null', 'null'); } // Memorize the context for custom inspection on proxies. const context = value; // Always check for proxies to prevent side effects and to prevent triggering // any proxy handlers. const proxy = getProxyDetails(value); if (proxy !== undefined) { if (ctx.showProxy) { return formatProxy(ctx, proxy, recurseTimes); } value = proxy[0]; } // Provide a hook for user-specified inspect functions. // Check that value is an object with an inspect function on it. if (ctx.customInspect) { const maybeCustom = value[customInspectSymbol]; if (typeof maybeCustom === 'function' && // Filter out the util module, its inspect function is special. maybeCustom !== inspect && // Also filter out any prototype objects using the circular check. !(value.constructor && value.constructor.prototype === value)) { // This makes sure the recurseTimes are reported as before while using // a counter internally. const depth = ctx.depth === null ? null : ctx.depth - recurseTimes; const ret = maybeCustom.call(context, depth, getUserOptions(ctx)); // If the custom inspection method returned `this`, don't go into // infinite recursion. if (ret !== context) { if (typeof ret !== 'string') { return formatValue(ctx, ret, recurseTimes); } return ret.replace(/\n/g, `\n${' '.repeat(ctx.indentationLvl)}`); } } } // Using an array here is actually better for the average case than using // a Set. `seen` will only check for the depth and will never grow too large. if (ctx.seen.includes(value)) { let index = 1; if (ctx.circular === undefined) { ctx.circular = new Map([[value, index]]); } else { index = ctx.circular.get(value); if (index === undefined) { index = ctx.circular.size + 1; ctx.circular.set(value, index); } } return ctx.stylize(`[Circular *${index}]`, 'special'); } return formatRaw(ctx, value, recurseTimes, typedArray); } function formatRaw(ctx, value, recurseTimes, typedArray) { let keys; const constructor = getConstructorName(value, ctx, recurseTimes); let tag = value[SymbolToStringTag]; // Only list the tag in case it's non-enumerable / not an own property. // Otherwise we'd print this twice. if (typeof tag !== 'string' || (tag !== '' && (ctx.showHidden ? ObjectPrototypeHasOwnProperty : ObjectPrototypePropertyIsEnumerable)( value, SymbolToStringTag ))) { tag = ''; } let base = ''; let formatter = getEmptyFormatArray; let braces; let noIterator = true; let i = 0; const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE; let extrasType = kObjectType; // Iterators and the rest are split to reduce checks. if (value[SymbolIterator]) { noIterator = false; if (ArrayIsArray(value)) { keys = getOwnNonIndexProperties(value, filter); // Only set the constructor for non ordinary ("Array [...]") arrays. const prefix = getPrefix(constructor, tag, 'Array'); braces = [`${prefix === 'Array ' ? '' : prefix}[`, ']']; if (value.length === 0 && keys.length === 0) return `${braces[0]}]`; extrasType = kArrayExtrasType; formatter = formatArray; } else if (isSet(value)) { keys = getKeys(value, ctx.showHidden); const prefix = getPrefix(constructor, tag, 'Set'); if (value.size === 0 && keys.length === 0) return `${prefix}{}`; braces = [`${prefix}{`, '}']; formatter = formatSet; } else if (isMap(value)) { keys = getKeys(value, ctx.showHidden); const prefix = getPrefix(constructor, tag, 'Map'); if (value.size === 0 && keys.length === 0) return `${prefix}{}`; braces = [`${prefix}{`, '}']; formatter = formatMap; } else if (isTypedArray(value)) { keys = getOwnNonIndexProperties(value, filter); const prefix = constructor !== null ? getPrefix(constructor, tag) : getPrefix(constructor, tag, findTypedConstructor(value).name); braces = [`${prefix}[`, ']']; if (value.length === 0 && keys.length === 0 && !ctx.showHidden) return `${braces[0]}]`; formatter = formatTypedArray; extrasType = kArrayExtrasType; } else if (isMapIterator(value)) { keys = getKeys(value, ctx.showHidden); braces = getIteratorBraces('Map', tag); formatter = formatIterator; } else if (isSetIterator(value)) { keys = getKeys(value, ctx.showHidden); braces = getIteratorBraces('Set', tag); formatter = formatIterator; } else { noIterator = true; } } if (noIterator) { keys = getKeys(value, ctx.showHidden); braces = ['{', '}']; if (constructor === 'Object') { if (isArgumentsObject(value)) { braces[0] = '[Arguments] {'; } else if (tag !== '') { braces[0] = `${getPrefix(constructor, tag, 'Object')}{`; } if (keys.length === 0) { return `${braces[0]}}`; } } else if (typeof value === 'function') { base = getFunctionBase(value, constructor, tag); if (keys.length === 0) return ctx.stylize(base, 'special'); } else if (isRegExp(value)) { // Make RegExps say that they are RegExps base = RegExpPrototypeToString( constructor !== null ? value : new RegExp(value) ); const prefix = getPrefix(constructor, tag, 'RegExp'); if (prefix !== 'RegExp ') base = `${prefix}${base}`; if (keys.length === 0 || (recurseTimes > ctx.depth && ctx.depth !== null)) return ctx.stylize(base, 'regexp'); } else if (isDate(value)) { // Make dates with properties first say the date base = NumberIsNaN(DatePrototypeGetTime(value)) ? DatePrototypeToString(value) : DatePrototypeToISOString(value); const prefix = getPrefix(constructor, tag, 'Date'); if (prefix !== 'Date ') base = `${prefix}${base}`; if (keys.length === 0) { return ctx.stylize(base, 'date'); } } else if (isError(value)) { base = formatError(value, constructor, tag, ctx); if (keys.length === 0) return base; } else if (isAnyArrayBuffer(value)) { // Fast path for ArrayBuffer and SharedArrayBuffer. // Can't do the same for DataView because it has a non-primitive // .buffer property that we need to recurse for. const arrayType = isArrayBuffer(value) ? 'ArrayBuffer' : 'SharedArrayBuffer'; const prefix = getPrefix(constructor, tag, arrayType); if (typedArray === undefined) { formatter = formatArrayBuffer; } else if (keys.length === 0) { return prefix + `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength)} }`; } braces[0] = `${prefix}{`; keys.unshift('byteLength'); } else if (isDataView(value)) { braces[0] = `${getPrefix(constructor, tag, 'DataView')}{`; // .buffer goes last, it's not a primitive like the others. keys.unshift('byteLength', 'byteOffset', 'buffer'); } else if (isPromise(value)) { braces[0] = `${getPrefix(constructor, tag, 'Promise')}{`; formatter = formatPromise; } else if (isWeakSet(value)) { braces[0] = `${getPrefix(constructor, tag, 'WeakSet')}{`; formatter = ctx.showHidden ? formatWeakSet : formatWeakCollection; } else if (isWeakMap(value)) { braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`; formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection; } else if (isModuleNamespaceObject(value)) { braces[0] = `[${tag}] {`; formatter = formatNamespaceObject; } else if (isBoxedPrimitive(value)) { base = getBoxedBase(value, ctx, keys, constructor, tag); if (keys.length === 0) { return base; } } else { // The input prototype got manipulated. Special handle these. We have to // rebuild the information so we are able to display everything. if (constructor === null) { const specialIterator = noPrototypeIterator(ctx, value, recurseTimes); if (specialIterator) { return specialIterator; } } if (isMapIterator(value)) { braces = getIteratorBraces('Map', tag); formatter = formatIterator; } else if (isSetIterator(value)) { braces = getIteratorBraces('Set', tag); formatter = formatIterator; // Handle other regular objects again. } else { if (keys.length === 0) { if (isExternal(value)) return ctx.stylize('[External]', 'special'); return `${getCtxStyle(value, constructor, tag)}{}`; } braces[0] = `${getCtxStyle(value, constructor, tag)}{`; } } } if (recurseTimes > ctx.depth && ctx.depth !== null) { let constructorName = getCtxStyle(value, constructor, tag).slice(0, -1); if (constructor !== null) constructorName = `[${constructorName}]`; return ctx.stylize(constructorName, 'special'); } recurseTimes += 1; ctx.seen.push(value); ctx.currentDepth = recurseTimes; let output; const indentationLvl = ctx.indentationLvl; try { output = formatter(ctx, value, recurseTimes, keys, braces); for (i = 0; i < keys.length; i++) { output.push( formatProperty(ctx, value, recurseTimes, keys[i], extrasType)); } } catch (err) { const constructorName = getCtxStyle(value, constructor, tag).slice(0, -1); return handleMaxCallStackSize(ctx, err, constructorName, indentationLvl); } if (ctx.circular !== undefined) { const index = ctx.circular.get(value); if (index !== undefined) { const reference = ctx.stylize(``, 'special'); // Add reference always to the very beginning of the output. if (ctx.compact !== true) { base = base === '' ? reference : `${reference} ${base}`; } else { braces[0] = `${reference} ${braces[0]}`; } } } ctx.seen.pop(); if (ctx.sorted) { const comparator = ctx.sorted === true ? undefined : ctx.sorted; if (extrasType === kObjectType) { output = output.sort(comparator); } else if (keys.length > 1) { const sorted = output.slice(output.length - keys.length).sort(comparator); output.splice(output.length - keys.length, keys.length, ...sorted); } } const res = reduceToSingleString( ctx, output, base, braces, extrasType, recurseTimes, value); const budget = ctx.budget[ctx.indentationLvl] || 0; const newLength = budget + res.length; ctx.budget[ctx.indentationLvl] = newLength; // If any indentationLvl exceeds this limit, limit further inspecting to the // minimum. Otherwise the recursive algorithm might continue inspecting the // object even though the maximum string size (~2 ** 28 on 32 bit systems and // ~2 ** 30 on 64 bit systems) exceeded. The actual output is not limited at // exactly 2 ** 27 but a bit higher. This depends on the object shape. // This limit also makes sure that huge objects don't block the event loop // significantly. if (newLength > 2 ** 27) { ctx.depth = -1; } return res; } function getIteratorBraces(type, tag) { if (tag !== `${type} Iterator`) { if (tag !== '') tag += '] ['; tag += `${type} Iterator`; } return [`[${tag}] {`, '}']; } function getBoxedBase(value, ctx, keys, constructor, tag) { let fn; let type; if (isNumberObject(value)) { fn = NumberPrototypeValueOf; type = 'Number'; } else if (isStringObject(value)) { fn = StringPrototypeValueOf; type = 'String'; // For boxed Strings, we have to remove the 0-n indexed entries, // since they just noisy up the output and are redundant // Make boxed primitive Strings look like such keys.splice(0, value.length); } else if (isBooleanObject(value)) { fn = BooleanPrototypeValueOf; type = 'Boolean'; } else if (isBigIntObject(value)) { fn = BigIntPrototypeValueOf; type = 'BigInt'; } else { fn = SymbolPrototypeValueOf; type = 'Symbol'; } let base = `[${type}`; if (type !== constructor) { if (constructor === null) { base += ' (null prototype)'; } else { base += ` (${constructor})`; } } base += `: ${formatPrimitive(stylizeNoColor, fn(value), ctx)}]`; if (tag !== '' && tag !== constructor) { base += ` [${tag}]`; } if (keys.length !== 0 || ctx.stylize === stylizeNoColor) return base; return ctx.stylize(base, type.toLowerCase()); } function getFunctionBase(value, constructor, tag) { let type = 'Function'; if (isGeneratorFunction(value)) { type = `Generator${type}`; } if (isAsyncFunction(value)) { type = `Async${type}`; } let base = `[${type}`; if (constructor === null) { base += ' (null prototype)'; } if (value.name === '') { base += ' (anonymous)'; } else { base += `: ${value.name}`; } base += ']'; if (constructor !== type && constructor !== null) { base += ` ${constructor}`; } if (tag !== '' && constructor !== tag) { base += ` [${tag}]`; } return base; } function formatError(err, constructor, tag, ctx) { const name = err.name != null ? String(err.name) : 'Error'; let len = name.length; let stack = err.stack ? String(err.stack) : ErrorPrototypeToString(err); // A stack trace may contain arbitrary data. Only manipulate the output // for "regular errors" (errors that "look normal") for now. if (constructor === null || (name.endsWith('Error') && stack.startsWith(name) && (stack.length === len || stack[len] === ':' || stack[len] === '\n'))) { let fallback = 'Error'; if (constructor === null) { const start = stack.match(/^([A-Z][a-z_ A-Z0-9[\]()-]+)(?::|\n {4}at)/) || stack.match(/^([a-z_A-Z0-9-]*Error)$/); fallback = (start && start[1]) || ''; len = fallback.length; fallback = fallback || 'Error'; } const prefix = getPrefix(constructor, tag, fallback).slice(0, -1); if (name !== prefix) { if (prefix.includes(name)) { if (len === 0) { stack = `${prefix}: ${stack}`; } else { stack = `${prefix}${stack.slice(len)}`; } } else { stack = `${prefix} [${name}]${stack.slice(len)}`; } } } // Ignore the error message if it's contained in the stack. let pos = (err.message && stack.indexOf(err.message)) || -1; if (pos !== -1) pos += err.message.length; // Wrap the error in brackets in case it has no stack trace. const stackStart = stack.indexOf('\n at', pos); if (stackStart === -1) { stack = `[${stack}]`; } else if (ctx.colors) { // Highlight userland code and node modules. let newStack = stack.slice(0, stackStart); const lines = stack.slice(stackStart + 1).split('\n'); for (const line of lines) { const core = line.match(coreModuleRegExp); if (core !== null && NativeModule.exists(core[1])) { newStack += `\n${ctx.stylize(line, 'undefined')}`; } else { // This adds underscores to all node_modules to quickly identify them. let nodeModule; newStack += '\n'; let pos = 0; while (nodeModule = nodeModulesRegExp.exec(line)) { // '/node_modules/'.length === 14 newStack += line.slice(pos, nodeModule.index + 14); newStack += ctx.stylize(nodeModule[1], 'module'); pos = nodeModule.index + nodeModule[0].length; } newStack += pos === 0 ? line : line.slice(pos); } } stack = newStack; } // The message and the stack have to be indented as well! if (ctx.indentationLvl !== 0) { const indentation = ' '.repeat(ctx.indentationLvl); stack = stack.replace(/\n/g, `\n${indentation}`); } return stack; } function groupArrayElements(ctx, output, value) { let totalLength = 0; let maxLength = 0; let i = 0; let outputLength = output.length; if (ctx.maxArrayLength < output.length) { // This makes sure the "... n more items" part is not taken into account. outputLength--; } const separatorSpace = 2; // Add 1 for the space and 1 for the separator. const dataLen = new Array(outputLength); // Calculate the total length of all output entries and the individual max // entries length of all output entries. We have to remove colors first, // otherwise the length would not be calculated properly. for (; i < outputLength; i++) { const len = ctx.colors ? removeColors(output[i]).length : output[i].length; dataLen[i] = len; totalLength += len + separatorSpace; if (maxLength < len) maxLength = len; } // Add two to `maxLength` as we add a single whitespace character plus a comma // in-between two entries. const actualMax = maxLength + separatorSpace; // Check if at least three entries fit next to each other and prevent grouping // of arrays that contains entries of very different length (i.e., if a single // entry is longer than 1/5 of all other entries combined). Otherwise the // space in-between small entries would be enormous. if (actualMax * 3 + ctx.indentationLvl < ctx.breakLength && (totalLength / actualMax > 5 || maxLength <= 6)) { const approxCharHeights = 2.5; const averageBias = MathSqrt(actualMax - totalLength / output.length); const biasedMax = MathMax(actualMax - 3 - averageBias, 1); // Dynamically check how many columns seem possible. const columns = MathMin( // Ideally a square should be drawn. We expect a character to be about 2.5 // times as high as wide. This is the area formula to calculate a square // which contains n rectangles of size `actualMax * approxCharHeights`. // Divide that by `actualMax` to receive the correct number of columns. // The added bias increases the columns for short entries. MathRound( MathSqrt( approxCharHeights * biasedMax * outputLength ) / biasedMax ), // Do not exceed the breakLength. MathFloor((ctx.breakLength - ctx.indentationLvl) / actualMax), // Limit array grouping for small `compact` modes as the user requested // minimal grouping. ctx.compact * 4, // Limit the columns to a maximum of fifteen. 15 ); // Return with the original output if no grouping should happen. if (columns <= 1) { return output; } const tmp = []; const maxLineLength = []; for (let i = 0; i < columns; i++) { let lineMaxLength = 0; for (let j = i; j < output.length; j += columns) { if (dataLen[j] > lineMaxLength) lineMaxLength = dataLen[j]; } lineMaxLength += separatorSpace; maxLineLength[i] = lineMaxLength; } let order = 'padStart'; if (value !== undefined) { for (let i = 0; i < output.length; i++) { if (typeof value[i] !== 'number' && typeof value[i] !== 'bigint') { order = 'padEnd'; break; } } } // Each iteration creates a single line of grouped entries. for (let i = 0; i < outputLength; i += columns) { // The last lines may contain less entries than columns. const max = MathMin(i + columns, outputLength); let str = ''; let j = i; for (; j < max - 1; j++) { // Calculate extra color padding in case it's active. This has to be // done line by line as some lines might contain more colors than // others. const padding = maxLineLength[j - i] + output[j].length - dataLen[j]; str += `${output[j]}, `[order](padding, ' '); } if (order === 'padStart') { const padding = maxLineLength[j - i] + output[j].length - dataLen[j] - separatorSpace; str += output[j].padStart(padding, ' '); } else { str += output[j]; } tmp.push(str); } if (ctx.maxArrayLength < output.length) { tmp.push(output[outputLength]); } output = tmp; } return output; } function handleMaxCallStackSize(ctx, err, constructorName, indentationLvl) { if (isStackOverflowError(err)) { ctx.seen.pop(); ctx.indentationLvl = indentationLvl; return ctx.stylize( `[${constructorName}: Inspection interrupted ` + 'prematurely. Maximum call stack size exceeded.]', 'special' ); } throw err; } function formatNumber(fn, value) { // Format -0 as '-0'. Checking `value === -0` won't distinguish 0 from -0. return fn(ObjectIs(value, -0) ? '-0' : `${value}`, 'number'); } function formatBigInt(fn, value) { return fn(`${value}n`, 'bigint'); } function formatPrimitive(fn, value, ctx) { if (typeof value === 'string') { if (ctx.compact !== true && value.length > kMinLineLength && value.length > ctx.breakLength - ctx.indentationLvl - 4) { return value .split(/(?<=\n)/) .map((line) => fn(strEscape(line), 'string')) .join(` +\n${' '.repeat(ctx.indentationLvl + 2)}`); } return fn(strEscape(value), 'string'); } if (typeof value === 'number') return formatNumber(fn, value); if (typeof value === 'bigint') return formatBigInt(fn, value); if (typeof value === 'boolean') return fn(`${value}`, 'boolean'); if (typeof value === 'undefined') return fn('undefined', 'undefined'); // es6 symbol primitive return fn(SymbolPrototypeToString(value), 'symbol'); } function formatNamespaceObject(ctx, value, recurseTimes, keys) { const output = new Array(keys.length); for (let i = 0; i < keys.length; i++) { try { output[i] = formatProperty(ctx, value, recurseTimes, keys[i], kObjectType); } catch (err) { if (!(isNativeError(err) && err.name === 'ReferenceError')) { throw err; } // Use the existing functionality. This makes sure the indentation and // line breaks are always correct. Otherwise it is very difficult to keep // this aligned, even though this is a hacky way of dealing with this. const tmp = { [keys[i]]: '' }; output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i], kObjectType); const pos = output[i].lastIndexOf(' '); // We have to find the last whitespace and have to replace that value as // it will be visualized as a regular string. output[i] = output[i].slice(0, pos + 1) + ctx.stylize('', 'special'); } } // Reset the keys to an empty array. This prevents duplicated inspection. keys.length = 0; return output; } // The array is sparse and/or has extra keys function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) { const keys = ObjectKeys(value); let index = i; for (; i < keys.length && output.length < maxLength; i++) { const key = keys[i]; const tmp = +key; // Arrays can only have up to 2^32 - 1 entries if (tmp > 2 ** 32 - 2) { break; } if (`${index}` !== key) { if (!numberRegExp.test(key)) { break; } const emptyItems = tmp - index; const ending = emptyItems > 1 ? 's' : ''; const message = `<${emptyItems} empty item${ending}>`; output.push(ctx.stylize(message, 'undefined')); index = tmp; if (output.length === maxLength) { break; } } output.push(formatProperty(ctx, value, recurseTimes, key, kArrayType)); index++; } const remaining = value.length - index; if (output.length !== maxLength) { if (remaining > 0) { const ending = remaining > 1 ? 's' : ''; const message = `<${remaining} empty item${ending}>`; output.push(ctx.stylize(message, 'undefined')); } } else if (remaining > 0) { output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`); } return output; } function formatArrayBuffer(ctx, value) { let buffer; try { buffer = new Uint8Array(value); } catch { return [ctx.stylize('(detached)', 'special')]; } if (hexSlice === undefined) hexSlice = uncurryThis(require('buffer').Buffer.prototype.hexSlice); let str = hexSlice(buffer, 0, MathMin(ctx.maxArrayLength, buffer.length)) .replace(/(.{2})/g, '$1 ').trim(); const remaining = buffer.length - ctx.maxArrayLength; if (remaining > 0) str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`; return [`${ctx.stylize('[Uint8Contents]', 'special')}: <${str}>`]; } function formatArray(ctx, value, recurseTimes) { const valLen = value.length; const len = MathMin(MathMax(0, ctx.maxArrayLength), valLen); const remaining = valLen - len; const output = []; for (let i = 0; i < len; i++) { // Special handle sparse arrays. if (!ObjectPrototypeHasOwnProperty(value, i)) { return formatSpecialArray(ctx, value, recurseTimes, len, output, i); } output.push(formatProperty(ctx, value, recurseTimes, i, kArrayType)); } if (remaining > 0) output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`); return output; } function formatTypedArray(ctx, value, recurseTimes) { const maxLength = MathMin(MathMax(0, ctx.maxArrayLength), value.length); const remaining = value.length - maxLength; const output = new Array(maxLength); const elementFormatter = value.length > 0 && typeof value[0] === 'number' ? formatNumber : formatBigInt; for (let i = 0; i < maxLength; ++i) output[i] = elementFormatter(ctx.stylize, value[i]); if (remaining > 0) { output[maxLength] = `... ${remaining} more item${remaining > 1 ? 's' : ''}`; } if (ctx.showHidden) { // .buffer goes last, it's not a primitive like the others. ctx.indentationLvl += 2; for (const key of [ 'BYTES_PER_ELEMENT', 'length', 'byteLength', 'byteOffset', 'buffer' ]) { const str = formatValue(ctx, value[key], recurseTimes, true); output.push(`[${key}]: ${str}`); } ctx.indentationLvl -= 2; } return output; } function formatSet(ctx, value, recurseTimes) { const output = []; ctx.indentationLvl += 2; for (const v of value) { output.push(formatValue(ctx, v, recurseTimes)); } ctx.indentationLvl -= 2; // With `showHidden`, `length` will display as a hidden property for // arrays. For consistency's sake, do the same for `size`, even though this // property isn't selected by ObjectGetOwnPropertyNames(). if (ctx.showHidden) output.push(`[size]: ${ctx.stylize(`${value.size}`, 'number')}`); return output; } function formatMap(ctx, value, recurseTimes) { const output = []; ctx.indentationLvl += 2; for (const [k, v] of value) { output.push(`${formatValue(ctx, k, recurseTimes)} => ` + formatValue(ctx, v, recurseTimes)); } ctx.indentationLvl -= 2; // See comment in formatSet if (ctx.showHidden) output.push(`[size]: ${ctx.stylize(`${value.size}`, 'number')}`); return output; } function formatSetIterInner(ctx, recurseTimes, entries, state) { const maxArrayLength = MathMax(ctx.maxArrayLength, 0); const maxLength = MathMin(maxArrayLength, entries.length); let output = new Array(maxLength); ctx.indentationLvl += 2; for (let i = 0; i < maxLength; i++) { output[i] = formatValue(ctx, entries[i], recurseTimes); } ctx.indentationLvl -= 2; if (state === kWeak && !ctx.sorted) { // Sort all entries to have a halfway reliable output (if more entries than // retrieved ones exist, we can not reliably return the same output) if the // output is not sorted anyway. output = output.sort(); } const remaining = entries.length - maxLength; if (remaining > 0) { output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`); } return output; } function formatMapIterInner(ctx, recurseTimes, entries, state) { const maxArrayLength = MathMax(ctx.maxArrayLength, 0); // Entries exist as [key1, val1, key2, val2, ...] const len = entries.length / 2; const remaining = len - maxArrayLength; const maxLength = MathMin(maxArrayLength, len); let output = new Array(maxLength); let i = 0; ctx.indentationLvl += 2; if (state === kWeak) { for (; i < maxLength; i++) { const pos = i * 2; output[i] = `${formatValue(ctx, entries[pos], recurseTimes)}` + ` => ${formatValue(ctx, entries[pos + 1], recurseTimes)}`; } // Sort all entries to have a halfway reliable output (if more entries than // retrieved ones exist, we can not reliably return the same output) if the // output is not sorted anyway. if (!ctx.sorted) output = output.sort(); } else { for (; i < maxLength; i++) { const pos = i * 2; const res = [ formatValue(ctx, entries[pos], recurseTimes), formatValue(ctx, entries[pos + 1], recurseTimes) ]; output[i] = reduceToSingleString( ctx, res, '', ['[', ']'], kArrayExtrasType, recurseTimes); } } ctx.indentationLvl -= 2; if (remaining > 0) { output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`); } return output; } function formatWeakCollection(ctx) { return [ctx.stylize('', 'special')]; } function formatWeakSet(ctx, value, recurseTimes) { const entries = previewEntries(value); return formatSetIterInner(ctx, recurseTimes, entries, kWeak); } function formatWeakMap(ctx, value, recurseTimes) { const entries = previewEntries(value); return formatMapIterInner(ctx, recurseTimes, entries, kWeak); } function formatIterator(ctx, value, recurseTimes, keys, braces) { const [entries, isKeyValue] = previewEntries(value, true); if (isKeyValue) { // Mark entry iterators as such. braces[0] = braces[0].replace(/ Iterator] {$/, ' Entries] {'); return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries); } return formatSetIterInner(ctx, recurseTimes, entries, kIterator); } function formatPromise(ctx, value, recurseTimes) { let output; const [state, result] = getPromiseDetails(value); if (state === kPending) { output = [ctx.stylize('', 'special')]; } else { ctx.indentationLvl += 2; const str = formatValue(ctx, result, recurseTimes); ctx.indentationLvl -= 2; output = [ state === kRejected ? `${ctx.stylize('', 'special')} ${str}` : str ]; } return output; } function formatProperty(ctx, value, recurseTimes, key, type) { let name, str; let extra = ' '; const desc = ObjectGetOwnPropertyDescriptor(value, key) || { value: value[key], enumerable: true }; if (desc.value !== undefined) { const diff = (type !== kObjectType || ctx.compact !== true) ? 2 : 3; ctx.indentationLvl += diff; str = formatValue(ctx, desc.value, recurseTimes); if (diff === 3) { const len = ctx.colors ? removeColors(str).length : str.length; if (ctx.breakLength < len) { extra = `\n${' '.repeat(ctx.indentationLvl)}`; } } ctx.indentationLvl -= diff; } else if (desc.get !== undefined) { const label = desc.set !== undefined ? 'Getter/Setter' : 'Getter'; const s = ctx.stylize; const sp = 'special'; if (ctx.getters && (ctx.getters === true || (ctx.getters === 'get' && desc.set === undefined) || (ctx.getters === 'set' && desc.set !== undefined))) { try { const tmp = value[key]; ctx.indentationLvl += 2; if (tmp === null) { str = `${s(`[${label}:`, sp)} ${s('null', 'null')}${s(']', sp)}`; } else if (typeof tmp === 'object') { str = `${s(`[${label}]`, sp)} ${formatValue(ctx, tmp, recurseTimes)}`; } else { const primitive = formatPrimitive(s, tmp, ctx); str = `${s(`[${label}:`, sp)} ${primitive}${s(']', sp)}`; } ctx.indentationLvl -= 2; } catch (err) { const message = ``; str = `${s(`[${label}:`, sp)} ${message}${s(']', sp)}`; } } else { str = ctx.stylize(`[${label}]`, sp); } } else if (desc.set !== undefined) { str = ctx.stylize('[Setter]', 'special'); } else { str = ctx.stylize('undefined', 'undefined'); } if (type === kArrayType) { return str; } if (typeof key === 'symbol') { const tmp = key.toString().replace(strEscapeSequencesReplacer, escapeFn); name = `[${ctx.stylize(tmp, 'symbol')}]`; } else if (desc.enumerable === false) { name = `[${key.replace(strEscapeSequencesReplacer, escapeFn)}]`; } else if (keyStrRegExp.test(key)) { name = ctx.stylize(key, 'name'); } else { name = ctx.stylize(strEscape(key), 'string'); } return `${name}:${extra}${str}`; } function isBelowBreakLength(ctx, output, start, base) { // Each entry is separated by at least a comma. Thus, we start with a total // length of at least `output.length`. In addition, some cases have a // whitespace in-between each other that is added to the total as well. let totalLength = output.length + start; if (totalLength + output.length > ctx.breakLength) return false; for (let i = 0; i < output.length; i++) { if (ctx.colors) { totalLength += removeColors(output[i]).length; } else { totalLength += output[i].length; } if (totalLength > ctx.breakLength) { return false; } } // Do not line up properties on the same line if `base` contains line breaks. return base === '' || !base.includes('\n'); } function reduceToSingleString( ctx, output, base, braces, extrasType, recurseTimes, value) { if (ctx.compact !== true) { if (typeof ctx.compact === 'number' && ctx.compact >= 1) { // Memorize the original output length. In case the the output is grouped, // prevent lining up the entries on a single line. const entries = output.length; // Group array elements together if the array contains at least six // separate entries. if (extrasType === kArrayExtrasType && entries > 6) { output = groupArrayElements(ctx, output, value); } // `ctx.currentDepth` is set to the most inner depth of the currently // inspected object part while `recurseTimes` is the actual current depth // that is inspected. // // Example: // // const a = { first: [ 1, 2, 3 ], second: { inner: [ 1, 2, 3 ] } } // // The deepest depth of `a` is 2 (a.second.inner) and `a.first` has a max // depth of 1. // // Consolidate all entries of the local most inner depth up to // `ctx.compact`, as long as the properties are smaller than // `ctx.breakLength`. if (ctx.currentDepth - recurseTimes < ctx.compact && entries === output.length) { // Line up all entries on a single line in case the entries do not // exceed `breakLength`. Add 10 as constant to start next to all other // factors that may reduce `breakLength`. const start = output.length + ctx.indentationLvl + braces[0].length + base.length + 10; if (isBelowBreakLength(ctx, output, start, base)) { return `${base ? `${base} ` : ''}${braces[0]} ${join(output, ', ')}` + ` ${braces[1]}`; } } } // Line up each entry on an individual line. const indentation = `\n${' '.repeat(ctx.indentationLvl)}`; return `${base ? `${base} ` : ''}${braces[0]}${indentation} ` + `${join(output, `,${indentation} `)}${indentation}${braces[1]}`; } // Line up all entries on a single line in case the entries do not exceed // `breakLength`. if (isBelowBreakLength(ctx, output, 0, base)) { return `${braces[0]}${base ? ` ${base}` : ''} ${join(output, ', ')} ` + braces[1]; } const indentation = ' '.repeat(ctx.indentationLvl); // If the opening "brace" is too large, like in the case of "Set {", // we need to force the first item to be on the next line or the // items will not line up correctly. const ln = base === '' && braces[0].length === 1 ? ' ' : `${base ? ` ${base}` : ''}\n${indentation} `; // Line up each entry on an individual line. return `${braces[0]}${ln}${join(output, `,\n${indentation} `)} ${braces[1]}`; } function hasBuiltInToString(value) { // Count objects that have no `toString` function as built-in. if (typeof value.toString !== 'function') { return true; } // The object has a own `toString` property. Thus it's not not a built-in one. if (ObjectPrototypeHasOwnProperty(value, 'toString')) { return false; } // Find the object that has the `toString` property as own property in the // prototype chain. let pointer = value; do { pointer = ObjectGetPrototypeOf(pointer); } while (!ObjectPrototypeHasOwnProperty(pointer, 'toString')); // Check closer if the object is a built-in. const descriptor = ObjectGetOwnPropertyDescriptor(pointer, 'constructor'); return descriptor !== undefined && typeof descriptor.value === 'function' && builtInObjects.has(descriptor.value.name); } const firstErrorLine = (error) => error.message.split('\n')[0]; let CIRCULAR_ERROR_MESSAGE; function tryStringify(arg) { try { return JSONStringify(arg); } catch (err) { // Populate the circular error message lazily if (!CIRCULAR_ERROR_MESSAGE) { try { const a = {}; a.a = a; JSONStringify(a); } catch (err) { CIRCULAR_ERROR_MESSAGE = firstErrorLine(err); } } if (err.name === 'TypeError' && firstErrorLine(err) === CIRCULAR_ERROR_MESSAGE) { return '[Circular]'; } throw err; } } function format(...args) { return formatWithOptionsInternal(undefined, ...args); } function formatWithOptions(inspectOptions, ...args) { if (typeof inspectOptions !== 'object' || inspectOptions === null) { throw new ERR_INVALID_ARG_TYPE( 'inspectOptions', 'object', inspectOptions); } return formatWithOptionsInternal(inspectOptions, ...args); } function formatWithOptionsInternal(inspectOptions, ...args) { const first = args[0]; let a = 0; let str = ''; let join = ''; if (typeof first === 'string') { if (args.length === 1) { return first; } let tempStr; let lastPos = 0; for (let i = 0; i < first.length - 1; i++) { if (first.charCodeAt(i) === 37) { // '%' const nextChar = first.charCodeAt(++i); if (a + 1 !== args.length) { switch (nextChar) { case 115: // 's' const tempArg = args[++a]; if (typeof tempArg === 'number') { tempStr = formatNumber(stylizeNoColor, tempArg); } else if (typeof tempArg === 'bigint') { tempStr = `${tempArg}n`; } else if (typeof tempArg !== 'object' || tempArg === null || !hasBuiltInToString(tempArg)) { tempStr = String(tempArg); } else { tempStr = inspect(tempArg, { ...inspectOptions, compact: 3, colors: false, depth: 0 }); } break; case 106: // 'j' tempStr = tryStringify(args[++a]); break; case 100: // 'd' const tempNum = args[++a]; if (typeof tempNum === 'bigint') { tempStr = `${tempNum}n`; } else if (typeof tempNum === 'symbol') { tempStr = 'NaN'; } else { tempStr = formatNumber(stylizeNoColor, Number(tempNum)); } break; case 79: // 'O' tempStr = inspect(args[++a], inspectOptions); break; case 111: // 'o' tempStr = inspect(args[++a], { ...inspectOptions, showHidden: true, showProxy: true, depth: 4 }); break; case 105: // 'i' const tempInteger = args[++a]; if (typeof tempInteger === 'bigint') { tempStr = `${tempInteger}n`; } else if (typeof tempInteger === 'symbol') { tempStr = 'NaN'; } else { tempStr = formatNumber(stylizeNoColor, parseInt(tempInteger)); } break; case 102: // 'f' const tempFloat = args[++a]; if (typeof tempFloat === 'symbol') { tempStr = 'NaN'; } else { tempStr = formatNumber(stylizeNoColor, parseFloat(tempFloat)); } break; case 99: // 'c' a += 1; tempStr = ''; break; case 37: // '%' str += first.slice(lastPos, i); lastPos = i + 1; continue; default: // Any other character is not a correct placeholder continue; } if (lastPos !== i - 1) { str += first.slice(lastPos, i - 1); } str += tempStr; lastPos = i + 1; } else if (nextChar === 37) { str += first.slice(lastPos, i); lastPos = i + 1; } } } if (lastPos !== 0) { a++; join = ' '; if (lastPos < first.length) { str += first.slice(lastPos); } } } while (a < args.length) { const value = args[a]; str += join; str += typeof value !== 'string' ? inspect(value, inspectOptions) : value; join = ' '; a++; } return str; } module.exports = { inspect, format, formatWithOptions, inspectDefaultOptions };