Skip to main content
Module

std/node/internal/util/inspect.mjs

Deno standard library
Go to Latest
File
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.// 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.
import * as types from "./types.ts";import { validateObject, validateString } from "../validators.mjs";import { codes } from "../error_codes.ts";
import { ALL_PROPERTIES, getOwnNonIndexProperties, ONLY_ENUMERABLE,} from "../../internal_binding/util.ts";
const kObjectType = 0;const kArrayType = 1;const kArrayExtrasType = 2;
const kMinLineLength = 16;
// Constants to map the iterator state.const kWeak = 0;const kIterator = 1;const kMapEntries = 2;
const kPending = 0;const kRejected = 2;
// Escaped control characters (plus the single quote and the backslash). Use// empty strings to fill up unused entries.// deno-fmt-ignoreconst meta = [ '\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07 '\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F', // x0F '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17 '\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F '', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '', // x2F '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', // x3F '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', // x4F '', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '', // x5F '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', // x6F '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F', // x7F '\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87 '\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F '\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97 '\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F];
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slotconst isUndetectableObject = (v) => typeof v === "undefined" && v !== undefined;
// deno-lint-ignore no-control-regexconst strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c\x7f-\x9f]/;// deno-lint-ignore no-control-regexconst strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c\x7f-\x9f]/g;// deno-lint-ignore no-control-regexconst strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c\x7f-\x9f]/;// deno-lint-ignore no-control-regexconst strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]/g;
const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;const numberRegExp = /^(0|[1-9][0-9]*)$/;const nodeModulesRegExp = /[/\\]node_modules[/\\](.+?)(?=[/\\])/g;
const classRegExp = /^(\s+[^(]*?)\s*{/;// eslint-disable-next-line node-core/no-unescaped-regexp-dotconst stripCommentsRegExp = /(\/\/.*?\n)|(\/\*(.|\n)*?\*\/)/g;
const inspectDefaultOptions = { showHidden: false, depth: 2, colors: false, customInspect: true, showProxy: false, maxArrayLength: 100, maxStringLength: 10000, breakLength: 80, compact: 3, sorted: false, getters: false,};
function getUserOptions(ctx, isCrossContext) { const ret = { stylize: ctx.stylize, showHidden: ctx.showHidden, depth: ctx.depth, colors: ctx.colors, customInspect: ctx.customInspect, showProxy: ctx.showProxy, maxArrayLength: ctx.maxArrayLength, maxStringLength: ctx.maxStringLength, breakLength: ctx.breakLength, compact: ctx.compact, sorted: ctx.sorted, getters: ctx.getters, ...ctx.userOptions, };
// Typically, the target value will be an instance of `Object`. If that is // *not* the case, the object may come from another vm.Context, and we want // to avoid passing it objects from this Context in that case, so we remove // the prototype from the returned object itself + the `stylize()` function, // and remove all other non-primitives, including non-primitive user options. if (isCrossContext) { Object.setPrototypeOf(ret, null); for (const key of Object.keys(ret)) { if ( (typeof ret[key] === "object" || typeof ret[key] === "function") && ret[key] !== null ) { delete ret[key]; } } ret.stylize = Object.setPrototypeOf((value, flavour) => { let stylized; try { stylized = `${ctx.stylize(value, flavour)}`; } catch { // noop }
if (typeof stylized !== "string") return value; // `stylized` is a string as it should be, which is safe to pass along. return stylized; }, null); }
return ret;}
/** * Echos the value of any input. Tries to print the value out * in the best way possible given the different types. *//* Legacy: value, showHidden, depth, colors */export function inspect(value, opts) { // Default options const ctx = { budget: {}, indentationLvl: 0, seen: [], currentDepth: 0, stylize: stylizeNoColor, showHidden: inspectDefaultOptions.showHidden, depth: inspectDefaultOptions.depth, colors: inspectDefaultOptions.colors, customInspect: inspectDefaultOptions.customInspect, showProxy: inspectDefaultOptions.showProxy, maxArrayLength: inspectDefaultOptions.maxArrayLength, maxStringLength: inspectDefaultOptions.maxStringLength, breakLength: inspectDefaultOptions.breakLength, compact: inspectDefaultOptions.compact, sorted: inspectDefaultOptions.sorted, getters: inspectDefaultOptions.getters, }; if (arguments.length > 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 = Object.keys(opts); for (let i = 0; i < optKeys.length; ++i) { const key = optKeys[i]; // 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 ( // deno-lint-ignore no-prototype-builtins inspectDefaultOptions.hasOwnProperty(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; if (ctx.maxStringLength === null) ctx.maxStringLength = Infinity; return formatValue(ctx, value, 0);}const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");inspect.custom = customInspectSymbol;
Object.defineProperty(inspect, "defaultOptions", { get() { return inspectDefaultOptions; }, set(options) { validateObject(options, "options"); return Object.assign(inspectDefaultOptions, options); },});
// Set Graphics Rendition https://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 = Object.assign(Object.create(null), { reset: [0, 0], bold: [1, 22], dim: [2, 22], // Alias: faint italic: [3, 23], underline: [4, 24], blink: [5, 25], // Swap foreground 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) { Object.defineProperty(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.exeinspect.styles = Object.assign(Object.create(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}'`;}
// TODO(wafuwafu13): Figure outconst 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]; if (color !== undefined) { return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`; } } return str;}
function stylizeNoColor(str) { return str;}
// 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" && !isUndetectableObject(value) ) { 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. // TODO(wafuwafu13): Set Proxy const proxy = undefined; // const proxy = getProxyDetails(value, !!ctx.showProxy); // if (proxy !== undefined) { // if (ctx.showProxy) { // return formatProxy(ctx, proxy, recurseTimes); // } // value = proxy; // }
// 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 isCrossContext = proxy !== undefined || !(context instanceof Object); const ret = maybeCustom.call( context, depth, getUserOptions(ctx, isCrossContext), ); // 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(); ctx.circular.set(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; let protoProps; if (ctx.showHidden && (recurseTimes <= ctx.depth || ctx.depth === null)) { protoProps = []; }
const constructor = getConstructorName(value, ctx, recurseTimes, protoProps); // Reset the variable to check for this later on. if (protoProps !== undefined && protoProps.length === 0) { protoProps = undefined; }
let tag = value[Symbol.toStringTag]; // Only list the tag in case it's non-enumerable / not an own property. // Otherwise we'd print this twice. if ( typeof tag !== "string" // TODO(wafuwafu13): Implement // (tag !== "" && // (ctx.showHidden // ? Object.prototype.hasOwnProperty // : Object.prototype.propertyIsEnumerable)( // value, // Symbol.toStringTag, // )) ) { 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. // We have to check all values in case the constructor is set to null. // Otherwise it would not possible to identify all types properly. if (value[Symbol.iterator] || constructor === null) { noIterator = false; if (Array.isArray(value)) { // Only set the constructor for non ordinary ("Array [...]") arrays. const prefix = (constructor !== "Array" || tag !== "") ? getPrefix(constructor, tag, "Array", `(${value.length})`) : ""; keys = getOwnNonIndexProperties(value, filter); braces = [`${prefix}[`, "]"]; if (value.length === 0 && keys.length === 0 && protoProps === undefined) { return `${braces[0]}]`; } extrasType = kArrayExtrasType; formatter = formatArray; } else if (types.isSet(value)) { const size = value.size; const prefix = getPrefix(constructor, tag, "Set", `(${size})`); keys = getKeys(value, ctx.showHidden); formatter = constructor !== null ? formatSet.bind(null, value) : formatSet.bind(null, value.values()); if (size === 0 && keys.length === 0 && protoProps === undefined) { return `${prefix}{}`; } braces = [`${prefix}{`, "}"]; } else if (types.isMap(value)) { const size = value.size; const prefix = getPrefix(constructor, tag, "Map", `(${size})`); keys = getKeys(value, ctx.showHidden); formatter = constructor !== null ? formatMap.bind(null, value) : formatMap.bind(null, value.entries()); if (size === 0 && keys.length === 0 && protoProps === undefined) { return `${prefix}{}`; } braces = [`${prefix}{`, "}"]; } else if (types.isTypedArray(value)) { keys = getOwnNonIndexProperties(value, filter); const bound = value; const fallback = ""; if (constructor === null) { // TODO(wafuwafu13): Implement // fallback = TypedArrayPrototypeGetSymbolToStringTag(value); // // Reconstruct the array information. // bound = new primordials[fallback](value); } const size = value.length; const prefix = getPrefix(constructor, tag, fallback, `(${size})`); braces = [`${prefix}[`, "]"]; if (value.length === 0 && keys.length === 0 && !ctx.showHidden) { return `${braces[0]}]`; } // Special handle the value. The original value is required below. The // bound function is required to reconstruct missing information. (formatter) = formatTypedArray.bind(null, bound, size); extrasType = kArrayExtrasType; } else if (types.isMapIterator(value)) { keys = getKeys(value, ctx.showHidden); braces = getIteratorBraces("Map", tag); // Add braces to the formatter parameters. (formatter) = formatIterator.bind(null, braces); } else if (types.isSetIterator(value)) { keys = getKeys(value, ctx.showHidden); braces = getIteratorBraces("Set", tag); // Add braces to the formatter parameters. (formatter) = formatIterator.bind(null, braces); } else { noIterator = true; } } if (noIterator) { keys = getKeys(value, ctx.showHidden); braces = ["{", "}"]; if (constructor === "Object") { if (types.isArgumentsObject(value)) { braces[0] = "[Arguments] {"; } else if (tag !== "") { braces[0] = `${getPrefix(constructor, tag, "Object")}{`; } if (keys.length === 0 && protoProps === undefined) { return `${braces[0]}}`; } } else if (typeof value === "function") { base = getFunctionBase(value, constructor, tag); if (keys.length === 0 && protoProps === undefined) { return ctx.stylize(base, "special"); } } else if (types.isRegExp(value)) { // Make RegExps say that they are RegExps base = RegExp(constructor !== null ? value : new RegExp(value)) .toString(); const prefix = getPrefix(constructor, tag, "RegExp"); if (prefix !== "RegExp ") { base = `${prefix}${base}`; } if ( (keys.length === 0 && protoProps === undefined) || (recurseTimes > ctx.depth && ctx.depth !== null) ) { return ctx.stylize(base, "regexp"); } } else if (types.isDate(value)) { // Make dates with properties first say the date base = Number.isNaN(value.getTime()) ? value.toString() : value.toISOString(); const prefix = getPrefix(constructor, tag, "Date"); if (prefix !== "Date ") { base = `${prefix}${base}`; } if (keys.length === 0 && protoProps === undefined) { return ctx.stylize(base, "date"); } } else if (value instanceof Error) { base = formatError(value, constructor, tag, ctx, keys); if (keys.length === 0 && protoProps === undefined) { return base; } } else if (types.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 = types.isArrayBuffer(value) ? "ArrayBuffer" : "SharedArrayBuffer"; const prefix = getPrefix(constructor, tag, arrayType); if (typedArray === undefined) { (formatter) = formatArrayBuffer; } else if (keys.length === 0 && protoProps === undefined) { return prefix + `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength)} }`; } braces[0] = `${prefix}{`; Array.prototype.unshift.call(keys, "byteLength"); } else if (types.isDataView(value)) { braces[0] = `${getPrefix(constructor, tag, "DataView")}{`; // .buffer goes last, it's not a primitive like the others. Array.prototype.unshift.call(keys, "byteLength", "byteOffset", "buffer"); } else if (types.isPromise(value)) { braces[0] = `${getPrefix(constructor, tag, "Promise")}{`; (formatter) = formatPromise; } else if (types.isWeakSet(value)) { braces[0] = `${getPrefix(constructor, tag, "WeakSet")}{`; (formatter) = ctx.showHidden ? formatWeakSet : formatWeakCollection; } else if (types.isWeakMap(value)) { braces[0] = `${getPrefix(constructor, tag, "WeakMap")}{`; (formatter) = ctx.showHidden ? formatWeakMap : formatWeakCollection; } else if (types.isModuleNamespaceObject(value)) { braces[0] = `${getPrefix(constructor, tag, "Module")}{`; // Special handle keys for namespace objects. (formatter) = formatNamespaceObject.bind(null, keys); } else if (types.isBoxedPrimitive(value)) { base = getBoxedBase(value, ctx, keys, constructor, tag); if (keys.length === 0 && protoProps === undefined) { return base; } } else { if (keys.length === 0 && protoProps === undefined) { // TODO(wafuwafu13): Implement // if (types.isExternal(value)) { // const address = getExternalValue(value).toString(16); // return ctx.stylize(`[External: ${address}]`, '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); for (i = 0; i < keys.length; i++) { output.push( formatProperty(ctx, value, recurseTimes, keys[i], extrasType), ); } if (protoProps !== undefined) { output.push(...protoProps); } } 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(`<ref *${index}>`, "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;}
const builtInObjects = new Set( Object.getOwnPropertyNames(globalThis).filter((e) => /^[A-Z][a-zA-Z0-9]+$/.test(e) ),);
function addPrototypeProperties( ctx, main, obj, recurseTimes, output,) { let depth = 0; let keys; let keySet; do { if (depth !== 0 || main === obj) { obj = Object.getPrototypeOf(obj); // Stop as soon as a null prototype is encountered. if (obj === null) { return; } // Stop as soon as a built-in object type is detected. const descriptor = Object.getOwnPropertyDescriptor(obj, "constructor"); if ( descriptor !== undefined && typeof descriptor.value === "function" && builtInObjects.has(descriptor.value.name) ) { return; } }
if (depth === 0) { keySet = new Set(); } else { Array.prototype.forEach.call(keys, (key) => keySet.add(key)); } // Get all own property names and symbols. keys = Reflect.ownKeys(obj); Array.prototype.push.call(ctx.seen, main); for (const key of keys) { // Ignore the `constructor` property and keys that exist on layers above. if ( key === "constructor" || // deno-lint-ignore no-prototype-builtins main.hasOwnProperty(key) || (depth !== 0 && keySet.has(key)) ) { continue; } const desc = Object.getOwnPropertyDescriptor(obj, key); if (typeof desc.value === "function") { continue; } const value = formatProperty( ctx, obj, recurseTimes, key, kObjectType, desc, main, ); if (ctx.colors) { // Faint! Array.prototype.push.call(output, `\u001b[2m${value}\u001b[22m`); } else { Array.prototype.push.call(output, value); } } Array.prototype.pop.call(ctx.seen); // Limit the inspection to up to three prototype layers. Using `recurseTimes` // is not a good choice here, because it's as if the properties are declared // on the current object from the users perspective. } while (++depth !== 3);}
function getConstructorName( obj, ctx, recurseTimes, protoProps,) { let firstProto; const tmp = obj; while (obj || isUndetectableObject(obj)) { const descriptor = Object.getOwnPropertyDescriptor(obj, "constructor"); if ( descriptor !== undefined && typeof descriptor.value === "function" && descriptor.value.name !== "" && isInstanceof(tmp, descriptor.value) ) { if ( protoProps !== undefined && (firstProto !== obj || !builtInObjects.has(descriptor.value.name)) ) { addPrototypeProperties( ctx, tmp, firstProto || tmp, recurseTimes, protoProps, ); } return descriptor.value.name; }
obj = Object.getPrototypeOf(obj); if (firstProto === undefined) { firstProto = obj; } }
if (firstProto === null) { return null; }
// TODO(wafuwafu13): Implement // const res = internalGetConstructorName(tmp); const res = undefined;
if (recurseTimes > ctx.depth && ctx.depth !== null) { return `${res} <Complex prototype>`; }
const protoConstr = getConstructorName( firstProto, ctx, recurseTimes + 1, protoProps, );
if (protoConstr === null) { return `${res} <${ inspect(firstProto, { ...ctx, customInspect: false, depth: -1, }) }>`; }
return `${res} <${protoConstr}>`;}
function formatPrimitive(fn, value, ctx) { if (typeof value === "string") { let trailer = ""; if (value.length > ctx.maxStringLength) { const remaining = value.length - ctx.maxStringLength; value = value.slice(0, ctx.maxStringLength); trailer = `... ${remaining} more character${remaining > 1 ? "s" : ""}`; } if ( ctx.compact !== true && // TODO(BridgeAR): Add unicode support. Use the readline getStringWidth // function. 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)}`) + trailer; } return fn(strEscape(value), "string") + trailer; } 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(value.toString(), "symbol");}
// Return a new empty array to push in the results of the default formatter.function getEmptyFormatArray() { return [];}
function isInstanceof(object, proto) { try { return object instanceof proto; } catch { return false; }}
function getPrefix(constructor, tag, fallback, size = "") { if (constructor === null) { if (tag !== "" && fallback !== tag) { return `[${fallback}${size}: null prototype] [${tag}] `; } return `[${fallback}${size}: null prototype] `; }
if (tag !== "" && constructor !== tag) { return `${constructor}${size} [${tag}] `; } return `${constructor}${size} `;}
function formatArray(ctx, value, recurseTimes) { const valLen = value.length; const len = Math.min(Math.max(0, ctx.maxArrayLength), valLen);
const remaining = valLen - len; const output = []; for (let i = 0; i < len; i++) { // Special handle sparse arrays. // deno-lint-ignore no-prototype-builtins if (!value.hasOwnProperty(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 getCtxStyle(_value, constructor, tag) { let fallback = ""; if (constructor === null) { // TODO(wafuwafu13): Implement // fallback = internalGetConstructorName(value); if (fallback === tag) { fallback = "Object"; } } return getPrefix(constructor, tag, fallback);}
// Look up the keys of the object.function getKeys(value, showHidden) { let keys; const symbols = Object.getOwnPropertySymbols(value); if (showHidden) { keys = Object.getOwnPropertyNames(value); if (symbols.length !== 0) { Array.prototype.push.apply(keys, 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 = Object.keys(value); } catch (_err) { // TODO(wafuwafu13): Implement // assert(isNativeError(err) && err.name === 'ReferenceError' && // isModuleNamespaceObject(value)); keys = Object.getOwnPropertyNames(value); } if (symbols.length !== 0) { // TODO(wafuwafu13): Implement // const filter = (key: any) => // // Object.prototype.propertyIsEnumerable(value, key); // Array.prototype.push.apply( // keys, // symbols.filter(filter), // ); } } return keys;}
function formatSet(value, ctx, _ignored, recurseTimes) { const output = []; ctx.indentationLvl += 2; for (const v of value) { Array.prototype.push.call(output, formatValue(ctx, v, recurseTimes)); } ctx.indentationLvl -= 2; return output;}
function formatMap(value, ctx, _gnored, recurseTimes) { const output = []; ctx.indentationLvl += 2; for (const { 0: k, 1: v } of value) { output.push( `${formatValue(ctx, k, recurseTimes)} => ${ formatValue(ctx, v, recurseTimes) }`, ); } ctx.indentationLvl -= 2; return output;}
function formatTypedArray( value, length, ctx, _ignored, recurseTimes,) { const maxLength = Math.min(Math.max(0, ctx.maxArrayLength), 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. // All besides `BYTES_PER_ELEMENT` are actually getters. ctx.indentationLvl += 2; for ( const key of [ "BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset", "buffer", ] ) { const str = formatValue(ctx, value[key], recurseTimes, true); Array.prototype.push.call(output, `[${key}]: ${str}`); } ctx.indentationLvl -= 2; } return output;}
function getIteratorBraces(type, tag) { if (tag !== `${type} Iterator`) { if (tag !== "") { tag += "] ["; } tag += `${type} Iterator`; } return [`[${tag}] {`, "}"];}
function formatIterator(braces, ctx, value, recurseTimes) { // TODO(wafuwafu13): Implement // const { 0: entries, 1: isKeyValue } = previewEntries(value, true); const { 0: entries, 1: isKeyValue } = value; 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 getFunctionBase(value, constructor, tag) { const stringified = Function.prototype.toString.call(value); if (stringified.slice(0, 5) === "class" && stringified.endsWith("}")) { const slice = stringified.slice(5, -1); const bracketIndex = slice.indexOf("{"); if ( bracketIndex !== -1 && (!slice.slice(0, bracketIndex).includes("(") || // Slow path to guarantee that it's indeed a class. classRegExp.test(slice.replace(stripCommentsRegExp))) ) { return getClassBase(value, constructor, tag); } } let type = "Function"; if (types.isGeneratorFunction(value)) { type = `Generator${type}`; } if (types.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, keys,) { const name = err.name != null ? String(err.name) : "Error"; let len = name.length; let stack = err.stack ? String(err.stack) : err.toString();
// Do not "duplicate" error properties that are already included in the output // otherwise. if (!ctx.showHidden && keys.length !== 0) { for (const name of ["name", "message", "stack"]) { const index = keys.indexOf(name); // Only hide the property in case it's part of the original stack if (index !== -1 && stack.includes(err[name])) { keys.splice(index, 1); } } }
// 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); // TODO(wafuwafu13): Implement // 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; // deno-lint-ignore no-cond-assign 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;}
let hexSlice;
function formatArrayBuffer(ctx, value) { let buffer; try { buffer = new Uint8Array(value); } catch { return [ctx.stylize("(detached)", "special")]; } // TODO(wafuwafu13): Implement // if (hexSlice === undefined) // hexSlice = uncurryThis(require('buffer').Buffer.prototype.hexSlice); let str = hexSlice(buffer, 0, Math.min(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 formatNumber(fn, value) { // Format -0 as '-0'. Checking `value === -0` won't distinguish 0 from -0. return fn(Object.is(value, -0) ? "-0" : `${value}`, "number");}
function formatPromise(ctx, value, recurseTimes) { let output; // TODO(wafuwafu13): Implement // const { 0: state, 1: result } = getPromiseDetails(value); const { 0: state, 1: result } = value; if (state === kPending) { output = [ctx.stylize("<pending>", "special")]; } else { ctx.indentationLvl += 2; const str = formatValue(ctx, result, recurseTimes); ctx.indentationLvl -= 2; output = [ state === kRejected ? `${ctx.stylize("<rejected>", "special")} ${str}` : str, ]; } return output;}
function formatWeakCollection(ctx) { return [ctx.stylize("<items unknown>", "special")];}
function formatWeakSet(ctx, value, recurseTimes) { // TODO(wafuwafu13): Implement // const entries = previewEntries(value); const entries = value; return formatSetIterInner(ctx, recurseTimes, entries, kWeak);}
function formatWeakMap(ctx, value, recurseTimes) { // TODO(wafuwafu13): Implement // const entries = previewEntries(value); const entries = value; return formatMapIterInner(ctx, recurseTimes, entries, kWeak);}
function formatProperty( ctx, value, recurseTimes, key, type, desc, original = value,) { let name, str; let extra = " "; desc = desc || Object.getOwnPropertyDescriptor(value, key) || { value: value[key], enumerable: true }; if (desc.value !== undefined) { const diff = (ctx.compact !== true || type !== kObjectType) ? 2 : 3; ctx.indentationLvl += diff; str = formatValue(ctx, desc.value, recurseTimes); if (diff === 3 && ctx.breakLength < getStringWidth(str, ctx.colors)) { 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 = desc.get.call(original); 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 = `<Inspection threw (${err.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 (key === "__proto__") { name = "['__proto__']"; } else if (desc.enumerable === false) { const tmp = key.replace(strEscapeSequencesReplacer, escapeFn);
name = `[${tmp}]`; } else if (keyStrRegExp.test(key)) { name = ctx.stylize(key, "name"); } else { name = ctx.stylize(strEscape(key), "string"); } return `${name}:${extra}${str}`;}
function handleMaxCallStackSize( _ctx, _err, _constructorName, _indentationLvl,) { // TODO(wafuwafu13): Implement // if (types.isStackOverflowError(err)) { // ctx.seen.pop(); // ctx.indentationLvl = indentationLvl; // return ctx.stylize( // `[${constructorName}: Inspection interrupted ` + // 'prematurely. Maximum call stack size exceeded.]', // 'special' // ); // } // /* c8 ignore next */ // assert.fail(err.stack);}
// deno-lint-ignore no-control-regexconst colorRegExp = /\u001b\[\d\d?m/g;function removeColors(str) { return str.replace(colorRegExp, "");}
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. // TODO(BridgeAR): Add unicode support. Use the readline getStringWidth // function. Check the performance overhead and make it an opt-in in case it's // significant. 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 formatBigInt(fn, value) { return fn(`${value}n`, "bigint");}
function formatNamespaceObject( keys, ctx, value, recurseTimes,) { 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) { // TODO(wafuwfu13): Implement // assert(isNativeError(err) && err.name === 'ReferenceError'); // 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("<uninitialized>", "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 keysfunction formatSpecialArray( ctx, value, recurseTimes, maxLength, output, i,) { const keys = Object.keys(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 getBoxedBase( value, ctx, keys, constructor, tag,) { let type; if (types.isNumberObject(value)) { type = "Number"; } else if (types.isStringObject(value)) { 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 (types.isBooleanObject(value)) { type = "Boolean"; } else if (types.isBigIntObject(value)) { type = "BigInt"; } else { type = "Symbol"; } let base = `[${type}`; if (type !== constructor) { if (constructor === null) { base += " (null prototype)"; } else { base += ` (${constructor})`; } }
base += `: ${formatPrimitive(stylizeNoColor, value.valueOf(), ctx)}]`; if (tag !== "" && tag !== constructor) { base += ` [${tag}]`; } if (keys.length !== 0 || ctx.stylize === stylizeNoColor) { return base; } return ctx.stylize(base, type.toLowerCase());}
function getClassBase(value, constructor, tag) { // deno-lint-ignore no-prototype-builtins const hasName = value.hasOwnProperty("name"); const name = (hasName && value.name) || "(anonymous)"; let base = `class ${name}`; if (constructor !== "Function" && constructor !== null) { base += ` [${constructor}]`; } if (tag !== "" && constructor !== tag) { base += ` [${tag}]`; } if (constructor !== null) { const superName = Object.getPrototypeOf(value).name; if (superName) { base += ` extends ${superName}`; } } else { base += " extends [null prototype]"; } return `[${base}]`;}
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 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]}`;}
// The built-in Array#join is slower in v8 6.0function join(output, separator) { let str = ""; if (output.length !== 0) { const lastIndex = output.length - 1; for (let i = 0; i < lastIndex; i++) { // It is faster not to use a template string here str += output[i]; str += separator; } str += output[lastIndex]; } return str;}
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 = getStringWidth(output[i], ctx.colors); 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 = Math.sqrt(actualMax - totalLength / output.length); const biasedMax = Math.max(actualMax - 3 - averageBias, 1); // Dynamically check how many columns seem possible. const columns = Math.min( // 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. Math.round( Math.sqrt( approxCharHeights * biasedMax * outputLength, ) / biasedMax, ), // Do not exceed the breakLength. Math.floor((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 = String.prototype.padStart; if (value !== undefined) { for (let i = 0; i < output.length; i++) { if (typeof value[i] !== "number" && typeof value[i] !== "bigint") { order = String.prototype.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 = Math.min(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]}, `.padStart(padding, " "); } if (order === String.prototype.padStart) { const padding = maxLineLength[j - i] + output[j].length - dataLen[j] - separatorSpace; str += output[j].padStart(padding, " "); } else { str += output[j]; } Array.prototype.push.call(tmp, str); } if (ctx.maxArrayLength < output.length) { Array.prototype.push.call(tmp, output[outputLength]); } output = tmp; } return output;}
function formatMapIterInner( ctx, recurseTimes, entries, state,) { const maxArrayLength = Math.max(ctx.maxArrayLength, 0); // Entries exist as [key1, val1, key2, val2, ...] const len = entries.length / 2; const remaining = len - maxArrayLength; const maxLength = Math.min(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 formatSetIterInner( ctx, recurseTimes, entries, state,) { const maxArrayLength = Math.max(ctx.maxArrayLength, 0); const maxLength = Math.min(maxArrayLength, entries.length); const 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.sort(); } const remaining = entries.length - maxLength; if (remaining > 0) { Array.prototype.push.call( output, `... ${remaining} more item${remaining > 1 ? "s" : ""}`, ); } return output;}
// Regex used for ansi escape code splitting// Adopted from https://github.com/chalk/ansi-regex/blob/HEAD/index.js// License: MIT, authors: @sindresorhus, Qix-, arjunmehta and LitoMore// Matches all ansi escape code sequences in a stringconst ansiPattern = "[\\u001B\\u009B][[\\]()#;?]*" + "(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*" + "|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)" + "|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))";const ansi = new RegExp(ansiPattern, "g");
/** * Returns the number of columns required to display the given string. */export function getStringWidth(str, removeControlChars = true) { let width = 0;
if (removeControlChars) { str = stripVTControlCharacters(str); } str = str.normalize("NFC"); for (const char of str[Symbol.iterator]()) { const code = char.codePointAt(0); if (isFullWidthCodePoint(code)) { width += 2; } else if (!isZeroWidthCodePoint(code)) { width++; } }
return width;}
/** * Returns true if the character represented by a given * Unicode code point is full-width. Otherwise returns false. */const isFullWidthCodePoint = (code) => { // Code points are partially derived from: // https://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt return code >= 0x1100 && ( code <= 0x115f || // Hangul Jamo code === 0x2329 || // LEFT-POINTING ANGLE BRACKET code === 0x232a || // RIGHT-POINTING ANGLE BRACKET // CJK Radicals Supplement .. Enclosed CJK Letters and Months (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A (code >= 0x3250 && code <= 0x4dbf) || // CJK Unified Ideographs .. Yi Radicals (code >= 0x4e00 && code <= 0xa4c6) || // Hangul Jamo Extended-A (code >= 0xa960 && code <= 0xa97c) || // Hangul Syllables (code >= 0xac00 && code <= 0xd7a3) || // CJK Compatibility Ideographs (code >= 0xf900 && code <= 0xfaff) || // Vertical Forms (code >= 0xfe10 && code <= 0xfe19) || // CJK Compatibility Forms .. Small Form Variants (code >= 0xfe30 && code <= 0xfe6b) || // Halfwidth and Fullwidth Forms (code >= 0xff01 && code <= 0xff60) || (code >= 0xffe0 && code <= 0xffe6) || // Kana Supplement (code >= 0x1b000 && code <= 0x1b001) || // Enclosed Ideographic Supplement (code >= 0x1f200 && code <= 0x1f251) || // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff // Emoticons 0x1f600 - 0x1f64f (code >= 0x1f300 && code <= 0x1f64f) || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane (code >= 0x20000 && code <= 0x3fffd) );};
const isZeroWidthCodePoint = (code) => { return code <= 0x1F || // C0 control codes (code >= 0x7F && code <= 0x9F) || // C1 control codes (code >= 0x300 && code <= 0x36F) || // Combining Diacritical Marks (code >= 0x200B && code <= 0x200F) || // Modifying Invisible Characters // Combining Diacritical Marks for Symbols (code >= 0x20D0 && code <= 0x20FF) || (code >= 0xFE00 && code <= 0xFE0F) || // Variation Selectors (code >= 0xFE20 && code <= 0xFE2F) || // Combining Half Marks (code >= 0xE0100 && code <= 0xE01EF); // Variation Selectors};
function hasBuiltInToString(value) { // TODO(wafuwafu13): Implement // // Prevent triggering proxy traps. // const getFullProxy = false; // const proxyTarget = getProxyDetails(value, getFullProxy); const proxyTarget = undefined; if (proxyTarget !== undefined) { value = proxyTarget; }
// 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 (Object.prototype.hasOwnProperty.call(value, "toString")) { return false; }
// Find the object that has the `toString` property as own property in the // prototype chain. let pointer = value; do { pointer = Object.getPrototypeOf(pointer); } while (!Object.prototype.hasOwnProperty.call(pointer, "toString"));
// Check closer if the object is a built-in. const descriptor = Object.getOwnPropertyDescriptor(pointer, "constructor"); return descriptor !== undefined && typeof descriptor.value === "function" && builtInObjects.has(descriptor.value.name);}
const firstErrorLine = (error) => error.message.split("\n", 1)[0];let CIRCULAR_ERROR_MESSAGE;function tryStringify(arg) { try { return JSON.stringify(arg); } catch (err) { // Populate the circular error message lazily if (!CIRCULAR_ERROR_MESSAGE) { try { const a = {}; a.a = a; JSON.stringify(a); } catch (circularError) { CIRCULAR_ERROR_MESSAGE = firstErrorLine(circularError); } } if ( err.name === "TypeError" && firstErrorLine(err) === CIRCULAR_ERROR_MESSAGE ) { return "[Circular]"; } throw err; }}
export function format(...args) { return formatWithOptionsInternal(undefined, args);}
export function formatWithOptions(inspectOptions, ...args) { if (typeof inspectOptions !== "object" || inspectOptions === null) { throw new codes.ERR_INVALID_ARG_TYPE( "inspectOptions", "object", inspectOptions, ); } return formatWithOptionsInternal(inspectOptions, args);}
function formatNumberNoColor(number, options) { return formatNumber( stylizeNoColor, number, options?.numericSeparator ?? inspectDefaultOptions.numericSeparator, );}
function formatBigIntNoColor(bigint, options) { return formatBigInt( stylizeNoColor, bigint, options?.numericSeparator ?? inspectDefaultOptions.numericSeparator, );}
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) { // deno-lint-ignore no-case-declarations case 115: // 's' const tempArg = args[++a]; if (typeof tempArg === "number") { tempStr = formatNumberNoColor(tempArg, inspectOptions); } else if (typeof tempArg === "bigint") { tempStr = formatBigIntNoColor(tempArg, inspectOptions); } 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; // deno-lint-ignore no-case-declarations case 100: // 'd' const tempNum = args[++a]; if (typeof tempNum === "bigint") { tempStr = formatBigIntNoColor(tempNum, inspectOptions); } else if (typeof tempNum === "symbol") { tempStr = "NaN"; } else { tempStr = formatNumberNoColor(Number(tempNum), inspectOptions); } 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; // deno-lint-ignore no-case-declarations case 105: // 'i' const tempInteger = args[++a]; if (typeof tempInteger === "bigint") { tempStr = formatBigIntNoColor(tempInteger, inspectOptions); } else if (typeof tempInteger === "symbol") { tempStr = "NaN"; } else { tempStr = formatNumberNoColor( Number.parseInt(tempInteger), inspectOptions, ); } break; // deno-lint-ignore no-case-declarations case 102: // 'f' const tempFloat = args[++a]; if (typeof tempFloat === "symbol") { tempStr = "NaN"; } else { tempStr = formatNumberNoColor( Number.parseFloat(tempFloat), inspectOptions, ); } 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;}
/** * Remove all VT control characters. Use to estimate displayed string width. */export function stripVTControlCharacters(str) { validateString(str, "str");
return str.replace(ansi, "");}
export default { format, getStringWidth, inspect, stripVTControlCharacters, formatWithOptions,};