From 9bfe45ba2e0f66981d0c09c9f6f0aaed511bbc62 Mon Sep 17 00:00:00 2001
From: ExE Boss <3889017+ExE-Boss@users.noreply.github.com>
Date: Sun, 9 Feb 2020 01:15:00 +0100
Subject: [PATCH 1/3] =?UTF-8?q?feat:=20Add=C2=A0support=C2=A0for=C2=A0Node?=
 =?UTF-8?q?=E2=80=99s=20`util.inspect.custom`=C2=A0symbol=C2=A0method?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/constructs/interface.js     |   44 +
 lib/output/utils.js             |    2 +
 test/__snapshots__/test.js.snap | 2628 ++++++++++++++++++++++++++++++-
 3 files changed, 2660 insertions(+), 14 deletions(-)

diff --git a/lib/constructs/interface.js b/lib/constructs/interface.js
index deda7ff4..ef361bb5 100644
--- a/lib/constructs/interface.js
+++ b/lib/constructs/interface.js
@@ -1376,6 +1376,50 @@ class Interface {
       const props = [...classProps].map(([name, body]) => `${name}: ${body}`);
       this.str += `Object.defineProperties(${this.name}, { ${props.join(", ")} });`;
     }
+
+    // This code can't currently be generated as the operation, parameters
+    // and overloads code doesn't currently support symbol properties.
+    // This method is also made non-enumerable to match the other 'utils' symbol properties.
+    this.str += `
+        if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+          Object.defineProperty(${this.name}.prototype, utils.inspectCustomSymbol, {
+            value: {
+              [utils.inspectCustomSymbol](depth, ctx) {
+                if (!this || !exports.is(this)) {
+                  throw new TypeError("Illegal invocation");
+                }
+                if (arguments.length < 2) {
+                  throw new TypeError("Failed to execute '[nodejs.util.inspect.custom]' on '${
+  this.name}': 2 arguments required, but only " + arguments.length + " present.");
+                }
+                const args = [];
+                {
+                  let curArg = arguments[0];
+                  curArg = conversions["unrestricted double"](curArg, {
+                    context: "Failed to execute '[nodejs.util.inspect.custom]' on '${this.name}': parameter 1",
+                  });
+                  args.push(curArg);
+                }
+                {
+                  let curArg = arguments[1];
+                  curArg = conversions["object"](curArg, {
+                    context: "Failed to execute '[nodejs.util.inspect.custom]' on '${this.name}': parameter 2",
+                  });
+                  conversions["Function"](curArg.stylize, {
+                    context: "Failed to execute '[nodejs.util.inspect.custom]' on '${
+  this.name}': parameter 2 has member stylize that",
+                  });
+                  args.push(curArg);
+                }
+                return this[impl][utils.inspectCustomSymbol](...args);
+              },
+            }[utils.inspectCustomSymbol],
+            writable: true,
+            enumerable: false,
+            configurable: true
+          });
+        }
+    `;
   }
 
   generateOnInstance() {
diff --git a/lib/output/utils.js b/lib/output/utils.js
index c020d0b0..2198dd7f 100644
--- a/lib/output/utils.js
+++ b/lib/output/utils.js
@@ -13,6 +13,7 @@ const wrapperSymbol = Symbol("wrapper");
 const implSymbol = Symbol("impl");
 const sameObjectCaches = Symbol("SameObject caches");
 const ctorRegistrySymbol = Symbol.for("[webidl2js]  constructor registry");
+const inspectCustomSymbol = Symbol.for("nodejs.util.inspect.custom");
 
 function getSameObject(wrapper, prop, creator) {
   if (!wrapper[sameObjectCaches]) {
@@ -93,6 +94,7 @@ module.exports = exports = {
   implSymbol,
   getSameObject,
   ctorRegistrySymbol,
+  inspectCustomSymbol,
   wrapperForImpl,
   implForWrapper,
   tryWrapperForImpl,
diff --git a/test/__snapshots__/test.js.snap b/test/__snapshots__/test.js.snap
index 3f13d0a7..9e818f37 100644
--- a/test/__snapshots__/test.js.snap
+++ b/test/__snapshots__/test.js.snap
@@ -252,6 +252,48 @@ exports.install = function install(globalObject) {
     u8aUnion: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"BufferSourceTypes\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(BufferSourceTypes.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -411,6 +453,48 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"CEReactions\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(CEReactions.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -825,6 +909,48 @@ exports.install = function install(globalObject) {
     hasFeature: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DOMImplementation\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(DOMImplementation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -1038,6 +1164,48 @@ exports.install = function install(globalObject) {
     op: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DictionaryConvert\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(DictionaryConvert.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -1193,6 +1361,47 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Enum\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Enum.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -1387,6 +1596,48 @@ exports.install = function install(globalObject) {
     }
   }
   Object.defineProperties(Global.prototype, { [Symbol.toStringTag]: { value: \\"Global\\", configurable: true } });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Global.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -1499,6 +1750,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(HTMLConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"HTMLConstructor\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(HTMLConstructor.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -1620,6 +1913,48 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"LegacyArrayClass\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(LegacyArrayClass.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -1797,6 +2132,48 @@ exports.install = function install(globalObject) {
     mixedInConst: { value: 43, enumerable: true },
     ifaceMixinConst: { value: 42, enumerable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(MixedIn.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -2216,6 +2593,48 @@ exports.install = function install(globalObject) {
     incompatible3: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Overloads\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Overloads.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -2383,6 +2802,48 @@ exports.install = function install(globalObject) {
     promiseConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"PromiseTypes\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(PromiseTypes.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -2629,6 +3090,48 @@ exports.install = function install(globalObject) {
     withUnderscore: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Reflect\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Reflect.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -2974,6 +3477,48 @@ exports.install = function install(globalObject) {
     frozenArrayConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"SeqAndRec\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(SeqAndRec.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -3126,15 +3671,57 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"Static\\", configurable: true }
   });
   Object.defineProperties(Static, { def: { enumerable: true }, abc: { enumerable: true } });
-  if (globalObject[ctorRegistry] === undefined) {
-    globalObject[ctorRegistry] = Object.create(null);
-  }
-  globalObject[ctorRegistry][interfaceName] = Static;
-
-  Object.defineProperty(globalObject, interfaceName, {
-    configurable: true,
-    writable: true,
-    value: Static
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Static.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
+  if (globalObject[ctorRegistry] === undefined) {
+    globalObject[ctorRegistry] = Object.create(null);
+  }
+  globalObject[ctorRegistry][interfaceName] = Static;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: Static
   });
 };
 
@@ -3344,6 +3931,48 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Storage\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Storage.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -3636,6 +4265,48 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierAttribute\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierAttribute.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -3758,6 +4429,48 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierDefaultOperation\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierDefaultOperation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -3889,6 +4602,48 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierNamedOperation\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierNamedOperation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -4009,6 +4764,48 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierOperation\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierOperation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -4537,6 +5334,48 @@ exports.install = function install(globalObject) {
     time: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"TypedefsAndUnions\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(TypedefsAndUnions.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -4903,6 +5742,47 @@ exports.install = function install(globalObject) {
     hash: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"URL\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URL.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -5052,6 +5932,48 @@ exports.install = function install(globalObject) {
     entries: { value: Array.prototype.entries, configurable: true, enumerable: true, writable: true },
     forEach: { value: Array.prototype.forEach, configurable: true, enumerable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLList.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -5676,6 +6598,48 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParams\\", configurable: true },
     [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLSearchParams.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -5849,6 +6813,48 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLSearchParamsCollection.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -6161,6 +7167,48 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection2\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLSearchParamsCollection2.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -6569,6 +7617,48 @@ exports.install = function install(globalObject) {
     static: { enumerable: true },
     const: { value: 42, enumerable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(UnderscoredProperties.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -6765,6 +7855,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(Unforgeable.prototype, {
     [Symbol.toStringTag]: { value: \\"Unforgeable\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Unforgeable.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -6893,6 +8025,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(UnforgeableMap.prototype, {
     [Symbol.toStringTag]: { value: \\"UnforgeableMap\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(UnforgeableMap.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -7225,6 +8399,48 @@ exports.install = function install(globalObject) {
       configurable: true
     }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Unscopable.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -7488,6 +8704,48 @@ exports.install = function install(globalObject) {
     overloaded2: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Variadic\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Variadic.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -7599,6 +8857,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(ZeroArgConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"ZeroArgConstructor\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(ZeroArgConstructor.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -7867,6 +9167,48 @@ exports.install = function install(globalObject) {
     u8aUnion: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"BufferSourceTypes\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(BufferSourceTypes.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -8010,6 +9352,48 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"CEReactions\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(CEReactions.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -8409,6 +9793,48 @@ exports.install = function install(globalObject) {
     hasFeature: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DOMImplementation\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(DOMImplementation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -8622,6 +10048,48 @@ exports.install = function install(globalObject) {
     op: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DictionaryConvert\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(DictionaryConvert.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -8777,6 +10245,47 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Enum\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Enum.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -8971,6 +10480,48 @@ exports.install = function install(globalObject) {
     }
   }
   Object.defineProperties(Global.prototype, { [Symbol.toStringTag]: { value: \\"Global\\", configurable: true } });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Global.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -9082,6 +10633,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(HTMLConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"HTMLConstructor\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(HTMLConstructor.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -9203,6 +10796,48 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"LegacyArrayClass\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(LegacyArrayClass.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -9380,6 +11015,48 @@ exports.install = function install(globalObject) {
     mixedInConst: { value: 43, enumerable: true },
     ifaceMixinConst: { value: 42, enumerable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(MixedIn.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -9799,6 +11476,48 @@ exports.install = function install(globalObject) {
     incompatible3: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Overloads\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Overloads.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -9966,6 +11685,48 @@ exports.install = function install(globalObject) {
     promiseConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"PromiseTypes\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(PromiseTypes.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -10212,6 +11973,48 @@ exports.install = function install(globalObject) {
     withUnderscore: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Reflect\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Reflect.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -10557,6 +12360,48 @@ exports.install = function install(globalObject) {
     frozenArrayConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"SeqAndRec\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(SeqAndRec.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -10709,6 +12554,48 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"Static\\", configurable: true }
   });
   Object.defineProperties(Static, { def: { enumerable: true }, abc: { enumerable: true } });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Static.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -10927,6 +12814,48 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Storage\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Storage.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -11219,6 +13148,48 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierAttribute\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierAttribute.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -11341,6 +13312,48 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierDefaultOperation\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierDefaultOperation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -11467,11 +13480,53 @@ exports.install = function install(globalObject) {
       return this[impl].operation();
     }
   }
-  Object.defineProperties(StringifierNamedOperation.prototype, {
-    operation: { enumerable: true },
-    toString: { enumerable: true },
-    [Symbol.toStringTag]: { value: \\"StringifierNamedOperation\\", configurable: true }
-  });
+  Object.defineProperties(StringifierNamedOperation.prototype, {
+    operation: { enumerable: true },
+    toString: { enumerable: true },
+    [Symbol.toStringTag]: { value: \\"StringifierNamedOperation\\", configurable: true }
+  });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierNamedOperation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -11592,6 +13647,48 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierOperation\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(StringifierOperation.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -12120,6 +14217,48 @@ exports.install = function install(globalObject) {
     time: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"TypedefsAndUnions\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(TypedefsAndUnions.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -12486,6 +14625,47 @@ exports.install = function install(globalObject) {
     hash: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"URL\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URL.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -12635,6 +14815,48 @@ exports.install = function install(globalObject) {
     entries: { value: Array.prototype.entries, configurable: true, enumerable: true, writable: true },
     forEach: { value: Array.prototype.forEach, configurable: true, enumerable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLList.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -13259,6 +15481,48 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParams\\", configurable: true },
     [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLSearchParams.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -13432,6 +15696,48 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLSearchParamsCollection.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -13744,6 +16050,48 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection2\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(URLSearchParamsCollection2.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -14152,6 +16500,48 @@ exports.install = function install(globalObject) {
     static: { enumerable: true },
     const: { value: 42, enumerable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(UnderscoredProperties.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -14348,6 +16738,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(Unforgeable.prototype, {
     [Symbol.toStringTag]: { value: \\"Unforgeable\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Unforgeable.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -14476,6 +16908,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(UnforgeableMap.prototype, {
     [Symbol.toStringTag]: { value: \\"UnforgeableMap\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(UnforgeableMap.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -14808,6 +17282,48 @@ exports.install = function install(globalObject) {
       configurable: true
     }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Unscopable.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -15071,6 +17587,48 @@ exports.install = function install(globalObject) {
     overloaded2: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Variadic\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(Variadic.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }
@@ -15182,6 +17740,48 @@ exports.install = function install(globalObject) {
   Object.defineProperties(ZeroArgConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"ZeroArgConstructor\\", configurable: true }
   });
+  if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
+    Object.defineProperty(ZeroArgConstructor.prototype, utils.inspectCustomSymbol, {
+      value: {
+        [utils.inspectCustomSymbol](depth, ctx) {
+          if (!this || !exports.is(this)) {
+            throw new TypeError(\\"Illegal invocation\\");
+          }
+          if (arguments.length < 2) {
+            throw new TypeError(
+              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': 2 arguments required, but only \\" +
+                arguments.length +
+                \\" present.\\"
+            );
+          }
+          const args = [];
+          {
+            let curArg = arguments[0];
+            curArg = conversions[\\"unrestricted double\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 1\\"
+            });
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            curArg = conversions[\\"object\\"](curArg, {
+              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2\\"
+            });
+            conversions[\\"Function\\"](curArg.stylize, {
+              context:
+                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2 has member stylize that\\"
+            });
+            args.push(curArg);
+          }
+          return this[impl][utils.inspectCustomSymbol](...args);
+        }
+      }[utils.inspectCustomSymbol],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
   if (globalObject[ctorRegistry] === undefined) {
     globalObject[ctorRegistry] = Object.create(null);
   }

From d56357adcfc2712dbc87e66dbaf6f4308acae12e Mon Sep 17 00:00:00 2001
From: ExE Boss <3889017+ExE-Boss@users.noreply.github.com>
Date: Fri, 14 Feb 2020 00:10:00 +0100
Subject: [PATCH 2/3] =?UTF-8?q?refactor:=20Add=C2=A0linebreak=C2=A0before?=
 =?UTF-8?q?=20the=C2=A0`util.inspect.custom`=20symbol=C2=A0method?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/constructs/interface.js     |  1 +
 test/__snapshots__/test.js.snap | 62 +++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/lib/constructs/interface.js b/lib/constructs/interface.js
index ef361bb5..575989a5 100644
--- a/lib/constructs/interface.js
+++ b/lib/constructs/interface.js
@@ -1381,6 +1381,7 @@ class Interface {
     // and overloads code doesn't currently support symbol properties.
     // This method is also made non-enumerable to match the other 'utils' symbol properties.
     this.str += `
+
         if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
           Object.defineProperty(${this.name}.prototype, utils.inspectCustomSymbol, {
             value: {
diff --git a/test/__snapshots__/test.js.snap b/test/__snapshots__/test.js.snap
index 9e818f37..7838004e 100644
--- a/test/__snapshots__/test.js.snap
+++ b/test/__snapshots__/test.js.snap
@@ -252,6 +252,7 @@ exports.install = function install(globalObject) {
     u8aUnion: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"BufferSourceTypes\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(BufferSourceTypes.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -453,6 +454,7 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"CEReactions\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(CEReactions.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -909,6 +911,7 @@ exports.install = function install(globalObject) {
     hasFeature: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DOMImplementation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DOMImplementation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -1164,6 +1167,7 @@ exports.install = function install(globalObject) {
     op: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DictionaryConvert\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DictionaryConvert.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -1361,6 +1365,7 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Enum\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Enum.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -1596,6 +1601,7 @@ exports.install = function install(globalObject) {
     }
   }
   Object.defineProperties(Global.prototype, { [Symbol.toStringTag]: { value: \\"Global\\", configurable: true } });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Global.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -1750,6 +1756,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(HTMLConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"HTMLConstructor\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(HTMLConstructor.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -1913,6 +1920,7 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"LegacyArrayClass\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(LegacyArrayClass.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -2132,6 +2140,7 @@ exports.install = function install(globalObject) {
     mixedInConst: { value: 43, enumerable: true },
     ifaceMixinConst: { value: 42, enumerable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(MixedIn.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -2593,6 +2602,7 @@ exports.install = function install(globalObject) {
     incompatible3: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Overloads\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Overloads.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -2802,6 +2812,7 @@ exports.install = function install(globalObject) {
     promiseConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"PromiseTypes\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(PromiseTypes.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -3090,6 +3101,7 @@ exports.install = function install(globalObject) {
     withUnderscore: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Reflect\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Reflect.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -3477,6 +3489,7 @@ exports.install = function install(globalObject) {
     frozenArrayConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"SeqAndRec\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(SeqAndRec.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -3671,6 +3684,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"Static\\", configurable: true }
   });
   Object.defineProperties(Static, { def: { enumerable: true }, abc: { enumerable: true } });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Static.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -3931,6 +3945,7 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Storage\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Storage.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -4265,6 +4280,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierAttribute\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierAttribute.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -4429,6 +4445,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierDefaultOperation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierDefaultOperation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -4602,6 +4619,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierNamedOperation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierNamedOperation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -4764,6 +4782,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierOperation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierOperation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -5334,6 +5353,7 @@ exports.install = function install(globalObject) {
     time: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"TypedefsAndUnions\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(TypedefsAndUnions.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -5742,6 +5762,7 @@ exports.install = function install(globalObject) {
     hash: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"URL\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URL.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -5932,6 +5953,7 @@ exports.install = function install(globalObject) {
     entries: { value: Array.prototype.entries, configurable: true, enumerable: true, writable: true },
     forEach: { value: Array.prototype.forEach, configurable: true, enumerable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLList.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -6598,6 +6620,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParams\\", configurable: true },
     [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParams.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -6813,6 +6836,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -7167,6 +7191,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection2\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection2.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -7617,6 +7642,7 @@ exports.install = function install(globalObject) {
     static: { enumerable: true },
     const: { value: 42, enumerable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnderscoredProperties.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -7855,6 +7881,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(Unforgeable.prototype, {
     [Symbol.toStringTag]: { value: \\"Unforgeable\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unforgeable.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -8025,6 +8052,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(UnforgeableMap.prototype, {
     [Symbol.toStringTag]: { value: \\"UnforgeableMap\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnforgeableMap.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -8399,6 +8427,7 @@ exports.install = function install(globalObject) {
       configurable: true
     }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unscopable.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -8704,6 +8733,7 @@ exports.install = function install(globalObject) {
     overloaded2: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Variadic\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Variadic.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -8857,6 +8887,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(ZeroArgConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"ZeroArgConstructor\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(ZeroArgConstructor.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -9167,6 +9198,7 @@ exports.install = function install(globalObject) {
     u8aUnion: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"BufferSourceTypes\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(BufferSourceTypes.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -9352,6 +9384,7 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"CEReactions\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(CEReactions.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -9793,6 +9826,7 @@ exports.install = function install(globalObject) {
     hasFeature: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DOMImplementation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DOMImplementation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -10048,6 +10082,7 @@ exports.install = function install(globalObject) {
     op: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"DictionaryConvert\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DictionaryConvert.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -10245,6 +10280,7 @@ exports.install = function install(globalObject) {
     attr: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Enum\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Enum.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -10480,6 +10516,7 @@ exports.install = function install(globalObject) {
     }
   }
   Object.defineProperties(Global.prototype, { [Symbol.toStringTag]: { value: \\"Global\\", configurable: true } });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Global.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -10633,6 +10670,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(HTMLConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"HTMLConstructor\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(HTMLConstructor.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -10796,6 +10834,7 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"LegacyArrayClass\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(LegacyArrayClass.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -11015,6 +11054,7 @@ exports.install = function install(globalObject) {
     mixedInConst: { value: 43, enumerable: true },
     ifaceMixinConst: { value: 42, enumerable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(MixedIn.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -11476,6 +11516,7 @@ exports.install = function install(globalObject) {
     incompatible3: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Overloads\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Overloads.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -11685,6 +11726,7 @@ exports.install = function install(globalObject) {
     promiseConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"PromiseTypes\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(PromiseTypes.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -11973,6 +12015,7 @@ exports.install = function install(globalObject) {
     withUnderscore: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Reflect\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Reflect.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -12360,6 +12403,7 @@ exports.install = function install(globalObject) {
     frozenArrayConsumer: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"SeqAndRec\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(SeqAndRec.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -12554,6 +12598,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"Static\\", configurable: true }
   });
   Object.defineProperties(Static, { def: { enumerable: true }, abc: { enumerable: true } });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Static.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -12814,6 +12859,7 @@ exports.install = function install(globalObject) {
     length: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Storage\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Storage.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -13148,6 +13194,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierAttribute\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierAttribute.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -13312,6 +13359,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierDefaultOperation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierDefaultOperation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -13485,6 +13533,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierNamedOperation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierNamedOperation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -13647,6 +13696,7 @@ exports.install = function install(globalObject) {
     toString: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"StringifierOperation\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierOperation.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -14217,6 +14267,7 @@ exports.install = function install(globalObject) {
     time: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"TypedefsAndUnions\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(TypedefsAndUnions.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -14625,6 +14676,7 @@ exports.install = function install(globalObject) {
     hash: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"URL\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URL.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -14815,6 +14867,7 @@ exports.install = function install(globalObject) {
     entries: { value: Array.prototype.entries, configurable: true, enumerable: true, writable: true },
     forEach: { value: Array.prototype.forEach, configurable: true, enumerable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLList.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -15481,6 +15534,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParams\\", configurable: true },
     [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParams.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -15696,6 +15750,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -16050,6 +16105,7 @@ exports.install = function install(globalObject) {
     [Symbol.toStringTag]: { value: \\"URLSearchParamsCollection2\\", configurable: true },
     [Symbol.iterator]: { value: Array.prototype[Symbol.iterator], configurable: true, writable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection2.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -16500,6 +16556,7 @@ exports.install = function install(globalObject) {
     static: { enumerable: true },
     const: { value: 42, enumerable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnderscoredProperties.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -16738,6 +16795,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(Unforgeable.prototype, {
     [Symbol.toStringTag]: { value: \\"Unforgeable\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unforgeable.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -16908,6 +16966,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(UnforgeableMap.prototype, {
     [Symbol.toStringTag]: { value: \\"UnforgeableMap\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnforgeableMap.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -17282,6 +17341,7 @@ exports.install = function install(globalObject) {
       configurable: true
     }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unscopable.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -17587,6 +17647,7 @@ exports.install = function install(globalObject) {
     overloaded2: { enumerable: true },
     [Symbol.toStringTag]: { value: \\"Variadic\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Variadic.prototype, utils.inspectCustomSymbol, {
       value: {
@@ -17740,6 +17801,7 @@ exports.install = function install(globalObject) {
   Object.defineProperties(ZeroArgConstructor.prototype, {
     [Symbol.toStringTag]: { value: \\"ZeroArgConstructor\\", configurable: true }
   });
+
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(ZeroArgConstructor.prototype, utils.inspectCustomSymbol, {
       value: {

From 67fc204fb25fc6751768c2e053dc32b7967f2c1a Mon Sep 17 00:00:00 2001
From: ExE Boss <3889017+ExE-Boss@users.noreply.github.com>
Date: Sun, 16 Feb 2020 07:40:00 +0100
Subject: [PATCH 3/3] =?UTF-8?q?refactor:=20Remove=C2=A0type=C2=A0checking?=
 =?UTF-8?q?=20from=C2=A0the=C2=A0[util.inspect.custom]=C2=A0method?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/constructs/interface.js     |   37 +-
 test/__snapshots__/test.js.snap | 2352 ++++---------------------------
 2 files changed, 316 insertions(+), 2073 deletions(-)

diff --git a/lib/constructs/interface.js b/lib/constructs/interface.js
index 575989a5..6f17f552 100644
--- a/lib/constructs/interface.js
+++ b/lib/constructs/interface.js
@@ -1384,37 +1384,12 @@ class Interface {
 
         if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
           Object.defineProperty(${this.name}.prototype, utils.inspectCustomSymbol, {
-            value: {
-              [utils.inspectCustomSymbol](depth, ctx) {
-                if (!this || !exports.is(this)) {
-                  throw new TypeError("Illegal invocation");
-                }
-                if (arguments.length < 2) {
-                  throw new TypeError("Failed to execute '[nodejs.util.inspect.custom]' on '${
-  this.name}': 2 arguments required, but only " + arguments.length + " present.");
-                }
-                const args = [];
-                {
-                  let curArg = arguments[0];
-                  curArg = conversions["unrestricted double"](curArg, {
-                    context: "Failed to execute '[nodejs.util.inspect.custom]' on '${this.name}': parameter 1",
-                  });
-                  args.push(curArg);
-                }
-                {
-                  let curArg = arguments[1];
-                  curArg = conversions["object"](curArg, {
-                    context: "Failed to execute '[nodejs.util.inspect.custom]' on '${this.name}': parameter 2",
-                  });
-                  conversions["Function"](curArg.stylize, {
-                    context: "Failed to execute '[nodejs.util.inspect.custom]' on '${
-  this.name}': parameter 2 has member stylize that",
-                  });
-                  args.push(curArg);
-                }
-                return this[impl][utils.inspectCustomSymbol](...args);
-              },
-            }[utils.inspectCustomSymbol],
+            value(depth, ctx) {
+              if (!exports.is(this)) {
+                throw new TypeError("Illegal invocation");
+              }
+              return this[impl][utils.inspectCustomSymbol](...arguments);
+            },
             writable: true,
             enumerable: false,
             configurable: true
diff --git a/test/__snapshots__/test.js.snap b/test/__snapshots__/test.js.snap
index 7838004e..94dc808e 100644
--- a/test/__snapshots__/test.js.snap
+++ b/test/__snapshots__/test.js.snap
@@ -255,40 +255,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(BufferSourceTypes.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -457,40 +429,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(CEReactions.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -914,40 +858,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DOMImplementation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -1170,40 +1086,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DictionaryConvert.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -1368,39 +1256,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Enum.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -1604,40 +1465,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Global.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -1759,40 +1592,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(HTMLConstructor.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -1923,40 +1728,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(LegacyArrayClass.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -2143,40 +1920,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(MixedIn.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -2605,40 +2354,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Overloads.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -2815,40 +2536,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(PromiseTypes.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -3104,40 +2797,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Reflect.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -3492,40 +3157,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(SeqAndRec.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -3687,40 +3324,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Static.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -3948,40 +3557,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Storage.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -4283,40 +3864,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierAttribute.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -4448,40 +4001,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierDefaultOperation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -4622,40 +4147,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierNamedOperation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -4785,40 +4282,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierOperation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -5356,40 +4825,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(TypedefsAndUnions.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -5765,39 +5206,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URL.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -5956,40 +5370,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLList.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -6623,40 +6009,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParams.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -6839,40 +6197,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -7194,40 +6524,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection2.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -7645,40 +6947,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnderscoredProperties.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -7884,40 +7158,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unforgeable.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -8055,40 +7301,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnforgeableMap.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -8430,40 +7648,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unscopable.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -8736,40 +7926,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Variadic.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -8890,40 +8052,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(ZeroArgConstructor.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -9201,40 +8335,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(BufferSourceTypes.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'BufferSourceTypes': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -9387,40 +8493,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(CEReactions.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'CEReactions': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -9829,40 +8907,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DOMImplementation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DOMImplementation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -10085,40 +9135,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(DictionaryConvert.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'DictionaryConvert': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -10283,39 +9305,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Enum.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Enum': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -10519,40 +9514,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Global.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Global': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -10673,40 +9640,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(HTMLConstructor.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'HTMLConstructor': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -10837,40 +9776,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(LegacyArrayClass.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'LegacyArrayClass': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -11057,40 +9968,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(MixedIn.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'MixedIn': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -11519,40 +10402,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Overloads.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Overloads': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -11729,40 +10584,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(PromiseTypes.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'PromiseTypes': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -12018,40 +10845,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Reflect.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Reflect': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -12406,40 +11205,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(SeqAndRec.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'SeqAndRec': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -12601,40 +11372,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Static.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Static': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -12862,40 +11605,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Storage.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Storage': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -13197,40 +11912,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierAttribute.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierAttribute': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -13362,40 +12049,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierDefaultOperation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierDefaultOperation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -13536,40 +12195,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierNamedOperation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierNamedOperation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -13699,40 +12330,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(StringifierOperation.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'StringifierOperation': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -14270,40 +12873,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(TypedefsAndUnions.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'TypedefsAndUnions': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -14679,39 +13254,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URL.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URL': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -14870,40 +13418,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLList.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLList': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -15537,40 +14057,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParams.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParams': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -15753,40 +14245,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -16108,40 +14572,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(URLSearchParamsCollection2.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'URLSearchParamsCollection2': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -16559,40 +14995,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnderscoredProperties.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnderscoredProperties': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -16798,40 +15206,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unforgeable.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unforgeable': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -16969,40 +15349,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(UnforgeableMap.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'UnforgeableMap': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -17344,40 +15696,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Unscopable.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Unscopable': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -17650,40 +15974,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(Variadic.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'Variadic': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true
@@ -17804,40 +16100,12 @@ exports.install = function install(globalObject) {
 
   if (utils.hasOwn(Impl.implementation.prototype, utils.inspectCustomSymbol)) {
     Object.defineProperty(ZeroArgConstructor.prototype, utils.inspectCustomSymbol, {
-      value: {
-        [utils.inspectCustomSymbol](depth, ctx) {
-          if (!this || !exports.is(this)) {
-            throw new TypeError(\\"Illegal invocation\\");
-          }
-          if (arguments.length < 2) {
-            throw new TypeError(
-              \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': 2 arguments required, but only \\" +
-                arguments.length +
-                \\" present.\\"
-            );
-          }
-          const args = [];
-          {
-            let curArg = arguments[0];
-            curArg = conversions[\\"unrestricted double\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 1\\"
-            });
-            args.push(curArg);
-          }
-          {
-            let curArg = arguments[1];
-            curArg = conversions[\\"object\\"](curArg, {
-              context: \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2\\"
-            });
-            conversions[\\"Function\\"](curArg.stylize, {
-              context:
-                \\"Failed to execute '[nodejs.util.inspect.custom]' on 'ZeroArgConstructor': parameter 2 has member stylize that\\"
-            });
-            args.push(curArg);
-          }
-          return this[impl][utils.inspectCustomSymbol](...args);
+      value(depth, ctx) {
+        if (!exports.is(this)) {
+          throw new TypeError(\\"Illegal invocation\\");
         }
-      }[utils.inspectCustomSymbol],
+        return this[impl][utils.inspectCustomSymbol](...arguments);
+      },
       writable: true,
       enumerable: false,
       configurable: true