napi-rs/.yarn/patches/node-inspect-extracted-npm-3.0.0-f661b6c334.patch

diff --git a/dist/inspect.js b/dist/inspect.js
index 8a323f4df754c11beffd03bb63c5d24c0ea43724..da0515280b09ea8d7bcd2c3aeb5f1a48649be80a 100644
--- a/dist/inspect.js
+++ b/dist/inspect.js
@@ -1 +1,3831 @@
-!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.util=e():t.util=e()}(this,(()=>(()=>{"use strict";var t={165:(t,e)=>{function r(t){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},r(t)}function n(t,e){for(var n=0;n<e.length;n++){var o=e[n];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(t,(void 0,i=function(t,e){if("object"!==r(t)||null===t)return t;var n=t[Symbol.toPrimitive];if(void 0!==n){var o=n.call(t,"string");if("object"!==r(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(t)}(o.key),"symbol"===r(i)?i:String(i)),o)}var i}var o=function(){function t(){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t)}var e,r;return e=t,r=[{key:"hexSlice",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,e=arguments.length>1?arguments[1]:void 0;return Array.prototype.map.call(this.slice(t,e),(function(t){return("00"+t.toString(16)).slice(-2)})).join("")}}],r&&n(e.prototype,r),Object.defineProperty(e,"prototype",{writable:!1}),t}();e.l=o},777:(t,e,r)=>{function n(t){return n="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},n(t)}function o(t,e){var r="undefined"!=typeof Symbol&&t[Symbol.iterator]||t["@@iterator"];if(!r){if(Array.isArray(t)||(r=function(t,e){if(t){if("string"==typeof t)return i(t,e);var r=Object.prototype.toString.call(t).slice(8,-1);return"Object"===r&&t.constructor&&(r=t.constructor.name),"Map"===r||"Set"===r?Array.from(t):"Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?i(t,e):void 0}}(t))||e&&t&&"number"==typeof t.length){r&&(t=r);var n=0,o=function(){};return{s:o,n:function(){return n>=t.length?{done:!0}:{done:!1,value:t[n++]}},e:function(t){throw t},f:o}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,c=!0,l=!1;return{s:function(){r=r.call(t)},n:function(){var t=r.next();return c=t.done,t},e:function(t){l=!0,a=t},f:function(){try{c||null==r.return||r.return()}finally{if(l)throw a}}}}function i(t,e){(null==e||e>t.length)&&(e=t.length);for(var r=0,n=new Array(e);r<e;r++)n[r]=t[r];return n}function a(t,e){var r=Object.keys(t);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(t);e&&(n=n.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),r.push.apply(r,n)}return r}function c(t){for(var e=1;e<arguments.length;e++){var r=null!=arguments[e]?arguments[e]:{};e%2?a(Object(r),!0).forEach((function(e){l(t,e,r[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(r)):a(Object(r)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(r,e))}))}return t}function l(t,e,r){return(e=function(t){var e=function(t,e){if("object"!==n(t)||null===t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,"string");if("object"!==n(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(t)}(t);return"symbol"===n(e)?e:String(e)}(e))in t?Object.defineProperty(t,e,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[e]=r,t}var u,p,f=r(541),y=f.internalBinding,s=f.Array,g=f.ArrayIsArray,d=f.ArrayPrototypeFilter,b=f.ArrayPrototypeForEach,h=f.ArrayPrototypeIncludes,v=f.ArrayPrototypeIndexOf,m=f.ArrayPrototypeJoin,S=f.ArrayPrototypeMap,P=f.ArrayPrototypePop,x=f.ArrayPrototypePush,O=f.ArrayPrototypePushApply,A=f.ArrayPrototypeSlice,w=f.ArrayPrototypeSplice,j=f.ArrayPrototypeSort,E=f.ArrayPrototypeUnshift,_=f.BigIntPrototypeValueOf,F=f.BooleanPrototype
\ No newline at end of file
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var primordials = {exports: {}};
+
+// back-patch in primordials in user-land
+
+const createSafeIterator = (factory, next) => {
+  class SafeIterator {
+    constructor(iterable) {
+      this._iterator = factory(iterable);
+    }
+    next() {
+      return next(this._iterator);
+    }
+    [Symbol.iterator]() {
+      return this;
+    }
+  }
+  Object.setPrototypeOf(SafeIterator.prototype, null);
+  Object.freeze(SafeIterator.prototype);
+  Object.freeze(SafeIterator);
+  return SafeIterator;
+};
+
+function getGetter(cls, getter) {
+  // TODO: __lookupGetter__ is deprecated, but Object.getOwnPropertyDescriptor
+  // doesn't work on built-ins like Typed Arrays.
+  return Function.prototype.call.bind(cls.prototype.__lookupGetter__(getter));
+}
+
+function getterCaller(getter) {
+  return (val) => {
+    return val.constructor.prototype.__lookupGetter__(getter).call(val);
+  };
+}
+
+function uncurryThis(func) {
+  return Function.prototype.call.bind(func);
+}
+
+const copyProps = (src, dest) => {
+  Array.prototype.forEach.call(Reflect.ownKeys(src), (key) => {
+    if (!Reflect.getOwnPropertyDescriptor(dest, key)) {
+      Reflect.defineProperty(
+        dest,
+        key,
+        Reflect.getOwnPropertyDescriptor(src, key));
+    }
+  });
+};
+
+const makeSafe = (unsafe, safe) => {
+  if (Symbol.iterator in unsafe.prototype) {
+    const dummy = new unsafe();
+    let next; // We can reuse the same `next` method.
+
+    Array.prototype.forEach.call(Reflect.ownKeys(unsafe.prototype), (key) => {
+      if (!Reflect.getOwnPropertyDescriptor(safe.prototype, key)) {
+        const desc = Reflect.getOwnPropertyDescriptor(unsafe.prototype, key);
+        if (typeof desc.value === 'function' && desc.value.length === 0) {
+            const called = Function.prototype.call.call(desc.value, dummy) || {};
+            if (Symbol.iterator in (typeof called === "object" ? called : {})) {
+                const createIterator = uncurryThis(desc.value);
+                if (next == null) {
+                    next = uncurryThis(createIterator(dummy).next);
+                }
+                const SafeIterator = createSafeIterator(createIterator, next);
+                desc.value = function() {
+                    return new SafeIterator(this);
+                };
+            }
+        }
+        Reflect.defineProperty(safe.prototype, key, desc);
+      }
+    });
+  } else {
+    copyProps(unsafe.prototype, safe.prototype);
+  }
+  copyProps(unsafe, safe);
+
+  Object.setPrototypeOf(safe.prototype, null);
+  Object.freeze(safe.prototype);
+  Object.freeze(safe);
+  return safe;
+};
+
+const StringIterator =
+  Function.prototype.call.bind(String.prototype[Symbol.iterator]);
+const StringIteratorPrototype = Reflect.getPrototypeOf(StringIterator(''));
+
+function ErrorCaptureStackTrace(targetObject) {
+  const stack = new Error().stack;
+  // Remove the second line, which is this function
+  targetObject.stack = stack.replace(/.*\n.*/, '$1');
+}
+
+primordials.exports = {
+  makeSafe, // exported for testing
+  internalBinding(mod) {
+    if (mod === 'config') {
+      return {
+        hasIntl: false,
+      };
+    }
+    throw new Error(`unknown module: "${mod}"`);
+  },
+  Array,
+  ArrayIsArray: Array.isArray,
+  ArrayPrototypeFilter: Function.prototype.call.bind(Array.prototype.filter),
+  ArrayPrototypeForEach: Function.prototype.call.bind(Array.prototype.forEach),
+  ArrayPrototypeIncludes:
+    Function.prototype.call.bind(Array.prototype.includes),
+  ArrayPrototypeIndexOf: Function.prototype.call.bind(Array.prototype.indexOf),
+  ArrayPrototypeJoin: Function.prototype.call.bind(Array.prototype.join),
+  ArrayPrototypeMap: Function.prototype.call.bind(Array.prototype.map),
+  ArrayPrototypePop: Function.prototype.call.bind(Array.prototype.pop),
+  ArrayPrototypePush: Function.prototype.call.bind(Array.prototype.push),
+  ArrayPrototypePushApply: Function.apply.bind(Array.prototype.push),
+  ArrayPrototypeSlice: Function.prototype.call.bind(Array.prototype.slice),
+  ArrayPrototypeSort: Function.prototype.call.bind(Array.prototype.sort),
+  ArrayPrototypeSplice: Function.prototype.call.bind(Array.prototype.splice),
+  ArrayPrototypeUnshift: Function.prototype.call.bind(Array.prototype.unshift),
+  BigIntPrototypeValueOf:
+    Function.prototype.call.bind(BigInt.prototype.valueOf),
+  BooleanPrototypeValueOf:
+    Function.prototype.call.bind(Boolean.prototype.valueOf),
+  DatePrototypeGetTime: Function.prototype.call.bind(Date.prototype.getTime),
+  DatePrototypeToISOString:
+    Function.prototype.call.bind(Date.prototype.toISOString),
+  DatePrototypeToString:
+    Function.prototype.call.bind(Date.prototype.toString),
+  ErrorCaptureStackTrace,
+  ErrorPrototypeToString:
+    Function.prototype.call.bind(Error.prototype.toString),
+  FunctionPrototypeBind: Function.prototype.call.bind(Function.prototype.bind),
+  FunctionPrototypeCall:
+    Function.prototype.call.bind(Function.prototype.call),
+  FunctionPrototypeToString:
+    Function.prototype.call.bind(Function.prototype.toString),
+  globalThis: (typeof globalThis === 'undefined') ? commonjsGlobal : globalThis,
+  JSONStringify: JSON.stringify,
+  MapPrototypeGetSize: getGetter(Map, 'size'),
+  MapPrototypeEntries: Function.prototype.call.bind(Map.prototype.entries),
+  MathFloor: Math.floor,
+  MathMax: Math.max,
+  MathMin: Math.min,
+  MathRound: Math.round,
+  MathSqrt: Math.sqrt,
+  MathTrunc: Math.trunc,
+  Number,
+  NumberIsFinite: Number.isFinite,
+  NumberIsNaN: Number.isNaN,
+  NumberParseFloat: Number.parseFloat,
+  NumberParseInt: Number.parseInt,
+  NumberPrototypeToString: Function.prototype.call.bind(Number.prototype.toString),
+  NumberPrototypeValueOf:
+    Function.prototype.call.bind(Number.prototype.valueOf),
+  Object,
+  ObjectAssign: Object.assign,
+  ObjectCreate: Object.create,
+  ObjectDefineProperty: Object.defineProperty,
+  ObjectGetOwnPropertyDescriptor: Object.getOwnPropertyDescriptor,
+  ObjectGetOwnPropertyNames: Object.getOwnPropertyNames,
+  ObjectGetOwnPropertySymbols: Object.getOwnPropertySymbols,
+  ObjectGetPrototypeOf: Object.getPrototypeOf,
+  ObjectIs: Object.is,
+  ObjectKeys: Object.keys,
+  ObjectPrototypeHasOwnProperty:
+    Function.prototype.call.bind(Object.prototype.hasOwnProperty),
+  ObjectPrototypePropertyIsEnumerable:
+    Function.prototype.call.bind(Object.prototype.propertyIsEnumerable),
+  ObjectSeal: Object.seal,
+  ObjectSetPrototypeOf: Object.setPrototypeOf,
+  ReflectApply: Reflect.apply,
+  ReflectOwnKeys: Reflect.ownKeys,
+  RegExp,
+  RegExpPrototypeExec: Function.prototype.call.bind(RegExp.prototype.exec),
+  RegExpPrototypeSymbolReplace: Function.prototype.call.bind(RegExp.prototype[Symbol.replace]),
+  RegExpPrototypeSymbolSplit: Function.prototype.call.bind(RegExp.prototype[Symbol.split]),
+  RegExpPrototypeTest: Function.prototype.call.bind(RegExp.prototype.test),
+  RegExpPrototypeToString:
+    Function.prototype.call.bind(RegExp.prototype.toString),
+  SafeStringIterator: createSafeIterator(
+    StringIterator,
+    Function.prototype.call.bind(StringIteratorPrototype.next),
+  ),
+  SafeMap: makeSafe(
+    Map,
+    class SafeMap extends Map {
+      constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
+    }),
+  SafeSet: makeSafe(
+    Set,
+    class SafeSet extends Set {
+      constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
+    }),
+  SetPrototypeGetSize: getGetter(Set, 'size'),
+  SetPrototypeValues: Function.prototype.call.bind(Set.prototype.values),
+  String,
+  StringPrototypeCharCodeAt:
+    Function.prototype.call.bind(String.prototype.charCodeAt),
+  StringPrototypeCodePointAt:
+    Function.prototype.call.bind(String.prototype.codePointAt),
+  StringPrototypeEndsWith:
+    Function.prototype.call.bind(String.prototype.endsWith),
+  StringPrototypeIncludes:
+    Function.prototype.call.bind(String.prototype.includes),
+  StringPrototypeIndexOf:
+    Function.prototype.call.bind(String.prototype.indexOf),
+  StringPrototypeLastIndexOf:
+    Function.prototype.call.bind(String.prototype.lastIndexOf),
+  StringPrototypeNormalize:
+    Function.prototype.call.bind(String.prototype.normalize),
+  StringPrototypePadEnd:
+    Function.prototype.call.bind(String.prototype.padEnd),
+  StringPrototypePadStart:
+    Function.prototype.call.bind(String.prototype.padStart),
+  StringPrototypeRepeat: Function.prototype.call.bind(String.prototype.repeat),
+  StringPrototypeReplace:
+    Function.prototype.call.bind(String.prototype.replace),
+  StringPrototypeReplaceAll:
+    Function.prototype.call.bind(String.prototype.replaceAll),
+  StringPrototypeSlice: Function.prototype.call.bind(String.prototype.slice),
+  StringPrototypeSplit: Function.prototype.call.bind(String.prototype.split),
+  StringPrototypeStartsWith: Function.prototype.call.bind(String.prototype.startsWith),
+  StringPrototypeToLowerCase:
+    Function.prototype.call.bind(String.prototype.toLowerCase),
+  StringPrototypeTrim: Function.prototype.call.bind(String.prototype.trim),
+  StringPrototypeValueOf:
+    Function.prototype.call.bind(String.prototype.valueOf),
+  SymbolPrototypeToString:
+    Function.prototype.call.bind(Symbol.prototype.toString),
+  SymbolPrototypeValueOf:
+    Function.prototype.call.bind(Symbol.prototype.valueOf),
+  SymbolIterator: Symbol.iterator,
+  SymbolFor: Symbol.for,
+  SymbolToStringTag: Symbol.toStringTag,
+  TypedArrayPrototypeGetLength: getterCaller('length'),
+  Uint8Array,
+  uncurryThis,
+};
+
+// Node 14
+/* c8 ignore start */
+if (!String.prototype.replaceAll) {
+  // Lifted and simplified from core-js for the moment.  Will remove when we
+  // drop node 14 support.
+
+  function requireObjectCoercible(it) {
+    if (it == null) throw new TypeError("Can't call method on " + it);
+    return it;
+  }
+
+  function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {
+    const tailPos = position + matched.length;
+    const m = captures.length;
+    let symbols = /\$([$&'`]|\d{1,2})/;
+    if (namedCaptures !== undefined) {
+      namedCaptures = Object(requireObjectCoercible(namedCaptures));
+      symbols = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
+    }
+    return replacement.replace(symbols, (match, ch) => {
+      let capture;
+      switch (ch.charAt(0)) {
+        case '$': return '$';
+        case '&': return matched;
+        case '`': return str.slice(0, position);
+        case "'": return str.slice(tailPos);
+        case '<':
+          capture = namedCaptures[ch.slice(1, -1)];
+          break;
+        default: { // \d\d?
+          const n = +ch;
+          if (n === 0) return match;
+          if (n > m) {
+            const f = Math.floor(n / 10);
+            if (f === 0) return match;
+            if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
+            return match;
+          }
+          capture = captures[n - 1];
+        }
+      }
+      return capture === undefined ? '' : capture;
+    });
+  }
+
+  primordials.exports.StringPrototypeReplaceAll = (str, searchValue, replaceValue) => {
+    const O = requireObjectCoercible(str);
+    let IS_REG_EXP, flags, replacer, replacement;
+    let position = 0;
+    let endOfLastMatch = 0;
+    let result = '';
+    if (searchValue != null) {
+      IS_REG_EXP = searchValue instanceof RegExp;
+      if (IS_REG_EXP) {
+        flags = searchValue.flags;
+        if (!~flags.indexOf('g')) {
+          throw new TypeError('`.replaceAll` does not allow non-global regexes');
+        }
+      }
+      replacer = searchValue[Symbol.replace];
+      if (replacer) {
+        return replacer.call(searchValue, O, replaceValue);
+      }
+    }
+    const string = String(O);
+    const searchString = String(searchValue);
+    const functionalReplace = (typeof replaceValue === 'function');
+    if (!functionalReplace) replaceValue = String(replaceValue);
+    const searchLength = searchString.length;
+    const advanceBy = Math.max(1, searchLength);
+    position = string.indexOf(searchString, 0);
+    while (position !== -1) {
+      replacement = functionalReplace ?
+        String(replaceValue(searchString, position, string)) :
+        getSubstitution(searchString, string, position, [], undefined, replaceValue);
+      result += string.slice(endOfLastMatch, position) + replacement;
+      endOfLastMatch = position + searchLength;
+      position = string.indexOf(searchString, position + advanceBy);
+    }
+    if (endOfLastMatch < string.length) {
+      result += string.slice(endOfLastMatch);
+    }
+    return result;
+  };
+}
+/* c8 ignore stop */
+
+var primordialsExports = primordials.exports;
+
+const ALL_PROXIES = new WeakMap();
+
+// Wrap Proxy's to remember their details.
+class Prxy {
+  constructor(target, handler) {
+    const p = new Proxy(target, handler);
+    ALL_PROXIES.set(p, [target, handler]);
+    // eslint-disable-next-line no-constructor-return
+    return p;
+  }
+  static getProxyDetails(obj, getFullProxy = true) {
+    const deets = ALL_PROXIES.get(obj);
+    if (!deets) {
+      return undefined;
+    }
+    if (getFullProxy) {
+      return deets;
+    }
+    return deets[0];
+  }
+  static revocable(target, handler) {
+    const p = Proxy.revocable(target, handler);
+    ALL_PROXIES.set(p.proxy, [target, handler]);
+    const revoke = p.revoke;
+    p.revoke = () => {
+      ALL_PROXIES.set(p.proxy, [null, null]);
+      revoke();
+    };
+    return p;
+  }
+}
+
+var proxy = {
+  getProxyDetails: Prxy.getProxyDetails.bind(Prxy),
+  Proxy: Prxy,
+};
+
+const prxy = proxy;
+const ALL_PROPERTIES = 0;
+const ONLY_ENUMERABLE = 2;
+const kPending = Symbol('kPending');
+const kRejected = Symbol('kRejected');
+
+function getOwnNonIndexProperties(a, filter = ONLY_ENUMERABLE) {
+  const desc = Object.getOwnPropertyDescriptors(a);
+  const ret = [];
+  for (const [k, v] of Object.entries(desc)) {
+    if (!/^(0|[1-9][0-9]*)$/.test(k) ||
+        (parseInt(k, 10) >= (2 ** 32 - 1))) { // Arrays are limited in size
+      if ((filter === ONLY_ENUMERABLE) && !v.enumerable) {
+        continue;
+      }
+      ret.push(k);
+    }
+  }
+  for (const s of Object.getOwnPropertySymbols(a)) {
+    const v = Object.getOwnPropertyDescriptor(a, s);
+    if ((filter === ONLY_ENUMERABLE) && !v.enumerable) {
+      continue;
+    }
+    ret.push(s);
+  }
+  return ret;
+}
+
+var util$1 = {
+  constants: {
+    kPending,
+    kRejected,
+    ALL_PROPERTIES,
+    ONLY_ENUMERABLE,
+  },
+  getOwnNonIndexProperties,
+  getPromiseDetails() { return [kPending, undefined]; },
+  getProxyDetails: prxy.getProxyDetails,
+  Proxy: prxy.Proxy,
+  previewEntries(val) {
+    return [[], false];
+  },
+  getConstructorName(val) {
+    if (!val || typeof val !== 'object') {
+      throw new Error('Invalid object');
+    }
+    if (val.constructor && val.constructor.name) {
+      return val.constructor.name;
+    }
+    const str = Object.prototype.toString.call(val);
+    // e.g. [object Boolean]
+    const m = str.match(/^\[object ([^\]]+)\]/);
+    if (m) {
+      return m[1];
+    }
+    return 'Object';
+  },
+  getExternalValue() { return BigInt(0); },
+};
+
+// eslint-disable-next-line no-control-regex
+const colorRegExp = /\u001b\[\d\d?m/g;
+
+var util = {
+  customInspectSymbol: Symbol.for('nodejs.util.inspect.custom'),
+  isError(e) {
+    return e instanceof Error;
+  },
+  join: Array.prototype.join.call.bind(Array.prototype.join),
+  removeColors(str) {
+    return String.prototype.replace.call(str, colorRegExp, '');
+  },
+};
+
+function assert(p) {
+  if (!p) {
+    throw new Error('Assertion failed');
+  }
+}
+
+assert.fail = function fail(message) {
+  throw new Error(message);
+};
+
+var assert_1 = assert;
+
+/* eslint node-core/documented-errors: "error" */
+
+var errors;
+var hasRequiredErrors;
+
+function requireErrors () {
+	if (hasRequiredErrors) return errors;
+	hasRequiredErrors = 1;
+
+	// The whole point behind this internal module is to allow Node.js to no
+	// longer be forced to treat every error message change as a semver-major
+	// change. The NodeError classes here all expose a `code` property whose
+	// value statically and permanently identifies the error. While the error
+	// message may change, the code should not.
+
+	const {
+	  ArrayIsArray,
+	  ArrayPrototypeIncludes,
+	  ArrayPrototypeIndexOf,
+	  ArrayPrototypeJoin,
+	  ArrayPrototypePop,
+	  ArrayPrototypePush,
+	  ArrayPrototypeSplice,
+	  ErrorCaptureStackTrace,
+	  ObjectDefineProperty,
+	  ReflectApply,
+	  RegExpPrototypeTest,
+	  SafeMap,
+	  StringPrototypeEndsWith,
+	  StringPrototypeIncludes,
+	  StringPrototypeSlice,
+	  StringPrototypeToLowerCase,
+	} = primordialsExports;
+
+	const messages = new SafeMap();
+	const codes = {};
+
+	const classRegExp = /^([A-Z][a-z0-9]*)+$/;
+	// Sorted by a rough estimate on most frequently used entries.
+	const kTypes = [
+	  'string',
+	  'function',
+	  'number',
+	  'object',
+	  // Accept 'Function' and 'Object' as alternative to the lower cased version.
+	  'Function',
+	  'Object',
+	  'boolean',
+	  'bigint',
+	  'symbol',
+	];
+
+	let userStackTraceLimit;
+	const nodeInternalPrefix = '__node_internal_';
+
+	// Lazily loaded
+	let assert;
+	let internalUtilInspect = null;
+	function lazyInternalUtilInspect() {
+	  if (!internalUtilInspect) {
+	    internalUtilInspect = requireInspect();
+	  }
+	  return internalUtilInspect;
+	}
+
+	const addCodeToName = hideStackFrames(function addCodeToName(err, name, code) {
+	  // Set the stack
+	  err = captureLargerStackTrace(err);
+	  // Add the error code to the name to include it in the stack trace.
+	  err.name = `${name} [${code}]`;
+	  // Access the stack to generate the error message including the error code
+	  // from the name.
+	  err.stack; // eslint-disable-line no-unused-expressions
+	  // Reset the name to the actual name.
+	  delete err.name;
+	});
+
+	function makeNodeErrorWithCode(Base, key) {
+	  return function NodeError(...args) {
+	    const limit = Error.stackTraceLimit;
+	    Error.stackTraceLimit = 0;
+	    const error = new Base();
+	    // Reset the limit and setting the name property.
+	    Error.stackTraceLimit = limit;
+	    const message = getMessage(key, args, error);
+	    ObjectDefineProperty(error, 'message', {
+	      value: message,
+	      enumerable: false,
+	      writable: true,
+	      configurable: true,
+	    });
+	    ObjectDefineProperty(error, 'toString', {
+	      value() {
+	        return `${this.name} [${key}]: ${this.message}`;
+	      },
+	      enumerable: false,
+	      writable: true,
+	      configurable: true,
+	    });
+	    addCodeToName(error, Base.name, key);
+	    error.code = key;
+	    return error;
+	  };
+	}
+
+	// This function removes unnecessary frames from Node.js core errors.
+	function hideStackFrames(fn) {
+	  // We rename the functions that will be hidden to cut off the stacktrace
+	  // at the outermost one
+	  const hidden = nodeInternalPrefix + fn.name;
+	  ObjectDefineProperty(fn, 'name', { value: hidden });
+	  return fn;
+	}
+
+	// Utility function for registering the error codes. Only used here. Exported
+	// *only* to allow for testing.
+	function E(sym, val, def) {
+	  // Special case for SystemError that formats the error message differently
+	  // The SystemErrors only have SystemError as their base classes.
+	  messages.set(sym, val);
+	  codes[sym] = makeNodeErrorWithCode(def, sym);
+	}
+
+	function getMessage(key, args, self) {
+	  const msg = messages.get(key);
+
+	  if (assert === undefined) assert = assert_1;
+
+	  assert(typeof msg === 'function');
+	  assert(
+	    msg.length <= args.length, // Default options do not count.
+	    `Code: ${key}; The provided arguments length (${args.length}) does not ` +
+	      `match the required ones (${msg.length}).`,
+	  );
+	  return ReflectApply(msg, self, args);
+	}
+
+	const captureLargerStackTrace = hideStackFrames(
+	  function captureLargerStackTrace(err) {
+	    userStackTraceLimit = Error.stackTraceLimit;
+	    Error.stackTraceLimit = Infinity;
+	    ErrorCaptureStackTrace(err);
+	    // Reset the limit
+	    Error.stackTraceLimit = userStackTraceLimit;
+
+	    return err;
+	  });
+
+	let maxStack_ErrorName;
+	let maxStack_ErrorMessage;
+	/**
+	 * Returns true if `err.name` and `err.message` are equal to engine-specific
+	 * values indicating max call stack size has been exceeded.
+	 * "Maximum call stack size exceeded" in V8.
+	 * @param {Error} err
+	 * @returns {boolean}
+	 */
+	function isStackOverflowError(err) {
+	  if (maxStack_ErrorMessage === undefined) {
+	    try {
+	      function overflowStack() { overflowStack(); }
+	      overflowStack();
+	    } catch (err) {
+	      maxStack_ErrorMessage = err.message;
+	      maxStack_ErrorName = err.name;
+	    }
+	  }
+
+	  return err && err.name === maxStack_ErrorName &&
+	         err.message === maxStack_ErrorMessage;
+	}
+
+	errors = {
+	  codes,
+	  hideStackFrames,
+	  isStackOverflowError,
+	};
+
+	E('ERR_INVALID_ARG_TYPE',
+	  (name, expected, actual) => {
+	    assert(typeof name === 'string', "'name' must be a string");
+	    if (!ArrayIsArray(expected)) {
+	      expected = [expected];
+	    }
+
+	    let msg = 'The ';
+	    if (StringPrototypeEndsWith(name, ' argument')) {
+	      // For cases like 'first argument'
+	      msg += `${name} `;
+	    } else {
+	      const type = StringPrototypeIncludes(name, '.') ? 'property' : 'argument';
+	      msg += `"${name}" ${type} `;
+	    }
+	    msg += 'must be ';
+
+	    const types = [];
+	    const instances = [];
+	    const other = [];
+
+	    for (const value of expected) {
+	      assert(typeof value === 'string',
+	             'All expected entries have to be of type string');
+	      if (ArrayPrototypeIncludes(kTypes, value)) {
+	        ArrayPrototypePush(types, StringPrototypeToLowerCase(value));
+	      } else if (RegExpPrototypeTest(classRegExp, value)) {
+	        ArrayPrototypePush(instances, value);
+	      } else {
+	        assert(value !== 'object',
+	               'The value "object" should be written as "Object"');
+	        ArrayPrototypePush(other, value);
+	      }
+	    }
+
+	    // Special handle `object` in case other instances are allowed to outline
+	    // the differences between each other.
+	    if (instances.length > 0) {
+	      const pos = ArrayPrototypeIndexOf(types, 'object');
+	      if (pos !== -1) {
+	        ArrayPrototypeSplice(types, pos, 1);
+	        ArrayPrototypePush(instances, 'Object');
+	      }
+	    }
+
+	    if (types.length > 0) {
+	      if (types.length > 2) {
+	        const last = ArrayPrototypePop(types);
+	        msg += `one of type ${ArrayPrototypeJoin(types, ', ')}, or ${last}`;
+	      } else if (types.length === 2) {
+	        msg += `one of type ${types[0]} or ${types[1]}`;
+	      } else {
+	        msg += `of type ${types[0]}`;
+	      }
+	      if (instances.length > 0 || other.length > 0)
+	        msg += ' or ';
+	    }
+
+	    if (instances.length > 0) {
+	      if (instances.length > 2) {
+	        const last = ArrayPrototypePop(instances);
+	        msg +=
+	          `an instance of ${ArrayPrototypeJoin(instances, ', ')}, or ${last}`;
+	      } else {
+	        msg += `an instance of ${instances[0]}`;
+	        if (instances.length === 2) {
+	          msg += ` or ${instances[1]}`;
+	        }
+	      }
+	      if (other.length > 0)
+	        msg += ' or ';
+	    }
+
+	    if (other.length > 0) {
+	      if (other.length > 2) {
+	        const last = ArrayPrototypePop(other);
+	        msg += `one of ${ArrayPrototypeJoin(other, ', ')}, or ${last}`;
+	      } else if (other.length === 2) {
+	        msg += `one of ${other[0]} or ${other[1]}`;
+	      } else {
+	        if (StringPrototypeToLowerCase(other[0]) !== other[0])
+	          msg += 'an ';
+	        msg += `${other[0]}`;
+	      }
+	    }
+
+	    if (actual == null) {
+	      msg += `. Received ${actual}`;
+	    } else if (typeof actual === 'function' && actual.name) {
+	      msg += `. Received function ${actual.name}`;
+	    } else if (typeof actual === 'object') {
+	      if (actual.constructor && actual.constructor.name) {
+	        msg += `. Received an instance of ${actual.constructor.name}`;
+	      } else {
+	        const inspected = lazyInternalUtilInspect()
+	          .inspect(actual, { depth: -1 });
+	        msg += `. Received ${inspected}`;
+	      }
+	    } else {
+	      let inspected = lazyInternalUtilInspect()
+	        .inspect(actual, { colors: false });
+	      if (inspected.length > 25)
+	        inspected = `${StringPrototypeSlice(inspected, 0, 25)}...`;
+	      msg += `. Received type ${typeof actual} (${inspected})`;
+	    }
+	    return msg;
+	  }, TypeError);
+	return errors;
+}
+
+const { getConstructorName } = util$1;
+
+// From https://mathiasbynens.be/notes/globalthis
+/* c8 ignore start */ // only needed for node 10
+(function() {
+  if (typeof globalThis === 'object') return;
+  Object.defineProperty(Object.prototype, '__magic__', {
+    get: function() {
+      return this;
+    },
+    configurable: true,
+  });
+  // eslint-disable-next-line no-undef
+  __magic__.globalThis = __magic__;
+  delete Object.prototype.__magic__;
+}());
+/* c8 ignore stop */
+
+function constructorNamed(val, ...name) {
+  // Pass in names rather than types, in case SharedArrayBuffer (e.g.) isn't
+  // in your browser
+  for (const n of name) {
+    const typ = globalThis[n];
+    if (typ) {
+      if (val instanceof typ) {
+        return true;
+      }
+    }
+  }
+  // instanceOf doesn't work across vm boundaries, so check the whole
+  // inheritance chain
+  while (val) {
+    if (typeof val !== 'object') {
+      return false;
+    }
+    if (name.indexOf(getConstructorName(val)) >= 0) {
+      return true;
+    }
+    val = Object.getPrototypeOf(val);
+  }
+  return false;
+}
+
+function checkBox(cls) {
+  return (val) => {
+    if (!constructorNamed(val, cls.name)) {
+      return false;
+    }
+    try {
+      cls.prototype.valueOf.call(val);
+    } catch {
+      return false;
+    }
+    return true;
+  };
+}
+
+const isStringObject = checkBox(String);
+const isNumberObject = checkBox(Number);
+const isBooleanObject = checkBox(Boolean);
+const isBigIntObject = checkBox(BigInt);
+const isSymbolObject = checkBox(Symbol);
+
+var types = {
+  isAsyncFunction(val) {
+    return (typeof val === 'function') &&
+      Function.prototype.toString.call(val).startsWith('async');
+  },
+  isGeneratorFunction(val) {
+    return (typeof val === 'function') &&
+      Function.prototype.toString.call(val).match(/^(async\s+)?function *\*/);
+  },
+  isAnyArrayBuffer(val) {
+    return constructorNamed(val, 'ArrayBuffer', 'SharedArrayBuffer');
+  },
+  isArrayBuffer(val) {
+    return constructorNamed(val, 'ArrayBuffer');
+  },
+  isArgumentsObject(val) {
+    const cond = (val !== null) &&
+      (typeof val === 'object') &&
+      !Array.isArray(val) &&
+      (typeof val.length === 'number') &&
+      (val.length === (val.length | 0)) &&
+      (val.length >= 0);
+    if (cond) {
+      const prop = Object.getOwnPropertyDescriptor(val, 'callee');
+      return prop && !prop.enumerable;
+    }
+    return false;
+  },
+  isBoxedPrimitive(val) {
+    return isNumberObject(val) ||
+      isStringObject(val) ||
+      isBooleanObject(val) ||
+      isBigIntObject(val) ||
+      isSymbolObject(val);
+  },
+  isDataView(val) {
+    return constructorNamed(val, 'DataView');
+  },
+  isExternal(val) {
+    return (typeof val === 'object') &&
+      (Object.isFrozen(val)) &&
+      (Object.getPrototypeOf(val) == null);
+  },
+  isMap(val) {
+    if (!constructorNamed(val, 'Map')) {
+      return false;
+    }
+    try {
+      val.has();
+    } catch {
+      return false;
+    }
+    return true;
+  },
+  isMapIterator(val) {
+    return Object.prototype.toString.call(Object.getPrototypeOf(val)) ===
+      '[object Map Iterator]';
+  },
+  isModuleNamespaceObject(val) {
+    // TODO: this is weak and easily faked
+    return val &&
+      (typeof val === 'object') &&
+      (val[Symbol.toStringTag] === 'Module');
+  },
+  isNativeError(val) {
+    return (val instanceof Error) && constructorNamed(
+      val,
+      'Error',
+      'EvalError',
+      'RangeError',
+      'ReferenceError',
+      'SyntaxError',
+      'TypeError',
+      'URIError',
+      'AggregateError');
+  },
+  isPromise(val) {
+    return constructorNamed(val, 'Promise');
+  },
+  isSet(val) {
+    if (!constructorNamed(val, 'Set')) {
+      return false;
+    }
+    try {
+      val.has();
+    } catch {
+      return false;
+    }
+    return true;
+  },
+  isSetIterator(val) {
+    return Object.prototype.toString.call(Object.getPrototypeOf(val)) ===
+      '[object Set Iterator]';
+  },
+  isWeakMap(val) {
+    return constructorNamed(val, 'WeakMap');
+  },
+  isWeakSet(val) {
+    return constructorNamed(val, 'WeakSet');
+  },
+  isRegExp(val) {
+    return constructorNamed(val, 'RegExp');
+  },
+  isDate(val) {
+    if (constructorNamed(val, 'Date')) {
+      try {
+        Date.prototype.getTime.call(val); // Throws for pseudo-dates
+        return true;
+      } catch {
+        // Ignored
+      }
+    }
+    return false;
+  },
+  isTypedArray(val) {
+    return constructorNamed(
+      val,
+      'Int8Array',
+      'Uint8Array',
+      'Uint8ClampedArray',
+      'Int16Array',
+      'Uint16Array',
+      'Int32Array',
+      'Uint32Array',
+      'Float32Array',
+      'Float64Array',
+      'BigInt64Array',
+      'BigUint64Array',
+    );
+  },
+  isStringObject,
+  isNumberObject,
+  isBooleanObject,
+  isBigIntObject,
+  isSymbolObject,
+};
+
+var realm = {};
+
+// This is a snapshot from node 18.11.0
+const builtinModules = [
+  '_http_agent',
+  '_http_client',
+  '_http_common',
+  '_http_incoming',
+  '_http_outgoing',
+  '_http_server',
+  '_stream_duplex',
+  '_stream_passthrough',
+  '_stream_readable',
+  '_stream_transform',
+  '_stream_wrap',
+  '_stream_writable',
+  '_tls_common',
+  '_tls_wrap',
+  'assert',
+  'assert/strict',
+  'async_hooks',
+  'buffer',
+  'child_process',
+  'cluster',
+  'console',
+  'constants',
+  'crypto',
+  'dgram',
+  'diagnostics_channel',
+  'dns',
+  'dns/promises',
+  'domain',
+  'events',
+  'fs',
+  'fs/promises',
+  'http',
+  'http2',
+  'https',
+  'inspector',
+  'module',
+  'Module',
+  'net',
+  'os',
+  'path',
+  'path/posix',
+  'path/win32',
+  'perf_hooks',
+  'process',
+  'punycode',
+  'querystring',
+  'readline',
+  'readline/promises',
+  'repl',
+  'stream',
+  'stream/consumers',
+  'stream/promises',
+  'stream/web',
+  'string_decoder',
+  'sys',
+  'timers',
+  'timers/promises',
+  'tls',
+  'trace_events',
+  'tty',
+  'url',
+  'util',
+  'util/types',
+  'v8',
+  'vm',
+  'wasi',
+  'worker_threads',
+  'zlib',
+];
+
+realm.BuiltinModule = {
+  exists(s) {
+    return s.startsWith('internal/') || builtinModules.indexOf(s) !== -1;
+  },
+};
+
+var validators;
+var hasRequiredValidators;
+
+function requireValidators () {
+	if (hasRequiredValidators) return validators;
+	hasRequiredValidators = 1;
+
+	const {
+	  ArrayIsArray,
+	} = primordialsExports;
+
+	const {
+	  hideStackFrames,
+	  codes: {
+	    ERR_INVALID_ARG_TYPE,
+	  },
+	} = requireErrors();
+
+	/**
+	 * @param {unknown} value
+	 * @param {string} name
+	 * @param {{
+	 *   allowArray?: boolean,
+	 *   allowFunction?: boolean,
+	 *   nullable?: boolean
+	 * }} [options]
+	 */
+	const validateObject = hideStackFrames(
+	  (value, name, options) => {
+	    const useDefaultOptions = options == null;
+	    const allowArray = useDefaultOptions ? false : options.allowArray;
+	    const allowFunction = useDefaultOptions ? false : options.allowFunction;
+	    const nullable = useDefaultOptions ? false : options.nullable;
+	    if ((!nullable && value === null) ||
+	        (!allowArray && ArrayIsArray(value)) ||
+	        (typeof value !== 'object' && (
+	          !allowFunction || typeof value !== 'function'
+	        ))) {
+	      throw new ERR_INVALID_ARG_TYPE(name, 'Object', value);
+	    }
+	  });
+
+	function validateString(value, name) {
+	  if (typeof value !== 'string')
+	    throw new ERR_INVALID_ARG_TYPE(name, 'string', value);
+	}
+
+	validators = {
+	  validateObject,
+	  validateString,
+	};
+	return validators;
+}
+
+var constants;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+
+	constants = {
+	  // Non-alphabetic chars.
+	  CHAR_DOT: 46, /* . */
+	  CHAR_FORWARD_SLASH: 47, /* / */
+	  CHAR_BACKWARD_SLASH: 92, /* \ */
+	};
+	return constants;
+}
+
+var path;
+var hasRequiredPath;
+
+function requirePath () {
+	if (hasRequiredPath) return path;
+	hasRequiredPath = 1;
+
+	const {
+	  StringPrototypeCharCodeAt,
+	  StringPrototypeLastIndexOf,
+	  StringPrototypeSlice,
+	} = primordialsExports;
+
+	const {
+	  CHAR_DOT,
+	  CHAR_FORWARD_SLASH,
+	} = requireConstants();
+	const {
+	  validateString,
+	} = requireValidators();
+
+	function posixCwd() {
+	  return '/'; // Fake for the web case
+	}
+
+	function isPosixPathSeparator(code) {
+	  return code === CHAR_FORWARD_SLASH;
+	}
+
+	// Resolves . and .. elements in a path with directory names
+	function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
+	  let res = '';
+	  let lastSegmentLength = 0;
+	  let lastSlash = -1;
+	  let dots = 0;
+	  let code = 0;
+	  for (let i = 0; i <= path.length; ++i) {
+	    if (i < path.length)
+	      code = StringPrototypeCharCodeAt(path, i);
+	    else if (isPathSeparator(code))
+	      break;
+	    else
+	      code = CHAR_FORWARD_SLASH;
+
+	    if (isPathSeparator(code)) {
+	      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
+	        if (res.length < 2 || lastSegmentLength !== 2 ||
+	            StringPrototypeCharCodeAt(res, res.length - 1) !== CHAR_DOT ||
+	            StringPrototypeCharCodeAt(res, res.length - 2) !== CHAR_DOT) {
+	          if (res.length > 2) {
+	            const lastSlashIndex = StringPrototypeLastIndexOf(res, separator);
+	            if (lastSlashIndex === -1) {
+	              res = '';
+	              lastSegmentLength = 0;
+	            } else {
+	              res = StringPrototypeSlice(res, 0, lastSlashIndex);
+	              lastSegmentLength =
+	                res.length - 1 - StringPrototypeLastIndexOf(res, separator);
+	            }
+	            lastSlash = i;
+	            dots = 0;
+	            continue;
+	          } else if (res.length !== 0) {
+	            res = '';
+	            lastSegmentLength = 0;
+	            lastSlash = i;
+	            dots = 0;
+	            continue;
+	          }
+	        }
+	        if (allowAboveRoot) {
+	          res += res.length > 0 ? `${separator}..` : '..';
+	          lastSegmentLength = 2;
+	        }
+	      } else {
+	        if (res.length > 0)
+	          res += `${separator}${StringPrototypeSlice(path, lastSlash + 1, i)}`;
+	        else
+	          res = StringPrototypeSlice(path, lastSlash + 1, i);
+	        lastSegmentLength = i - lastSlash - 1;
+	      }
+	      lastSlash = i;
+	      dots = 0;
+	    } else if (code === CHAR_DOT && dots !== -1) {
+	      ++dots;
+	    } else {
+	      dots = -1;
+	    }
+	  }
+	  return res;
+	}
+
+	function resolve(...args) {
+	  let resolvedPath = '';
+	  let resolvedAbsolute = false;
+
+	  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+	    const path = i >= 0 ? args[i] : posixCwd();
+
+	    validateString(path, 'path');
+
+	    // Skip empty entries
+	    if (path.length === 0) {
+	      continue;
+	    }
+
+	    resolvedPath = `${path}/${resolvedPath}`;
+	    resolvedAbsolute =
+	      StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
+	  }
+
+	  // At this point the path should be resolved to a full absolute path, but
+	  // handle relative paths to be safe (might happen when process.cwd() fails)
+
+	  // Normalize the path
+	  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/',
+	                                 isPosixPathSeparator);
+
+	  if (resolvedAbsolute) {
+	    return `/${resolvedPath}`;
+	  }
+	  return resolvedPath.length > 0 ? resolvedPath : '.';
+	}
+
+	path = {
+	  resolve,
+	};
+	return path;
+}
+
+var url;
+var hasRequiredUrl;
+
+function requireUrl () {
+	if (hasRequiredUrl) return url;
+	hasRequiredUrl = 1;
+
+	// The main use case is browsers, and I rarely test on Windows, so all of the
+	// Windows-specific stuff is removed.
+
+	const {
+	  StringPrototypeCharCodeAt,
+	  StringPrototypeIncludes,
+	  StringPrototypeReplace,
+	} = primordialsExports;
+
+	const {
+	  CHAR_FORWARD_SLASH,
+	} = requireConstants();
+	const path = requirePath();
+
+	const percentRegEx = /%/g;
+	const backslashRegEx = /\\/g;
+	const newlineRegEx = /\n/g;
+	const carriageReturnRegEx = /\r/g;
+	const tabRegEx = /\t/g;
+
+	function encodePathChars(filepath) {
+	  if (StringPrototypeIncludes(filepath, '%'))
+	    filepath = StringPrototypeReplace(filepath, percentRegEx, '%25');
+	  // In posix, backslash is a valid character in paths:
+	  if (StringPrototypeIncludes(filepath, '\\'))
+	    filepath = StringPrototypeReplace(filepath, backslashRegEx, '%5C');
+	  if (StringPrototypeIncludes(filepath, '\n'))
+	    filepath = StringPrototypeReplace(filepath, newlineRegEx, '%0A');
+	  if (StringPrototypeIncludes(filepath, '\r'))
+	    filepath = StringPrototypeReplace(filepath, carriageReturnRegEx, '%0D');
+	  if (StringPrototypeIncludes(filepath, '\t'))
+	    filepath = StringPrototypeReplace(filepath, tabRegEx, '%09');
+	  return filepath;
+	}
+
+	function pathToFileURL(filepath) {
+	  const outURL = new URL('file://');
+
+	  let resolved = path.resolve(filepath);
+	  // path.resolve strips trailing slashes so we must add them back
+	  const filePathLast = StringPrototypeCharCodeAt(filepath,
+	                                                 filepath.length - 1);
+	  if ((filePathLast === CHAR_FORWARD_SLASH) &&
+	      resolved[resolved.length - 1] !== path.sep)
+	    resolved += '/';
+	  outURL.pathname = encodePathChars(resolved);
+
+	  return outURL;
+	}
+
+	url = {
+	  pathToFileURL,
+	};
+	return url;
+}
+
+var buffer = {};
+
+var hasRequiredBuffer;
+
+function requireBuffer () {
+	if (hasRequiredBuffer) return buffer;
+	hasRequiredBuffer = 1;
+
+	class Buffer {
+	  hexSlice(start = 0, end) {
+	    return Array.prototype.map.call(
+	      this.slice(start, end),
+	      (x) => ('00' + x.toString(16)).slice(-2))
+	      .join('');
+	  }
+	}
+
+	buffer.Buffer = Buffer;
+	return buffer;
+}
+
+var inspect_1;
+var hasRequiredInspect;
+
+function requireInspect () {
+	if (hasRequiredInspect) return inspect_1;
+	hasRequiredInspect = 1;
+
+	const primordials = primordialsExports;
+	const {
+	  internalBinding,
+	  Array,
+	  ArrayIsArray,
+	  ArrayPrototypeFilter,
+	  ArrayPrototypeForEach,
+	  ArrayPrototypeIncludes,
+	  ArrayPrototypeIndexOf,
+	  ArrayPrototypeJoin,
+	  ArrayPrototypeMap,
+	  ArrayPrototypePop,
+	  ArrayPrototypePush,
+	  ArrayPrototypePushApply,
+	  ArrayPrototypeSlice,
+	  ArrayPrototypeSplice,
+	  ArrayPrototypeSort,
+	  ArrayPrototypeUnshift,
+	  BigIntPrototypeValueOf,
+	  BooleanPrototypeValueOf,
+	  DatePrototypeGetTime,
+	  DatePrototypeToISOString,
+	  DatePrototypeToString,
+	  ErrorPrototypeToString,
+	  FunctionPrototypeBind,
+	  FunctionPrototypeCall,
+	  FunctionPrototypeToString,
+	  JSONStringify,
+	  MapPrototypeGetSize,
+	  MapPrototypeEntries,
+	  MathFloor,
+	  MathMax,
+	  MathMin,
+	  MathRound,
+	  MathSqrt,
+	  MathTrunc,
+	  Number,
+	  NumberIsFinite,
+	  NumberIsNaN,
+	  NumberParseFloat,
+	  NumberParseInt,
+	  NumberPrototypeToString,
+	  NumberPrototypeValueOf,
+	  Object,
+	  ObjectAssign,
+	  ObjectDefineProperty,
+	  ObjectGetOwnPropertyDescriptor,
+	  ObjectGetOwnPropertyNames,
+	  ObjectGetOwnPropertySymbols,
+	  ObjectGetPrototypeOf,
+	  ObjectIs,
+	  ObjectKeys,
+	  ObjectPrototypeHasOwnProperty,
+	  ObjectPrototypePropertyIsEnumerable,
+	  ObjectSeal,
+	  ObjectSetPrototypeOf,
+	  ReflectApply,
+	  ReflectOwnKeys,
+	  RegExp,
+	  RegExpPrototypeExec,
+	  RegExpPrototypeSymbolReplace,
+	  RegExpPrototypeSymbolSplit,
+	  RegExpPrototypeToString,
+	  SafeStringIterator,
+	  SafeMap,
+	  SafeSet,
+	  SetPrototypeGetSize,
+	  SetPrototypeValues,
+	  String,
+	  StringPrototypeCharCodeAt,
+	  StringPrototypeCodePointAt,
+	  StringPrototypeIncludes,
+	  StringPrototypeIndexOf,
+	  StringPrototypeLastIndexOf,
+	  StringPrototypeNormalize,
+	  StringPrototypePadEnd,
+	  StringPrototypePadStart,
+	  StringPrototypeRepeat,
+	  StringPrototypeReplaceAll,
+	  StringPrototypeSlice,
+	  StringPrototypeSplit,
+	  StringPrototypeEndsWith,
+	  StringPrototypeStartsWith,
+	  StringPrototypeToLowerCase,
+	  StringPrototypeTrim,
+	  StringPrototypeValueOf,
+	  SymbolPrototypeToString,
+	  SymbolPrototypeValueOf,
+	  SymbolIterator,
+	  SymbolToStringTag,
+	  TypedArrayPrototypeGetLength,
+	  TypedArrayPrototypeGetSymbolToStringTag,
+	  Uint8Array,
+	  globalThis,
+	  uncurryThis,
+	} = primordials;
+
+	const {
+	  constants: {
+	    ALL_PROPERTIES,
+	    ONLY_ENUMERABLE,
+	    kPending,
+	    kRejected,
+	  },
+	  getOwnNonIndexProperties,
+	  getPromiseDetails,
+	  getProxyDetails,
+	  previewEntries,
+	  getConstructorName: internalGetConstructorName,
+	  getExternalValue,
+	  Proxy,
+	} = util$1;
+
+	const {
+	  customInspectSymbol,
+	  isError,
+	  join,
+	  removeColors,
+	} = util;
+
+	const {
+	  isStackOverflowError,
+	} = requireErrors();
+
+	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,
+	} = types;
+
+	const assert = assert_1;
+
+	const { BuiltinModule } = realm;
+	const {
+	  validateObject,
+	  validateString,
+	} = requireValidators();
+
+	let hexSlice;
+	let internalUrl;
+
+	function pathToFileUrlHref(filepath) {
+	  // Maintain node 14 compat
+	  // internalUrl ??= require('./internal/url');
+	  internalUrl = (internalUrl == null) ? requireUrl() : internalUrl;
+	  return internalUrl.pathToFileURL(filepath).href;
+	}
+
+	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 */
+	// Work-arounds for Safari not implementing negative look-behinds.
+	// Remove all of this once Safari 16.4 is rolled out "enough".
+	let strEscapeSequencesRegExp,
+	  strEscapeSequencesReplacer,
+	  strEscapeSequencesRegExpSingle,
+	  strEscapeSequencesReplacerSingle,
+	  extractedSplitNewLines;
+	try {
+	  // Change from regex literals to RegExp constructors to avoid unrecoverable
+	  // syntax error at load time.
+	  strEscapeSequencesRegExp =
+	    // eslint-disable-next-line max-len
+	    new RegExp('[\\x00-\\x1f\\x27\\x5c\\x7f-\\x9f]|[\\ud800-\\udbff](?![\\udc00-\\udfff])|(?<![\\ud800-\\udbff])[\\udc00-\\udfff]');
+	  strEscapeSequencesReplacer =
+	    new RegExp(
+	      // eslint-disable-next-line max-len
+	      '[\x00-\\x1f\\x27\\x5c\\x7f-\\x9f]|[\\ud800-\\udbff](?![\\udc00-\\udfff])|(?<![\\ud800-\\udbff])[\\udc00-\\udfff]',
+	      'g',
+	    );
+	  strEscapeSequencesRegExpSingle =
+	    // eslint-disable-next-line max-len
+	    new RegExp('[\\x00-\\x1f\\x5c\\x7f-\\x9f]|[\\ud800-\\udbff](?![\\udc00-\\udfff])|(?<![\\ud800-\\udbff])[\\udc00-\\udfff]');
+	  strEscapeSequencesReplacerSingle =
+	    // eslint-disable-next-line max-len
+	    new RegExp('[\\x00-\\x1f\\x5c\\x7f-\\x9f]|[\\ud800-\\udbff](?![\\udc00-\\udfff])|(?<![\\ud800-\\udbff])[\\udc00-\\udfff]', 'g');
+	  const extractedNewLineRe = new RegExp('(?<=\\n)');
+	  extractedSplitNewLines = (value) => RegExpPrototypeSymbolSplit(extractedNewLineRe, value);
+	  /* c8 ignore start */
+	  // CI doesn't run in an elderly runtime
+	} catch {
+	  // These are from a previous version of node,
+	  // see commit 76372607a6743cc75eae50ca58657c9e8a654428
+	  // dated 2021-12-06
+	  strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c\x7f-\x9f]/;
+	  strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c\x7f-\x9f]/g;
+	  strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c\x7f-\x9f]/;
+	  strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]/g;
+	  extractedSplitNewLines = (value) => {
+	    const lines = RegExpPrototypeSymbolSplit(/\n/, value);
+	    const last = ArrayPrototypePop(lines);
+	    const nlLines = ArrayPrototypeMap(lines, (line) => line + '\n');
+	    if (last !== '') {
+	      nlLines.push(last);
+	    }
+	    return nlLines;
+	  };
+	}
+	/* c8 ignore stop */
+	/* 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
+	// Adopted from https://github.com/chalk/ansi-regex/blob/HEAD/index.js
+	// License: MIT, authors: @sindresorhus, Qix-, arjunmehta and LitoMore
+	// Matches all ansi escape code sequences in a string
+	const ansiPattern = '[\\u001B\\u009B][[\\]()#;?]*' +
+	  '(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*' +
+	  '|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' +
+	  '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))';
+	const ansi = new RegExp(ansiPattern, 'g');
+
+	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;
+	  }
+	}
+
+	function getConstructorName(obj, ctx, recurseTimes, protoProps) {
+	  let firstProto;
+	  const tmp = obj;
+	  while (obj || isUndetectableObject(obj)) {
+	    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);
+	}
+
+	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.
+	        !(value.constructor && value.constructor.prototype === value)) {
+	      // This makes sure the recurseTimes are reported as before while using
+	      // a counter internally.
+	      const depth = ctx.depth === null ? null : ctx.depth - recurseTimes;
+	      const isCrossContext =
+	        proxy !== undefined || !(context instanceof Object);
+	      const ret = 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 (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 (typeof value === 'function') {
+	      base = getFunctionBase(value, constructor, tag);
+	      if (keys.length === 0 && protoProps === undefined)
+	        return ctx.stylize(base, 'special');
+	    } else if (isRegExp(value)) {
+	      // Make RegExps say that they are RegExps
+	      base = RegExpPrototypeToString(
+	        constructor !== null ? value : new RegExp(value),
+	      );
+	      const prefix = getPrefix(constructor, tag, 'RegExp');
+	      if (prefix !== 'RegExp ')
+	        base = `${prefix}${base}`;
+	      if ((keys.length === 0 && 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 (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) {
+	    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(value, constructor, tag) {
+	  const stringified = FunctionPrototypeToString(value);
+	  if (StringPrototypeStartsWith(stringified, 'class') && StringPrototypeEndsWith(stringified, '}')) {
+	    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 += `: ${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 = b.indexOf(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(error) {
+	  return error.stack ? String(error.stack) : 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(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;
+	}
+
+	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 (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 && start[1]) || '';
+	      len = fallback.length;
+	      fallback = 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 in case it's part of the original stack
+	      if (index !== -1 && 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 ? String(err.name) : 'Error';
+	  let stack = getStackString(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) {
+	              // Maintain node 14 compat
+	              // esmWorkingDirectory ??= pathToFileUrlHref(workingDirectory);
+	              esmWorkingDirectory =
+	                (esmWorkingDirectory == null) ? pathToFileUrlHref(workingDirectory) : esmWorkingDirectory;
+	              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) {
+	  if (isStackOverflowError(err)) {
+	    ctx.seen.pop();
+	    ctx.indentationLvl = indentationLvl;
+	    return ctx.stylize(
+	      `[${constructorName}: Inspection interrupted ` +
+	        'prematurely. Maximum call stack size exceeded.]',
+	      'special',
+	    );
+	  }
+	  assert.fail(err.stack);
+	}
+
+	function addNumericSeparator(integerString) {
+	  let result = '';
+	  let i = integerString.length;
+	  const start = StringPrototypeStartsWith(integerString, '-') ? 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(
+	          extractedSplitNewLines(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(requireBuffer().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 = 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;
+	  }
+
+	  // Count objects that have no `toString` function as built-in.
+	  if (typeof value.toString !== 'function') {
+	    return true;
+	  }
+
+	  // The object has a own `toString` property. Thus it's not not a built-in one.
+	  if (ObjectPrototypeHasOwnProperty(value, 'toString')) {
+	    return false;
+	  }
+
+	  // Find the object that has the `toString` property as own property in the
+	  // prototype chain.
+	  let pointer = value;
+	  do {
+	    pointer = ObjectGetPrototypeOf(pointer);
+	  } while (!ObjectPrototypeHasOwnProperty(pointer, 'toString'));
+
+	  // Check closer if the object is a built-in.
+	  const descriptor = ObjectGetOwnPropertyDescriptor(pointer, 'constructor');
+	  return descriptor !== undefined &&
+	    typeof descriptor.value === 'function' &&
+	    builtInObjects.has(descriptor.value.name);
+	}
+
+	const firstErrorLine = (error) => 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', { allowArray: true });
+	  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
+	}
+
+	/* c8 ignore start */
+	if (internalBinding('config').hasIntl) {
+	  assert(false);
+	  // Can't use node internals
+	  // 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;
+	  // };
+	  /* c8 ignore stop */
+	} 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, '');
+	}
+
+	const entities = {
+	  34: '&quot;',
+	  38: '&amp;',
+	  39: '&apos;',
+	  60: '&lt;',
+	  62: '&gt;',
+	  160: '&nbsp;',
+	};
+
+	function escapeHTML(str) {
+	  return str.replace(
+	    // eslint-disable-next-line no-control-regex
+	    /[\u0000-\u002F\u003A-\u0040\u005B-\u0060\u007B-\u00FF]/g,
+	    (c) => {
+	      const code = String(c.charCodeAt(0));
+	      const ent = entities[code];
+	      return ent || ('&#' + code + ';');
+	    },
+	  );
+	}
+
+	inspect_1 = {
+	  identicalSequenceRange,
+	  inspect,
+	  inspectDefaultOptions,
+	  format,
+	  formatWithOptions,
+	  getStringWidth,
+	  stripVTControlCharacters,
+	  isZeroWidthCodePoint,
+	  stylizeWithColor,
+	  stylizeWithHTML(str, styleType) {
+	    const style = inspect.styles[styleType];
+	    if (style !== undefined) {
+	      return `<span style="color:${style};">${escapeHTML(str)}</span>`;
+	    }
+	    return escapeHTML(str);
+	  },
+	  Proxy,
+	};
+	return inspect_1;
+}
+
+var inspectExports = requireInspect();
+var inspect = /*@__PURE__*/getDefaultExportFromCjs(inspectExports);
+
+export { inspect as default };