Как не терять прототип объявленный у дочернего класса до наследования:
[code]
Function.prototype.inheritsFrom = function(superClass) {
var protot = this.prototype;
var Inheritance = function(){};
Inheritance.prototype = superClass.prototype;

this.prototype = new Inheritance();
this.prototype.constructor = this;
this.superClass = superClass;

for (var key in protot) this.prototype[key] = protot[key];
}

class1 = function () {}
class1.prototype = {
m : 0
}

class2 = function () {}
class2.prototype = {
m1 : 1
}

class2.inheritsFrom(class1);

alert(new class2().m1)

[/code]

Дык "решил" или "написал"?
Дай-ка и я напишу…

Мне режет слух данная формулировка поскольку из нее предполагается, что после того как вы выполнили присвоение
Cat.prototype = new Animal(); // наследуем от класса Animal
у объекта Cat.prottype могли бы сохраниться ранее объявленные методы или свойства

Cat.prototype.boo = function () {alert ('boo');}
Cat.prototype = new Animal(); // наследуем от класса Animal
…..
cat_thing.boo ();// как и ожидалось не работает

– может это как-то переформулировать ?

function Class(params) {

  var Class = function oopClass() {
    // вот здесь вызовятся рекурсивно все конструкторы в нужном порядке
    if (this.__construct) {
      var t = this; var a = arguments; var __construrct;
      (__construrct = function(class) {
        if (class) {
          __construrct(class.__parent);
          class.__constructor.apply(t, a);
        }
      })(this);
    }
  }

   // здесь ниже определение наследования, если нужно,
   // запись в Class.prototype.__constructor = params.__constructor,
   // Class.prototype.__destructor = params.__destructor,
   // Class.prototype.__parent = params.__extends (если надо),
   // и т.д.

  return Class;

}

// создание "класса" Widget

var Widget = Class({
  __constructor: function(obj) {
    if (obj) {
      for (var k in obj) {
        this[k] = obj[k];
      }
    }
    !this.data && (this.data = {});
    //alert('Widget constructor');
  },
  __destructor: function() {
    alert('Widget destructor');
  }
});

// какие-то методы Widget'a

Widget.prototype.setValue = function(value) {
  this.data.value = value;
}

Widget.prototype.getValue = function() {
  alert(this.data.value);
}

Widget.prototype.getParentObj = function() {
  if (!this.__parent) {
    return null;
  }
  return this.__parent;
}

// создание "класса" WidgetRoot, наследуемого от Widget

var WidgetRoot = Class({
  __extends: Widget,
  __constructor: function(_obj) {
    //alert('WidgetRoot constructor');
  },
  __destructor: function() {
    alert('WidgetRoot destructor');
  }
});

// переопределение метода родительского "класса"

WidgetRoot.prototype.getValue = function() {
  alert(this.data.value + ' from WidgetRoot');
}

// а здесь уже объект "класса" WidgetRoot

var wr = new WidgetRoot({a: 2, b: 3});
wr.setValue(10);
wr.getValue(); // свой (переопределенный) метод
wr.__parent.getValue.call(wt); // вызов родительского

Я хотел хранить ссылку на .superClass в .prototype.superClass функции-конструктора подкласса:

this.prototype.superClass = superClass;

Потом, пользуясь свойством прототипов, я хотел ловко подцеплять эту ссылку при конструировании объекта подкласса, во время вызовов new ClassSub():

this.SuperClass.apply(this, arguments);

Но ведь это же очевидно, что когда мы начинаем вызывать подкласс самого подкласса: new ClassSubSub(), то при входе в функцию-конструктор подкласса (ClassSub), слово this ссылается не на этот подкласс, а на ClassSubSub (т.к. мы применяем функцию apply)! И получается бесконечный вызов ClassSubSub самого себя! Черт.

Вот как надо делать по-честному:

// Универсальная функция наследования
Function.prototype.inheritsFrom = function(superClass) {
	var Inheritance = function(){};
	Inheritance.prototype = superClass.prototype;

	this.prototype = new Inheritance();
	this.prototype.constructor = this;
	this.prototype.superClass = superClass;
	this.superClass = superClass;
}

// функция-конструктор класса
var Class = function(){}

// описание свойств и методов класса
Class.prototype.method = function(){};

// функция-конструктор подкласса
var ClassSub = function(){
	this.superClass.apply(this, arguments);
	ClassSub.superClass.apply(this, arguments);
}
// определение наследования
ClassSub.inheritsFrom(Class); // sic!

// описание свойств и методов подкласса
ClassSub.prototype.method = function(){
	this.superClass.prototype.method.apply(this, arguments);
	ClassSub.superClass.prototype.method.apply(this, arguments);
}

Dmitry A. Soshnikov! Большое вам спасибо, что указали мне на эту досадную ошибку! Теперь наследовать можно до бесконечности (= (Михайлов Денис, приношу вам свои извинения)

p.s. в статье я испраил весь код в сотвествие с вышеизложенным рассуждением

// Универсальная функция наследования
Function.prototype.inheritsFrom = function(superClass) {
	var Inheritance = function(){};
	Inheritance.prototype = superClass.prototype;
	this.prototype = new Inheritance();
	this.prototype.constructor = this;
	this.prototype.superClass = superClass;
}

// функция-конструктор Class
var Class = function(data) {
	this.data = data || {};
	alert('Class');
}

// функция-конструктор ClassSub
var ClassSub = function() {
	this.superClass.apply(this, arguments);
	alert('ClassSub');
}
// определение наследования
ClassSub.inheritsFrom(Class); // sic!

// функция-конструктор ClassSubSub
var ClassSubSub = function() {
	this.superClass.apply(this, arguments);
	alert('ClassSubSub');
}

ClassSubSub.inheritsFrom(ClassSub); // sic!

var c = new ClassSubSub({a: 1, b: 3});