@volter/tabnode 0.2.14-volter.88

package/src/node-lib/internal/util/inspect.js

@@ -0,0 +1,2535 @@
+'use strict';
+
+const {
+  Array,
+  ArrayBuffer,
+  ArrayBufferPrototype,
+  ArrayIsArray,
+  ArrayPrototype,
+  ArrayPrototypeFilter,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypePushApply,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSort,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  BigIntPrototypeValueOf,
+  Boolean,
+  BooleanPrototype,
+  BooleanPrototypeValueOf,
+  DataView,
+  DataViewPrototype,
+  Date,
+  DatePrototype,
+  DatePrototypeGetTime,
+  DatePrototypeToISOString,
+  DatePrototypeToString,
+  Error,
+  ErrorPrototype,
+  ErrorPrototypeToString,
+  Function,
+  FunctionPrototype,
+  FunctionPrototypeBind,
+  FunctionPrototypeCall,
+  FunctionPrototypeSymbolHasInstance,
+  FunctionPrototypeToString,
+  JSONStringify,
+  Map,
+  MapPrototype,
+  MapPrototypeEntries,
+  MapPrototypeGetSize,
+  MathFloor,
+  MathMax,
+  MathMin,
+  MathRound,
+  MathSqrt,
+  MathTrunc,
+  Number,
+  NumberIsFinite,
+  NumberIsNaN,
+  NumberParseFloat,
+  NumberParseInt,
+  NumberPrototype,
+  NumberPrototypeToString,
+  NumberPrototypeValueOf,
+  Object,
+  ObjectAssign,
+  ObjectDefineProperty,
+  ObjectGetOwnPropertyDescriptor,
+  ObjectGetOwnPropertyNames,
+  ObjectGetOwnPropertySymbols,
+  ObjectGetPrototypeOf,
+  ObjectIs,
+  ObjectKeys,
+  ObjectPrototype,
+  ObjectPrototypeHasOwnProperty,
+  ObjectPrototypePropertyIsEnumerable,
+  ObjectSeal,
+  ObjectSetPrototypeOf,
+  Promise,
+  PromisePrototype,
+  ReflectApply,
+  ReflectOwnKeys,
+  RegExp,
+  RegExpPrototype,
+  RegExpPrototypeExec,
+  RegExpPrototypeSymbolReplace,
+  RegExpPrototypeSymbolSplit,
+  RegExpPrototypeToString,
+  SafeMap,
+  SafeSet,
+  SafeStringIterator,
+  Set,
+  SetPrototype,
+  SetPrototypeGetSize,
+  SetPrototypeValues,
+  String,
+  StringPrototype,
+  StringPrototypeCharCodeAt,
+  StringPrototypeCodePointAt,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  StringPrototypeIndexOf,
+  StringPrototypeLastIndexOf,
+  StringPrototypeNormalize,
+  StringPrototypePadEnd,
+  StringPrototypePadStart,
+  StringPrototypeRepeat,
+  StringPrototypeReplace,
+  StringPrototypeReplaceAll,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  StringPrototypeToLowerCase,
+  StringPrototypeTrim,
+  StringPrototypeValueOf,
+  SymbolIterator,
+  SymbolPrototypeToString,
+  SymbolPrototypeValueOf,
+  SymbolToPrimitive,
+  SymbolToStringTag,
+  TypedArray,
+  TypedArrayPrototype,
+  TypedArrayPrototypeGetLength,
+  TypedArrayPrototypeGetSymbolToStringTag,
+  Uint8Array,
+  WeakMap,
+  WeakMapPrototype,
+  WeakSet,
+  WeakSetPrototype,
+  globalThis,
+  uncurryThis,
+} = primordials;
+
+const {
+  constants: {
+    ALL_PROPERTIES,
+    ONLY_ENUMERABLE,
+    kPending,
+    kRejected,
+  },
+  getOwnNonIndexProperties,
+  getPromiseDetails,
+  getProxyDetails,
+  previewEntries,
+  getConstructorName: internalGetConstructorName,
+  getExternalValue,
+} = internalBinding('util');
+
+const {
+  customInspectSymbol,
+  isError,
+  join,
+  removeColors,
+} = require('internal/util');
+
+const {
+  isStackOverflowError,
+} = require('internal/errors');
+
+const {
+  isAsyncFunction,
+  isGeneratorFunction,
+  isAnyArrayBuffer,
+  isArrayBuffer,
+  isArgumentsObject,
+  isBoxedPrimitive,
+  isDataView,
+  isExternal,
+  isMap,
+  isMapIterator,
+  isModuleNamespaceObject,
+  isNativeError,
+  isPromise,
+  isSet,
+  isSetIterator,
+  isWeakMap,
+  isWeakSet,
+  isRegExp,
+  isDate,
+  isTypedArray,
+  isStringObject,
+  isNumberObject,
+  isBooleanObject,
+  isBigIntObject,
+} = require('internal/util/types');
+
+const assert = require('internal/assert');
+
+const { BuiltinModule } = require('internal/bootstrap/realm');
+const {
+  validateObject,
+  validateString,
+  kValidateObjectAllowArray,
+} = require('internal/validators');
+
+let hexSlice;
+let internalUrl;
+
+function pathToFileUrlHref(filepath) {
+  internalUrl ??= require('internal/url');
+  return internalUrl.pathToFileURL(filepath).href;
+}
+
+function isURL(value) {
+  internalUrl ??= require('internal/url');
+  return typeof value.href === 'string' && value instanceof internalUrl.URL;
+}
+
+const builtInObjects = new SafeSet(
+  ArrayPrototypeFilter(
+    ObjectGetOwnPropertyNames(globalThis),
+    (e) => RegExpPrototypeExec(/^[A-Z][a-zA-Z0-9]+$/, e) !== null,
+  ),
+);
+
+// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+const isUndetectableObject = (v) => typeof v === 'undefined' && v !== undefined;
+
+// These options must stay in sync with `getUserOptions`. So if any option will
+// be added or removed, `getUserOptions` must also be updated accordingly.
+const inspectDefaultOptions = ObjectSeal({
+  showHidden: false,
+  depth: 2,
+  colors: false,
+  customInspect: true,
+  showProxy: false,
+  maxArrayLength: 100,
+  maxStringLength: 10000,
+  breakLength: 80,
+  compact: 3,
+  sorted: false,
+  getters: false,
+  numericSeparator: false,
+});
+
+const kObjectType = 0;
+const kArrayType = 1;
+const kArrayExtrasType = 2;
+
+/* eslint-disable no-control-regex */
+const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;
+const strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+const strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;
+/* eslint-enable no-control-regex */
+
+const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+const numberRegExp = /^(0|[1-9][0-9]*)$/;
+
+const coreModuleRegExp = /^ {4}at (?:[^/\\(]+ \(|)node:(.+):\d+:\d+\)?$/;
+const nodeModulesRegExp = /[/\\]node_modules[/\\](.+?)(?=[/\\])/g;
+
+const classRegExp = /^(\s+[^(]*?)\s*{/;
+// eslint-disable-next-line node-core/no-unescaped-regexp-dot
+const stripCommentsRegExp = /(\/\/.*?\n)|(\/\*(.|\n)*?\*\/)/g;
+
+const kMinLineLength = 16;
+
+// Constants to map the iterator state.
+const kWeak = 0;
+const kIterator = 1;
+const kMapEntries = 2;
+
+// Escaped control characters (plus the single quote and the backslash). Use
+// empty strings to fill up unused entries.
+const meta = [
+  '\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07
+  '\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F',           // x0F
+  '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17
+  '\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F
+  '', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '',      // x2F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x3F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x4F
+  '', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '',     // x5F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x6F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F',    // x7F
+  '\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87
+  '\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F
+  '\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97
+  '\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F
+];
+
+// Regex used for ansi escape code splitting
+// Ref: https://github.com/chalk/ansi-regex/blob/f338e1814144efb950276aac84135ff86b72dc8e/index.js
+// License: MIT by Sindre Sorhus <sindresorhus@gmail.com>
+// Matches all ansi escape code sequences in a string
+const ansi = new RegExp(
+  '[\\u001B\\u009B][[\\]()#;?]*' +
+  '(?:(?:(?:(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]+)*' +
+  '|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]*)*)?' +
+  '(?:\\u0007|\\u001B\\u005C|\\u009C))' +
+  '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?' +
+  '[\\dA-PR-TZcf-nq-uy=><~]))', 'g',
+);
+
+let getStringWidth;
+
+function getUserOptions(ctx, isCrossContext) {
+  const ret = {
+    stylize: ctx.stylize,
+    showHidden: ctx.showHidden,
+    depth: ctx.depth,
+    colors: ctx.colors,
+    customInspect: ctx.customInspect,
+    showProxy: ctx.showProxy,
+    maxArrayLength: ctx.maxArrayLength,
+    maxStringLength: ctx.maxStringLength,
+    breakLength: ctx.breakLength,
+    compact: ctx.compact,
+    sorted: ctx.sorted,
+    getters: ctx.getters,
+    numericSeparator: ctx.numericSeparator,
+    ...ctx.userOptions,
+  };
+
+  // Typically, the target value will be an instance of `Object`. If that is
+  // *not* the case, the object may come from another vm.Context, and we want
+  // to avoid passing it objects from this Context in that case, so we remove
+  // the prototype from the returned object itself + the `stylize()` function,
+  // and remove all other non-primitives, including non-primitive user options.
+  if (isCrossContext) {
+    ObjectSetPrototypeOf(ret, null);
+    for (const key of ObjectKeys(ret)) {
+      if ((typeof ret[key] === 'object' || typeof ret[key] === 'function') &&
+          ret[key] !== null) {
+        delete ret[key];
+      }
+    }
+    ret.stylize = ObjectSetPrototypeOf((value, flavour) => {
+      let stylized;
+      try {
+        stylized = `${ctx.stylize(value, flavour)}`;
+      } catch {
+        // Continue regardless of error.
+      }
+
+      if (typeof stylized !== 'string') return value;
+      // `stylized` is a string as it should be, which is safe to pass along.
+      return stylized;
+    }, null);
+  }
+
+  return ret;
+}
+
+/**
+ * Echos the value of any input. Tries to print the value out
+ * in the best way possible given the different types.
+ * @param {any} value The value to print out.
+ * @param {object} opts Optional options object that alters the output.
+ */
+/* Legacy: value, showHidden, depth, colors */
+function inspect(value, opts) {
+  // Default options
+  const ctx = {
+    budget: {},
+    indentationLvl: 0,
+    seen: [],
+    currentDepth: 0,
+    stylize: stylizeNoColor,
+    showHidden: inspectDefaultOptions.showHidden,
+    depth: inspectDefaultOptions.depth,
+    colors: inspectDefaultOptions.colors,
+    customInspect: inspectDefaultOptions.customInspect,
+    showProxy: inspectDefaultOptions.showProxy,
+    maxArrayLength: inspectDefaultOptions.maxArrayLength,
+    maxStringLength: inspectDefaultOptions.maxStringLength,
+    breakLength: inspectDefaultOptions.breakLength,
+    compact: inspectDefaultOptions.compact,
+    sorted: inspectDefaultOptions.sorted,
+    getters: inspectDefaultOptions.getters,
+    numericSeparator: inspectDefaultOptions.numericSeparator,
+  };
+  if (arguments.length > 1) {
+    // Legacy...
+    if (arguments.length > 2) {
+      if (arguments[2] !== undefined) {
+        ctx.depth = arguments[2];
+      }
+      if (arguments.length > 3 && arguments[3] !== undefined) {
+        ctx.colors = arguments[3];
+      }
+    }
+    // Set user-specified options
+    if (typeof opts === 'boolean') {
+      ctx.showHidden = opts;
+    } else if (opts) {
+      const optKeys = ObjectKeys(opts);
+      for (let i = 0; i < optKeys.length; ++i) {
+        const key = optKeys[i];
+        // TODO(BridgeAR): Find a solution what to do about stylize. Either make
+        // this function public or add a new API with a similar or better
+        // functionality.
+        if (
+          ObjectPrototypeHasOwnProperty(inspectDefaultOptions, key) ||
+          key === 'stylize') {
+          ctx[key] = opts[key];
+        } else if (ctx.userOptions === undefined) {
+          // This is required to pass through the actual user input.
+          ctx.userOptions = opts;
+        }
+      }
+    }
+  }
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  if (ctx.maxArrayLength === null) ctx.maxArrayLength = Infinity;
+  if (ctx.maxStringLength === null) ctx.maxStringLength = Infinity;
+  return formatValue(ctx, value, 0);
+}
+inspect.custom = customInspectSymbol;
+
+ObjectDefineProperty(inspect, 'defaultOptions', {
+  __proto__: null,
+  get() {
+    return inspectDefaultOptions;
+  },
+  set(options) {
+    validateObject(options, 'options');
+    return ObjectAssign(inspectDefaultOptions, options);
+  },
+});
+
+// Set Graphics Rendition https://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+// Each color consists of an array with the color code as first entry and the
+// reset code as second entry.
+const defaultFG = 39;
+const defaultBG = 49;
+inspect.colors = {
+  __proto__: null,
+  reset: [0, 0],
+  bold: [1, 22],
+  dim: [2, 22], // Alias: faint
+  italic: [3, 23],
+  underline: [4, 24],
+  blink: [5, 25],
+  // Swap foreground and background colors
+  inverse: [7, 27], // Alias: swapcolors, swapColors
+  hidden: [8, 28], // Alias: conceal
+  strikethrough: [9, 29], // Alias: strikeThrough, crossedout, crossedOut
+  doubleunderline: [21, 24], // Alias: doubleUnderline
+  black: [30, defaultFG],
+  red: [31, defaultFG],
+  green: [32, defaultFG],
+  yellow: [33, defaultFG],
+  blue: [34, defaultFG],
+  magenta: [35, defaultFG],
+  cyan: [36, defaultFG],
+  white: [37, defaultFG],
+  bgBlack: [40, defaultBG],
+  bgRed: [41, defaultBG],
+  bgGreen: [42, defaultBG],
+  bgYellow: [43, defaultBG],
+  bgBlue: [44, defaultBG],
+  bgMagenta: [45, defaultBG],
+  bgCyan: [46, defaultBG],
+  bgWhite: [47, defaultBG],
+  framed: [51, 54],
+  overlined: [53, 55],
+  gray: [90, defaultFG], // Alias: grey, blackBright
+  redBright: [91, defaultFG],
+  greenBright: [92, defaultFG],
+  yellowBright: [93, defaultFG],
+  blueBright: [94, defaultFG],
+  magentaBright: [95, defaultFG],
+  cyanBright: [96, defaultFG],
+  whiteBright: [97, defaultFG],
+  bgGray: [100, defaultBG], // Alias: bgGrey, bgBlackBright
+  bgRedBright: [101, defaultBG],
+  bgGreenBright: [102, defaultBG],
+  bgYellowBright: [103, defaultBG],
+  bgBlueBright: [104, defaultBG],
+  bgMagentaBright: [105, defaultBG],
+  bgCyanBright: [106, defaultBG],
+  bgWhiteBright: [107, defaultBG],
+};
+
+function defineColorAlias(target, alias) {
+  ObjectDefineProperty(inspect.colors, alias, {
+    __proto__: null,
+    get() {
+      return this[target];
+    },
+    set(value) {
+      this[target] = value;
+    },
+    configurable: true,
+    enumerable: false,
+  });
+}
+
+defineColorAlias('gray', 'grey');
+defineColorAlias('gray', 'blackBright');
+defineColorAlias('bgGray', 'bgGrey');
+defineColorAlias('bgGray', 'bgBlackBright');
+defineColorAlias('dim', 'faint');
+defineColorAlias('strikethrough', 'crossedout');
+defineColorAlias('strikethrough', 'strikeThrough');
+defineColorAlias('strikethrough', 'crossedOut');
+defineColorAlias('hidden', 'conceal');
+defineColorAlias('inverse', 'swapColors');
+defineColorAlias('inverse', 'swapcolors');
+defineColorAlias('doubleunderline', 'doubleUnderline');
+
+// TODO(BridgeAR): Add function style support for more complex styles.
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = ObjectAssign({ __proto__: null }, {
+  special: 'cyan',
+  number: 'yellow',
+  bigint: 'yellow',
+  boolean: 'yellow',
+  undefined: 'grey',
+  null: 'bold',
+  string: 'green',
+  symbol: 'green',
+  date: 'magenta',
+  // "name": intentionally not styling
+  // TODO(BridgeAR): Highlight regular expressions properly.
+  regexp: 'red',
+  module: 'underline',
+});
+
+function addQuotes(str, quotes) {
+  if (quotes === -1) {
+    return `"${str}"`;
+  }
+  if (quotes === -2) {
+    return `\`${str}\``;
+  }
+  return `'${str}'`;
+}
+
+function escapeFn(str) {
+  const charCode = StringPrototypeCharCodeAt(str);
+  return meta.length > charCode ? meta[charCode] : `\\u${NumberPrototypeToString(charCode, 16)}`;
+}
+
+// Escape control characters, single quotes and the backslash.
+// This is similar to JSON stringify escaping.
+function strEscape(str) {
+  let escapeTest = strEscapeSequencesRegExp;
+  let escapeReplace = strEscapeSequencesReplacer;
+  let singleQuote = 39;
+
+  // Check for double quotes. If not present, do not escape single quotes and
+  // instead wrap the text in double quotes. If double quotes exist, check for
+  // backticks. If they do not exist, use those as fallback instead of the
+  // double quotes.
+  if (StringPrototypeIncludes(str, "'")) {
+    // This invalidates the charCode and therefore can not be matched for
+    // anymore.
+    if (!StringPrototypeIncludes(str, '"')) {
+      singleQuote = -1;
+    } else if (!StringPrototypeIncludes(str, '`') &&
+               !StringPrototypeIncludes(str, '${')) {
+      singleQuote = -2;
+    }
+    if (singleQuote !== 39) {
+      escapeTest = strEscapeSequencesRegExpSingle;
+      escapeReplace = strEscapeSequencesReplacerSingle;
+    }
+  }
+
+  // Some magic numbers that worked out fine while benchmarking with v8 6.0
+  if (str.length < 5000 && RegExpPrototypeExec(escapeTest, str) === null)
+    return addQuotes(str, singleQuote);
+  if (str.length > 100) {
+    str = RegExpPrototypeSymbolReplace(escapeReplace, str, escapeFn);
+    return addQuotes(str, singleQuote);
+  }
+
+  let result = '';
+  let last = 0;
+  for (let i = 0; i < str.length; i++) {
+    const point = StringPrototypeCharCodeAt(str, i);
+    if (point === singleQuote ||
+        point === 92 ||
+        point < 32 ||
+        (point > 126 && point < 160)) {
+      if (last === i) {
+        result += meta[point];
+      } else {
+        result += `${StringPrototypeSlice(str, last, i)}${meta[point]}`;
+      }
+      last = i + 1;
+    } else if (point >= 0xd800 && point <= 0xdfff) {
+      if (point <= 0xdbff && i + 1 < str.length) {
+        const point = StringPrototypeCharCodeAt(str, i + 1);
+        if (point >= 0xdc00 && point <= 0xdfff) {
+          i++;
+          continue;
+        }
+      }
+      result += `${StringPrototypeSlice(str, last, i)}\\u${NumberPrototypeToString(point, 16)}`;
+      last = i + 1;
+    }
+  }
+
+  if (last !== str.length) {
+    result += StringPrototypeSlice(str, last);
+  }
+  return addQuotes(result, singleQuote);
+}
+
+function stylizeWithColor(str, styleType) {
+  const style = inspect.styles[styleType];
+  if (style !== undefined) {
+    const color = inspect.colors[style];
+    if (color !== undefined)
+      return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`;
+  }
+  return str;
+}
+
+function stylizeNoColor(str) {
+  return str;
+}
+
+// Return a new empty array to push in the results of the default formatter.
+function getEmptyFormatArray() {
+  return [];
+}
+
+function isInstanceof(object, proto) {
+  try {
+    return object instanceof proto;
+  } catch {
+    return false;
+  }
+}
+
+// Special-case for some builtin prototypes in case their `constructor` property has been tampered.
+const wellKnownPrototypes = new SafeMap()
+  .set(ArrayPrototype, { name: 'Array', constructor: Array })
+  .set(ArrayBufferPrototype, { name: 'ArrayBuffer', constructor: ArrayBuffer })
+  .set(FunctionPrototype, { name: 'Function', constructor: Function })
+  .set(MapPrototype, { name: 'Map', constructor: Map })
+  .set(SetPrototype, { name: 'Set', constructor: Set })
+  .set(ObjectPrototype, { name: 'Object', constructor: Object })
+  .set(TypedArrayPrototype, { name: 'TypedArray', constructor: TypedArray })
+  .set(RegExpPrototype, { name: 'RegExp', constructor: RegExp })
+  .set(DatePrototype, { name: 'Date', constructor: Date })
+  .set(DataViewPrototype, { name: 'DataView', constructor: DataView })
+  .set(ErrorPrototype, { name: 'Error', constructor: Error })
+  .set(BooleanPrototype, { name: 'Boolean', constructor: Boolean })
+  .set(NumberPrototype, { name: 'Number', constructor: Number })
+  .set(StringPrototype, { name: 'String', constructor: String })
+  .set(PromisePrototype, { name: 'Promise', constructor: Promise })
+  .set(WeakMapPrototype, { name: 'WeakMap', constructor: WeakMap })
+  .set(WeakSetPrototype, { name: 'WeakSet', constructor: WeakSet });
+
+function getConstructorName(obj, ctx, recurseTimes, protoProps) {
+  let firstProto;
+  const tmp = obj;
+  while (obj || isUndetectableObject(obj)) {
+    const wellKnownPrototypeNameAndConstructor = wellKnownPrototypes.get(obj);
+    if (wellKnownPrototypeNameAndConstructor !== undefined) {
+      const { name, constructor } = wellKnownPrototypeNameAndConstructor;
+      if (FunctionPrototypeSymbolHasInstance(constructor, tmp)) {
+        if (protoProps !== undefined && firstProto !== obj) {
+          addPrototypeProperties(
+            ctx, tmp, firstProto || tmp, recurseTimes, protoProps);
+        }
+        return name;
+      }
+    }
+    const descriptor = ObjectGetOwnPropertyDescriptor(obj, 'constructor');
+    if (descriptor !== undefined &&
+        typeof descriptor.value === 'function' &&
+        descriptor.value.name !== '' &&
+        isInstanceof(tmp, descriptor.value)) {
+      if (protoProps !== undefined &&
+         (firstProto !== obj ||
+         !builtInObjects.has(descriptor.value.name))) {
+        addPrototypeProperties(
+          ctx, tmp, firstProto || tmp, recurseTimes, protoProps);
+      }
+      return String(descriptor.value.name);
+    }
+
+    obj = ObjectGetPrototypeOf(obj);
+    if (firstProto === undefined) {
+      firstProto = obj;
+    }
+  }
+
+  if (firstProto === null) {
+    return null;
+  }
+
+  const res = internalGetConstructorName(tmp);
+
+  if (recurseTimes > ctx.depth && ctx.depth !== null) {
+    return `${res} <Complex prototype>`;
+  }
+
+  const protoConstr = getConstructorName(
+    firstProto, ctx, recurseTimes + 1, protoProps);
+
+  if (protoConstr === null) {
+    return `${res} <${inspect(firstProto, {
+      ...ctx,
+      customInspect: false,
+      depth: -1,
+    })}>`;
+  }
+
+  return `${res} <${protoConstr}>`;
+}
+
+// This function has the side effect of adding prototype properties to the
+// `output` argument (which is an array). This is intended to highlight user
+// defined prototype properties.
+function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {
+  let depth = 0;
+  let keys;
+  let keySet;
+  do {
+    if (depth !== 0 || main === obj) {
+      obj = ObjectGetPrototypeOf(obj);
+      // Stop as soon as a null prototype is encountered.
+      if (obj === null) {
+        return;
+      }
+      // Stop as soon as a built-in object type is detected.
+      const descriptor = ObjectGetOwnPropertyDescriptor(obj, 'constructor');
+      if (descriptor !== undefined &&
+          typeof descriptor.value === 'function' &&
+          builtInObjects.has(descriptor.value.name)) {
+        return;
+      }
+    }
+
+    if (depth === 0) {
+      keySet = new SafeSet();
+    } else {
+      ArrayPrototypeForEach(keys, (key) => keySet.add(key));
+    }
+    // Get all own property names and symbols.
+    keys = ReflectOwnKeys(obj);
+    ArrayPrototypePush(ctx.seen, main);
+    for (const key of keys) {
+      // Ignore the `constructor` property and keys that exist on layers above.
+      if (key === 'constructor' ||
+          ObjectPrototypeHasOwnProperty(main, key) ||
+          (depth !== 0 && keySet.has(key))) {
+        continue;
+      }
+      const desc = ObjectGetOwnPropertyDescriptor(obj, key);
+      if (typeof desc.value === 'function') {
+        continue;
+      }
+      const value = formatProperty(
+        ctx, obj, recurseTimes, key, kObjectType, desc, main);
+      if (ctx.colors) {
+        // Faint!
+        ArrayPrototypePush(output, `\u001b[2m${value}\u001b[22m`);
+      } else {
+        ArrayPrototypePush(output, value);
+      }
+    }
+    ArrayPrototypePop(ctx.seen);
+  // Limit the inspection to up to three prototype layers. Using `recurseTimes`
+  // is not a good choice here, because it's as if the properties are declared
+  // on the current object from the users perspective.
+  } while (++depth !== 3);
+}
+
+/** @type {(constructor: string, tag: string, fallback: string, size?: string) => string} */
+function getPrefix(constructor, tag, fallback, size = '') {
+  if (constructor === null) {
+    if (tag !== '' && fallback !== tag) {
+      return `[${fallback}${size}: null prototype] [${tag}] `;
+    }
+    return `[${fallback}${size}: null prototype] `;
+  }
+
+  if (tag !== '' && constructor !== tag) {
+    return `${constructor}${size} [${tag}] `;
+  }
+  return `${constructor}${size} `;
+}
+
+// Look up the keys of the object.
+function getKeys(value, showHidden) {
+  let keys;
+  const symbols = ObjectGetOwnPropertySymbols(value);
+  if (showHidden) {
+    keys = ObjectGetOwnPropertyNames(value);
+    if (symbols.length !== 0)
+      ArrayPrototypePushApply(keys, symbols);
+  } else {
+    // This might throw if `value` is a Module Namespace Object from an
+    // unevaluated module, but we don't want to perform the actual type
+    // check because it's expensive.
+    // TODO(devsnek): track https://github.com/tc39/ecma262/issues/1209
+    // and modify this logic as needed.
+    try {
+      keys = ObjectKeys(value);
+    } catch (err) {
+      assert(isNativeError(err) && err.name === 'ReferenceError' &&
+             isModuleNamespaceObject(value));
+      keys = ObjectGetOwnPropertyNames(value);
+    }
+    if (symbols.length !== 0) {
+      const filter = (key) => ObjectPrototypePropertyIsEnumerable(value, key);
+      ArrayPrototypePushApply(keys, ArrayPrototypeFilter(symbols, filter));
+    }
+  }
+  return keys;
+}
+
+function getCtxStyle(value, constructor, tag) {
+  let fallback = '';
+  if (constructor === null) {
+    fallback = internalGetConstructorName(value);
+    if (fallback === tag) {
+      fallback = 'Object';
+    }
+  }
+  return getPrefix(constructor, tag, fallback);
+}
+
+function formatProxy(ctx, proxy, recurseTimes) {
+  if (recurseTimes > ctx.depth && ctx.depth !== null) {
+    return ctx.stylize('Proxy [Array]', 'special');
+  }
+  recurseTimes += 1;
+  ctx.indentationLvl += 2;
+  const res = [
+    formatValue(ctx, proxy[0], recurseTimes),
+    formatValue(ctx, proxy[1], recurseTimes),
+  ];
+  ctx.indentationLvl -= 2;
+  return reduceToSingleString(
+    ctx, res, '', ['Proxy [', ']'], kArrayExtrasType, recurseTimes);
+}
+
+// Note: using `formatValue` directly requires the indentation level to be
+// corrected by setting `ctx.indentationLvL += diff` and then to decrease the
+// value afterwards again.
+function formatValue(ctx, value, recurseTimes, typedArray) {
+  // Primitive types cannot have properties.
+  if (typeof value !== 'object' &&
+      typeof value !== 'function' &&
+      !isUndetectableObject(value)) {
+    return formatPrimitive(ctx.stylize, value, ctx);
+  }
+  if (value === null) {
+    return ctx.stylize('null', 'null');
+  }
+
+  // Memorize the context for custom inspection on proxies.
+  const context = value;
+  // Always check for proxies to prevent side effects and to prevent triggering
+  // any proxy handlers.
+  const proxy = getProxyDetails(value, !!ctx.showProxy);
+  if (proxy !== undefined) {
+    if (proxy === null || proxy[0] === null) {
+      return ctx.stylize('<Revoked Proxy>', 'special');
+    }
+    if (ctx.showProxy) {
+      return formatProxy(ctx, proxy, recurseTimes);
+    }
+    value = proxy;
+  }
+
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it.
+  if (ctx.customInspect) {
+    const maybeCustom = value[customInspectSymbol];
+    if (typeof maybeCustom === 'function' &&
+        // Filter out the util module, its inspect function is special.
+        maybeCustom !== inspect &&
+        // Also filter out any prototype objects using the circular check.
+        ObjectGetOwnPropertyDescriptor(value, 'constructor')?.value?.prototype !== value) {
+      // This makes sure the recurseTimes are reported as before while using
+      // a counter internally.
+      const depth = ctx.depth === null ? null : ctx.depth - recurseTimes;
+      const isCrossContext =
+        proxy !== undefined || !FunctionPrototypeSymbolHasInstance(Object, context);
+      const ret = FunctionPrototypeCall(
+        maybeCustom,
+        context,
+        depth,
+        getUserOptions(ctx, isCrossContext),
+        inspect,
+      );
+      // If the custom inspection method returned `this`, don't go into
+      // infinite recursion.
+      if (ret !== context) {
+        if (typeof ret !== 'string') {
+          return formatValue(ctx, ret, recurseTimes);
+        }
+        return StringPrototypeReplaceAll(ret, '\n', `\n${StringPrototypeRepeat(' ', ctx.indentationLvl)}`);
+      }
+    }
+  }
+
+  // Using an array here is actually better for the average case than using
+  // a Set. `seen` will only check for the depth and will never grow too large.
+  if (ctx.seen.includes(value)) {
+    let index = 1;
+    if (ctx.circular === undefined) {
+      ctx.circular = new SafeMap();
+      ctx.circular.set(value, index);
+    } else {
+      index = ctx.circular.get(value);
+      if (index === undefined) {
+        index = ctx.circular.size + 1;
+        ctx.circular.set(value, index);
+      }
+    }
+    return ctx.stylize(`[Circular *${index}]`, 'special');
+  }
+
+  return formatRaw(ctx, value, recurseTimes, typedArray);
+}
+
+function formatRaw(ctx, value, recurseTimes, typedArray) {
+  let keys;
+  let protoProps;
+  if (ctx.showHidden && (recurseTimes <= ctx.depth || ctx.depth === null)) {
+    protoProps = [];
+  }
+
+  const constructor = getConstructorName(value, ctx, recurseTimes, protoProps);
+  // Reset the variable to check for this later on.
+  if (protoProps !== undefined && protoProps.length === 0) {
+    protoProps = undefined;
+  }
+
+  let tag = value[SymbolToStringTag];
+  // Only list the tag in case it's non-enumerable / not an own property.
+  // Otherwise we'd print this twice.
+  if (typeof tag !== 'string' ||
+      (tag !== '' &&
+      (ctx.showHidden ?
+        ObjectPrototypeHasOwnProperty :
+        ObjectPrototypePropertyIsEnumerable)(
+        value, SymbolToStringTag,
+      ))) {
+    tag = '';
+  }
+  let base = '';
+  let formatter = getEmptyFormatArray;
+  let braces;
+  let noIterator = true;
+  let i = 0;
+  const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+
+  let extrasType = kObjectType;
+
+  // Iterators and the rest are split to reduce checks.
+  // We have to check all values in case the constructor is set to null.
+  // Otherwise it would not possible to identify all types properly.
+  if (SymbolIterator in value || constructor === null) {
+    noIterator = false;
+    if (ArrayIsArray(value)) {
+      // Only set the constructor for non ordinary ("Array [...]") arrays.
+      const prefix = (constructor !== 'Array' || tag !== '') ?
+        getPrefix(constructor, tag, 'Array', `(${value.length})`) :
+        '';
+      keys = getOwnNonIndexProperties(value, filter);
+      braces = [`${prefix}[`, ']'];
+      if (value.length === 0 && keys.length === 0 && protoProps === undefined)
+        return `${braces[0]}]`;
+      extrasType = kArrayExtrasType;
+      formatter = formatArray;
+    } else if (isSet(value)) {
+      const size = SetPrototypeGetSize(value);
+      const prefix = getPrefix(constructor, tag, 'Set', `(${size})`);
+      keys = getKeys(value, ctx.showHidden);
+      formatter = constructor !== null ?
+        FunctionPrototypeBind(formatSet, null, value) :
+        FunctionPrototypeBind(formatSet, null, SetPrototypeValues(value));
+      if (size === 0 && keys.length === 0 && protoProps === undefined)
+        return `${prefix}{}`;
+      braces = [`${prefix}{`, '}'];
+    } else if (isMap(value)) {
+      const size = MapPrototypeGetSize(value);
+      const prefix = getPrefix(constructor, tag, 'Map', `(${size})`);
+      keys = getKeys(value, ctx.showHidden);
+      formatter = constructor !== null ?
+        FunctionPrototypeBind(formatMap, null, value) :
+        FunctionPrototypeBind(formatMap, null, MapPrototypeEntries(value));
+      if (size === 0 && keys.length === 0 && protoProps === undefined)
+        return `${prefix}{}`;
+      braces = [`${prefix}{`, '}'];
+    } else if (isTypedArray(value)) {
+      keys = getOwnNonIndexProperties(value, filter);
+      let bound = value;
+      let fallback = '';
+      if (constructor === null) {
+        fallback = TypedArrayPrototypeGetSymbolToStringTag(value);
+        // Reconstruct the array information.
+        bound = new primordials[fallback](value);
+      }
+      const size = TypedArrayPrototypeGetLength(value);
+      const prefix = getPrefix(constructor, tag, fallback, `(${size})`);
+      braces = [`${prefix}[`, ']'];
+      if (value.length === 0 && keys.length === 0 && !ctx.showHidden)
+        return `${braces[0]}]`;
+      // Special handle the value. The original value is required below. The
+      // bound function is required to reconstruct missing information.
+      formatter = FunctionPrototypeBind(formatTypedArray, null, bound, size);
+      extrasType = kArrayExtrasType;
+    } else if (isMapIterator(value)) {
+      keys = getKeys(value, ctx.showHidden);
+      braces = getIteratorBraces('Map', tag);
+      // Add braces to the formatter parameters.
+      formatter = FunctionPrototypeBind(formatIterator, null, braces);
+    } else if (isSetIterator(value)) {
+      keys = getKeys(value, ctx.showHidden);
+      braces = getIteratorBraces('Set', tag);
+      // Add braces to the formatter parameters.
+      formatter = FunctionPrototypeBind(formatIterator, null, braces);
+    } else {
+      noIterator = true;
+    }
+  }
+  if (noIterator) {
+    keys = getKeys(value, ctx.showHidden);
+    braces = ['{', '}'];
+    if (typeof value === 'function') {
+      base = getFunctionBase(ctx, value, constructor, tag);
+      if (keys.length === 0 && protoProps === undefined)
+        return ctx.stylize(base, 'special');
+    } else if (constructor === 'Object') {
+      if (isArgumentsObject(value)) {
+        braces[0] = '[Arguments] {';
+      } else if (tag !== '') {
+        braces[0] = `${getPrefix(constructor, tag, 'Object')}{`;
+      }
+      if (keys.length === 0 && protoProps === undefined) {
+        return `${braces[0]}}`;
+      }
+    } else if (isRegExp(value)) {
+      // Make RegExps say that they are RegExps
+      base = RegExpPrototypeToString(
+        constructor !== null ? value : new RegExp(value),
+      );
+      const prefix = getPrefix(constructor, tag, 'RegExp');
+      if (prefix !== 'RegExp ')
+        base = `${prefix}${base}`;
+      if ((keys.length === 0 && protoProps === undefined) ||
+          (recurseTimes > ctx.depth && ctx.depth !== null)) {
+        return ctx.stylize(base, 'regexp');
+      }
+    } else if (isDate(value)) {
+      // Make dates with properties first say the date
+      base = NumberIsNaN(DatePrototypeGetTime(value)) ?
+        DatePrototypeToString(value) :
+        DatePrototypeToISOString(value);
+      const prefix = getPrefix(constructor, tag, 'Date');
+      if (prefix !== 'Date ')
+        base = `${prefix}${base}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (isError(value)) {
+      base = formatError(value, constructor, tag, ctx, keys);
+      if (keys.length === 0 && protoProps === undefined)
+        return base;
+    } else if (isAnyArrayBuffer(value)) {
+      // Fast path for ArrayBuffer and SharedArrayBuffer.
+      // Can't do the same for DataView because it has a non-primitive
+      // .buffer property that we need to recurse for.
+      const arrayType = isArrayBuffer(value) ? 'ArrayBuffer' :
+        'SharedArrayBuffer';
+      const prefix = getPrefix(constructor, tag, arrayType);
+      if (typedArray === undefined) {
+        formatter = formatArrayBuffer;
+      } else if (keys.length === 0 && protoProps === undefined) {
+        return prefix +
+              `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength, false)} }`;
+      }
+      braces[0] = `${prefix}{`;
+      ArrayPrototypeUnshift(keys, 'byteLength');
+    } else if (isDataView(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'DataView')}{`;
+      // .buffer goes last, it's not a primitive like the others.
+      ArrayPrototypeUnshift(keys, 'byteLength', 'byteOffset', 'buffer');
+    } else if (isPromise(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'Promise')}{`;
+      formatter = formatPromise;
+    } else if (isWeakSet(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'WeakSet')}{`;
+      formatter = ctx.showHidden ? formatWeakSet : formatWeakCollection;
+    } else if (isWeakMap(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`;
+      formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection;
+    } else if (isModuleNamespaceObject(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'Module')}{`;
+      // Special handle keys for namespace objects.
+      formatter = formatNamespaceObject.bind(null, keys);
+    } else if (isBoxedPrimitive(value)) {
+      base = getBoxedBase(value, ctx, keys, constructor, tag);
+      if (keys.length === 0 && protoProps === undefined) {
+        return base;
+      }
+    } else if (isURL(value) && !(recurseTimes > ctx.depth && ctx.depth !== null)) {
+      base = value.href;
+      if (keys.length === 0 && protoProps === undefined) {
+        return base;
+      }
+    } else {
+      if (keys.length === 0 && protoProps === undefined) {
+        if (isExternal(value)) {
+          const address = getExternalValue(value).toString(16);
+          return ctx.stylize(`[External: ${address}]`, 'special');
+        }
+        return `${getCtxStyle(value, constructor, tag)}{}`;
+      }
+      braces[0] = `${getCtxStyle(value, constructor, tag)}{`;
+    }
+  }
+
+  if (recurseTimes > ctx.depth && ctx.depth !== null) {
+    let constructorName = StringPrototypeSlice(getCtxStyle(value, constructor, tag), 0, -1);
+    if (constructor !== null)
+      constructorName = `[${constructorName}]`;
+    return ctx.stylize(constructorName, 'special');
+  }
+  recurseTimes += 1;
+
+  ctx.seen.push(value);
+  ctx.currentDepth = recurseTimes;
+  let output;
+  const indentationLvl = ctx.indentationLvl;
+  try {
+    output = formatter(ctx, value, recurseTimes);
+    for (i = 0; i < keys.length; i++) {
+      ArrayPrototypePush(
+        output,
+        formatProperty(ctx, value, recurseTimes, keys[i], extrasType),
+      );
+    }
+    if (protoProps !== undefined) {
+      ArrayPrototypePushApply(output, protoProps);
+    }
+  } catch (err) {
+    if (!isStackOverflowError(err)) throw err;
+    const constructorName = StringPrototypeSlice(getCtxStyle(value, constructor, tag), 0, -1);
+    return handleMaxCallStackSize(ctx, err, constructorName, indentationLvl);
+  }
+  if (ctx.circular !== undefined) {
+    const index = ctx.circular.get(value);
+    if (index !== undefined) {
+      const reference = ctx.stylize(`<ref *${index}>`, 'special');
+      // Add reference always to the very beginning of the output.
+      if (ctx.compact !== true) {
+        base = base === '' ? reference : `${reference} ${base}`;
+      } else {
+        braces[0] = `${reference} ${braces[0]}`;
+      }
+    }
+  }
+  ctx.seen.pop();
+
+  if (ctx.sorted) {
+    const comparator = ctx.sorted === true ? undefined : ctx.sorted;
+    if (extrasType === kObjectType) {
+      ArrayPrototypeSort(output, comparator);
+    } else if (keys.length > 1) {
+      const sorted = ArrayPrototypeSort(ArrayPrototypeSlice(output, output.length - keys.length), comparator);
+      ArrayPrototypeUnshift(sorted, output, output.length - keys.length, keys.length);
+      ReflectApply(ArrayPrototypeSplice, null, sorted);
+    }
+  }
+
+  const res = reduceToSingleString(
+    ctx, output, base, braces, extrasType, recurseTimes, value);
+  const budget = ctx.budget[ctx.indentationLvl] || 0;
+  const newLength = budget + res.length;
+  ctx.budget[ctx.indentationLvl] = newLength;
+  // If any indentationLvl exceeds this limit, limit further inspecting to the
+  // minimum. Otherwise the recursive algorithm might continue inspecting the
+  // object even though the maximum string size (~2 ** 28 on 32 bit systems and
+  // ~2 ** 30 on 64 bit systems) exceeded. The actual output is not limited at
+  // exactly 2 ** 27 but a bit higher. This depends on the object shape.
+  // This limit also makes sure that huge objects don't block the event loop
+  // significantly.
+  if (newLength > 2 ** 27) {
+    ctx.depth = -1;
+  }
+  return res;
+}
+
+function getIteratorBraces(type, tag) {
+  if (tag !== `${type} Iterator`) {
+    if (tag !== '')
+      tag += '] [';
+    tag += `${type} Iterator`;
+  }
+  return [`[${tag}] {`, '}'];
+}
+
+function getBoxedBase(value, ctx, keys, constructor, tag) {
+  let fn;
+  let type;
+  if (isNumberObject(value)) {
+    fn = NumberPrototypeValueOf;
+    type = 'Number';
+  } else if (isStringObject(value)) {
+    fn = StringPrototypeValueOf;
+    type = 'String';
+    // For boxed Strings, we have to remove the 0-n indexed entries,
+    // since they just noisy up the output and are redundant
+    // Make boxed primitive Strings look like such
+    keys.splice(0, value.length);
+  } else if (isBooleanObject(value)) {
+    fn = BooleanPrototypeValueOf;
+    type = 'Boolean';
+  } else if (isBigIntObject(value)) {
+    fn = BigIntPrototypeValueOf;
+    type = 'BigInt';
+  } else {
+    fn = SymbolPrototypeValueOf;
+    type = 'Symbol';
+  }
+  let base = `[${type}`;
+  if (type !== constructor) {
+    if (constructor === null) {
+      base += ' (null prototype)';
+    } else {
+      base += ` (${constructor})`;
+    }
+  }
+  base += `: ${formatPrimitive(stylizeNoColor, fn(value), ctx)}]`;
+  if (tag !== '' && tag !== constructor) {
+    base += ` [${tag}]`;
+  }
+  if (keys.length !== 0 || ctx.stylize === stylizeNoColor)
+    return base;
+  return ctx.stylize(base, StringPrototypeToLowerCase(type));
+}
+
+function getClassBase(value, constructor, tag) {
+  const hasName = ObjectPrototypeHasOwnProperty(value, 'name');
+  const name = (hasName && value.name) || '(anonymous)';
+  let base = `class ${name}`;
+  if (constructor !== 'Function' && constructor !== null) {
+    base += ` [${constructor}]`;
+  }
+  if (tag !== '' && constructor !== tag) {
+    base += ` [${tag}]`;
+  }
+  if (constructor !== null) {
+    const superName = ObjectGetPrototypeOf(value).name;
+    if (superName) {
+      base += ` extends ${superName}`;
+    }
+  } else {
+    base += ' extends [null prototype]';
+  }
+  return `[${base}]`;
+}
+
+function getFunctionBase(ctx, value, constructor, tag) {
+  const stringified = FunctionPrototypeToString(value);
+  if (StringPrototypeStartsWith(stringified, 'class') && stringified[stringified.length - 1] === '}') {
+    const slice = StringPrototypeSlice(stringified, 5, -1);
+    const bracketIndex = StringPrototypeIndexOf(slice, '{');
+    if (bracketIndex !== -1 &&
+        (!StringPrototypeIncludes(StringPrototypeSlice(slice, 0, bracketIndex), '(') ||
+        // Slow path to guarantee that it's indeed a class.
+        RegExpPrototypeExec(classRegExp, RegExpPrototypeSymbolReplace(stripCommentsRegExp, slice)) !== null)
+    ) {
+      return getClassBase(value, constructor, tag);
+    }
+  }
+  let type = 'Function';
+  if (isGeneratorFunction(value)) {
+    type = `Generator${type}`;
+  }
+  if (isAsyncFunction(value)) {
+    type = `Async${type}`;
+  }
+  let base = `[${type}`;
+  if (constructor === null) {
+    base += ' (null prototype)';
+  }
+  if (value.name === '') {
+    base += ' (anonymous)';
+  } else {
+    base += `: ${typeof value.name === 'string' ? value.name : formatValue(ctx, value.name)}`;
+  }
+  base += ']';
+  if (constructor !== type && constructor !== null) {
+    base += ` ${constructor}`;
+  }
+  if (tag !== '' && constructor !== tag) {
+    base += ` [${tag}]`;
+  }
+  return base;
+}
+
+function identicalSequenceRange(a, b) {
+  for (let i = 0; i < a.length - 3; i++) {
+    // Find the first entry of b that matches the current entry of a.
+    const pos = ArrayPrototypeIndexOf(b, a[i]);
+    if (pos !== -1) {
+      const rest = b.length - pos;
+      if (rest > 3) {
+        let len = 1;
+        const maxLen = MathMin(a.length - i, rest);
+        // Count the number of consecutive entries.
+        while (maxLen > len && a[i + len] === b[pos + len]) {
+          len++;
+        }
+        if (len > 3) {
+          return { len, offset: i };
+        }
+      }
+    }
+  }
+
+  return { len: 0, offset: 0 };
+}
+
+function getStackString(ctx, error) {
+  if (error.stack) {
+    if (typeof error.stack === 'string') {
+      return error.stack;
+    }
+    ctx.seen.push(error);
+    ctx.indentationLvl += 4;
+    const result = formatValue(ctx, error.stack);
+    ctx.indentationLvl -= 4;
+    ctx.seen.pop();
+    return `${ErrorPrototypeToString(error)}\n    ${result}`;
+  }
+  return ErrorPrototypeToString(error);
+}
+
+function getStackFrames(ctx, err, stack) {
+  const frames = StringPrototypeSplit(stack, '\n');
+
+  let cause;
+  try {
+    ({ cause } = err);
+  } catch {
+    // If 'cause' is a getter that throws, ignore it.
+  }
+
+  // Remove stack frames identical to frames in cause.
+  if (cause != null && isError(cause)) {
+    const causeStack = getStackString(ctx, cause);
+    const causeStackStart = StringPrototypeIndexOf(causeStack, '\n    at');
+    if (causeStackStart !== -1) {
+      const causeFrames = StringPrototypeSplit(StringPrototypeSlice(causeStack, causeStackStart + 1), '\n');
+      const { len, offset } = identicalSequenceRange(frames, causeFrames);
+      if (len > 0) {
+        const skipped = len - 2;
+        const msg = `    ... ${skipped} lines matching cause stack trace ...`;
+        frames.splice(offset + 1, skipped, ctx.stylize(msg, 'undefined'));
+      }
+    }
+  }
+  return frames;
+}
+
+/** @type {(stack: string, constructor: string | null, name: unknown, tag: string) => string} */
+function improveStack(stack, constructor, name, tag) {
+  // A stack trace may contain arbitrary data. Only manipulate the output
+  // for "regular errors" (errors that "look normal") for now.
+  let len = name.length;
+
+  if (typeof name !== 'string') {
+    stack = StringPrototypeReplace(
+      stack,
+      `${name}`,
+      `${name} [${StringPrototypeSlice(getPrefix(constructor, tag, 'Error'), 0, -1)}]`,
+    );
+  }
+
+  if (constructor === null ||
+      (StringPrototypeEndsWith(name, 'Error') &&
+      StringPrototypeStartsWith(stack, name) &&
+      (stack.length === len || stack[len] === ':' || stack[len] === '\n'))) {
+    let fallback = 'Error';
+    if (constructor === null) {
+      const start = RegExpPrototypeExec(/^([A-Z][a-z_ A-Z0-9[\]()-]+)(?::|\n {4}at)/, stack) ||
+      RegExpPrototypeExec(/^([a-z_A-Z0-9-]*Error)$/, stack);
+      fallback = (start?.[1]) || '';
+      len = fallback.length;
+      fallback ||= 'Error';
+    }
+    const prefix = StringPrototypeSlice(getPrefix(constructor, tag, fallback), 0, -1);
+    if (name !== prefix) {
+      if (StringPrototypeIncludes(prefix, name)) {
+        if (len === 0) {
+          stack = `${prefix}: ${stack}`;
+        } else {
+          stack = `${prefix}${StringPrototypeSlice(stack, len)}`;
+        }
+      } else {
+        stack = `${prefix} [${name}]${StringPrototypeSlice(stack, len)}`;
+      }
+    }
+  }
+  return stack;
+}
+
+function removeDuplicateErrorKeys(ctx, keys, err, stack) {
+  if (!ctx.showHidden && keys.length !== 0) {
+    for (const name of ['name', 'message', 'stack']) {
+      const index = ArrayPrototypeIndexOf(keys, name);
+      // Only hide the property if it's a string and if it's part of the original stack
+      if (index !== -1 && (typeof err[name] !== 'string' || StringPrototypeIncludes(stack, err[name]))) {
+        ArrayPrototypeSplice(keys, index, 1);
+      }
+    }
+  }
+}
+
+function markNodeModules(ctx, line) {
+  let tempLine = '';
+  let nodeModule;
+  let pos = 0;
+  while ((nodeModule = nodeModulesRegExp.exec(line)) !== null) {
+    // '/node_modules/'.length === 14
+    tempLine += StringPrototypeSlice(line, pos, nodeModule.index + 14);
+    tempLine += ctx.stylize(nodeModule[1], 'module');
+    pos = nodeModule.index + nodeModule[0].length;
+  }
+  if (pos !== 0) {
+    line = tempLine + StringPrototypeSlice(line, pos);
+  }
+  return line;
+}
+
+function markCwd(ctx, line, workingDirectory) {
+  let cwdStartPos = StringPrototypeIndexOf(line, workingDirectory);
+  let tempLine = '';
+  let cwdLength = workingDirectory.length;
+  if (cwdStartPos !== -1) {
+    if (StringPrototypeSlice(line, cwdStartPos - 7, cwdStartPos) === 'file://') {
+      cwdLength += 7;
+      cwdStartPos -= 7;
+    }
+    const start = line[cwdStartPos - 1] === '(' ? cwdStartPos - 1 : cwdStartPos;
+    const end = start !== cwdStartPos && StringPrototypeEndsWith(line, ')') ? -1 : line.length;
+    const workingDirectoryEndPos = cwdStartPos + cwdLength + 1;
+    const cwdSlice = StringPrototypeSlice(line, start, workingDirectoryEndPos);
+
+    tempLine += StringPrototypeSlice(line, 0, start);
+    tempLine += ctx.stylize(cwdSlice, 'undefined');
+    tempLine += StringPrototypeSlice(line, workingDirectoryEndPos, end);
+    if (end === -1) {
+      tempLine += ctx.stylize(')', 'undefined');
+    }
+  } else {
+    tempLine += line;
+  }
+  return tempLine;
+}
+
+function safeGetCWD() {
+  let workingDirectory;
+  try {
+    workingDirectory = process.cwd();
+  } catch {
+    return;
+  }
+  return workingDirectory;
+}
+
+function formatError(err, constructor, tag, ctx, keys) {
+  const name = err.name != null ? err.name : 'Error';
+  let stack = getStackString(ctx, err);
+
+  removeDuplicateErrorKeys(ctx, keys, err, stack);
+
+  if ('cause' in err &&
+      (keys.length === 0 || !ArrayPrototypeIncludes(keys, 'cause'))) {
+    ArrayPrototypePush(keys, 'cause');
+  }
+
+  // Print errors aggregated into AggregateError
+  if (ArrayIsArray(err.errors) &&
+      (keys.length === 0 || !ArrayPrototypeIncludes(keys, 'errors'))) {
+    ArrayPrototypePush(keys, 'errors');
+  }
+
+  stack = improveStack(stack, constructor, name, tag);
+
+  // Ignore the error message if it's contained in the stack.
+  let pos = (err.message && StringPrototypeIndexOf(stack, err.message)) || -1;
+  if (pos !== -1)
+    pos += err.message.length;
+  // Wrap the error in brackets in case it has no stack trace.
+  const stackStart = StringPrototypeIndexOf(stack, '\n    at', pos);
+  if (stackStart === -1) {
+    stack = `[${stack}]`;
+  } else {
+    let newStack = StringPrototypeSlice(stack, 0, stackStart);
+    const stackFramePart = StringPrototypeSlice(stack, stackStart + 1);
+    const lines = getStackFrames(ctx, err, stackFramePart);
+    if (ctx.colors) {
+      // Highlight userland code and node modules.
+      const workingDirectory = safeGetCWD();
+      let esmWorkingDirectory;
+      for (let line of lines) {
+        const core = RegExpPrototypeExec(coreModuleRegExp, line);
+        if (core !== null && BuiltinModule.exists(core[1])) {
+          newStack += `\n${ctx.stylize(line, 'undefined')}`;
+        } else {
+          newStack += '\n';
+
+          line = markNodeModules(ctx, line);
+          if (workingDirectory !== undefined) {
+            let newLine = markCwd(ctx, line, workingDirectory);
+            if (newLine === line) {
+              esmWorkingDirectory ??= pathToFileUrlHref(workingDirectory);
+              newLine = markCwd(ctx, line, esmWorkingDirectory);
+            }
+            line = newLine;
+          }
+
+          newStack += line;
+        }
+      }
+    } else {
+      newStack += `\n${ArrayPrototypeJoin(lines, '\n')}`;
+    }
+    stack = newStack;
+  }
+  // The message and the stack have to be indented as well!
+  if (ctx.indentationLvl !== 0) {
+    const indentation = StringPrototypeRepeat(' ', ctx.indentationLvl);
+    stack = StringPrototypeReplaceAll(stack, '\n', `\n${indentation}`);
+  }
+  return stack;
+}
+
+function groupArrayElements(ctx, output, value) {
+  let totalLength = 0;
+  let maxLength = 0;
+  let i = 0;
+  let outputLength = output.length;
+  if (ctx.maxArrayLength < output.length) {
+    // This makes sure the "... n more items" part is not taken into account.
+    outputLength--;
+  }
+  const separatorSpace = 2; // Add 1 for the space and 1 for the separator.
+  const dataLen = new Array(outputLength);
+  // Calculate the total length of all output entries and the individual max
+  // entries length of all output entries. We have to remove colors first,
+  // otherwise the length would not be calculated properly.
+  for (; i < outputLength; i++) {
+    const len = getStringWidth(output[i], ctx.colors);
+    dataLen[i] = len;
+    totalLength += len + separatorSpace;
+    if (maxLength < len)
+      maxLength = len;
+  }
+  // Add two to `maxLength` as we add a single whitespace character plus a comma
+  // in-between two entries.
+  const actualMax = maxLength + separatorSpace;
+  // Check if at least three entries fit next to each other and prevent grouping
+  // of arrays that contains entries of very different length (i.e., if a single
+  // entry is longer than 1/5 of all other entries combined). Otherwise the
+  // space in-between small entries would be enormous.
+  if (actualMax * 3 + ctx.indentationLvl < ctx.breakLength &&
+      (totalLength / actualMax > 5 || maxLength <= 6)) {
+
+    const approxCharHeights = 2.5;
+    const averageBias = MathSqrt(actualMax - totalLength / output.length);
+    const biasedMax = MathMax(actualMax - 3 - averageBias, 1);
+    // Dynamically check how many columns seem possible.
+    const columns = MathMin(
+      // Ideally a square should be drawn. We expect a character to be about 2.5
+      // times as high as wide. This is the area formula to calculate a square
+      // which contains n rectangles of size `actualMax * approxCharHeights`.
+      // Divide that by `actualMax` to receive the correct number of columns.
+      // The added bias increases the columns for short entries.
+      MathRound(
+        MathSqrt(
+          approxCharHeights * biasedMax * outputLength,
+        ) / biasedMax,
+      ),
+      // Do not exceed the breakLength.
+      MathFloor((ctx.breakLength - ctx.indentationLvl) / actualMax),
+      // Limit array grouping for small `compact` modes as the user requested
+      // minimal grouping.
+      ctx.compact * 4,
+      // Limit the columns to a maximum of fifteen.
+      15,
+    );
+    // Return with the original output if no grouping should happen.
+    if (columns <= 1) {
+      return output;
+    }
+    const tmp = [];
+    const maxLineLength = [];
+    for (let i = 0; i < columns; i++) {
+      let lineMaxLength = 0;
+      for (let j = i; j < output.length; j += columns) {
+        if (dataLen[j] > lineMaxLength)
+          lineMaxLength = dataLen[j];
+      }
+      lineMaxLength += separatorSpace;
+      maxLineLength[i] = lineMaxLength;
+    }
+    let order = StringPrototypePadStart;
+    if (value !== undefined) {
+      for (let i = 0; i < output.length; i++) {
+        if (typeof value[i] !== 'number' && typeof value[i] !== 'bigint') {
+          order = StringPrototypePadEnd;
+          break;
+        }
+      }
+    }
+    // Each iteration creates a single line of grouped entries.
+    for (let i = 0; i < outputLength; i += columns) {
+      // The last lines may contain less entries than columns.
+      const max = MathMin(i + columns, outputLength);
+      let str = '';
+      let j = i;
+      for (; j < max - 1; j++) {
+        // Calculate extra color padding in case it's active. This has to be
+        // done line by line as some lines might contain more colors than
+        // others.
+        const padding = maxLineLength[j - i] + output[j].length - dataLen[j];
+        str += order(`${output[j]}, `, padding, ' ');
+      }
+      if (order === StringPrototypePadStart) {
+        const padding = maxLineLength[j - i] +
+                        output[j].length -
+                        dataLen[j] -
+                        separatorSpace;
+        str += StringPrototypePadStart(output[j], padding, ' ');
+      } else {
+        str += output[j];
+      }
+      ArrayPrototypePush(tmp, str);
+    }
+    if (ctx.maxArrayLength < output.length) {
+      ArrayPrototypePush(tmp, output[outputLength]);
+    }
+    output = tmp;
+  }
+  return output;
+}
+
+function handleMaxCallStackSize(ctx, err, constructorName, indentationLvl) {
+  ctx.seen.pop();
+  ctx.indentationLvl = indentationLvl;
+  return ctx.stylize(
+    `[${constructorName}: Inspection interrupted ` +
+      'prematurely. Maximum call stack size exceeded.]',
+    'special',
+  );
+}
+
+function addNumericSeparator(integerString) {
+  let result = '';
+  let i = integerString.length;
+  assert(i !== 0);
+  const start = integerString[0] === '-' ? 1 : 0;
+  for (; i >= start + 4; i -= 3) {
+    result = `_${StringPrototypeSlice(integerString, i - 3, i)}${result}`;
+  }
+  return i === integerString.length ?
+    integerString :
+    `${StringPrototypeSlice(integerString, 0, i)}${result}`;
+}
+
+function addNumericSeparatorEnd(integerString) {
+  let result = '';
+  let i = 0;
+  for (; i < integerString.length - 3; i += 3) {
+    result += `${StringPrototypeSlice(integerString, i, i + 3)}_`;
+  }
+  return i === 0 ?
+    integerString :
+    `${result}${StringPrototypeSlice(integerString, i)}`;
+}
+
+const remainingText = (remaining) => `... ${remaining} more item${remaining > 1 ? 's' : ''}`;
+
+function formatNumber(fn, number, numericSeparator) {
+  if (!numericSeparator) {
+    // Format -0 as '-0'. Checking `number === -0` won't distinguish 0 from -0.
+    if (ObjectIs(number, -0)) {
+      return fn('-0', 'number');
+    }
+    return fn(`${number}`, 'number');
+  }
+  const integer = MathTrunc(number);
+  const string = String(integer);
+  if (integer === number) {
+    if (!NumberIsFinite(number) || StringPrototypeIncludes(string, 'e')) {
+      return fn(string, 'number');
+    }
+    return fn(`${addNumericSeparator(string)}`, 'number');
+  }
+  if (NumberIsNaN(number)) {
+    return fn(string, 'number');
+  }
+  return fn(`${
+    addNumericSeparator(string)
+  }.${
+    addNumericSeparatorEnd(
+      StringPrototypeSlice(String(number), string.length + 1),
+    )
+  }`, 'number');
+}
+
+function formatBigInt(fn, bigint, numericSeparator) {
+  const string = String(bigint);
+  if (!numericSeparator) {
+    return fn(`${string}n`, 'bigint');
+  }
+  return fn(`${addNumericSeparator(string)}n`, 'bigint');
+}
+
+function formatPrimitive(fn, value, ctx) {
+  if (typeof value === 'string') {
+    let trailer = '';
+    if (value.length > ctx.maxStringLength) {
+      const remaining = value.length - ctx.maxStringLength;
+      value = StringPrototypeSlice(value, 0, ctx.maxStringLength);
+      trailer = `... ${remaining} more character${remaining > 1 ? 's' : ''}`;
+    }
+    if (ctx.compact !== true &&
+        // We do not support handling unicode characters width with
+        // the readline getStringWidth function as there are
+        // performance implications.
+        value.length > kMinLineLength &&
+        value.length > ctx.breakLength - ctx.indentationLvl - 4) {
+      return ArrayPrototypeJoin(
+        ArrayPrototypeMap(
+          RegExpPrototypeSymbolSplit(/(?<=\n)/, value),
+          (line) => fn(strEscape(line), 'string'),
+        ),
+        ` +\n${StringPrototypeRepeat(' ', ctx.indentationLvl + 2)}`,
+      ) + trailer;
+    }
+    return fn(strEscape(value), 'string') + trailer;
+  }
+  if (typeof value === 'number')
+    return formatNumber(fn, value, ctx.numericSeparator);
+  if (typeof value === 'bigint')
+    return formatBigInt(fn, value, ctx.numericSeparator);
+  if (typeof value === 'boolean')
+    return fn(`${value}`, 'boolean');
+  if (typeof value === 'undefined')
+    return fn('undefined', 'undefined');
+  // es6 symbol primitive
+  return fn(SymbolPrototypeToString(value), 'symbol');
+}
+
+function formatNamespaceObject(keys, ctx, value, recurseTimes) {
+  const output = new Array(keys.length);
+  for (let i = 0; i < keys.length; i++) {
+    try {
+      output[i] = formatProperty(ctx, value, recurseTimes, keys[i],
+                                 kObjectType);
+    } catch (err) {
+      assert(isNativeError(err) && err.name === 'ReferenceError');
+      // Use the existing functionality. This makes sure the indentation and
+      // line breaks are always correct. Otherwise it is very difficult to keep
+      // this aligned, even though this is a hacky way of dealing with this.
+      const tmp = { [keys[i]]: '' };
+      output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i], kObjectType);
+      const pos = StringPrototypeLastIndexOf(output[i], ' ');
+      // We have to find the last whitespace and have to replace that value as
+      // it will be visualized as a regular string.
+      output[i] = StringPrototypeSlice(output[i], 0, pos + 1) +
+                  ctx.stylize('<uninitialized>', 'special');
+    }
+  }
+  // Reset the keys to an empty array. This prevents duplicated inspection.
+  keys.length = 0;
+  return output;
+}
+
+// The array is sparse and/or has extra keys
+function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) {
+  const keys = ObjectKeys(value);
+  let index = i;
+  for (; i < keys.length && output.length < maxLength; i++) {
+    const key = keys[i];
+    const tmp = +key;
+    // Arrays can only have up to 2^32 - 1 entries
+    if (tmp > 2 ** 32 - 2) {
+      break;
+    }
+    if (`${index}` !== key) {
+      if (RegExpPrototypeExec(numberRegExp, key) === null) {
+        break;
+      }
+      const emptyItems = tmp - index;
+      const ending = emptyItems > 1 ? 's' : '';
+      const message = `<${emptyItems} empty item${ending}>`;
+      ArrayPrototypePush(output, ctx.stylize(message, 'undefined'));
+      index = tmp;
+      if (output.length === maxLength) {
+        break;
+      }
+    }
+    ArrayPrototypePush(output, formatProperty(ctx, value, recurseTimes, key, kArrayType));
+    index++;
+  }
+  const remaining = value.length - index;
+  if (output.length !== maxLength) {
+    if (remaining > 0) {
+      const ending = remaining > 1 ? 's' : '';
+      const message = `<${remaining} empty item${ending}>`;
+      ArrayPrototypePush(output, ctx.stylize(message, 'undefined'));
+    }
+  } else if (remaining > 0) {
+    ArrayPrototypePush(output, remainingText(remaining));
+  }
+  return output;
+}
+
+function formatArrayBuffer(ctx, value) {
+  let buffer;
+  try {
+    buffer = new Uint8Array(value);
+  } catch {
+    return [ctx.stylize('(detached)', 'special')];
+  }
+  if (hexSlice === undefined)
+    hexSlice = uncurryThis(require('buffer').Buffer.prototype.hexSlice);
+  let str = StringPrototypeTrim(RegExpPrototypeSymbolReplace(
+    /(.{2})/g,
+    hexSlice(buffer, 0, MathMin(ctx.maxArrayLength, buffer.length)),
+    '$1 ',
+  ));
+  const remaining = buffer.length - ctx.maxArrayLength;
+  if (remaining > 0)
+    str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+  return [`${ctx.stylize('[Uint8Contents]', 'special')}: <${str}>`];
+}
+
+function formatArray(ctx, value, recurseTimes) {
+  const valLen = value.length;
+  const len = MathMin(MathMax(0, ctx.maxArrayLength), valLen);
+
+  const remaining = valLen - len;
+  const output = [];
+  for (let i = 0; i < len; i++) {
+    // Special handle sparse arrays.
+    if (!ObjectPrototypeHasOwnProperty(value, i)) {
+      return formatSpecialArray(ctx, value, recurseTimes, len, output, i);
+    }
+    ArrayPrototypePush(output, formatProperty(ctx, value, recurseTimes, i, kArrayType));
+  }
+  if (remaining > 0) {
+    ArrayPrototypePush(output, remainingText(remaining));
+  }
+  return output;
+}
+
+function formatTypedArray(value, length, ctx, ignored, recurseTimes) {
+  const maxLength = MathMin(MathMax(0, ctx.maxArrayLength), length);
+  const remaining = value.length - maxLength;
+  const output = new Array(maxLength);
+  const elementFormatter = value.length > 0 && typeof value[0] === 'number' ?
+    formatNumber :
+    formatBigInt;
+  for (let i = 0; i < maxLength; ++i) {
+    output[i] = elementFormatter(ctx.stylize, value[i], ctx.numericSeparator);
+  }
+  if (remaining > 0) {
+    output[maxLength] = remainingText(remaining);
+  }
+  if (ctx.showHidden) {
+    // .buffer goes last, it's not a primitive like the others.
+    // All besides `BYTES_PER_ELEMENT` are actually getters.
+    ctx.indentationLvl += 2;
+    for (const key of [
+      'BYTES_PER_ELEMENT',
+      'length',
+      'byteLength',
+      'byteOffset',
+      'buffer',
+    ]) {
+      const str = formatValue(ctx, value[key], recurseTimes, true);
+      ArrayPrototypePush(output, `[${key}]: ${str}`);
+    }
+    ctx.indentationLvl -= 2;
+  }
+  return output;
+}
+
+function formatSet(value, ctx, ignored, recurseTimes) {
+  const length = value.size;
+  const maxLength = MathMin(MathMax(0, ctx.maxArrayLength), length);
+  const remaining = length - maxLength;
+  const output = [];
+  ctx.indentationLvl += 2;
+  let i = 0;
+  for (const v of value) {
+    if (i >= maxLength) break;
+    ArrayPrototypePush(output, formatValue(ctx, v, recurseTimes));
+    i++;
+  }
+  if (remaining > 0) {
+    ArrayPrototypePush(output, remainingText(remaining));
+  }
+  ctx.indentationLvl -= 2;
+  return output;
+}
+
+function formatMap(value, ctx, ignored, recurseTimes) {
+  const length = value.size;
+  const maxLength = MathMin(MathMax(0, ctx.maxArrayLength), length);
+  const remaining = length - maxLength;
+  const output = [];
+  ctx.indentationLvl += 2;
+  let i = 0;
+  for (const { 0: k, 1: v } of value) {
+    if (i >= maxLength) break;
+    ArrayPrototypePush(
+      output,
+      `${formatValue(ctx, k, recurseTimes)} => ${formatValue(ctx, v, recurseTimes)}`,
+    );
+    i++;
+  }
+  if (remaining > 0) {
+    ArrayPrototypePush(output, remainingText(remaining));
+  }
+  ctx.indentationLvl -= 2;
+  return output;
+}
+
+function formatSetIterInner(ctx, recurseTimes, entries, state) {
+  const maxArrayLength = MathMax(ctx.maxArrayLength, 0);
+  const maxLength = MathMin(maxArrayLength, entries.length);
+  const output = new Array(maxLength);
+  ctx.indentationLvl += 2;
+  for (let i = 0; i < maxLength; i++) {
+    output[i] = formatValue(ctx, entries[i], recurseTimes);
+  }
+  ctx.indentationLvl -= 2;
+  if (state === kWeak && !ctx.sorted) {
+    // Sort all entries to have a halfway reliable output (if more entries than
+    // retrieved ones exist, we can not reliably return the same output) if the
+    // output is not sorted anyway.
+    ArrayPrototypeSort(output);
+  }
+  const remaining = entries.length - maxLength;
+  if (remaining > 0) {
+    ArrayPrototypePush(output, remainingText(remaining));
+  }
+  return output;
+}
+
+function formatMapIterInner(ctx, recurseTimes, entries, state) {
+  const maxArrayLength = MathMax(ctx.maxArrayLength, 0);
+  // Entries exist as [key1, val1, key2, val2, ...]
+  const len = entries.length / 2;
+  const remaining = len - maxArrayLength;
+  const maxLength = MathMin(maxArrayLength, len);
+  const output = new Array(maxLength);
+  let i = 0;
+  ctx.indentationLvl += 2;
+  if (state === kWeak) {
+    for (; i < maxLength; i++) {
+      const pos = i * 2;
+      output[i] =
+        `${formatValue(ctx, entries[pos], recurseTimes)} => ${formatValue(ctx, entries[pos + 1], recurseTimes)}`;
+    }
+    // Sort all entries to have a halfway reliable output (if more entries than
+    // retrieved ones exist, we can not reliably return the same output) if the
+    // output is not sorted anyway.
+    if (!ctx.sorted)
+      ArrayPrototypeSort(output);
+  } else {
+    for (; i < maxLength; i++) {
+      const pos = i * 2;
+      const res = [
+        formatValue(ctx, entries[pos], recurseTimes),
+        formatValue(ctx, entries[pos + 1], recurseTimes),
+      ];
+      output[i] = reduceToSingleString(
+        ctx, res, '', ['[', ']'], kArrayExtrasType, recurseTimes);
+    }
+  }
+  ctx.indentationLvl -= 2;
+  if (remaining > 0) {
+    ArrayPrototypePush(output, remainingText(remaining));
+  }
+  return output;
+}
+
+function formatWeakCollection(ctx) {
+  return [ctx.stylize('<items unknown>', 'special')];
+}
+
+function formatWeakSet(ctx, value, recurseTimes) {
+  const entries = previewEntries(value);
+  return formatSetIterInner(ctx, recurseTimes, entries, kWeak);
+}
+
+function formatWeakMap(ctx, value, recurseTimes) {
+  const entries = previewEntries(value);
+  return formatMapIterInner(ctx, recurseTimes, entries, kWeak);
+}
+
+function formatIterator(braces, ctx, value, recurseTimes) {
+  const { 0: entries, 1: isKeyValue } = previewEntries(value, true);
+  if (isKeyValue) {
+    // Mark entry iterators as such.
+    braces[0] = RegExpPrototypeSymbolReplace(/ Iterator] {$/, braces[0], ' Entries] {');
+    return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries);
+  }
+
+  return formatSetIterInner(ctx, recurseTimes, entries, kIterator);
+}
+
+function formatPromise(ctx, value, recurseTimes) {
+  let output;
+  const { 0: state, 1: result } = getPromiseDetails(value);
+  if (state === kPending) {
+    output = [ctx.stylize('<pending>', 'special')];
+  } else {
+    ctx.indentationLvl += 2;
+    const str = formatValue(ctx, result, recurseTimes);
+    ctx.indentationLvl -= 2;
+    output = [
+      state === kRejected ?
+        `${ctx.stylize('<rejected>', 'special')} ${str}` :
+        str,
+    ];
+  }
+  return output;
+}
+
+function formatProperty(ctx, value, recurseTimes, key, type, desc,
+                        original = value) {
+  let name, str;
+  let extra = ' ';
+  desc ||= ObjectGetOwnPropertyDescriptor(value, key) ||
+    { value: value[key], enumerable: true };
+  if (desc.value !== undefined) {
+    const diff = (ctx.compact !== true || type !== kObjectType) ? 2 : 3;
+    ctx.indentationLvl += diff;
+    str = formatValue(ctx, desc.value, recurseTimes);
+    if (diff === 3 && ctx.breakLength < getStringWidth(str, ctx.colors)) {
+      extra = `\n${StringPrototypeRepeat(' ', ctx.indentationLvl)}`;
+    }
+    ctx.indentationLvl -= diff;
+  } else if (desc.get !== undefined) {
+    const label = desc.set !== undefined ? 'Getter/Setter' : 'Getter';
+    const s = ctx.stylize;
+    const sp = 'special';
+    if (ctx.getters && (ctx.getters === true ||
+          (ctx.getters === 'get' && desc.set === undefined) ||
+          (ctx.getters === 'set' && desc.set !== undefined))) {
+      try {
+        const tmp = FunctionPrototypeCall(desc.get, original);
+        ctx.indentationLvl += 2;
+        if (tmp === null) {
+          str = `${s(`[${label}:`, sp)} ${s('null', 'null')}${s(']', sp)}`;
+        } else if (typeof tmp === 'object') {
+          str = `${s(`[${label}]`, sp)} ${formatValue(ctx, tmp, recurseTimes)}`;
+        } else {
+          const primitive = formatPrimitive(s, tmp, ctx);
+          str = `${s(`[${label}:`, sp)} ${primitive}${s(']', sp)}`;
+        }
+        ctx.indentationLvl -= 2;
+      } catch (err) {
+        const message = `<Inspection threw (${err.message})>`;
+        str = `${s(`[${label}:`, sp)} ${message}${s(']', sp)}`;
+      }
+    } else {
+      str = ctx.stylize(`[${label}]`, sp);
+    }
+  } else if (desc.set !== undefined) {
+    str = ctx.stylize('[Setter]', 'special');
+  } else {
+    str = ctx.stylize('undefined', 'undefined');
+  }
+  if (type === kArrayType) {
+    return str;
+  }
+  if (typeof key === 'symbol') {
+    const tmp = RegExpPrototypeSymbolReplace(
+      strEscapeSequencesReplacer,
+      SymbolPrototypeToString(key),
+      escapeFn,
+    );
+    name = `[${ctx.stylize(tmp, 'symbol')}]`;
+  } else if (key === '__proto__') {
+    name = "['__proto__']";
+  } else if (desc.enumerable === false) {
+    const tmp = RegExpPrototypeSymbolReplace(
+      strEscapeSequencesReplacer,
+      key,
+      escapeFn,
+    );
+    name = `[${tmp}]`;
+  } else if (RegExpPrototypeExec(keyStrRegExp, key) !== null) {
+    name = ctx.stylize(key, 'name');
+  } else {
+    name = ctx.stylize(strEscape(key), 'string');
+  }
+  return `${name}:${extra}${str}`;
+}
+
+function isBelowBreakLength(ctx, output, start, base) {
+  // Each entry is separated by at least a comma. Thus, we start with a total
+  // length of at least `output.length`. In addition, some cases have a
+  // whitespace in-between each other that is added to the total as well.
+  // TODO(BridgeAR): Add unicode support. Use the readline getStringWidth
+  // function. Check the performance overhead and make it an opt-in in case it's
+  // significant.
+  let totalLength = output.length + start;
+  if (totalLength + output.length > ctx.breakLength)
+    return false;
+  for (let i = 0; i < output.length; i++) {
+    if (ctx.colors) {
+      totalLength += removeColors(output[i]).length;
+    } else {
+      totalLength += output[i].length;
+    }
+    if (totalLength > ctx.breakLength) {
+      return false;
+    }
+  }
+  // Do not line up properties on the same line if `base` contains line breaks.
+  return base === '' || !StringPrototypeIncludes(base, '\n');
+}
+
+function reduceToSingleString(
+  ctx, output, base, braces, extrasType, recurseTimes, value) {
+  if (ctx.compact !== true) {
+    if (typeof ctx.compact === 'number' && ctx.compact >= 1) {
+      // Memorize the original output length. In case the output is grouped,
+      // prevent lining up the entries on a single line.
+      const entries = output.length;
+      // Group array elements together if the array contains at least six
+      // separate entries.
+      if (extrasType === kArrayExtrasType && entries > 6) {
+        output = groupArrayElements(ctx, output, value);
+      }
+      // `ctx.currentDepth` is set to the most inner depth of the currently
+      // inspected object part while `recurseTimes` is the actual current depth
+      // that is inspected.
+      //
+      // Example:
+      //
+      // const a = { first: [ 1, 2, 3 ], second: { inner: [ 1, 2, 3 ] } }
+      //
+      // The deepest depth of `a` is 2 (a.second.inner) and `a.first` has a max
+      // depth of 1.
+      //
+      // Consolidate all entries of the local most inner depth up to
+      // `ctx.compact`, as long as the properties are smaller than
+      // `ctx.breakLength`.
+      if (ctx.currentDepth - recurseTimes < ctx.compact &&
+          entries === output.length) {
+        // Line up all entries on a single line in case the entries do not
+        // exceed `breakLength`. Add 10 as constant to start next to all other
+        // factors that may reduce `breakLength`.
+        const start = output.length + ctx.indentationLvl +
+                      braces[0].length + base.length + 10;
+        if (isBelowBreakLength(ctx, output, start, base)) {
+          const joinedOutput = join(output, ', ');
+          if (!StringPrototypeIncludes(joinedOutput, '\n')) {
+            return `${base ? `${base} ` : ''}${braces[0]} ${joinedOutput}` +
+              ` ${braces[1]}`;
+          }
+        }
+      }
+    }
+    // Line up each entry on an individual line.
+    const indentation = `\n${StringPrototypeRepeat(' ', ctx.indentationLvl)}`;
+    return `${base ? `${base} ` : ''}${braces[0]}${indentation}  ` +
+      `${join(output, `,${indentation}  `)}${indentation}${braces[1]}`;
+  }
+  // Line up all entries on a single line in case the entries do not exceed
+  // `breakLength`.
+  if (isBelowBreakLength(ctx, output, 0, base)) {
+    return `${braces[0]}${base ? ` ${base}` : ''} ${join(output, ', ')} ` +
+      braces[1];
+  }
+  const indentation = StringPrototypeRepeat(' ', ctx.indentationLvl);
+  // If the opening "brace" is too large, like in the case of "Set {",
+  // we need to force the first item to be on the next line or the
+  // items will not line up correctly.
+  const ln = base === '' && braces[0].length === 1 ?
+    ' ' : `${base ? ` ${base}` : ''}\n${indentation}  `;
+  // Line up each entry on an individual line.
+  return `${braces[0]}${ln}${join(output, `,\n${indentation}  `)} ${braces[1]}`;
+}
+
+function hasBuiltInToString(value) {
+  // Prevent triggering proxy traps.
+  const getFullProxy = false;
+  const proxyTarget = getProxyDetails(value, getFullProxy);
+  if (proxyTarget !== undefined) {
+    if (proxyTarget === null) {
+      return true;
+    }
+    value = proxyTarget;
+  }
+
+  let hasOwnToString = ObjectPrototypeHasOwnProperty;
+  let hasOwnToPrimitive = ObjectPrototypeHasOwnProperty;
+
+  // Count objects without `toString` and `Symbol.toPrimitive` function as built-in.
+  if (typeof value.toString !== 'function') {
+    if (typeof value[SymbolToPrimitive] !== 'function') {
+      return true;
+    } else if (ObjectPrototypeHasOwnProperty(value, SymbolToPrimitive)) {
+      return false;
+    }
+    hasOwnToString = returnFalse;
+  } else if (ObjectPrototypeHasOwnProperty(value, 'toString')) {
+    return false;
+  } else if (typeof value[SymbolToPrimitive] !== 'function') {
+    hasOwnToPrimitive = returnFalse;
+  } else if (ObjectPrototypeHasOwnProperty(value, SymbolToPrimitive)) {
+    return false;
+  }
+
+  // Find the object that has the `toString` property or `Symbol.toPrimitive` property
+  // as own property in the prototype chain.
+  let pointer = value;
+  do {
+    pointer = ObjectGetPrototypeOf(pointer);
+  } while (!hasOwnToString(pointer, 'toString') &&
+    !hasOwnToPrimitive(pointer, SymbolToPrimitive));
+
+  // Check closer if the object is a built-in.
+  const descriptor = ObjectGetOwnPropertyDescriptor(pointer, 'constructor');
+  return descriptor !== undefined &&
+    typeof descriptor.value === 'function' &&
+    builtInObjects.has(descriptor.value.name);
+}
+
+function returnFalse() {
+  return false;
+}
+
+const firstErrorLine = (error) => StringPrototypeSplit(error.message, '\n', 1)[0];
+let CIRCULAR_ERROR_MESSAGE;
+function tryStringify(arg) {
+  try {
+    return JSONStringify(arg);
+  } catch (err) {
+    // Populate the circular error message lazily
+    if (!CIRCULAR_ERROR_MESSAGE) {
+      try {
+        const a = {};
+        a.a = a;
+        JSONStringify(a);
+      } catch (circularError) {
+        CIRCULAR_ERROR_MESSAGE = firstErrorLine(circularError);
+      }
+    }
+    if (err.name === 'TypeError' &&
+        firstErrorLine(err) === CIRCULAR_ERROR_MESSAGE) {
+      return '[Circular]';
+    }
+    throw err;
+  }
+}
+
+function format(...args) {
+  return formatWithOptionsInternal(undefined, args);
+}
+
+function formatWithOptions(inspectOptions, ...args) {
+  validateObject(inspectOptions, 'inspectOptions', kValidateObjectAllowArray);
+  return formatWithOptionsInternal(inspectOptions, args);
+}
+
+function formatNumberNoColor(number, options) {
+  return formatNumber(
+    stylizeNoColor,
+    number,
+    options?.numericSeparator ?? inspectDefaultOptions.numericSeparator,
+  );
+}
+
+function formatBigIntNoColor(bigint, options) {
+  return formatBigInt(
+    stylizeNoColor,
+    bigint,
+    options?.numericSeparator ?? inspectDefaultOptions.numericSeparator,
+  );
+}
+
+function formatWithOptionsInternal(inspectOptions, args) {
+  const first = args[0];
+  let a = 0;
+  let str = '';
+  let join = '';
+
+  if (typeof first === 'string') {
+    if (args.length === 1) {
+      return first;
+    }
+    let tempStr;
+    let lastPos = 0;
+
+    for (let i = 0; i < first.length - 1; i++) {
+      if (StringPrototypeCharCodeAt(first, i) === 37) { // '%'
+        const nextChar = StringPrototypeCharCodeAt(first, ++i);
+        if (a + 1 !== args.length) {
+          switch (nextChar) {
+            case 115: { // 's'
+              const tempArg = args[++a];
+              if (typeof tempArg === 'number') {
+                tempStr = formatNumberNoColor(tempArg, inspectOptions);
+              } else if (typeof tempArg === 'bigint') {
+                tempStr = formatBigIntNoColor(tempArg, inspectOptions);
+              } else if (typeof tempArg !== 'object' ||
+                         tempArg === null ||
+                         !hasBuiltInToString(tempArg)) {
+                tempStr = String(tempArg);
+              } else {
+                tempStr = inspect(tempArg, {
+                  ...inspectOptions,
+                  compact: 3,
+                  colors: false,
+                  depth: 0,
+                });
+              }
+              break;
+            }
+            case 106: // 'j'
+              tempStr = tryStringify(args[++a]);
+              break;
+            case 100: { // 'd'
+              const tempNum = args[++a];
+              if (typeof tempNum === 'bigint') {
+                tempStr = formatBigIntNoColor(tempNum, inspectOptions);
+              } else if (typeof tempNum === 'symbol') {
+                tempStr = 'NaN';
+              } else {
+                tempStr = formatNumberNoColor(Number(tempNum), inspectOptions);
+              }
+              break;
+            }
+            case 79: // 'O'
+              tempStr = inspect(args[++a], inspectOptions);
+              break;
+            case 111: // 'o'
+              tempStr = inspect(args[++a], {
+                ...inspectOptions,
+                showHidden: true,
+                showProxy: true,
+                depth: 4,
+              });
+              break;
+            case 105: { // 'i'
+              const tempInteger = args[++a];
+              if (typeof tempInteger === 'bigint') {
+                tempStr = formatBigIntNoColor(tempInteger, inspectOptions);
+              } else if (typeof tempInteger === 'symbol') {
+                tempStr = 'NaN';
+              } else {
+                tempStr = formatNumberNoColor(
+                  NumberParseInt(tempInteger), inspectOptions);
+              }
+              break;
+            }
+            case 102: { // 'f'
+              const tempFloat = args[++a];
+              if (typeof tempFloat === 'symbol') {
+                tempStr = 'NaN';
+              } else {
+                tempStr = formatNumberNoColor(
+                  NumberParseFloat(tempFloat), inspectOptions);
+              }
+              break;
+            }
+            case 99: // 'c'
+              a += 1;
+              tempStr = '';
+              break;
+            case 37: // '%'
+              str += StringPrototypeSlice(first, lastPos, i);
+              lastPos = i + 1;
+              continue;
+            default: // Any other character is not a correct placeholder
+              continue;
+          }
+          if (lastPos !== i - 1) {
+            str += StringPrototypeSlice(first, lastPos, i - 1);
+          }
+          str += tempStr;
+          lastPos = i + 1;
+        } else if (nextChar === 37) {
+          str += StringPrototypeSlice(first, lastPos, i);
+          lastPos = i + 1;
+        }
+      }
+    }
+    if (lastPos !== 0) {
+      a++;
+      join = ' ';
+      if (lastPos < first.length) {
+        str += StringPrototypeSlice(first, lastPos);
+      }
+    }
+  }
+
+  while (a < args.length) {
+    const value = args[a];
+    str += join;
+    str += typeof value !== 'string' ? inspect(value, inspectOptions) : value;
+    join = ' ';
+    a++;
+  }
+  return str;
+}
+
+function isZeroWidthCodePoint(code) {
+  return code <= 0x1F || // C0 control codes
+    (code >= 0x7F && code <= 0x9F) || // C1 control codes
+    (code >= 0x300 && code <= 0x36F) || // Combining Diacritical Marks
+    (code >= 0x200B && code <= 0x200F) || // Modifying Invisible Characters
+    // Combining Diacritical Marks for Symbols
+    (code >= 0x20D0 && code <= 0x20FF) ||
+    (code >= 0xFE00 && code <= 0xFE0F) || // Variation Selectors
+    (code >= 0xFE20 && code <= 0xFE2F) || // Combining Half Marks
+    (code >= 0xE0100 && code <= 0xE01EF); // Variation Selectors
+}
+
+if (internalBinding('config').hasIntl) {
+  const icu = internalBinding('icu');
+  // icu.getStringWidth(string, ambiguousAsFullWidth, expandEmojiSequence)
+  // Defaults: ambiguousAsFullWidth = false; expandEmojiSequence = true;
+  // TODO(BridgeAR): Expose the options to the user. That is probably the
+  // best thing possible at the moment, since it's difficult to know what
+  // the receiving end supports.
+  getStringWidth = function getStringWidth(str, removeControlChars = true) {
+    let width = 0;
+
+    if (removeControlChars) {
+      str = stripVTControlCharacters(str);
+    }
+    for (let i = 0; i < str.length; i++) {
+      // Try to avoid calling into C++ by first handling the ASCII portion of
+      // the string. If it is fully ASCII, we skip the C++ part.
+      const code = str.charCodeAt(i);
+      if (code >= 127) {
+        width += icu.getStringWidth(StringPrototypeNormalize(StringPrototypeSlice(str, i), 'NFC'));
+        break;
+      }
+      width += code >= 32 ? 1 : 0;
+    }
+    return width;
+  };
+} else {
+  /**
+   * Returns the number of columns required to display the given string.
+   */
+  getStringWidth = function getStringWidth(str, removeControlChars = true) {
+    let width = 0;
+
+    if (removeControlChars)
+      str = stripVTControlCharacters(str);
+    str = StringPrototypeNormalize(str, 'NFC');
+    for (const char of new SafeStringIterator(str)) {
+      const code = StringPrototypeCodePointAt(char, 0);
+      if (isFullWidthCodePoint(code)) {
+        width += 2;
+      } else if (!isZeroWidthCodePoint(code)) {
+        width++;
+      }
+    }
+
+    return width;
+  };
+
+  /**
+   * Returns true if the character represented by a given
+   * Unicode code point is full-width. Otherwise returns false.
+   */
+  const isFullWidthCodePoint = (code) => {
+    // Code points are partially derived from:
+    // https://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt
+    return code >= 0x1100 && (
+      code <= 0x115f ||  // Hangul Jamo
+      code === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+      code === 0x232a || // RIGHT-POINTING ANGLE BRACKET
+      // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+      (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) ||
+      // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+      (code >= 0x3250 && code <= 0x4dbf) ||
+      // CJK Unified Ideographs .. Yi Radicals
+      (code >= 0x4e00 && code <= 0xa4c6) ||
+      // Hangul Jamo Extended-A
+      (code >= 0xa960 && code <= 0xa97c) ||
+      // Hangul Syllables
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      // CJK Compatibility Ideographs
+      (code >= 0xf900 && code <= 0xfaff) ||
+      // Vertical Forms
+      (code >= 0xfe10 && code <= 0xfe19) ||
+      // CJK Compatibility Forms .. Small Form Variants
+      (code >= 0xfe30 && code <= 0xfe6b) ||
+      // Halfwidth and Fullwidth Forms
+      (code >= 0xff01 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6) ||
+      // Kana Supplement
+      (code >= 0x1b000 && code <= 0x1b001) ||
+      // Enclosed Ideographic Supplement
+      (code >= 0x1f200 && code <= 0x1f251) ||
+      // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff
+      // Emoticons 0x1f600 - 0x1f64f
+      (code >= 0x1f300 && code <= 0x1f64f) ||
+      // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+      (code >= 0x20000 && code <= 0x3fffd)
+    );
+  };
+
+}
+
+/**
+ * Remove all VT control characters. Use to estimate displayed string width.
+ */
+function stripVTControlCharacters(str) {
+  validateString(str, 'str');
+
+  return RegExpPrototypeSymbolReplace(ansi, str, '');
+}
+
+module.exports = {
+  identicalSequenceRange,
+  inspect,
+  inspectDefaultOptions,
+  format,
+  formatWithOptions,
+  getStringWidth,
+  stripVTControlCharacters,
+  isZeroWidthCodePoint,
+};