Cómo expresar llamadas recursivas en dimensiones superiores

Solo una pregunta de curiosidad, no es algo serio.

En el lenguaje JS, sé que se puede definir una operación factorial de la siguiente forma.

function factorial(n) {
    if (n === 1) return 1;
    return factorial(n - 1) * n;
}

Luego, definí una operación de factorial de un factorial de la siguiente forma y la llamé super_factorial_1. Hay una descripción similar aquí en Wikipedia.

function super_factorial_1(n) {
    if (n === 1) return factorial(1);
    return super_factorial_1(n - 1) * factorial(n);
}

De manera similar, utilizando super_factorial_1 como un operador, se define el super_factorial_2 aquí:

function super_factorial_2(n) {
    if (n === 1) return super_factorial_1(1);
    return super_factorial_2(n - 1) * super_factorial_1(n);
}

Ahora, la pregunta es cómo definir la operación super_factorial_n, y la super_factorial_n_n, y además, la super_factorial_n..._n{n de n}.

He utilizado un método básico para definir la operación super_factorial_n mencionada anteriormente, pero no creo que sea lo suficientemente bueno.

function super_factorial_n(n, m) {
    const fns = Array(n + 1).fill(0);
    fns[0] = factorial;
    for (let i = 1; i <= n; i++) {
        fns[i] = function (m) {
            if (m === 1) return fns[i - 1](1);
            return fns[i](m - 1) * fns[i - 1](m);
        }
    }
    return fns[n](m);
}

Quizás esta sea una dirección de optimización para el paradigma de programación de procesos. 🙂