function Outer()
{
  var one = this.foo();
  function Inner()
  {
    var another = this.foo(); // this?
  }
  Inner(); // <<< problem here, 'this' for Inner call is not set
}

function Outer()
{
  var me = this;
  var one = this.foo();
  function Inner()
  {
    var another = me.foo(); // (super this).foo() call
  }
  Inner(); // всё хорошо
}

function Outer()
{
  var one = this.foo();
  function Inner()
  {
    var another = super this.foo(); // 'super this' это один токен на самом деле.
  }
  Inner(); // всё хорошо
}

function Outer()
{
  var one = this.foo();
  var me = this;
  function Inner() { var another = me.foo(); }
  Inner(); 
}

function Outer()
{
  var one = this.foo();
  function Inner() { var another = (super this).foo(); }
  Inner();
}

namespace Z
{ 
  function A()
  {
    var this_a = this;
    function B()  
    {
      var this_b = this;    
      function C()
      {
        assert this_b == this super;  
        assert this_a == this super super;
      }
      C();
    }
    B();
  }
}

Z.A();

    <script type="text/javascript">
        function Outer() {
            foo = function() {
                alert("Wow!");
            }
            function Inner() {
                var another = this.foo();
            }
            Inner.prototype = this;
            Inner();
        }
    
    </script>

__local_vars[0] <- 'this'
__local_vars[1] <- function argument #1
__local_vars[2] <- function argument #2
...
__local_vars[N] <- function argument #N
__local_vars[N+1] <- local variable #1
__local_vars[N+2] <- local variable #2
...

function Outer()
{
  var me = this; // __local_vars[1] = __local_vars[0]
  function Inner() 
  { 
     me.foo();   // __scope[-1].__local_vars[1].foo()
  }
  Inner(); 
}

function Outer()
{
  function Inner() 
  { 
    (super this).foo(); // __scope[-1].__local_vars[0].foo()
  }
  Inner();
}

A>function Outer()
A>{
A>  function Inner() 
A>  { 
A>    this.foo();
A>  }
A>  Inner.apply(this);
A>}
A>

class Tape : Behavior
{
  function attached() // behavior ctor, 'this' is the DOM element this behavior is attached to
  {
    function clickHandler()
    {
      (super this).onButtonClicked(this);
    }
    self.$(button#some).onClick = clickHandler;
  }
  function onButtonClicked(theButton) { ... }
}

CS>function Outer()
CS>{
CS>  var me = this;
CS>  var one = this.foo();
CS>  function Inner()
CS>  {
CS>    var another = me.foo(); // (super this).foo() call
CS>  }
CS>  Inner(); // всё хорошо
CS>}
CS>

function Outer()
{
  var one = this.foo();
  function Inner(me)
  {
    var another = me.foo(); // (super this).foo() call
  }
  Inner(this); // всё хорошо
}

Y>function Outer()
Y>{
Y>  var one = this.foo();
Y>  function Inner(me)
Y>  {
Y>    var another = me.foo(); // (super this).foo() call
Y>  }
Y>  Inner(this); // всё хорошо
Y>}
Y>

// adding method sortContent() to the Element class:
function Element.sortContent()
{
  function Comparator(e1,e2)
  {
    if( (this super).tag == "select" )
       return e1.value < e2.value? -1:1; 
    else
       return e1.text < e2.text? -1:1; 
  }
  this.sort(Comparator);
}

function Outer()
{
  const this = <...get 'this' value from call stack...>; // declaration happens under the hood

  function Inner()
  {
    const this = <...get 'this' value from call stack...>; // declaration happens under the hood

    how to get that 'outer this' here?
  }
}

function Outer() 
{ 
  function Inner() { Outer.foo(); }  
}
Outer.foo = function() {  ... }

class Foo: Bar
{
  function foo() 
  { 
    ...
    return super.foo(); // Bar.foo() call with this.
  }
}

CS>// adding method sortContent() to the Element class:
CS>function Element.sortContent()
CS>{
CS>  function Comparator(e1,e2)
CS>  {
CS>    if( (this super).tag == "select" )
CS>       return e1.value < e2.value? -1:1; 
CS>    else
CS>       return e1.text < e2.text? -1:1; 
CS>  }
CS>  this.sort(Comparator);
CS>}
CS>

// adding method sortContent() to the Element class:
function Element.sortContent()
{
  function Comparator(me)
  {
    var me = me;
    return function(e1,e2)
    {
      if( me.tag == "select" )
        return e1.value < e2.value? -1:1; 
      else
        return e1.text < e2.text? -1:1; 
    }
  }
  this.sort(Comparator(this));
}

Y>// adding method sortContent() to the Element class:
Y>function Element.sortContent()
Y>{
Y>  function Comparator(me)
Y>  {
Y>    var me = me;
Y>    return function(e1,e2)
Y>    {
Y>      if( me.tag == "select" )
Y>        return e1.value < e2.value? -1:1; 
Y>      else
Y>        return e1.text < e2.text? -1:1; 
Y>    }
Y>  }
Y>  this.sort(Comparator(this));
Y>}
Y>

function Element.sortContent()
{
    var me = this;
    function Comparator(e1,e2)
    {
      if( me.tag == "select" )
        return e1.value < e2.value? -1:1; 
      else
        return e1.text < e2.text? -1:1; 
    }
    this.sort(Comparator);
}

super::this
super::super::this

A>super::this
A>super::super::this
A>

var c = 0;
element.post(::c+=1);

var c = 0;
element.post(function(){c+=1});

arr.sort(:e1,e2:e1-e2);

arr.sort(function(e1,e2){return e1-e2});