CommonJS Require Mechanics

According to my textbook, the definition of the require function is this

require.cache = Object.create(null);

function require(name) {
    if (!(name in require.cache)) {
        let code = readFile(name);
        let module = {exports: {}};
        require.cache[name] = module;
        let wrapper = Function("require, exports, module", code);
        wrapper(require, module.exports, module);
    }
    return require.cache[name].exports;
}

Notes:

• readFile(name) is an arbitrary function that depends on whether I am using node.js or a particular browser.
• We set the cache to be an empty object
• This is what my textbook quoted about the code.

> To avoid loading the same module multiple times, require keeps a store
> (cache) of already loaded modules. When called, it first checks if the
> requested module has been loaded and, if not, loads it. This involves
> reading the module’s code, wrapping it in a function, and calling it.

What I do not understand:
How does the recursion work in this case. I am just really confused about the wrapper function.

Imagine you had these extremely simple modules¹:

// In square.js
const square = function (n) {
  return n * n;
}

module .exports = square

and

// In squareAll.js
const square = require ('./square')

const squareAll = function (ns) {
  return ns .map (n => square (n))
}

module .exports = squareAll

with this main module:

const squareAll = require ('./squareAll')

console .log (squareAll ([1, 2, 3, 4, 5]))

On that outer require ('./squareAll'), when we get to the line

let wrapper = Function("require, exports, module", code);

we create a new Function that looks something like this:

const wrapper = function (require, exports, module) {
  const square = require ('./square')

  const squareAll = function (ns) {
    return ns .map (n => square (n))
  }

  module .exports = squareAll
}

We call this constructed function passing our require function, our module object and its exports property. That will then recursively call require when its first line is called:

const square = require ('./square')

and that will use the Function constructor again, invoke that function, and will return the square function, assigning it to the square variable. Back in the outer call, we will use the square function to define squareAll, assign that to module.exports, and then we will return it with:

return require.cache[name].exports;

Our index.js function now has a reference to squareAll, which has a reference to square. And because of the caching, the next time we require one of them, we will return the already-loaded version.

It's a fairly elegant process.

^{¹Yes, these can be written more simply with arrow function. I do, but wanted to make this understandable to as many as possible.}