Perf impact on module load seems to be depending on the number of hooks defined.

During our investigations trying to optimize Kibana's startup time, we discovered that the perf impact of using require-in-the-middle was depending on the number of Hook that were defined. (More details in https://github.com/elastic/kibana/pull/178285, but we're talking about ~20% performance gain in total module load time by using only one hook instead of 5)

The implementation of RITM seems to confirm it, given each instance of Hook is patching Module.prototype.require, therefor patching the already-patched require from the previous Hook.

I would expect the library to perform the patching only once, and handle all the registered hooks from this single patched method. It would avoid the interception logic to be executed each time for each hook, for each import.

Start by tracing the Hook implementation and its patching of Module.prototype.require. Measure module-load behavior with multiple hooks, then verify that patching occurs once while all registered hooks still run. Done means the performance impact no longer scales with the number of hooks without changing hook behavior.