There becomes an issue of persistence of the scope of a function and if a nested function is called from outside its containing function, the containing function's scope is still present and added to the scope chain along the way when the inner function is called.
To illustrate this, suppose a function AAA is created and within it, another BBB is created.
You can call AAA and while executing its code, a call to BBB might be made. Inside BBB, the scope chain contains the global object, the call object of AAA and the call object of BBB. If BBB is called from outside AAA, as in AAA.BBB(), then the exact same scope chain is constructed.
This can become even more complex if function objects are manufactured at run-time. It might be possible to conceive a function object factory that can preserve the scope chain that persisted at the time the functions were created. If those function objects are preserved and executed later, the scope chain that was in existence at the time they were created will be restored when they are executed. This is far too confusing to be of great use and may turn out to be somewhat non-portable.
This capability is realized by storing the function that has been manufactured in a special kind of object. These are called Closure objects and are implemented visibly in Navigator 4.