Like I said, that code from last time was just test code, not real production code. Though clearly it works, I'd never write code like that in a million years. I'm not thrilled with the way it uses the answer variable of the outer scope as an accumulator, and it is profoundly weird that the "do this function n times" function is a member of the Number prototype and not the Function prototype.  Worse still, we have a function that is essentially used as a composition operator that only makes sense to use on functions that have side effects and no arguments or returns. That's a kind of crazy way to do composition operations.

First, define a self-composition factory on the Function prototype, so that it is of general use on all functions of one argument, not just functions of no arguments and no returns that have side effects. What we'll do is make a new member function for every function object that returns a new function which is equivalent to calling the input function n times:

Obviously we don't need to compose functions of more than one argument because we want to feed the single output back into the input.  Now we compose the function "multiply something by x" with itself n times. That gives us the function "multiply something by x, n times".  Pass 1 to that function and we have a handy raiseTo function:

Number.prototype.raiseTo = function(power) {
  var x = this;
  return function(y) {
    return x * y
  }.times(power)(1);
}

Number.prototype.raiseTo = function(power) {
  return function(x) {
    return function(y) {
      return x * y
    }
  }(this).times(power)(1);
}