hildjj / node-inspect-extracted / 1894732752

1894732752

push

github

Joe Hildebrand 
Update to node 17.6.0

1882 of 2062 branches covered (91.27%)

Branch coverage included in aggregate %.

214 of 278 new or added lines in 4 files covered. (76.98%)

3 existing lines in 1 file now uncovered.

2945 of 3186 relevant lines covered (92.44%)

2818.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.95
/src/inspect.js
1 
'use strict';
24✔
2 



24✔





3



const primordials = require('./primordials');




24✔





4



const {




24✔





5



  internalBinding,




24✔





6



  Array,




24✔





7



  ArrayIsArray,




24✔





8



  ArrayPrototypeFilter,




24✔





9



  ArrayPrototypeForEach,




24✔





10



  ArrayPrototypePop,




24✔





11



  ArrayPrototypePush,




24✔





12



  ArrayPrototypePushApply,




24✔





13



  ArrayPrototypeSort,




24✔





14



  ArrayPrototypeUnshift,




24✔





15



  BigIntPrototypeValueOf,




24✔





16



  BooleanPrototypeValueOf,




24✔





17



  DatePrototypeGetTime,




24✔





18



  DatePrototypeToISOString,




24✔





19



  DatePrototypeToString,




24✔





20



  ErrorPrototypeToString,




24✔





21



  FunctionPrototypeCall,




24✔





22



  FunctionPrototypeToString,




24✔





23



  JSONStringify,




24✔





24



  MapPrototypeGetSize,




24✔





25



  MapPrototypeEntries,




24✔





26



  MathFloor,




24✔





27



  MathMax,




24✔





28



  MathMin,




24✔





29



  MathRound,




24✔





30



  MathSqrt,




24✔






31



  MathTrunc,




24✔





32



  Number,




24✔






33



  NumberIsFinite,




24✔





34



  NumberIsNaN,




24✔





35



  NumberParseFloat,




24✔





36



  NumberParseInt,




24✔





37



  NumberPrototypeValueOf,




24✔





38



  Object,




24✔





39



  ObjectAssign,




24✔





40



  ObjectCreate,




24✔





41



  ObjectDefineProperty,




24✔





42



  ObjectGetOwnPropertyDescriptor,




24✔





43



  ObjectGetOwnPropertyNames,




24✔





44



  ObjectGetOwnPropertySymbols,




24✔





45



  ObjectGetPrototypeOf,




24✔





46



  ObjectIs,




24✔





47



  ObjectKeys,




24✔





48



  ObjectPrototypeHasOwnProperty,




24✔





49



  ObjectPrototypePropertyIsEnumerable,




24✔





50



  ObjectSeal,




24✔





51



  ObjectSetPrototypeOf,




24✔





52



  ReflectOwnKeys,




24✔





53



  RegExp,




24✔





54



  RegExpPrototypeTest,




24✔





55



  RegExpPrototypeToString,




24✔





56



  SafeStringIterator,




24✔





57



  SafeMap,




24✔





58



  SafeSet,




24✔





59



  SetPrototypeGetSize,




24✔





60



  SetPrototypeValues,




24✔





61



  String,




24✔





62



  StringPrototypeCharCodeAt,




24✔





63



  StringPrototypeCodePointAt,




24✔





64



  StringPrototypeIncludes,




24✔





65



  StringPrototypeNormalize,




24✔





66



  StringPrototypePadEnd,




24✔





67



  StringPrototypePadStart,




24✔





68



  StringPrototypeRepeat,




24✔





69



  StringPrototypeReplace,




24✔





70



  StringPrototypeSlice,




24✔





71



  StringPrototypeSplit,




24✔





72



  StringPrototypeToLowerCase,




24✔





73



  StringPrototypeTrim,




24✔





74



  StringPrototypeValueOf,




24✔





75



  SymbolPrototypeToString,




24✔





76



  SymbolPrototypeValueOf,




24✔





77



  SymbolIterator,




24✔





78



  SymbolToStringTag,




24✔





79



  TypedArrayPrototypeGetLength,




24✔





80



  TypedArrayPrototypeGetSymbolToStringTag,




24✔





81



  Uint8Array,




24✔





82



  globalThis,




24✔





83



  uncurryThis,




24✔





84



} = primordials;




24✔





85






24✔





86



const {




24✔





87



  getOwnNonIndexProperties,




24✔





88



  getPromiseDetails,




24✔





89



  getProxyDetails,




24✔





90



  kPending,




24✔





91



  kRejected,




24✔





92



  previewEntries,




24✔





93



  getConstructorName: internalGetConstructorName,




24✔





94



  getExternalValue,




24✔





95



  propertyFilter: {




24✔





96



    ALL_PROPERTIES,




24✔





97



    ONLY_ENUMERABLE




24✔





98



  },




24✔





99



  Proxy




24✔





100



} = require('./util');




24✔





101






24✔





102



const {




24✔





103



  customInspectSymbol,




24✔





104



  isError,




24✔





105



  join,




24✔





106



  removeColors




24✔





107



} = require('./internal/util');




24✔





108






24✔





109



const {




24✔





110



  codes: {




24✔





111



    ERR_INVALID_ARG_TYPE




24✔





112



  },




24✔





113



  isStackOverflowError




24✔





114



} = require('./internal/errors');




24✔





115






24✔





116



const {




24✔





117



  isAsyncFunction,




24✔





118



  isGeneratorFunction,




24✔





119



  isAnyArrayBuffer,




24✔





120



  isArrayBuffer,




24✔





121



  isArgumentsObject,




24✔





122



  isBoxedPrimitive,




24✔





123



  isDataView,




24✔





124



  isExternal,




24✔





125



  isMap,




24✔





126



  isMapIterator,




24✔





127



  isModuleNamespaceObject,




24✔





128



  isNativeError,




24✔





129



  isPromise,




24✔





130



  isSet,




24✔





131



  isSetIterator,




24✔





132



  isWeakMap,




24✔





133



  isWeakSet,




24✔





134



  isRegExp,




24✔





135



  isDate,




24✔





136



  isTypedArray,




24✔





137



  isStringObject,




24✔





138



  isNumberObject,




24✔





139



  isBooleanObject,




24✔





140



  isBigIntObject,




24✔





141



} = require('./internal/util/types');




24✔





142






24✔





143



const assert = require('./internal/assert');




24✔





144






24✔





145



const { NativeModule } = require('./internal/bootstrap/loaders');




24✔





146



const {




24✔





147



  validateObject,




24✔






148



  validateString,




24✔





149



} = require('./internal/validators');




24✔





150






24✔





151



let hexSlice;




24✔





152






24✔





153



const builtInObjects = new SafeSet(




24✔





154



  ArrayPrototypeFilter(




24✔





155



    ObjectGetOwnPropertyNames(globalThis),




24✔





156



    (e) => RegExpPrototypeTest(/^[A-Z][a-zA-Z0-9]+$/, e)





24✔





157



  )




24✔





158



);




24✔





159






24✔





160



// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot




24✔





161



const isUndetectableObject = (v) => typeof v === 'undefined' && v !== undefined;





24✔





162






24✔





163



// These options must stay in sync with `getUserOptions`. So if any option will




24✔





164



// be added or removed, `getUserOptions` must also be updated accordingly.




24✔





165



const inspectDefaultOptions = ObjectSeal({




24✔





166



  showHidden: false,




24✔





167



  depth: 2,




24✔





168



  colors: false,




24✔





169



  customInspect: true,




24✔





170



  showProxy: false,




24✔





171



  maxArrayLength: 100,




24✔





172



  maxStringLength: 10000,




24✔





173



  breakLength: 80,




24✔





174



  compact: 3,




24✔





175



  sorted: false,




24✔






176



  getters: false,




24✔






177



  numericSeparator: false,




24✔





178



});




24✔





179






24✔





180



const kObjectType = 0;




24✔





181



const kArrayType = 1;




24✔





182



const kArrayExtrasType = 2;




24✔





183






24✔





184



/* eslint-disable no-control-regex */




24✔






185



const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;




24✔






186



const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;




24✔






187



const strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;




24✔






188



const strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;




24✔





189



/* eslint-enable no-control-regex */




24✔





190






24✔





191



const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;




24✔





192



const numberRegExp = /^(0|[1-9][0-9]*)$/;




24✔





193






24✔






194



const coreModuleRegExp = /^ {4}at (?:[^/\\(]+ \(|)node:(.+):\d+:\d+\)?$/;




24✔





195



const nodeModulesRegExp = /[/\\]node_modules[/\\](.+?)(?=[/\\])/g;




24✔





196






24✔





197



const classRegExp = /^(\s+[^(]*?)\s*{/;




24✔





198



// eslint-disable-next-line node-core/no-unescaped-regexp-dot




24✔





199



const stripCommentsRegExp = /(\/\/.*?\n)|(\/\*(.|\n)*?\*\/)/g;




24✔





200






24✔





201



const kMinLineLength = 16;




24✔





202






24✔





203



// Constants to map the iterator state.




24✔





204



const kWeak = 0;




24✔





205



const kIterator = 1;




24✔





206



const kMapEntries = 2;




24✔





207






24✔





208



// Escaped control characters (plus the single quote and the backslash). Use




24✔





209



// empty strings to fill up unused entries.




24✔





210



const meta = [




24✔





211



  '\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07




24✔





212



  '\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F',           // x0F




24✔





213



  '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17




24✔





214



  '\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F




24✔





215



  '', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '',      // x2F




24✔





216



  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x3F




24✔





217



  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x4F




24✔





218



  '', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '',     // x5F




24✔





219



  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x6F




24✔





220



  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F',    // x7F




24✔





221



  '\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87




24✔





222



  '\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F




24✔





223



  '\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97




24✔





224



  '\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F




24✔





225



];




24✔





226






24✔





227



// Regex used for ansi escape code splitting




24✔





228



// Adopted from https://github.com/chalk/ansi-regex/blob/HEAD/index.js




24✔





229



// License: MIT, authors: @sindresorhus, Qix-, arjunmehta and LitoMore




24✔





230



// Matches all ansi escape code sequences in a string




24✔





231



const ansiPattern = '[\\u001B\\u009B][[\\]()#;?]*' +




24✔






232



  '(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*' +




24✔






233



  '|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' +




24✔





234



  '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))';




24✔





235



const ansi = new RegExp(ansiPattern, 'g');




24✔





236






24✔





237



let getStringWidth;




24✔





238






24✔





239



function getUserOptions(ctx, isCrossContext) {





94✔





240



  const ret = {




94✔





241



    stylize: ctx.stylize,




94✔





242



    showHidden: ctx.showHidden,




94✔





243



    depth: ctx.depth,




94✔





244



    colors: ctx.colors,




94✔





245



    customInspect: ctx.customInspect,




94✔





246



    showProxy: ctx.showProxy,




94✔





247



    maxArrayLength: ctx.maxArrayLength,




94✔





248



    maxStringLength: ctx.maxStringLength,




94✔





249



    breakLength: ctx.breakLength,




94✔





250



    compact: ctx.compact,




94✔





251



    sorted: ctx.sorted,




94✔





252



    getters: ctx.getters,




94✔






253



    numericSeparator: ctx.numericSeparator,




94✔





254



    ...ctx.userOptions




94✔





255



  };




94✔





256






94✔





257



  // Typically, the target value will be an instance of `Object`. If that is




94✔





258



  // *not* the case, the object may come from another vm.Context, and we want




94✔





259



  // to avoid passing it objects from this Context in that case, so we remove




94✔





260



  // the prototype from the returned object itself + the `stylize()` function,




94✔





261



  // and remove all other non-primitives, including non-primitive user options.




94✔





262



  if (isCrossContext) {





94✔





263



    ObjectSetPrototypeOf(ret, null);




20✔





264



    for (const key of ObjectKeys(ret)) {





20✔





265



      if ((typeof ret[key] === 'object' || typeof ret[key] === 'function') &&





260✔





266



          ret[key] !== null) {





260✔





267



        delete ret[key];




20✔





268



      }




20✔





269



    }




260✔





270



    ret.stylize = ObjectSetPrototypeOf((value, flavour) => {





20✔





271



      let stylized;




12✔





272



      try {




12✔





273



        stylized = `${ctx.stylize(value, flavour)}`;




12✔






274



      } catch {





12✔






275



        // Continue regardless of error.




4✔






276



      }




4✔





277






12✔





278



      if (typeof stylized !== 'string') return value;





12✔





279



      // `stylized` is a string as it should be, which is safe to pass along.




12✔





280



      return stylized;




12✔





281



    }, null);




20✔





282



  }




20✔





283






94✔





284



  return ret;




94✔





285



}




94✔





286






24✔





287



/**




24✔





288



 * Echos the value of any input. Tries to print the value out




24✔





289



 * in the best way possible given the different types.




24✔





290



 *




24✔





291



 * @param {any} value The value to print out.




24✔






292



 * @param {object} opts Optional options object that alters the output.




24✔





293



 */




24✔





294



/* Legacy: value, showHidden, depth, colors */




24✔





295



function inspect(value, opts) {





39,814✔





296



  // Default options




39,814✔





297



  const ctx = {




39,814✔





298



    budget: {},




39,814✔





299



    indentationLvl: 0,




39,814✔





300



    seen: [],




39,814✔





301



    currentDepth: 0,




39,814✔





302



    stylize: stylizeNoColor,




39,814✔





303



    showHidden: inspectDefaultOptions.showHidden,




39,814✔





304



    depth: inspectDefaultOptions.depth,




39,814✔





305



    colors: inspectDefaultOptions.colors,




39,814✔





306



    customInspect: inspectDefaultOptions.customInspect,




39,814✔





307



    showProxy: inspectDefaultOptions.showProxy,




39,814✔





308



    maxArrayLength: inspectDefaultOptions.maxArrayLength,




39,814✔





309



    maxStringLength: inspectDefaultOptions.maxStringLength,




39,814✔





310



    breakLength: inspectDefaultOptions.breakLength,




39,814✔





311



    compact: inspectDefaultOptions.compact,




39,814✔





312



    sorted: inspectDefaultOptions.sorted,




39,814✔






313



    getters: inspectDefaultOptions.getters,




39,814✔






314



    numericSeparator: inspectDefaultOptions.numericSeparator,




39,814✔





315



  };




39,814✔





316



  if (arguments.length > 1) {





39,814✔





317



    // Legacy...




1,036✔





318



    if (arguments.length > 2) {





1,036✔





319



      if (arguments[2] !== undefined) {





92✔





320



        ctx.depth = arguments[2];




88✔





321



      }




88✔





322



      if (arguments.length > 3 && arguments[3] !== undefined) {





92✔





323



        ctx.colors = arguments[3];




72✔





324



      }




72✔





325



    }




92✔





326



    // Set user-specified options




1,036✔





327



    if (typeof opts === 'boolean') {





1,036✔





328



      ctx.showHidden = opts;




268✔





329



    } else if (opts) {





1,036✔





330



      const optKeys = ObjectKeys(opts);




760✔





331



      for (let i = 0; i < optKeys.length; ++i) {





760✔





332



        const key = optKeys[i];




1,420✔





333



        // TODO(BridgeAR): Find a solution what to do about stylize. Either make




1,420✔





334



        // this function public or add a new API with a similar or better




1,420✔





335



        // functionality.




1,420✔





336



        if (




1,420✔





337



          ObjectPrototypeHasOwnProperty(inspectDefaultOptions, key) ||





1,420✔





338



          key === 'stylize') {





1,420✔





339



          ctx[key] = opts[key];




1,316✔





340



        } else if (ctx.userOptions === undefined) {





1,420✔





341



          // This is required to pass through the actual user input.




28✔





342



          ctx.userOptions = opts;




28✔





343



        }




28✔





344



      }




1,420✔





345



    }




760✔





346



  }




1,036✔





347



  if (ctx.colors) ctx.stylize = stylizeWithColor;





39,814✔





348



  if (ctx.maxArrayLength === null) ctx.maxArrayLength = Infinity;





39,814✔





349



  if (ctx.maxStringLength === null) ctx.maxStringLength = Infinity;





39,814✔





350



  return formatValue(ctx, value, 0);




39,814✔





351



}




39,814✔





352



inspect.custom = customInspectSymbol;




24✔





353






24✔





354



ObjectDefineProperty(inspect, 'defaultOptions', {




24✔





355



  get() {





24✔





356



    return inspectDefaultOptions;




44✔





357



  },




24✔





358



  set(options) {





24✔





359



    validateObject(options, 'options');




16✔





360



    return ObjectAssign(inspectDefaultOptions, options);




16✔





361



  }




16✔





362



});




24✔





363






24✔





364



// Set Graphics Rendition https://en.wikipedia.org/wiki/ANSI_escape_code#graphics




24✔





365



// Each color consists of an array with the color code as first entry and the




24✔





366



// reset code as second entry.




24✔





367



const defaultFG = 39;




24✔





368



const defaultBG = 49;




24✔





369



inspect.colors = ObjectAssign(ObjectCreate(null), {




24✔





370



  reset: [0, 0],




24✔





371



  bold: [1, 22],




24✔





372



  dim: [2, 22], // Alias: faint




24✔





373



  italic: [3, 23],




24✔





374



  underline: [4, 24],




24✔





375



  blink: [5, 25],




24✔





376



  // Swap foreground and background colors




24✔





377



  inverse: [7, 27], // Alias: swapcolors, swapColors




24✔





378



  hidden: [8, 28], // Alias: conceal




24✔





379



  strikethrough: [9, 29], // Alias: strikeThrough, crossedout, crossedOut




24✔





380



  doubleunderline: [21, 24], // Alias: doubleUnderline




24✔





381



  black: [30, defaultFG],




24✔





382



  red: [31, defaultFG],




24✔





383



  green: [32, defaultFG],




24✔





384



  yellow: [33, defaultFG],




24✔





385



  blue: [34, defaultFG],




24✔





386



  magenta: [35, defaultFG],




24✔





387



  cyan: [36, defaultFG],




24✔





388



  white: [37, defaultFG],




24✔





389



  bgBlack: [40, defaultBG],




24✔





390



  bgRed: [41, defaultBG],




24✔





391



  bgGreen: [42, defaultBG],




24✔





392



  bgYellow: [43, defaultBG],




24✔





393



  bgBlue: [44, defaultBG],




24✔





394



  bgMagenta: [45, defaultBG],




24✔





395



  bgCyan: [46, defaultBG],




24✔





396



  bgWhite: [47, defaultBG],




24✔





397



  framed: [51, 54],




24✔





398



  overlined: [53, 55],




24✔





399



  gray: [90, defaultFG], // Alias: grey, blackBright




24✔





400



  redBright: [91, defaultFG],




24✔





401



  greenBright: [92, defaultFG],




24✔





402



  yellowBright: [93, defaultFG],




24✔





403



  blueBright: [94, defaultFG],




24✔





404



  magentaBright: [95, defaultFG],




24✔





405



  cyanBright: [96, defaultFG],




24✔





406



  whiteBright: [97, defaultFG],




24✔





407



  bgGray: [100, defaultBG], // Alias: bgGrey, bgBlackBright




24✔





408



  bgRedBright: [101, defaultBG],




24✔





409



  bgGreenBright: [102, defaultBG],




24✔





410



  bgYellowBright: [103, defaultBG],




24✔





411



  bgBlueBright: [104, defaultBG],




24✔





412



  bgMagentaBright: [105, defaultBG],




24✔





413



  bgCyanBright: [106, defaultBG],




24✔





414



  bgWhiteBright: [107, defaultBG],




24✔





415



});




24✔





416






24✔





417



function defineColorAlias(target, alias) {





288✔





418



  ObjectDefineProperty(inspect.colors, alias, {




288✔





419



    get() {





288✔





420



      return this[target];




120✔





421



    },




288✔





422



    set(value) {





288✔





423



      this[target] = value;




4✔





424



    },




288✔





425



    configurable: true,




288✔





426



    enumerable: false




288✔





427



  });




288✔





428



}




288✔





429






24✔





430



defineColorAlias('gray', 'grey');




24✔





431



defineColorAlias('gray', 'blackBright');




24✔





432



defineColorAlias('bgGray', 'bgGrey');




24✔





433



defineColorAlias('bgGray', 'bgBlackBright');




24✔





434



defineColorAlias('dim', 'faint');




24✔





435



defineColorAlias('strikethrough', 'crossedout');




24✔





436



defineColorAlias('strikethrough', 'strikeThrough');




24✔





437



defineColorAlias('strikethrough', 'crossedOut');




24✔





438



defineColorAlias('hidden', 'conceal');




24✔





439



defineColorAlias('inverse', 'swapColors');




24✔





440



defineColorAlias('inverse', 'swapcolors');




24✔





441



defineColorAlias('doubleunderline', 'doubleUnderline');




24✔





442






24✔





443



// TODO(BridgeAR): Add function style support for more complex styles.




24✔





444



// Don't use 'blue' not visible on cmd.exe




24✔





445



inspect.styles = ObjectAssign(ObjectCreate(null), {




24✔





446



  special: 'cyan',




24✔





447



  number: 'yellow',




24✔





448



  bigint: 'yellow',




24✔





449



  boolean: 'yellow',




24✔





450



  undefined: 'grey',




24✔





451



  null: 'bold',




24✔





452



  string: 'green',




24✔





453



  symbol: 'green',




24✔





454



  date: 'magenta',




24✔





455



  // "name": intentionally not styling




24✔





456



  // TODO(BridgeAR): Highlight regular expressions properly.




24✔





457



  regexp: 'red',




24✔





458



  module: 'underline'




24✔





459



});




24✔





460






24✔





461



function addQuotes(str, quotes) {





40,793✔





462



  if (quotes === -1) {





40,793✔





463



    return `"${str}"`;




12✔





464



  }




12✔





465



  if (quotes === -2) {





40,793✔





466



    return `\`${str}\``;




4✔





467



  }




4✔





468



  return `'${str}'`;




40,793✔





469



}




40,793✔





470






24✔






471



function escapeFn(str) {





16,424✔






472



  const charCode = StringPrototypeCharCodeAt(str);




16,424✔






473



  return meta.length > charCode ? meta[charCode] : `\\u${charCode.toString(16)}`;





16,424✔






474



}




16,424✔





475






24✔





476



// Escape control characters, single quotes and the backslash.




24✔





477



// This is similar to JSON stringify escaping.




24✔





478



function strEscape(str) {





40,793✔





479



  let escapeTest = strEscapeSequencesRegExp;




40,793✔





480



  let escapeReplace = strEscapeSequencesReplacer;




40,793✔





481



  let singleQuote = 39;




40,793✔





482






40,793✔





483



  // Check for double quotes. If not present, do not escape single quotes and




40,793✔





484



  // instead wrap the text in double quotes. If double quotes exist, check for




40,793✔





485



  // backticks. If they do not exist, use those as fallback instead of the




40,793✔





486



  // double quotes.




40,793✔





487



  if (StringPrototypeIncludes(str, "'")) {





40,793✔





488



    // This invalidates the charCode and therefore can not be matched for




20✔





489



    // anymore.




20✔





490



    if (!StringPrototypeIncludes(str, '"')) {





20✔





491



      singleQuote = -1;




12✔





492



    } else if (!StringPrototypeIncludes(str, '`') &&





16✔





493



               !StringPrototypeIncludes(str, '${')) {





8✔





494



      singleQuote = -2;




4✔





495



    }




4✔





496



    if (singleQuote !== 39) {





20✔





497



      escapeTest = strEscapeSequencesRegExpSingle;




16✔





498



      escapeReplace = strEscapeSequencesReplacerSingle;




16✔





499



    }




16✔





500



  }




20✔





501






40,793✔





502



  // Some magic numbers that worked out fine while benchmarking with v8 6.0




40,793✔





503



  if (str.length < 5000 && !RegExpPrototypeTest(escapeTest, str))





40,793✔





504



    return addQuotes(str, singleQuote);





40,793✔





505



  if (str.length > 100) {





40,789✔





506



    str = StringPrototypeReplace(str, escapeReplace, escapeFn);




16,404✔





507



    return addQuotes(str, singleQuote);




16,404✔





508



  }




16,404✔





509







16,460✔





510



  let result = '';




16,460✔





511



  let last = 0;




16,460✔






512



  for (let i = 0; i < str.length; i++) {





40,789✔





513



    const point = StringPrototypeCharCodeAt(str, i);




30,427✔





514



    if (point === singleQuote ||





30,427✔





515



        point === 92 ||





30,427✔





516



        point < 32 ||





30,427✔





517



        (point > 126 && point < 160)) {





30,427✔





518



      if (last === i) {





132✔





519



        result += meta[point];




92✔





520



      } else {





132✔





521



        result += `${StringPrototypeSlice(str, last, i)}${meta[point]}`;




40✔





522



      }




40✔





523



      last = i + 1;




132✔






524



    } else if (point >= 0xd800 && point <= 0xdfff) {





30,427✔






525



      if (point <= 0xdbff && i + 1 < str.length) {





20,472✔






526



        const point = StringPrototypeCharCodeAt(str, i + 1);




8,192✔






527



        if (point >= 0xdc00 && point <= 0xdfff) {





8,192✔






528



          i++;




4,096✔






529



          continue;




4,096✔






530



        }




4,096✔






531



      }




8,192✔






532



      result += `${StringPrototypeSlice(str, last, i)}${`\\u${point.toString(16)}`}`;





16,376✔






533



      last = i + 1;




16,376✔





534



    }




16,376✔





535



  }




30,427✔





536







16,460✔






537



  if (last !== str.length) {





40,789✔





538



    result += StringPrototypeSlice(str, last);




8,196✔





539



  }




8,196✔





540



  return addQuotes(result, singleQuote);




40,789✔





541



}




40,793✔





542






24✔





543



function stylizeWithColor(str, styleType) {





1,128✔





544



  const style = inspect.styles[styleType];




1,128✔





545



  if (style !== undefined) {





1,128✔





546



    const color = inspect.colors[style];




952✔





547



    if (color !== undefined)




952✔





548



      return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`;





952✔





549



  }




952✔





550



  return str;





180✔





551



}




1,128✔





552






24✔





553



function stylizeNoColor(str) {





59,302✔





554



  return str;




59,302✔





555



}




59,302✔





556






24✔





557



// Return a new empty array to push in the results of the default formatter.




24✔





558



function getEmptyFormatArray() {





5,437✔





559



  return [];




5,437✔





560



}




5,437✔





561






24✔





562



function isInstanceof(object, proto) {





7,656✔





563



  try {




7,656✔





564



    return object instanceof proto;




7,656✔





565



  } catch {





7,656!





566



    return false;




4✔





567



  }




4✔





568



}




7,656✔





569






24✔





570



function getConstructorName(obj, ctx, recurseTimes, protoProps) {





8,216✔





571



  let firstProto;




8,216✔





572



  const tmp = obj;




8,216✔





573



  while (obj || isUndetectableObject(obj)) {





8,216✔





574



    const descriptor = ObjectGetOwnPropertyDescriptor(obj, 'constructor');




16,207✔





575



    if (descriptor !== undefined &&





16,207✔





576



        typeof descriptor.value === 'function' &&





16,207✔





577



        descriptor.value.name !== '' &&





16,207✔





578



        isInstanceof(tmp, descriptor.value)) {





16,207✔





579



      if (protoProps !== undefined &&





7,636✔





580



         (firstProto !== obj ||





468✔





581



         !builtInObjects.has(descriptor.value.name))) {





7,636✔





582



        addPrototypeProperties(




80✔





583



          ctx, tmp, firstProto || tmp, recurseTimes, protoProps);





80✔





584



      }




80✔





585



      return descriptor.value.name;




7,636✔





586



    }




7,636✔





587







8,571✔





588



    obj = ObjectGetPrototypeOf(obj);




8,571✔





589



    if (firstProto === undefined) {





15,907✔





590



      firstProto = obj;




8,212✔





591



    }




8,212✔





592



  }




16,207✔





593






8,216✔





594



  if (firstProto === null) {





8,216✔





595



    return null;




536✔





596



  }




536✔





597






8,216✔





598



  const res = internalGetConstructorName(tmp);




8,216✔





599






8,216✔





600



  if (recurseTimes > ctx.depth && ctx.depth !== null) {





8,216✔





601



    return `${res} <Complex prototype>`;




4✔





602



  }




4✔





603







40✔





604



  const protoConstr = getConstructorName(




40✔





605



    firstProto, ctx, recurseTimes + 1, protoProps);




40✔





606






40✔





607



  if (protoConstr === null) {





7,908✔





608



    return `${res} <${inspect(firstProto, {




24✔





609



      ...ctx,




24✔





610



      customInspect: false,




24✔





611



      depth: -1




24✔





612



    })}>`;




24✔





613



  }




24✔





614







16✔





615



  return `${res} <${protoConstr}>`;




16✔





616



}




8,216✔





617






24✔





618



// This function has the side effect of adding prototype properties to the




24✔





619



// `output` argument (which is an array). This is intended to highlight user




24✔





620



// defined prototype properties.




24✔





621



function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {





80✔





622



  let depth = 0;




80✔





623



  let keys;




80✔





624



  let keySet;




80✔





625



  do {





80✔





626



    if (depth !== 0 || main === obj) {





200✔





627



      obj = ObjectGetPrototypeOf(obj);




124✔





628



      // Stop as soon as a null prototype is encountered.




124✔





629



      if (obj === null) {





124✔





630



        return;




4✔





631



      }




4✔





632



      // Stop as soon as a built-in object type is detected.





120✔





633



      const descriptor = ObjectGetOwnPropertyDescriptor(obj, 'constructor');




120✔





634



      if (descriptor !== undefined &&





124✔





635



          typeof descriptor.value === 'function' &&





124✔





636



          builtInObjects.has(descriptor.value.name)) {





124✔





637



        return;




76✔





638



      }




76✔





639



    }




124✔





640






200✔





641



    if (depth === 0) {





200✔





642



      keySet = new SafeSet();




80✔





643



    } else {





200✔





644



      ArrayPrototypeForEach(keys, (key) => keySet.add(key));





40✔





645



    }




40✔





646



    // Get all own property names and symbols.




200✔





647



    keys = ReflectOwnKeys(obj);




200✔





648



    ArrayPrototypePush(ctx.seen, main);




200✔





649



    for (const key of keys) {





200✔





650



      // Ignore the `constructor` property and keys that exist on layers above.




296✔





651



      if (key === 'constructor' ||





296✔





652



          ObjectPrototypeHasOwnProperty(main, key) ||





296✔





653



          (depth !== 0 && keySet.has(key))) {





296✔





654



        continue;




116✔





655



      }




116✔





656



      const desc = ObjectGetOwnPropertyDescriptor(obj, key);




280✔





657



      if (typeof desc.value === 'function') {





296✔





658



        continue;




88✔





659



      }




88✔





660



      const value = formatProperty(




296✔





661



        ctx, obj, recurseTimes, key, kObjectType, desc, main);




296✔





662



      if (ctx.colors) {





296✔





663



        // Faint!




16✔





664



        ArrayPrototypePush(output, `\u001b[2m${value}\u001b[22m`);




16✔





665



      } else {





296✔





666



        ArrayPrototypePush(output, value);




76✔





667



      }




76✔





668



    }




296✔





669



    ArrayPrototypePop(ctx.seen);




200✔





670



  // Limit the inspection to up to three prototype layers. Using `recurseTimes`




200✔





671



  // is not a good choice here, because it's as if the properties are declared




200✔





672



  // on the current object from the users perspective.




200✔





673



  } while (++depth !== 3);




80✔





674



}




80✔





675






24✔





676



function getPrefix(constructor, tag, fallback, size = '') {





2,001✔





677



  if (constructor === null) {





2,001✔





678



    if (tag !== '' && fallback !== tag) {





436✔





679



      return `[${fallback}${size}: null prototype] [${tag}] `;




44✔





680



    }




44✔





681



    return `[${fallback}${size}: null prototype] `;





392✔





682



  }




392✔





683






2,001✔





684



  if (tag !== '' && constructor !== tag) {





2,001✔





685



    return `${constructor}${size} [${tag}] `;




144✔





686



  }




144✔





687



  return `${constructor}${size} `;




1,989✔





688



}




2,001✔





689






24✔





690



// Look up the keys of the object.




24✔





691



function getKeys(value, showHidden) {





7,191✔





692



  let keys;




7,191✔





693



  const symbols = ObjectGetOwnPropertySymbols(value);




7,191✔





694



  if (showHidden) {





7,191✔





695



    keys = ObjectGetOwnPropertyNames(value);




344✔





696



    if (symbols.length !== 0)




344✔





697



      ArrayPrototypePushApply(keys, symbols);





344✔





698



  } else {





7,191✔





699



    // This might throw if `value` is a Module Namespace Object from an




6,847✔





700



    // unevaluated module, but we don't want to perform the actual type




6,847✔





701



    // check because it's expensive.




6,847✔





702



    // TODO(devsnek): track https://github.com/tc39/ecma262/issues/1209




6,847✔





703



    // and modify this logic as needed.




6,847✔





704



    try {




6,847✔





705



      keys = ObjectKeys(value);




6,847✔





706



    } catch (err) {





6,847!





707



      assert(isNativeError(err) && err.name === 'ReferenceError' &&




×







708



             isModuleNamespaceObject(value));




×







709



      keys = ObjectGetOwnPropertyNames(value);




×







710



    }




×







711



    if (symbols.length !== 0) {





6,847✔





712



      const filter = (key) => ObjectPrototypePropertyIsEnumerable(value, key);





455✔





713



      ArrayPrototypePushApply(keys, ArrayPrototypeFilter(symbols, filter));




455✔





714



    }




455✔





715



  }




6,847✔





716



  return keys;




7,191✔





717



}




7,191✔





718






24✔





719



function getCtxStyle(value, constructor, tag) {





977✔





720



  let fallback = '';




977✔





721



  if (constructor === null) {





977✔





722



    fallback = internalGetConstructorName(value);




404✔





723



    if (fallback === tag) {





404✔





724



      fallback = 'Object';




44✔





725



    }




44✔





726



  }




404✔





727



  return getPrefix(constructor, tag, fallback);




977✔





728



}




977✔





729






24✔





730



function formatProxy(ctx, proxy, recurseTimes) {





160✔





731



  if (recurseTimes > ctx.depth && ctx.depth !== null) {





160✔





732



    return ctx.stylize('Proxy [Array]', 'special');




40✔





733



  }




40✔





734



  recurseTimes += 1;




160✔





735



  ctx.indentationLvl += 2;




160✔





736



  const res = [




160✔





737



    formatValue(ctx, proxy[0], recurseTimes),




160✔





738



    formatValue(ctx, proxy[1], recurseTimes),




160✔





739



  ];




160✔





740



  ctx.indentationLvl -= 2;




160✔





741



  return reduceToSingleString(




160✔





742



    ctx, res, '', ['Proxy [', ']'], kArrayExtrasType, recurseTimes);




160✔





743



}




160✔





744






24✔





745



// Note: using `formatValue` directly requires the indentation level to be




24✔





746



// corrected by setting `ctx.indentationLvL += diff` and then to decrease the




24✔





747



// value afterwards again.




24✔





748



function formatValue(ctx, value, recurseTimes, typedArray) {





54,135✔





749



  // Primitive types cannot have properties.




54,135✔





750



  if (typeof value !== 'object' &&





54,135✔





751



      typeof value !== 'function' &&





54,135✔





752



      !isUndetectableObject(value)) {





54,135✔





753



    return formatPrimitive(ctx.stylize, value, ctx);




44,806✔





754



  }




44,806✔





755



  if (value === null) {





54,135✔





756



    return ctx.stylize('null', 'null');




848✔





757



  }




848✔





758







8,481✔





759



  // Memorize the context for custom inspection on proxies.




8,481✔





760



  const context = value;




8,481✔





761



  // Always check for proxies to prevent side effects and to prevent triggering




8,481✔





762



  // any proxy handlers.




8,481✔





763



  const proxy = getProxyDetails(value, !!ctx.showProxy);




8,481✔





764



  if (proxy !== undefined) {





54,135✔





765



    if (ctx.showProxy) {





212✔





766



      return formatProxy(ctx, proxy, recurseTimes);




160✔





767



    }




160✔





768



    value = proxy;




212✔





769



  }




212✔





770






54,135✔





771



  // Provide a hook for user-specified inspect functions.




54,135✔





772



  // Check that value is an object with an inspect function on it.




54,135✔





773



  if (ctx.customInspect) {





54,135✔





774



    const maybeCustom = value[customInspectSymbol];




8,281✔





775



    if (typeof maybeCustom === 'function' &&





8,281✔





776



        // Filter out the util module, its inspect function is special.




114✔





777



        maybeCustom !== inspect &&





8,281✔





778



        // Also filter out any prototype objects using the circular check.




110✔





779



        !(value.constructor && value.constructor.prototype === value)) {





8,281✔





780



      // This makes sure the recurseTimes are reported as before while using




94✔





781



      // a counter internally.




94✔





782



      const depth = ctx.depth === null ? null : ctx.depth - recurseTimes;





94✔





783



      const isCrossContext =




94✔





784



        proxy !== undefined || !(context instanceof Object);





94✔





785



      const ret = FunctionPrototypeCall(




94✔






786



        maybeCustom,




94✔






787



        context,




94✔






788



        depth,




94✔






789



        getUserOptions(ctx, isCrossContext),




94✔






790



        inspect




94✔






791



      );




94✔





792



      // If the custom inspection method returned `this`, don't go into




94✔





793



      // infinite recursion.




94✔





794



      if (ret !== context) {





94✔





795



        if (typeof ret !== 'string') {





75✔





796



          return formatValue(ctx, ret, recurseTimes);




56✔





797



        }




56✔





798



        return ret.replace(/\n/g, `\n${' '.repeat(ctx.indentationLvl)}`);





19✔





799



      }




19✔





800



    }




94✔





801



  }




8,281✔





802






54,135✔





803



  // Using an array here is actually better for the average case than using




54,135✔





804



  // a Set. `seen` will only check for the depth and will never grow too large.




54,135✔





805



  if (ctx.seen.includes(value)) {





54,135✔





806



    let index = 1;




68✔





807



    if (ctx.circular === undefined) {





68✔





808



      ctx.circular = new SafeMap();




44✔





809



      ctx.circular.set(value, index);




44✔





810



    } else {





68✔





811



      index = ctx.circular.get(value);




24✔





812



      if (index === undefined) {





24✔





813



        index = ctx.circular.size + 1;




4✔





814



        ctx.circular.set(value, index);




4✔





815



      }




4✔





816



    }




24✔





817



    return ctx.stylize(`[Circular *${index}]`, 'special');




68✔





818



  }




68✔





819







8,178✔





820



  return formatRaw(ctx, value, recurseTimes, typedArray);




8,178✔





821



}




54,135✔





822






24✔





823



function formatRaw(ctx, value, recurseTimes, typedArray) {





8,176✔





824



  let keys;




8,176✔





825



  let protoProps;




8,176✔





826



  if (ctx.showHidden && (recurseTimes <= ctx.depth || ctx.depth === null)) {





8,176✔





827



    protoProps = [];




484✔





828



  }




484✔





829






8,176✔





830



  const constructor = getConstructorName(value, ctx, recurseTimes, protoProps);




8,176✔





831



  // Reset the variable to check for this later on.




8,176✔





832



  if (protoProps !== undefined && protoProps.length === 0) {





8,176✔





833



    protoProps = undefined;




412✔





834



  }




412✔





835






8,176✔





836



  let tag = value[SymbolToStringTag];




8,176✔





837



  // Only list the tag in case it's non-enumerable / not an own property.




8,176✔





838



  // Otherwise we'd print this twice.




8,176✔





839



  if (typeof tag !== 'string' ||





8,176✔





840



      (tag !== '' &&




1,100✔





841



      (ctx.showHidden ?





1,100✔





842



        ObjectPrototypeHasOwnProperty :





1,100✔





843



        ObjectPrototypePropertyIsEnumerable)(




1,100✔





844



        value, SymbolToStringTag




1,100✔





845



      ))) {





8,176✔





846



    tag = '';




7,080✔





847



  }




7,080✔





848



  let base = '';





8,172✔





849



  let formatter = getEmptyFormatArray;




8,172✔





850



  let braces;




8,172✔





851



  let noIterator = true;




8,172✔





852



  let i = 0;




8,172✔





853



  const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;





8,176✔





854






8,176✔





855



  let extrasType = kObjectType;




8,176✔





856






8,176✔





857



  // Iterators and the rest are split to reduce checks.




8,176✔





858



  // We have to check all values in case the constructor is set to null.




8,176✔





859



  // Otherwise it would not possible to identify all types properly.




8,176✔





860



  if (value[SymbolIterator] || constructor === null) {





8,176✔





861



    noIterator = false;




1,769✔





862



    if (ArrayIsArray(value)) {





1,769✔





863



      // Only set the constructor for non ordinary ("Array [...]") arrays.




749✔





864



      const prefix = (constructor !== 'Array' || tag !== '') ?





749✔





865



        getPrefix(constructor, tag, 'Array', `(${value.length})`) :





749✔





866



        '';




749✔





867



      keys = getOwnNonIndexProperties(value, filter);




749✔





868



      braces = [`${prefix}[`, ']'];




749✔





869



      if (value.length === 0 && keys.length === 0 && protoProps === undefined)





749✔





870



        return `${braces[0]}]`;





749✔





871



      extrasType = kArrayExtrasType;





709✔





872



      formatter = formatArray;




709✔





873



    } else if (isSet(value)) {





1,769✔





874



      const size = SetPrototypeGetSize(value);




44✔





875



      const prefix = getPrefix(constructor, tag, 'Set', `(${size})`);




44✔





876



      keys = getKeys(value, ctx.showHidden);




44✔





877



      formatter = constructor !== null ?




44✔





878



        formatSet.bind(null, value) :





44!





879



        formatSet.bind(null, SetPrototypeValues(value));




44✔





880



      if (size === 0 && keys.length === 0 && protoProps === undefined)





44✔





881



        return `${prefix}{}`;





44✔





882



      braces = [`${prefix}{`, '}'];




44✔





883



    } else if (isMap(value)) {





1,020✔





884



      const size = MapPrototypeGetSize(value);




80✔





885



      const prefix = getPrefix(constructor, tag, 'Map', `(${size})`);




80✔





886



      keys = getKeys(value, ctx.showHidden);




80✔





887



      formatter = constructor !== null ?




80✔





888



        formatMap.bind(null, value) :





80!





889



        formatMap.bind(null, MapPrototypeEntries(value));




80✔





890



      if (size === 0 && keys.length === 0 && protoProps === undefined)





80✔





891



        return `${prefix}{}`;





80✔





892



      braces = [`${prefix}{`, '}'];





76✔





893



    } else if (isTypedArray(value)) {





976✔





894



      keys = getOwnNonIndexProperties(value, filter);




232✔





895



      let bound = value;




232✔





896



      let fallback = '';




232✔





897



      if (constructor === null) {





232!





898



        fallback = TypedArrayPrototypeGetSymbolToStringTag(value);




×







899



        // Reconstruct the array information.




×







900



        bound = new primordials[fallback](value);




×







901



      }




×







902



      const size = TypedArrayPrototypeGetLength(value);




232✔





903



      const prefix = getPrefix(constructor, tag, fallback, `(${size})`);




232✔





904



      braces = [`${prefix}[`, ']'];




232✔





905



      if (value.length === 0 && keys.length === 0 && !ctx.showHidden)





232✔





906



        return `${braces[0]}]`;





232✔





907



      // Special handle the value. The original value is required below. The





228✔





908



      // bound function is required to reconstruct missing information.




228✔





909



      formatter = formatTypedArray.bind(null, bound, size);




228✔





910



      extrasType = kArrayExtrasType;




228✔





911



    } else if (isMapIterator(value)) {





896✔





912



      keys = getKeys(value, ctx.showHidden);




48✔





913



      braces = getIteratorBraces('Map', tag);




48✔





914



      // Add braces to the formatter parameters.




48✔





915



      formatter = formatIterator.bind(null, braces);




48✔





916



    } else if (isSetIterator(value)) {





664✔





917



      keys = getKeys(value, ctx.showHidden);




52✔





918



      braces = getIteratorBraces('Set', tag);




52✔





919



      // Add braces to the formatter parameters.




52✔





920



      formatter = formatIterator.bind(null, braces);




52✔





921



    } else {





616✔





922



      noIterator = true;




564✔





923



    }




564✔





924



  }




1,769✔





925



  if (noIterator) {





8,176✔





926



    keys = getKeys(value, ctx.showHidden);




6,967✔





927



    braces = ['{', '}'];




6,967✔





928



    if (constructor === 'Object') {





6,967✔





929



      if (isArgumentsObject(value)) {





5,000!





930



        braces[0] = '[Arguments] {';




×







931



      } else if (tag !== '') {





5,000✔





932



        braces[0] = `${getPrefix(constructor, tag, 'Object')}{`;




8✔





933



      }




8✔





934



      if (keys.length === 0 && protoProps === undefined) {





5,000✔





935



        return `${braces[0]}}`;




152✔





936



      }




152✔





937



    } else if (typeof value === 'function') {





6,967✔





938



      base = getFunctionBase(value, constructor, tag);




620✔





939



      if (keys.length === 0 && protoProps === undefined)





620✔





940



        return ctx.stylize(base, 'special');





620✔





941



    } else if (isRegExp(value)) {





1,967✔





942



      // Make RegExps say that they are RegExps




52✔





943



      base = RegExpPrototypeToString(




52✔





944



        constructor !== null ? value : new RegExp(value)





52!





945



      );




52✔





946



      const prefix = getPrefix(constructor, tag, 'RegExp');




52✔





947



      if (prefix !== 'RegExp ')




52✔





948



        base = `${prefix}${base}`;





52✔





949



      if ((keys.length === 0 && protoProps === undefined) ||





52✔





950



          (recurseTimes > ctx.depth && ctx.depth !== null)) {





52✔





951



        return ctx.stylize(base, 'regexp');




24✔





952



      }




24✔





953



    } else if (isDate(value)) {





1,347✔





954



      // Make dates with properties first say the date




92✔





955



      base = NumberIsNaN(DatePrototypeGetTime(value)) ?





92✔





956



        DatePrototypeToString(value) :





92✔





957



        DatePrototypeToISOString(value);




92✔





958



      const prefix = getPrefix(constructor, tag, 'Date');




92✔





959



      if (prefix !== 'Date ')




92✔





960



        base = `${prefix}${base}`;





92✔





961



      if (keys.length === 0 && protoProps === undefined) {





92✔





962



        return ctx.stylize(base, 'date');




40✔





963



      }




40✔





964



    } else if (isError(value)) {





1,295✔





965



      base = formatError(value, constructor, tag, ctx, keys);




236✔





966



      if (keys.length === 0 && protoProps === undefined)





236✔





967



        return base;





236✔





968



    } else if (isAnyArrayBuffer(value)) {





1,203✔





969



      // Fast path for ArrayBuffer and SharedArrayBuffer.




148✔





970



      // Can't do the same for DataView because it has a non-primitive




148✔





971



      // .buffer property that we need to recurse for.




148✔





972



      const arrayType = isArrayBuffer(value) ? 'ArrayBuffer' :





148!





973



        'SharedArrayBuffer';




148✔





974



      const prefix = getPrefix(constructor, tag, arrayType);




148✔





975



      if (typedArray === undefined) {





148✔





976



        formatter = formatArrayBuffer;




60✔





977



      } else if (keys.length === 0 && protoProps === undefined) {





148✔





978



        return prefix +




76✔






979



              `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength, false)} }`;




76✔





980



      }




76✔





981



      braces[0] = `${prefix}{`;




148✔





982



      ArrayPrototypeUnshift(keys, 'byteLength');




148✔





983



    } else if (isDataView(value)) {





967✔





984



      braces[0] = `${getPrefix(constructor, tag, 'DataView')}{`;




24✔





985



      // .buffer goes last, it's not a primitive like the others.




24✔





986



      ArrayPrototypeUnshift(keys, 'byteLength', 'byteOffset', 'buffer');




24✔





987



    } else if (isPromise(value)) {





819✔





988



      braces[0] = `${getPrefix(constructor, tag, 'Promise')}{`;




40✔





989



      formatter = formatPromise;




40✔





990



    } else if (isWeakSet(value)) {





795✔





991



      braces[0] = `${getPrefix(constructor, tag, 'WeakSet')}{`;




48✔





992



      formatter = ctx.showHidden ? formatWeakSet : formatWeakCollection;





48✔





993



    } else if (isWeakMap(value)) {





755✔





994



      braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`;




48✔





995



      formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection;





48✔





996



    } else if (isModuleNamespaceObject(value)) {





707✔





997



      braces[0] = `${getPrefix(constructor, tag, 'Module')}{`;




4✔





998



      // Special handle keys for namespace objects.




4✔





999



      formatter = formatNamespaceObject.bind(null, keys);




4✔





1000



    } else if (isBoxedPrimitive(value)) {





659✔





1001



      base = getBoxedBase(value, ctx, keys, constructor, tag);




132✔





1002



      if (keys.length === 0 && protoProps === undefined) {





132✔





1003



        return base;




68✔





1004



      }




68✔





1005



    } else {





655✔





1006



      if (keys.length === 0 && protoProps === undefined) {





523✔





1007



        if (isExternal(value)) {





140✔





1008



          const address = getExternalValue(value).toString(16);




4✔





1009



          return ctx.stylize(`[External: ${address}]`, 'special');




4✔





1010



        }




4✔





1011



        return `${getCtxStyle(value, constructor, tag)}{}`;





136✔





1012



      }




136✔





1013



      braces[0] = `${getCtxStyle(value, constructor, tag)}{`;





383✔





1014



    }




383✔





1015



  }




6,967✔





1016






8,176✔





1017



  if (recurseTimes > ctx.depth && ctx.depth !== null) {





8,176✔





1018



    let constructorName = getCtxStyle(value, constructor, tag).slice(0, -1);




284✔





1019



    if (constructor !== null)




284✔





1020



      constructorName = `[${constructorName}]`;





284✔





1021



    return ctx.stylize(constructorName, 'special');




284✔





1022



  }




284✔





1023



  recurseTimes += 1;




8,176✔





1024






8,176✔





1025



  ctx.seen.push(value);




8,176✔





1026



  ctx.currentDepth = recurseTimes;




8,176✔





1027



  let output;




8,176✔





1028



  const indentationLvl = ctx.indentationLvl;




8,176✔





1029



  try {




8,176✔





1030



    output = formatter(ctx, value, recurseTimes);




8,176✔





1031



    for (i = 0; i < keys.length; i++) {





8,176✔





1032



      output.push(




8,641✔





1033



        formatProperty(ctx, value, recurseTimes, keys[i], extrasType));




8,641✔





1034



    }




8,641✔





1035



    if (protoProps !== undefined) {





8,176✔





1036



      output.push(...protoProps);




72✔





1037



    }




72✔





1038



  } catch (err) {





8,176✔





1039



    const constructorName = getCtxStyle(value, constructor, tag).slice(0, -1);




174✔





1040



    return handleMaxCallStackSize(ctx, err, constructorName, indentationLvl);




174✔





1041



  }




174✔





1042



  if (ctx.circular !== undefined) {





8,172✔





1043



    const index = ctx.circular.get(value);




92✔





1044



    if (index !== undefined) {





92✔





1045



      const reference = ctx.stylize(`<ref *${index}>`, 'special');




48✔





1046



      // Add reference always to the very beginning of the output.




48✔





1047



      if (ctx.compact !== true) {




48✔





1048



        base = base === '' ? reference : `${reference} ${base}`;





48✔





1049



      } else {





48!





1050



        braces[0] = `${reference} ${braces[0]}`;




×







1051



      }




×







1052



    }




48✔





1053



  }




92✔





1054



  ctx.seen.pop();





6,427✔





1055






6,427✔





1056



  if (ctx.sorted) {





8,172✔





1057



    const comparator = ctx.sorted === true ? undefined : ctx.sorted;





16✔





1058



    if (extrasType === kObjectType) {





16✔





1059



      output = output.sort(comparator);




8✔





1060



    } else if (keys.length > 1) {





8✔





1061



      const sorted = output.slice(output.length - keys.length).sort(comparator);




4✔





1062



      output.splice(output.length - keys.length, keys.length, ...sorted);




4✔





1063



    }




4✔





1064



  }




16✔





1065







6,427✔





1066



  const res = reduceToSingleString(




6,427✔





1067



    ctx, output, base, braces, extrasType, recurseTimes, value);




6,427✔





1068



  const budget = ctx.budget[ctx.indentationLvl] || 0;





8,176✔





1069



  const newLength = budget + res.length;




8,176✔





1070



  ctx.budget[ctx.indentationLvl] = newLength;




8,176✔





1071



  // If any indentationLvl exceeds this limit, limit further inspecting to the




8,176✔





1072



  // minimum. Otherwise the recursive algorithm might continue inspecting the




8,176✔





1073



  // object even though the maximum string size (~2 ** 28 on 32 bit systems and




8,176✔





1074



  // ~2 ** 30 on 64 bit systems) exceeded. The actual output is not limited at




8,176✔





1075



  // exactly 2 ** 27 but a bit higher. This depends on the object shape.




8,176✔





1076



  // This limit also makes sure that huge objects don't block the event loop




8,176✔





1077



  // significantly.




8,176✔





1078



  if (newLength > 2 ** 27) {





8,176!





1079



    ctx.depth = -1;




×







1080



  }




×







1081



  return res;





6,427✔





1082



}




8,176✔





1083






24✔





1084



function getIteratorBraces(type, tag) {





100✔





1085



  if (tag !== `${type} Iterator`) {





100✔





1086



    if (tag !== '')




20✔





1087



      tag += '] [';





20✔





1088



    tag += `${type} Iterator`;




20✔





1089



  }




20✔





1090



  return [`[${tag}] {`, '}'];




100✔





1091



}




100✔





1092






24✔





1093



function getBoxedBase(value, ctx, keys, constructor, tag) {





132✔





1094



  let fn;




132✔





1095



  let type;




132✔





1096



  if (isNumberObject(value)) {





132✔





1097



    fn = NumberPrototypeValueOf;




36✔





1098



    type = 'Number';




36✔





1099



  } else if (isStringObject(value)) {





132✔





1100



    fn = StringPrototypeValueOf;




28✔





1101



    type = 'String';




28✔





1102



    // For boxed Strings, we have to remove the 0-n indexed entries,




28✔





1103



    // since they just noisy up the output and are redundant




28✔





1104



    // Make boxed primitive Strings look like such




28✔





1105



    keys.splice(0, value.length);




28✔





1106



  } else if (isBooleanObject(value)) {





96✔





1107



    fn = BooleanPrototypeValueOf;




24✔





1108



    type = 'Boolean';




24✔





1109



  } else if (isBigIntObject(value)) {





68✔





1110



    fn = BigIntPrototypeValueOf;




24✔





1111



    type = 'BigInt';




24✔





1112



  } else {





44✔





1113



    fn = SymbolPrototypeValueOf;




20✔





1114



    type = 'Symbol';




20✔





1115



  }




20✔





1116



  let base = `[${type}`;




132✔





1117



  if (type !== constructor) {





132✔





1118



    if (constructor === null) {




4✔





1119



      base += ' (null prototype)';




4✔





1120



    } else {





4!





1121



      base += ` (${constructor})`;




×







1122



    }




×







1123



  }




4✔





1124



  base += `: ${formatPrimitive(stylizeNoColor, fn(value), ctx)}]`;




132✔





1125



  if (tag !== '' && tag !== constructor) {





132!





1126



    base += ` [${tag}]`;




×







1127



  }




×







1128



  if (keys.length !== 0 || ctx.stylize === stylizeNoColor)





132✔





1129



    return base;





132✔





1130



  return ctx.stylize(base, StringPrototypeToLowerCase(type));





4✔





1131



}




132✔





1132






24✔





1133



function getClassBase(value, constructor, tag) {





124✔





1134



  const hasName = ObjectPrototypeHasOwnProperty(value, 'name');




124✔





1135



  const name = (hasName && value.name) || '(anonymous)';





124✔





1136



  let base = `class ${name}`;




124✔





1137



  if (constructor !== 'Function' && constructor !== null) {





124✔





1138



    base += ` [${constructor}]`;




20✔





1139



  }




20✔





1140



  if (tag !== '' && constructor !== tag) {





124✔





1141



    base += ` [${tag}]`;




100✔





1142



  }




100✔





1143



  if (constructor !== null) {





124✔





1144



    const superName = ObjectGetPrototypeOf(value).name;




64✔





1145



    if (superName) {





64✔





1146



      base += ` extends ${superName}`;




28✔





1147



    }




28✔





1148



  } else {





124✔





1149



    base += ' extends [null prototype]';




60✔





1150



  }




60✔





1151



  return `[${base}]`;




124✔





1152



}




124✔





1153






24✔





1154



function getFunctionBase(value, constructor, tag) {





620✔





1155



  const stringified = FunctionPrototypeToString(value);




620✔






1156



  if (stringified.startsWith('class') && stringified.endsWith('}')) {





620✔





1157



    const slice = stringified.slice(5, -1);




128✔





1158



    const bracketIndex = slice.indexOf('{');




128✔





1159



    if (bracketIndex !== -1 &&




128✔





1160



        (!slice.slice(0, bracketIndex).includes('(') ||





128✔





1161



          // Slow path to guarantee that it's indeed a class.




4✔





1162



          classRegExp.test(slice.replace(stripCommentsRegExp)))) {





128✔





1163



      return getClassBase(value, constructor, tag);




124✔





1164



    }




124✔





1165



  }




128✔





1166



  let type = 'Function';




620✔





1167



  if (isGeneratorFunction(value)) {





620✔





1168



    type = `Generator${type}`;




36✔





1169



  }




36✔





1170



  if (isAsyncFunction(value)) {





620✔





1171



    type = `Async${type}`;




20✔





1172



  }




20✔





1173



  let base = `[${type}`;




620✔





1174



  if (constructor === null) {





620✔





1175



    base += ' (null prototype)';




16✔





1176



  }




16✔





1177



  if (value.name === '') {





620✔





1178



    base += ' (anonymous)';




116✔





1179



  } else {





620✔





1180



    base += `: ${value.name}`;




380✔





1181



  }




380✔





1182



  base += ']';




620✔





1183



  if (constructor !== type && constructor !== null) {





620✔





1184



    base += ` ${constructor}`;




12✔





1185



  }




12✔





1186



  if (tag !== '' && constructor !== tag) {





620✔





1187



    base += ` [${tag}]`;




12✔





1188



  }




12✔





1189



  return base;




620✔





1190



}




620✔





1191






24✔






NEW


1192



function identicalSequenceRange(a, b) {




×








NEW


1193



  for (let i = 0; i < a.length - 3; i++) {




×








NEW


1194



    // Find the first entry of b that matches the current entry of a.




×








NEW


1195



    const pos = b.indexOf(a[i]);




×








NEW


1196



    if (pos !== -1) {




×








NEW


1197



      const rest = b.length - pos;




×








NEW


1198



      if (rest > 3) {




×








NEW


1199



        let len = 1;




×








NEW


1200



        const maxLen = MathMin(a.length - i, rest);




×








NEW


1201



        // Count the number of consecutive entries.




×








NEW


1202



        while (maxLen > len && a[i + len] === b[pos + len]) {




×








NEW


1203



          len++;




×








NEW


1204



        }




×








NEW


1205



        if (len > 3) {




×








NEW


1206



          return { len, offset: i };




×








NEW


1207



        }




×








NEW


1208



      }




×








NEW


1209



    }




×








NEW


1210



  }




×








NEW


1211



  return { len: 0, offset: 0 };




×








NEW


1212



}




×







1213






24✔






1214



function getStackString(error) {





236✔






1215



  return error.stack ? String(error.stack) : ErrorPrototypeToString(error);





236✔






1216



}




236✔






1217






24✔






1218



function getStackFrames(ctx, err, stack) {





138✔






1219



  const frames = stack.split('\n');




138✔






1220






138✔






1221



  // Remove stack frames identical to frames in cause.




138✔






1222



  if (err.cause && isError(err.cause)) {





138!






NEW


1223



    const causeStack = getStackString(err.cause);




×








NEW


1224



    const causeStackStart = causeStack.indexOf('\n    at');




×








NEW


1225



    if (causeStackStart !== -1) {




×








NEW


1226



      const causeFrames = causeStack.slice(causeStackStart + 1).split('\n');




×








NEW


1227



      const { len, offset } = identicalSequenceRange(frames, causeFrames);




×








NEW


1228



      if (len > 0) {




×








NEW


1229



        const skipped = len - 2;




×








NEW


1230



        const msg = `    ... ${skipped} lines matching cause stack trace ...`;




×








NEW


1231



        frames.splice(offset + 1, skipped, ctx.stylize(msg, 'undefined'));




×








UNCOV

1232



      }




×








UNCOV

1233



    }




×








UNCOV

1234



  }




×








1235



  return frames;




138✔






1236



}




138✔





1237






24✔






1238



function improveStack(stack, constructor, name, tag) {





236✔





1239



  // A stack trace may contain arbitrary data. Only manipulate the output




236✔





1240



  // for "regular errors" (errors that "look normal") for now.




236✔






1241



  let len = name.length;




236✔






1242






236✔





1243



  if (constructor === null ||




236✔





1244



      (name.endsWith('Error') &&





236✔





1245



      stack.startsWith(name) &&





236✔





1246



      (stack.length === len || stack[len] === ':' || stack[len] === '\n'))) {





236✔





1247



    let fallback = 'Error';




172✔





1248



    if (constructor === null) {





172!





1249



      const start = stack.match(/^([A-Z][a-z_ A-Z0-9[\]()-]+)(?::|\n {4}at)/) ||




×







1250



        stack.match(/^([a-z_A-Z0-9-]*Error)$/);




×







1251



      fallback = (start && start[1]) || '';




×







1252



      len = fallback.length;




×







1253



      fallback = fallback || 'Error';




×







1254



    }




×







1255



    const prefix = getPrefix(constructor, tag, fallback).slice(0, -1);




172✔





1256



    if (name !== prefix) {





172✔





1257



      if (prefix.includes(name)) {





60✔





1258



        if (len === 0) {





28!





1259



          stack = `${prefix}: ${stack}`;




×







1260



        } else {




28✔





1261



          stack = `${prefix}${stack.slice(len)}`;




28✔





1262



        }




28✔





1263



      } else {





60✔





1264



        stack = `${prefix} [${name}]${stack.slice(len)}`;




32✔





1265



      }




32✔





1266



    }




60✔





1267



  }




172✔






1268



  return stack;




236✔






1269



}




236✔






1270






24✔






1271



function removeDuplicateErrorKeys(ctx, keys, err, stack) {





236✔






1272



  if (!ctx.showHidden && keys.length !== 0) {





236✔






1273



    for (const name of ['name', 'message', 'stack']) {





72✔






1274



      const index = keys.indexOf(name);




216✔






1275



      // Only hide the property in case it's part of the original stack




216✔






1276



      if (index !== -1 && stack.includes(err[name])) {





216✔






1277



        keys.splice(index, 1);




52✔






1278



      }




52✔






1279



    }




216✔






1280



  }




72✔






1281



}




236✔






1282






24✔






1283



function formatError(err, constructor, tag, ctx, keys) {





236✔






1284



  const name = err.name != null ? String(err.name) : 'Error';





236✔






1285



  let stack = getStackString(err);




236✔






1286






236✔






1287



  removeDuplicateErrorKeys(ctx, keys, err, stack);




236✔






1288






236✔






1289



  if ('cause' in err &&





236!






1290



      (keys.length === 0 || !keys.includes('cause'))) {





236!






1291



    keys.push('cause');




6✔






1292



  }




6✔






1293






236✔






1294



  stack = improveStack(stack, constructor, name, tag);




236✔






1295






236✔





1296



  // Ignore the error message if it's contained in the stack.




236✔





1297



  let pos = (err.message && stack.indexOf(err.message)) || -1;





236✔





1298



  if (pos !== -1)




236✔





1299



    pos += err.message.length;





236✔





1300



  // Wrap the error in brackets in case it has no stack trace.




236✔





1301



  const stackStart = stack.indexOf('\n    at', pos);




236✔





1302



  if (stackStart === -1) {





236✔





1303



    stack = `[${stack}]`;




98✔






1304



  } else {





236✔





1305



    let newStack = stack.slice(0, stackStart);




138✔






1306



    const lines = getStackFrames(ctx, err, stack.slice(stackStart + 1));




138✔






1307



    if (ctx.colors) {





138✔






1308



      // Highlight userland code and node modules.




6✔






1309



      for (const line of lines) {





6✔






1310



        const core = line.match(coreModuleRegExp);




42✔






1311



        if (core !== null && NativeModule.exists(core[1])) {





42✔






1312



          newStack += `\n${ctx.stylize(line, 'undefined')}`;




32✔






1313



        } else {





42✔






1314



          // This adds underscores to all node_modules to quickly identify them.




10✔






1315



          let nodeModule;




10✔






1316



          newStack += '\n';




10✔






1317



          let pos = 0;




10✔






1318



          while ((nodeModule = nodeModulesRegExp.exec(line)) !== null) {





10✔






1319



            // '/node_modules/'.length === 14




8✔






1320



            newStack += line.slice(pos, nodeModule.index + 14);




8✔






1321



            newStack += ctx.stylize(nodeModule[1], 'module');




8✔






1322



            pos = nodeModule.index + nodeModule[0].length;




8✔






1323



          }




8✔






1324



          newStack += pos === 0 ? line : line.slice(pos);





10✔





1325



        }




10✔





1326



      }




42✔






1327



    } else {





138✔






1328



      newStack += `\n${lines.join('\n')}`;




132✔





1329



    }




132✔





1330



    stack = newStack;




138✔





1331



  }




138✔





1332



  // The message and the stack have to be indented as well!




236✔





1333



  if (ctx.indentationLvl !== 0) {





236!





1334



    const indentation = ' '.repeat(ctx.indentationLvl);




×







1335



    stack = stack.replace(/\n/g, `\n${indentation}`);




×







1336



  }




×







1337



  return stack;




236✔





1338



}




236✔





1339






24✔





1340



function groupArrayElements(ctx, output, value) {





204✔





1341



  let totalLength = 0;




204✔





1342



  let maxLength = 0;




204✔





1343



  let i = 0;




204✔





1344



  let outputLength = output.length;




204✔





1345



  if (ctx.maxArrayLength < output.length) {





204✔





1346



    // This makes sure the "... n more items" part is not taken into account.




24✔





1347



    outputLength--;




24✔





1348



  }




24✔





1349



  const separatorSpace = 2; // Add 1 for the space and 1 for the separator.




204✔





1350



  const dataLen = new Array(outputLength);




204✔





1351



  // Calculate the total length of all output entries and the individual max




204✔





1352



  // entries length of all output entries. We have to remove colors first,




204✔





1353



  // otherwise the length would not be calculated properly.




204✔





1354



  for (; i < outputLength; i++) {





204✔





1355



    const len = getStringWidth(output[i], ctx.colors);




7,556✔





1356



    dataLen[i] = len;




7,556✔





1357



    totalLength += len + separatorSpace;




7,556✔





1358



    if (maxLength < len)




7,556✔





1359



      maxLength = len;





7,556✔





1360



  }




7,556✔





1361



  // Add two to `maxLength` as we add a single whitespace character plus a comma




204✔





1362



  // in-between two entries.




204✔





1363



  const actualMax = maxLength + separatorSpace;




204✔





1364



  // Check if at least three entries fit next to each other and prevent grouping




204✔





1365



  // of arrays that contains entries of very different length (i.e., if a single




204✔





1366



  // entry is longer than 1/5 of all other entries combined). Otherwise the




204✔





1367



  // space in-between small entries would be enormous.




204✔





1368



  if (actualMax * 3 + ctx.indentationLvl < ctx.breakLength &&





204✔





1369



      (totalLength / actualMax > 5 || maxLength <= 6)) {





204✔





1370






104✔





1371



    const approxCharHeights = 2.5;




104✔





1372



    const averageBias = MathSqrt(actualMax - totalLength / output.length);




104✔





1373



    const biasedMax = MathMax(actualMax - 3 - averageBias, 1);




104✔





1374



    // Dynamically check how many columns seem possible.




104✔





1375



    const columns = MathMin(




104✔





1376



      // Ideally a square should be drawn. We expect a character to be about 2.5




104✔





1377



      // times as high as wide. This is the area formula to calculate a square




104✔





1378



      // which contains n rectangles of size `actualMax * approxCharHeights`.




104✔





1379



      // Divide that by `actualMax` to receive the correct number of columns.




104✔





1380



      // The added bias increases the columns for short entries.




104✔





1381



      MathRound(




104✔





1382



        MathSqrt(




104✔





1383



          approxCharHeights * biasedMax * outputLength




104✔





1384



        ) / biasedMax




104✔





1385



      ),




104✔





1386



      // Do not exceed the breakLength.




104✔





1387



      MathFloor((ctx.breakLength - ctx.indentationLvl) / actualMax),




104✔





1388



      // Limit array grouping for small `compact` modes as the user requested




104✔





1389



      // minimal grouping.




104✔





1390



      ctx.compact * 4,




104✔





1391



      // Limit the columns to a maximum of fifteen.




104✔





1392



      15




104✔





1393



    );




104✔





1394



    // Return with the original output if no grouping should happen.




104✔





1395



    if (columns <= 1) {





104✔





1396



      return output;




4✔





1397



    }




4✔





1398



    const tmp = [];




104✔





1399



    const maxLineLength = [];




104✔





1400



    for (let i = 0; i < columns; i++) {





104✔





1401



      let lineMaxLength = 0;




636✔





1402



      for (let j = i; j < output.length; j += columns) {





636✔





1403



        if (dataLen[j] > lineMaxLength)




6,404✔





1404



          lineMaxLength = dataLen[j];





6,404✔





1405



      }




6,404✔





1406



      lineMaxLength += separatorSpace;




636✔





1407



      maxLineLength[i] = lineMaxLength;




636✔





1408



    }




636✔





1409



    let order = StringPrototypePadStart;




104✔





1410



    if (value !== undefined) {




104✔





1411



      for (let i = 0; i < output.length; i++) {





104✔





1412



        if (typeof value[i] !== 'number' && typeof value[i] !== 'bigint') {





3,384✔





1413



          order = StringPrototypePadEnd;




44✔





1414



          break;




44✔





1415



        }




44✔





1416



      }




3,384✔





1417



    }




104✔





1418



    // Each iteration creates a single line of grouped entries.




104✔





1419



    for (let i = 0; i < outputLength; i += columns) {





104✔





1420



      // The last lines may contain less entries than columns.




1,052✔





1421



      const max = MathMin(i + columns, outputLength);




1,052✔





1422



      let str = '';




1,052✔





1423



      let j = i;




1,052✔





1424



      for (; j < max - 1; j++) {





1,052✔





1425



        // Calculate extra color padding in case it's active. This has to be




5,332✔





1426



        // done line by line as some lines might contain more colors than




5,332✔





1427



        // others.




5,332✔





1428



        const padding = maxLineLength[j - i] + output[j].length - dataLen[j];




5,332✔





1429



        str += order(`${output[j]}, `, padding, ' ');




5,332✔





1430



      }




5,332✔





1431



      if (order === StringPrototypePadStart) {





1,052✔





1432



        const padding = maxLineLength[j - i] +




392✔





1433



                        output[j].length -




392✔





1434



                        dataLen[j] -




392✔





1435



                        separatorSpace;




392✔





1436



        str += StringPrototypePadStart(output[j], padding, ' ');




392✔





1437



      } else {





1,052✔





1438



        str += output[j];




660✔





1439



      }




660✔





1440



      ArrayPrototypePush(tmp, str);




1,052✔





1441



    }




1,052✔





1442



    if (ctx.maxArrayLength < output.length) {





104✔





1443



      ArrayPrototypePush(tmp, output[outputLength]);




20✔





1444



    }




20✔





1445



    output = tmp;




104✔





1446



  }




104✔





1447



  return output;




204✔





1448



}




204✔





1449






24✔





1450



function handleMaxCallStackSize(ctx, err, constructorName, indentationLvl) {





6✔





1451



  if (isStackOverflowError(err)) {





6✔





1452



    ctx.seen.pop();




4✔





1453



    ctx.indentationLvl = indentationLvl;




4✔





1454



    return ctx.stylize(




4✔





1455



      `[${constructorName}: Inspection interrupted ` +




4✔





1456



        'prematurely. Maximum call stack size exceeded.]',




4✔





1457



      'special'




4✔





1458



    );




4✔





1459



  }




4✔





1460



  /* c8 ignore next */





4✔





1461



  assert.fail(err.stack);




4✔





1462



}




6✔





1463






24✔






1464



function addNumericSeparator(integerString) {





52✔






1465



  let result = '';




52✔






1466



  let i = integerString.length;




52✔






1467



  const start = integerString.startsWith('-') ? 1 : 0;





52✔






1468



  for (; i >= start + 4; i -= 3) {





52✔






1469



    result = `_${integerString.slice(i - 3, i)}${result}`;




88✔






1470



  }




88✔






1471



  return i === integerString.length ?





52✔






1472



    integerString :





52✔






1473



    `${integerString.slice(0, i)}${result}`;




52✔





1474



}




52✔





1475






24✔






1476



function addNumericSeparatorEnd(integerString) {





16✔






1477



  let result = '';




16✔






1478



  let i = 0;




16✔






1479



  for (; i < integerString.length - 3; i += 3) {





16✔






1480



    result += `${integerString.slice(i, i + 3)}_`;




24✔






1481



  }




24✔






1482



  return i === 0 ?





16✔






1483



    integerString :





16✔






1484



    `${result}${integerString.slice(i)}`;




16✔






1485



}




16✔






1486






24✔






1487



function formatNumber(fn, number, numericSeparator) {





6,457✔






1488



  if (!numericSeparator) {





6,457✔






1489



    // Format -0 as '-0'. Checking `number === -0` won't distinguish 0 from -0.




6,397✔






1490



    if (ObjectIs(number, -0)) {





6,397✔






1491



      return fn('-0', 'number');




4✔






1492



    }




4✔






1493



    return fn(`${number}`, 'number');





6,393✔






1494



  }




6,393✔






1495



  const integer = MathTrunc(number);




6,457✔






1496



  const string = String(integer);




6,457✔






1497



  if (integer === number) {





6,457✔






1498



    if (!NumberIsFinite(number) || string.includes('e')) {





40✔






1499



      return fn(string, 'number');




12✔






1500



    }




12✔






1501



    return fn(`${addNumericSeparator(string)}`, 'number');




40✔






1502



  }




40✔






1503



  if (NumberIsNaN(number)) {





6,457✔






1504



    return fn(string, 'number');




4✔






1505



  }




4✔






1506



  return fn(`${




6,457✔






1507



    addNumericSeparator(string)




6,457✔






1508



  }.${




6,457✔






1509



    addNumericSeparatorEnd(String(number).slice(string.length + 1))




6,457✔






1510



  }`, 'number');




6,457✔






1511



}




6,457✔






1512






24✔






1513



function formatBigInt(fn, bigint, numericSeparator) {





268✔






1514



  const string = String(bigint);




268✔






1515



  if (!numericSeparator) {





268✔






1516



    return fn(`${string}n`, 'bigint');




260✔






1517



  }




260✔






1518



  return fn(`${addNumericSeparator(string)}n`, 'bigint');





8✔





1519



}




268✔





1520






24✔





1521



function formatPrimitive(fn, value, ctx) {





44,990✔





1522



  if (typeof value === 'string') {





44,990✔





1523



    let trailer = '';




39,949✔





1524



    if (value.length > ctx.maxStringLength) {





39,949✔





1525



      const remaining = value.length - ctx.maxStringLength;




12✔





1526



      value = value.slice(0, ctx.maxStringLength);




12✔





1527



      trailer = `... ${remaining} more character${remaining > 1 ? 's' : ''}`;





12✔





1528



    }




12✔





1529



    if (ctx.compact !== true &&





39,949✔





1530



        // TODO(BridgeAR): Add unicode support. Use the readline getStringWidth




39,917✔





1531



        // function.




39,917✔





1532



        value.length > kMinLineLength &&





39,949✔





1533



        value.length > ctx.breakLength - ctx.indentationLvl - 4) {





39,949✔





1534



      return value




16,470✔





1535



        .split(/\n/) // Safari hack to avoid negative lookbehind




16,470✔





1536



        .map((line, i, a) => fn(strEscape(





16,470✔





1537



          line + ((i === a.length - 1) ? '' : '\n')





16,514✔





1538



        ), 'string'))




16,470✔





1539



        .join(` +\n${' '.repeat(ctx.indentationLvl + 2)}`) + trailer;




16,470✔





1540



    }




16,470✔





1541



    return fn(strEscape(value), 'string') + trailer;





23,479✔





1542



  }




23,479✔





1543



  if (typeof value === 'number')





5,041✔






1544



    return formatNumber(fn, value, ctx.numericSeparator);





44,986✔





1545



  if (typeof value === 'bigint')





588✔






1546



    return formatBigInt(fn, value, ctx.numericSeparator);





44,878✔





1547



  if (typeof value === 'boolean')





500✔





1548



    return fn(`${value}`, 'boolean');





44,874✔





1549



  if (typeof value === 'undefined')




44,874✔





1550



    return fn('undefined', 'undefined');





44,874✔





1551



  // es6 symbol primitive




44,874✔





1552



  return fn(SymbolPrototypeToString(value), 'symbol');




44,874✔





1553



}




44,990✔





1554






24✔





1555



function formatNamespaceObject(keys, ctx, value, recurseTimes) {





4✔





1556



  const output = new Array(keys.length);




4✔





1557



  for (let i = 0; i < keys.length; i++) {




4✔





1558



    try {




4✔





1559



      output[i] = formatProperty(ctx, value, recurseTimes, keys[i],




4✔





1560



                                 kObjectType);




4✔





1561



    } catch (err) {





4!





1562



      assert(isNativeError(err) && err.name === 'ReferenceError');




×







1563



      // Use the existing functionality. This makes sure the indentation and




×







1564



      // line breaks are always correct. Otherwise it is very difficult to keep




×







1565



      // this aligned, even though this is a hacky way of dealing with this.




×







1566



      const tmp = { [keys[i]]: '' };




×







1567



      output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i], kObjectType);




×







1568



      const pos = output[i].lastIndexOf(' ');




×







1569



      // We have to find the last whitespace and have to replace that value as




×







1570



      // it will be visualized as a regular string.




×







1571



      output[i] = output[i].slice(0, pos + 1) +




×







1572



                  ctx.stylize('<uninitialized>', 'special');




×







1573



    }




×







1574



  }




4✔





1575



  // Reset the keys to an empty array. This prevents duplicated inspection.




4✔





1576



  keys.length = 0;




4✔





1577



  return output;




4✔





1578



}




4✔





1579






24✔





1580



// The array is sparse and/or has extra keys




24✔





1581



function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) {





100✔





1582



  const keys = ObjectKeys(value);




100✔





1583



  let index = i;




100✔





1584



  for (; i < keys.length && output.length < maxLength; i++) {





100✔





1585



    const key = keys[i];




116✔





1586



    const tmp = +key;




116✔





1587



    // Arrays can only have up to 2^32 - 1 entries




116✔





1588



    if (tmp > 2 ** 32 - 2) {





116✔





1589



      break;




12✔





1590



    }




12✔





1591



    if (`${index}` !== key) {





116✔





1592



      if (!numberRegExp.test(key)) {





100✔





1593



        break;




32✔





1594



      }




32✔





1595



      const emptyItems = tmp - index;





68✔





1596



      const ending = emptyItems > 1 ? 's' : '';





100✔





1597



      const message = `<${emptyItems} empty item${ending}>`;




100✔





1598



      output.push(ctx.stylize(message, 'undefined'));




100✔





1599



      index = tmp;




100✔





1600



      if (output.length === maxLength) {





100✔





1601



        break;




8✔





1602



      }




8✔





1603



    }




100✔





1604



    output.push(formatProperty(ctx, value, recurseTimes, key, kArrayType));





64✔





1605



    index++;




64✔





1606



  }




64✔





1607



  const remaining = value.length - index;




100✔





1608



  if (output.length !== maxLength) {





100✔





1609



    if (remaining > 0) {





76✔





1610



      const ending = remaining > 1 ? 's' : '';





52✔





1611



      const message = `<${remaining} empty item${ending}>`;




52✔





1612



      output.push(ctx.stylize(message, 'undefined'));




52✔





1613



    }




52✔





1614



  } else if (remaining > 0) {





100✔





1615



    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);





8✔





1616



  }




8✔





1617



  return output;




100✔





1618



}




100✔





1619






24✔





1620



function formatArrayBuffer(ctx, value) {





60✔





1621



  let buffer;




60✔





1622



  try {




60✔





1623



    buffer = new Uint8Array(value);




60✔





1624



  } catch {





60✔





1625



    return [ctx.stylize('(detached)', 'special')];




4✔





1626



  }




4✔





1627



  if (hexSlice === undefined)




60✔





1628



    hexSlice = uncurryThis(require('./buffer').Buffer.prototype.hexSlice);





60✔





1629



  let str = StringPrototypeTrim(StringPrototypeReplace(




60✔





1630



    hexSlice(buffer, 0, MathMin(ctx.maxArrayLength, buffer.length)),




60✔





1631



    /(.{2})/g, '$1 '));




60✔





1632



  const remaining = buffer.length - ctx.maxArrayLength;




60✔





1633



  if (remaining > 0)




60✔





1634



    str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;





60✔





1635



  return [`${ctx.stylize('[Uint8Contents]', 'special')}: <${str}>`];





56✔





1636



}




60✔





1637






24✔





1638



function formatArray(ctx, value, recurseTimes) {





520✔





1639



  const valLen = value.length;




520✔





1640



  const len = MathMin(MathMax(0, ctx.maxArrayLength), valLen);




520✔





1641






520✔





1642



  const remaining = valLen - len;




520✔





1643



  const output = [];




520✔





1644



  for (let i = 0; i < len; i++) {





520✔





1645



    // Special handle sparse arrays.




5,956✔





1646



    if (!ObjectPrototypeHasOwnProperty(value, i)) {





5,956✔





1647



      return formatSpecialArray(ctx, value, recurseTimes, len, output, i);




100✔





1648



    }




100✔





1649



    output.push(formatProperty(ctx, value, recurseTimes, i, kArrayType));





5,856✔





1650



  }




5,856✔





1651



  if (remaining > 0)





420✔





1652



    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);





520✔





1653



  return output;





420✔





1654



}




520✔





1655






24✔





1656



function formatTypedArray(value, length, ctx, ignored, recurseTimes) {





228✔





1657



  const maxLength = MathMin(MathMax(0, ctx.maxArrayLength), length);




228✔





1658



  const remaining = value.length - maxLength;




228✔





1659



  const output = new Array(maxLength);




228✔





1660



  const elementFormatter = value.length > 0 && typeof value[0] === 'number' ?





228✔





1661



    formatNumber :





228✔





1662



    formatBigInt;




228✔






1663



  for (let i = 0; i < maxLength; ++i) {





228✔






1664



    output[i] = elementFormatter(ctx.stylize, value[i], ctx.numericSeparator);




2,108✔






1665



  }




2,108✔





1666



  if (remaining > 0) {





228✔





1667



    output[maxLength] = `... ${remaining} more item${remaining > 1 ? 's' : ''}`;





8✔





1668



  }




8✔





1669



  if (ctx.showHidden) {





228✔





1670



    // .buffer goes last, it's not a primitive like the others.




88✔





1671



    // All besides `BYTES_PER_ELEMENT` are actually getters.




88✔





1672



    ctx.indentationLvl += 2;




88✔





1673



    for (const key of [




88✔





1674



      'BYTES_PER_ELEMENT',




88✔





1675



      'length',




88✔





1676



      'byteLength',




88✔





1677



      'byteOffset',




88✔





1678



      'buffer',




88✔





1679



    ]) {





88✔





1680



      const str = formatValue(ctx, value[key], recurseTimes, true);




440✔





1681



      ArrayPrototypePush(output, `[${key}]: ${str}`);




440✔





1682



    }




440✔





1683



    ctx.indentationLvl -= 2;




88✔





1684



  }




88✔





1685



  return output;




228✔





1686



}




228✔





1687






24✔





1688



function formatSet(value, ctx, ignored, recurseTimes) {





40✔





1689



  const output = [];




40✔





1690



  ctx.indentationLvl += 2;




40✔





1691



  for (const v of value) {





40✔





1692



    ArrayPrototypePush(output, formatValue(ctx, v, recurseTimes));




476✔





1693



  }




476✔





1694



  ctx.indentationLvl -= 2;




40✔





1695



  return output;




40✔





1696



}




40✔





1697






24✔





1698



function formatMap(value, ctx, ignored, recurseTimes) {





76✔





1699



  const output = [];




76✔





1700



  ctx.indentationLvl += 2;




76✔





1701



  for (const { 0: k, 1: v } of value) {





76✔





1702



    output.push(




488✔





1703



      `${formatValue(ctx, k, recurseTimes)} => ${formatValue(ctx, v, recurseTimes)}`




488✔





1704



    );




488✔





1705



  }




488✔





1706



  ctx.indentationLvl -= 2;




76✔





1707



  return output;




76✔





1708



}




76✔





1709






24✔





1710



function formatSetIterInner(ctx, recurseTimes, entries, state) {





112✔





1711



  const maxArrayLength = MathMax(ctx.maxArrayLength, 0);




112✔





1712



  const maxLength = MathMin(maxArrayLength, entries.length);




112✔





1713



  const output = new Array(maxLength);




112✔





1714



  ctx.indentationLvl += 2;




112✔





1715



  for (let i = 0; i < maxLength; i++) {





112✔





1716



    output[i] = formatValue(ctx, entries[i], recurseTimes);




12✔





1717



  }




12✔





1718



  ctx.indentationLvl -= 2;




112✔





1719



  if (state === kWeak && !ctx.sorted) {





112✔





1720



    // Sort all entries to have a halfway reliable output (if more entries than




12✔





1721



    // retrieved ones exist, we can not reliably return the same output) if the




12✔





1722



    // output is not sorted anyway.




12✔





1723



    ArrayPrototypeSort(output);




12✔





1724



  }




12✔





1725



  const remaining = entries.length - maxLength;




112✔





1726



  if (remaining > 0) {





112✔





1727



    ArrayPrototypePush(output,




8✔





1728



                       `... ${remaining} more item${remaining > 1 ? 's' : ''}`);





8✔





1729



  }




8✔





1730



  return output;




112✔





1731



}




112✔





1732






24✔





1733



function formatMapIterInner(ctx, recurseTimes, entries, state) {





12✔





1734



  const maxArrayLength = MathMax(ctx.maxArrayLength, 0);




12✔





1735



  // Entries exist as [key1, val1, key2, val2, ...]




12✔





1736



  const len = entries.length / 2;




12✔





1737



  const remaining = len - maxArrayLength;




12✔





1738



  const maxLength = MathMin(maxArrayLength, len);




12✔





1739



  let output = new Array(maxLength);




12✔





1740



  let i = 0;




12✔





1741



  ctx.indentationLvl += 2;




12✔





1742



  if (state === kWeak) {




12✔





1743



    for (; i < maxLength; i++) {





12✔





1744



      const pos = i * 2;




8✔





1745



      output[i] =




8✔





1746



        `${formatValue(ctx, entries[pos], recurseTimes)} => ${formatValue(ctx, entries[pos + 1], recurseTimes)}`;




8✔





1747



    }




8✔





1748



    // Sort all entries to have a halfway reliable output (if more entries than




12✔





1749



    // retrieved ones exist, we can not reliably return the same output) if the




12✔





1750



    // output is not sorted anyway.




12✔





1751



    if (!ctx.sorted)




12✔





1752



      output = output.sort();




12✔





1753



  } else {





12!





1754



    for (; i < maxLength; i++) {




×







1755



      const pos = i * 2;




×







1756



      const res = [




×







1757



        formatValue(ctx, entries[pos], recurseTimes),




×







1758



        formatValue(ctx, entries[pos + 1], recurseTimes),




×







1759



      ];




×







1760



      output[i] = reduceToSingleString(




×







1761



        ctx, res, '', ['[', ']'], kArrayExtrasType, recurseTimes);




×







1762



    }




×







1763



  }




×







1764



  ctx.indentationLvl -= 2;




12✔





1765



  if (remaining > 0) {





12✔





1766



    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);





4!





1767



  }




4✔





1768



  return output;




12✔





1769



}




12✔





1770






24✔





1771



function formatWeakCollection(ctx) {





72✔





1772



  return [ctx.stylize('<items unknown>', 'special')];




72✔





1773



}




72✔





1774






24✔





1775



function formatWeakSet(ctx, value, recurseTimes) {





12✔





1776



  const entries = previewEntries(value);




12✔





1777



  return formatSetIterInner(ctx, recurseTimes, entries, kWeak);




12✔





1778



}




12✔





1779






24✔





1780



function formatWeakMap(ctx, value, recurseTimes) {





12✔





1781



  const entries = previewEntries(value);




12✔





1782



  return formatMapIterInner(ctx, recurseTimes, entries, kWeak);




12✔





1783



}




12✔





1784






24✔





1785



function formatIterator(braces, ctx, value, recurseTimes) {





100✔





1786



  const { 0: entries, 1: isKeyValue } = previewEntries(value, true);




100✔





1787



  if (isKeyValue) {





100!





1788



    // Mark entry iterators as such.




×







1789



    braces[0] = braces[0].replace(/ Iterator] {$/, ' Entries] {');




×







1790



    return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries);




×







1791



  }




×







1792






100✔





1793



  return formatSetIterInner(ctx, recurseTimes, entries, kIterator);




100✔





1794



}




100✔





1795






24✔





1796



function formatPromise(ctx, value, recurseTimes) {





40✔





1797



  let output;




40✔





1798



  const { 0: state, 1: result } = getPromiseDetails(value);




40✔





1799



  if (state === kPending) {




40✔





1800



    output = [ctx.stylize('<pending>', 'special')];




40✔





1801



  } else {





40!





1802



    ctx.indentationLvl += 2;




×







1803



    const str = formatValue(ctx, result, recurseTimes);




×







1804



    ctx.indentationLvl -= 2;




×







1805



    output = [




×







1806



      state === kRejected ?




×







1807



        `${ctx.stylize('<rejected>', 'special')} ${str}` :




×







1808



        str,




×







1809



    ];




×







1810



  }




×







1811



  return output;




40✔





1812



}




40✔





1813






24✔





1814



function formatProperty(ctx, value, recurseTimes, key, type, desc,





14,657✔





1815



                        original = value) {




14,657✔





1816



  let name, str;




14,657✔





1817



  let extra = ' ';




14,657✔





1818



  desc = desc || ObjectGetOwnPropertyDescriptor(value, key) ||





14,657✔





1819



    { value: value[key], enumerable: true };




14,657✔





1820



  if (desc.value !== undefined) {





14,657✔





1821



    const diff = (ctx.compact !== true || type !== kObjectType) ? 2 : 3;





12,091✔





1822



    ctx.indentationLvl += diff;




12,091✔





1823



    str = formatValue(ctx, desc.value, recurseTimes);




12,091✔





1824



    if (diff === 3 && ctx.breakLength < getStringWidth(str, ctx.colors)) {





12,091✔





1825



      extra = `\n${' '.repeat(ctx.indentationLvl)}`;




16✔





1826



    }




16✔





1827



    ctx.indentationLvl -= diff;





11,917✔





1828



  } else if (desc.get !== undefined) {





14,657✔





1829



    const label = desc.set !== undefined ? 'Getter/Setter' : 'Getter';





136✔





1830



    const s = ctx.stylize;




136✔





1831



    const sp = 'special';




136✔





1832



    if (ctx.getters && (ctx.getters === true ||





136✔





1833



          (ctx.getters === 'get' && desc.set === undefined) ||





84✔





1834



          (ctx.getters === 'set' && desc.set !== undefined))) {





136✔





1835



      try {




76✔





1836



        const tmp = FunctionPrototypeCall(desc.get, original);




76✔





1837



        ctx.indentationLvl += 2;




76✔





1838



        if (tmp === null) {





76✔





1839



          str = `${s(`[${label}:`, sp)} ${s('null', 'null')}${s(']', sp)}`;




4✔





1840



        } else if (typeof tmp === 'object') {





76✔





1841



          str = `${s(`[${label}]`, sp)} ${formatValue(ctx, tmp, recurseTimes)}`;




16✔





1842



        } else {





68✔





1843



          const primitive = formatPrimitive(s, tmp, ctx);




52✔





1844



          str = `${s(`[${label}:`, sp)} ${primitive}${s(']', sp)}`;




52✔





1845



        }




52✔





1846



        ctx.indentationLvl -= 2;




68✔





1847



      } catch (err) {





76✔





1848



        const message = `<Inspection threw (${err.message})>`;




8✔





1849



        str = `${s(`[${label}:`, sp)} ${message}${s(']', sp)}`;




8✔





1850



      }




8✔





1851



    } else {





136✔





1852



      str = ctx.stylize(`[${label}]`, sp);




60✔





1853



    }




60✔





1854



  } else if (desc.set !== undefined) {





2,566✔





1855



    str = ctx.stylize('[Setter]', 'special');




8✔





1856



  } else {





2,430✔





1857



    str = ctx.stylize('undefined', 'undefined');




2,422✔





1858



  }




2,422✔





1859



  if (type === kArrayType) {





14,657✔





1860



    return str;




5,920✔





1861



  }




5,920✔





1862



  if (typeof key === 'symbol') {





14,657✔





1863



    const tmp = StringPrototypeReplace(




292✔





1864



      SymbolPrototypeToString(key),




292✔





1865



      strEscapeSequencesReplacer, escapeFn




292✔





1866



    );




292✔





1867



    name = `[${ctx.stylize(tmp, 'symbol')}]`;




292✔





1868



  } else if (key === '__proto__') {





14,657✔





1869



    name = "['__proto__']";




4✔





1870



  } else if (desc.enumerable === false) {





8,271✔





1871



    const tmp = StringPrototypeReplace(key,




206✔





1872



                                       strEscapeSequencesReplacer, escapeFn);




206✔





1873



    name = `[${tmp}]`;




206✔





1874



  } else if (RegExpPrototypeTest(keyStrRegExp, key)) {





8,251✔





1875



    name = ctx.stylize(key, 'name');




7,261✔





1876



  } else {





8,061✔





1877



    name = ctx.stylize(strEscape(key), 'string');




800✔





1878



  }




800✔





1879



  return `${name}:${extra}${str}`;





8,563✔





1880



}




14,657✔





1881






24✔





1882



function isBelowBreakLength(ctx, output, start, base) {





2,393✔





1883



  // Each entry is separated by at least a comma. Thus, we start with a total




2,393✔





1884



  // length of at least `output.length`. In addition, some cases have a




2,393✔





1885



  // whitespace in-between each other that is added to the total as well.




2,393✔





1886



  // TODO(BridgeAR): Add unicode support. Use the readline getStringWidth




2,393✔





1887



  // function. Check the performance overhead and make it an opt-in in case it's




2,393✔





1888



  // significant.




2,393✔





1889



  let totalLength = output.length + start;




2,393✔





1890



  if (totalLength + output.length > ctx.breakLength)




2,393✔





1891



    return false;





2,393✔





1892



  for (let i = 0; i < output.length; i++) {





2,393✔





1893



    if (ctx.colors) {





4,406✔





1894



      totalLength += removeColors(output[i]).length;




200✔





1895



    } else {





4,406✔





1896



      totalLength += output[i].length;




4,206✔





1897



    }




4,206✔





1898



    if (totalLength > ctx.breakLength) {





4,406✔





1899



      return false;




352✔





1900



    }




352✔





1901



  }




4,406✔





1902



  // Do not line up properties on the same line if `base` contains line breaks.





1,991✔





1903



  return base === '' || !StringPrototypeIncludes(base, '\n');





2,393✔





1904



}




2,393✔





1905






24✔





1906



function reduceToSingleString(





6,547✔





1907



  ctx, output, base, braces, extrasType, recurseTimes, value) {




6,547✔





1908



  if (ctx.compact !== true) {





6,547✔





1909



    if (typeof ctx.compact === 'number' && ctx.compact >= 1) {





6,483✔





1910



      // Memorize the original output length. In case the output is grouped,




6,411✔





1911



      // prevent lining up the entries on a single line.




6,411✔





1912



      const entries = output.length;




6,411✔





1913



      // Group array elements together if the array contains at least six




6,411✔





1914



      // separate entries.




6,411✔





1915



      if (extrasType === kArrayExtrasType && entries > 6) {





6,411✔





1916



        output = groupArrayElements(ctx, output, value);




204✔





1917



      }




204✔





1918



      // `ctx.currentDepth` is set to the most inner depth of the currently




6,411✔





1919



      // inspected object part while `recurseTimes` is the actual current depth




6,411✔





1920



      // that is inspected.




6,411✔





1921



      //




6,411✔





1922



      // Example:




6,411✔





1923



      //




6,411✔





1924



      // const a = { first: [ 1, 2, 3 ], second: { inner: [ 1, 2, 3 ] } }




6,411✔





1925



      //




6,411✔





1926



      // The deepest depth of `a` is 2 (a.second.inner) and `a.first` has a max




6,411✔





1927



      // depth of 1.




6,411✔





1928



      //




6,411✔





1929



      // Consolidate all entries of the local most inner depth up to




6,411✔





1930



      // `ctx.compact`, as long as the properties are smaller than




6,411✔





1931



      // `ctx.breakLength`.




6,411✔





1932



      if (ctx.currentDepth - recurseTimes < ctx.compact &&





6,411✔





1933



          entries === output.length) {





6,411✔





1934



        // Line up all entries on a single line in case the entries do not




2,329✔





1935



        // exceed `breakLength`. Add 10 as constant to start next to all other




2,329✔





1936



        // factors that may reduce `breakLength`.




2,329✔





1937



        const start = output.length + ctx.indentationLvl +




2,329✔





1938



                      braces[0].length + base.length + 10;




2,329✔





1939



        if (isBelowBreakLength(ctx, output, start, base)) {





2,329✔






1940



          const joinedOutput = join(output, ', ');




1,979✔






1941



          if (!joinedOutput.includes('\n')) {





1,979✔






1942



            return `${base ? `${base} ` : ''}${braces[0]} ${joinedOutput}` +





1,971✔






1943



              ` ${braces[1]}`;




1,971✔






1944



          }




1,971✔





1945



        }




1,979✔





1946



      }




2,329✔





1947



    }




6,411✔





1948



    // Line up each entry on an individual line.




6,483✔





1949



    const indentation = `\n${StringPrototypeRepeat(' ', ctx.indentationLvl)}`;




6,483✔





1950



    return `${base ? `${base} ` : ''}${braces[0]}${indentation}  ` +





6,483✔





1951



      `${join(output, `,${indentation}  `)}${indentation}${braces[1]}`;




6,483✔





1952



  }




6,483✔





1953



  // Line up all entries on a single line in case the entries do not exceed





64✔





1954



  // `breakLength`.




64✔





1955



  if (isBelowBreakLength(ctx, output, 0, base)) {





6,379✔





1956



    return `${braces[0]}${base ? ` ${base}` : ''} ${join(output, ', ')} ` +





8✔





1957



      braces[1];




8✔





1958



  }




8✔





1959



  const indentation = StringPrototypeRepeat(' ', ctx.indentationLvl);




6,379✔





1960



  // If the opening "brace" is too large, like in the case of "Set {",




6,379✔





1961



  // we need to force the first item to be on the next line or the




6,379✔





1962



  // items will not line up correctly.




6,379✔





1963



  const ln = base === '' && braces[0].length === 1 ?





6,547✔





1964



    ' ' : `${base ? ` ${base}` : ''}\n${indentation}  `;





6,547✔





1965



  // Line up each entry on an individual line.




6,547✔





1966



  return `${braces[0]}${ln}${join(output, `,\n${indentation}  `)} ${braces[1]}`;




6,547✔





1967



}




6,547✔





1968






24✔





1969



function hasBuiltInToString(value) {





4✔





1970



  // Prevent triggering proxy traps.




4✔





1971



  const getFullProxy = false;




4✔





1972



  const proxyTarget = getProxyDetails(value, getFullProxy);




4✔





1973



  if (proxyTarget !== undefined) {




4✔





1974



    value = proxyTarget;




4✔





1975



  }




4✔





1976






4✔





1977



  // Count objects that have no `toString` function as built-in.




4✔





1978



  if (typeof value.toString !== 'function') {





4!





1979



    return true;




×







1980



  }




×







1981






4✔





1982



  // The object has a own `toString` property. Thus it's not not a built-in one.




4✔





1983



  if (ObjectPrototypeHasOwnProperty(value, 'toString')) {





4!





1984



    return false;




×







1985



  }




×







1986






4✔





1987



  // Find the object that has the `toString` property as own property in the




4✔





1988



  // prototype chain.




4✔





1989



  let pointer = value;




4✔





1990



  do {




4✔





1991



    pointer = ObjectGetPrototypeOf(pointer);




4✔





1992



  } while (!ObjectPrototypeHasOwnProperty(pointer, 'toString'));




4✔





1993






4✔





1994



  // Check closer if the object is a built-in.




4✔





1995



  const descriptor = ObjectGetOwnPropertyDescriptor(pointer, 'constructor');




4✔





1996



  return descriptor !== undefined &&




4✔





1997



    typeof descriptor.value === 'function' &&




4✔





1998



    builtInObjects.has(descriptor.value.name);




4✔





1999



}




4✔





2000






24✔





2001



const firstErrorLine = (error) =>




24✔





2002



  StringPrototypeSplit(error.message, '\n', 1)[0];




24✔





2003



let CIRCULAR_ERROR_MESSAGE;




24✔





2004



function tryStringify(arg) {




×







2005



  try {




×







2006



    return JSONStringify(arg);




×







2007



  } catch (err) {




×







2008



    // Populate the circular error message lazily




×







2009



    if (!CIRCULAR_ERROR_MESSAGE) {




×







2010



      try {




×







2011



        const a = {}; a.a = a; JSONStringify(a);




×








NEW


2012



      } catch (circularError) {




×








NEW


2013



        CIRCULAR_ERROR_MESSAGE = firstErrorLine(circularError);




×







2014



      }




×







2015



    }




×







2016



    if (err.name === 'TypeError' &&




×







2017



        firstErrorLine(err) === CIRCULAR_ERROR_MESSAGE) {




×







2018



      return '[Circular]';




×







2019



    }




×







2020



    throw err;




×







2021



  }




×







2022



}




×







2023






24✔





2024



function format(...args) {





36✔





2025



  return formatWithOptionsInternal(undefined, args);




36✔





2026



}




36✔





2027






24✔





2028



function formatWithOptions(inspectOptions, ...args) {




×







2029



  if (typeof inspectOptions !== 'object' || inspectOptions === null) {




×







2030



    throw new ERR_INVALID_ARG_TYPE(




×







2031



      'inspectOptions', 'object', inspectOptions);




×







2032



  }




×







2033



  return formatWithOptionsInternal(inspectOptions, args);




×







2034



}




×







2035






24✔






NEW


2036



function formatNumberNoColor(number, options) {




×








NEW


2037



  return formatNumber(




×








NEW


2038



    stylizeNoColor,




×








NEW


2039



    number,




×








NEW


2040



    // Maintain node 12 compat




×








NEW


2041



    // options?.numericSeparator ?? inspectDefaultOptions.numericSeparator




×








NEW


2042



    (options != null) && (options.numericSeparator != null) ?




×








NEW


2043



      options.numericSeparator : inspectDefaultOptions.numericSeparator




×








NEW


2044



  );




×








NEW


2045



}




×








2046






24✔






NEW


2047



function formatBigIntNoColor(bigint, options) {




×








NEW


2048



  return formatBigInt(




×








NEW


2049



    stylizeNoColor,




×








NEW


2050



    bigint,




×








NEW


2051



    // Maintain node 12 compat




×








NEW


2052



    // options?.numericSeparator ?? inspectDefaultOptions.numericSeparator




×








NEW


2053



    (options != null) && (options.numericSeparator != null) ?




×








NEW


2054



      options.numericSeparator : inspectDefaultOptions.numericSeparator




×








NEW


2055



  );




×








NEW


2056



}




×








2057






24✔





2058



function formatWithOptionsInternal(inspectOptions, args) {





36✔





2059



  const first = args[0];




36✔





2060



  let a = 0;




36✔





2061



  let str = '';




36✔





2062



  let join = '';




36✔





2063






36✔





2064



  if (typeof first === 'string') {




36✔





2065



    if (args.length === 1) {





36!





2066



      return first;




×







2067



    }




×







2068



    let tempStr;




36✔





2069



    let lastPos = 0;




36✔





2070






36✔





2071



    for (let i = 0; i < first.length - 1; i++) {





36✔





2072



      if (StringPrototypeCharCodeAt(first, i) === 37) { // '%'





1,860✔





2073



        const nextChar = StringPrototypeCharCodeAt(first, ++i);




68✔





2074



        if (a + 1 !== args.length) {




68✔





2075



          switch (nextChar) {




68✔






2076



            case 115: { // 's'





68✔





2077



              const tempArg = args[++a];




36✔





2078



              if (typeof tempArg === 'number') {





36!






NEW


2079



                tempStr = formatNumberNoColor(tempArg, inspectOptions);




×







2080



              } else if (typeof tempArg === 'bigint') {





36!






NEW


2081



                tempStr = formatBigIntNoColor(tempArg, inspectOptions);




×







2082



              } else if (typeof tempArg !== 'object' ||





36✔





2083



                         tempArg === null ||





36✔





2084



                         !hasBuiltInToString(tempArg)) {





36✔





2085



                tempStr = String(tempArg);




32✔





2086



              } else {





36✔





2087



                tempStr = inspect(tempArg, {




4✔





2088



                  ...inspectOptions,




4✔





2089



                  compact: 3,




4✔





2090



                  colors: false,




4✔





2091



                  depth: 0




4✔





2092



                });




4✔





2093



              }




4✔





2094



              break;




36✔






2095



            }




36✔





2096



            case 106: // 'j'





68!





2097



              tempStr = tryStringify(args[++a]);




×







2098



              break;




×








2099



            case 100: { // 'd'





68!





2100



              const tempNum = args[++a];




×







2101



              if (typeof tempNum === 'bigint') {




×








NEW


2102



                tempStr = formatBigIntNoColor(tempNum, inspectOptions);




×







2103



              } else if (typeof tempNum === 'symbol') {




×







2104



                tempStr = 'NaN';




×







2105



              } else {




×








NEW


2106



                tempStr = formatNumberNoColor(Number(tempNum), inspectOptions);




×







2107



              }




×







2108



              break;




×








NEW


2109



            }




×







2110



            case 79: // 'O'





68!





2111



              tempStr = inspect(args[++a], inspectOptions);




×







2112



              break;




×







2113



            case 111: // 'o'





68✔





2114



              tempStr = inspect(args[++a], {




32✔





2115



                ...inspectOptions,




32✔





2116



                showHidden: true,




32✔





2117



                showProxy: true,




32✔





2118



                depth: 4




32✔





2119



              });




32✔





2120



              break;




32✔






2121



            case 105: { // 'i'





68!





2122



              const tempInteger = args[++a];




×







2123



              if (typeof tempInteger === 'bigint') {




×








NEW


2124



                tempStr = formatBigIntNoColor(tempInteger, inspectOptions);




×







2125



              } else if (typeof tempInteger === 'symbol') {




×







2126



                tempStr = 'NaN';




×







2127



              } else {




×








NEW


2128



                tempStr = formatNumberNoColor(




×








NEW


2129



                  NumberParseInt(tempInteger), inspectOptions);




×







2130



              }




×







2131



              break;




×








NEW


2132



            }




×








2133



            case 102: { // 'f'





68!





2134



              const tempFloat = args[++a];




×







2135



              if (typeof tempFloat === 'symbol') {




×







2136



                tempStr = 'NaN';




×







2137



              } else {




×








NEW


2138



                tempStr = formatNumberNoColor(




×








NEW


2139



                  NumberParseFloat(tempFloat), inspectOptions);




×







2140



              }




×







2141



              break;




×








NEW


2142



            }




×







2143



            case 99: // 'c'





68!





2144



              a += 1;




×







2145



              tempStr = '';




×







2146



              break;




×







2147



            case 37: // '%'





68!





2148



              str += StringPrototypeSlice(first, lastPos, i);




×







2149



              lastPos = i + 1;




×







2150



              continue;




×







2151



            default: // Any other character is not a correct placeholder





68!





2152



              continue;




×







2153



          }




68✔





2154



          if (lastPos !== i - 1) {





68✔





2155



            str += StringPrototypeSlice(first, lastPos, i - 1);




64✔





2156



          }




64✔





2157



          str += tempStr;




68✔





2158



          lastPos = i + 1;




68✔





2159



        } else if (nextChar === 37) {





68!





2160



          str += StringPrototypeSlice(first, lastPos, i);




×







2161



          lastPos = i + 1;




×







2162



        }




×







2163



      }




68✔





2164



    }




1,860✔





2165



    if (lastPos !== 0) {




36✔





2166



      a++;




36✔





2167



      join = ' ';




36✔





2168



      if (lastPos < first.length) {





36✔





2169



        str += StringPrototypeSlice(first, lastPos);




32✔





2170



      }




32✔





2171



    }




36✔





2172



  }




36✔





2173






36✔





2174



  while (a < args.length) {





36!





2175



    const value = args[a];




×







2176



    str += join;




×







2177



    str += typeof value !== 'string' ? inspect(value, inspectOptions) : value;




×







2178



    join = ' ';




×







2179



    a++;




×







2180



  }




×







2181



  return str;




36✔





2182



}




36✔





2183






24✔





2184



if (internalBinding('config').hasIntl) {





24!





2185



  const icu = internalBinding('icu');




×







2186



  // icu.getStringWidth(string, ambiguousAsFullWidth, expandEmojiSequence)




×







2187



  // Defaults: ambiguousAsFullWidth = false; expandEmojiSequence = true;




×







2188



  // TODO(BridgeAR): Expose the options to the user. That is probably the




×







2189



  // best thing possible at the moment, since it's difficult to know what




×







2190



  // the receiving end supports.




×







2191



  getStringWidth = function getStringWidth(str, removeControlChars = true) {




×







2192



    let width = 0;




×







2193






×







2194



    if (removeControlChars)




×







2195



      str = stripVTControlCharacters(str);




×







2196



    for (let i = 0; i < str.length; i++) {




×







2197



      // Try to avoid calling into C++ by first handling the ASCII portion of




×







2198



      // the string. If it is fully ASCII, we skip the C++ part.




×







2199



      const code = str.charCodeAt(i);




×







2200



      if (code >= 127) {




×







2201



        width += icu.getStringWidth(str.slice(i).normalize('NFC'));




×







2202



        break;




×







2203



      }




×







2204



      width += code >= 32 ? 1 : 0;




×







2205



    }




×







2206



    return width;




×







2207



  };




×







2208



} else {




24✔





2209



  /**




24✔





2210



   * Returns the number of columns required to display the given string.




24✔





2211



   */




24✔





2212



  getStringWidth = function getStringWidth(str, removeControlChars = true) {





24✔





2213



    let width = 0;




7,600✔





2214






7,600✔





2215



    if (removeControlChars)




7,600✔





2216



      str = stripVTControlCharacters(str);





7,600✔





2217



    str = StringPrototypeNormalize(str, 'NFC');




7,600✔





2218



    for (const char of new SafeStringIterator(str)) {





7,600✔





2219



      const code = StringPrototypeCodePointAt(char, 0);




59,912✔





2220



      if (isFullWidthCodePoint(code)) {





59,912✔





2221



        width += 2;




24✔





2222



      } else if (!isZeroWidthCodePoint(code)) {





59,912✔





2223



        width++;




59,868✔





2224



      }




59,868✔





2225



    }




59,912✔





2226






7,600✔





2227



    return width;




7,600✔





2228



  };




24✔





2229






24✔





2230



  /**




24✔





2231



   * Returns true if the character represented by a given




24✔





2232



   * Unicode code point is full-width. Otherwise returns false.




24✔





2233



   */




24✔





2234



  const isFullWidthCodePoint = (code) => {





24✔





2235



    // Code points are partially derived from:




59,912✔





2236



    // https://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt




59,912✔





2237



    return code >= 0x1100 && (





59,912✔





2238



      code <= 0x115f ||  // Hangul Jamo




24✔





2239



      code === 0x2329 || // LEFT-POINTING ANGLE BRACKET




24✔





2240



      code === 0x232a || // RIGHT-POINTING ANGLE BRACKET




24✔





2241



      // CJK Radicals Supplement .. Enclosed CJK Letters and Months




24✔





2242



      (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) ||





24!





2243



      // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A




×







2244



      (code >= 0x3250 && code <= 0x4dbf) ||





24!





2245



      // CJK Unified Ideographs .. Yi Radicals




×







2246



      (code >= 0x4e00 && code <= 0xa4c6) ||





24!





2247



      // Hangul Jamo Extended-A




×







2248



      (code >= 0xa960 && code <= 0xa97c) ||





24!





2249



      // Hangul Syllables




×







2250



      (code >= 0xac00 && code <= 0xd7a3) ||





24!





2251



      // CJK Compatibility Ideographs




×







2252



      (code >= 0xf900 && code <= 0xfaff) ||





24!





2253



      // Vertical Forms




×







2254



      (code >= 0xfe10 && code <= 0xfe19) ||





24!





2255



      // CJK Compatibility Forms .. Small Form Variants




×







2256



      (code >= 0xfe30 && code <= 0xfe6b) ||





24!





2257



      // Halfwidth and Fullwidth Forms




×







2258



      (code >= 0xff01 && code <= 0xff60) ||





24!





2259



      (code >= 0xffe0 && code <= 0xffe6) ||





24!





2260



      // Kana Supplement




×







2261



      (code >= 0x1b000 && code <= 0x1b001) ||





24!





2262



      // Enclosed Ideographic Supplement




×







2263



      (code >= 0x1f200 && code <= 0x1f251) ||





24!





2264



      // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff




×







2265



      // Emoticons 0x1f600 - 0x1f64f




×







2266



      (code >= 0x1f300 && code <= 0x1f64f) ||





24!





2267



      // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane




×







2268



      (code >= 0x20000 && code <= 0x3fffd)




×







2269



    );




59,912✔





2270



  };




24✔





2271






24✔





2272



  const isZeroWidthCodePoint = (code) => {





24✔





2273



    return code <= 0x1F || // C0 control codes





59,888✔





2274



      (code >= 0x7F && code <= 0x9F) || // C1 control codes





59,888!





2275



      (code >= 0x300 && code <= 0x36F) || // Combining Diacritical Marks





59,888!





2276



      (code >= 0x200B && code <= 0x200F) || // Modifying Invisible Characters





59,888!





2277



      // Combining Diacritical Marks for Symbols




59,868✔





2278



      (code >= 0x20D0 && code <= 0x20FF) ||





59,888!





2279



      (code >= 0xFE00 && code <= 0xFE0F) || // Variation Selectors





59,888!





2280



      (code >= 0xFE20 && code <= 0xFE2F) || // Combining Half Marks





59,888!





2281



      (code >= 0xE0100 && code <= 0xE01EF); // Variation Selectors





59,888!





2282



  };




24✔





2283



}




24✔





2284






24✔





2285



/**




24✔





2286



 * Remove all VT control characters. Use to estimate displayed string width.




24✔





2287



 */




24✔





2288



function stripVTControlCharacters(str) {





704✔






2289



  validateString(str, 'str');




704✔





2290



  return str.replace(ansi, '');




704✔





2291



}




704✔





2292






24✔





2293



module.exports = {




24✔





2294



  inspect,




24✔





2295



  format,




24✔





2296



  formatWithOptions,




24✔





2297



  getStringWidth,




24✔





2298



  inspectDefaultOptions,




24✔





2299



  stripVTControlCharacters,




24✔





2300



  stylizeWithColor,




24✔





2301



  stylizeWithHTML(str, styleType) {




24✔





2302



    const style = inspect.styles[styleType];




×







2303



    if (style !== undefined) {




×







2304



      return `<span style="color:${style};">${str}</span>`;




×







2305



    }




×







2306



    return str;




×







2307



  },




24✔





2308



  Proxy




24✔





2309



};




24✔



















    

  • 

    •