<STYLE>
  behavior:my_button_class;
  ....
<SCRIPT>
  var my_button_class = 
  {
    onclick: function() {....},
    onblur: function() {....}    
    ....
  }

String.prototype.mymethod = function() { something }
// invocation:
"one".mymethod();

String.mymethod = function() { something }
// invocation:
"one".mymethod();

 MyClass.myproperty = 
   property(val) 
     { 
       if(isExists(val)) // 'set' invocation
         this.val = val;
       return this.val; // either 'get' or 'set' invocation
     }
 // invocation:
 myclassinst.myproperty = "one";// set
 var s = myclassinst.myproperty; // get

scrollbar[type="vertical"]>.thumb
{
    width:100%%;
    min-height: 15px;
    border-left: 1px solid #C5C7C7;
    background-color:transparent;
    background-image:url(res:thumb-v-normal.png);
    background-position:50% 50%; /* center middle */
    background-repeat:no-repeat;
}

scrollbar[type="vertical"]>.thumb:hover
{
    background-color: #B1C4D9;
    border-top: 1px solid #CCD9E9;
    border-left: 1px solid #CCD9E9;
    border-right: 1px solid #90A5C3;
    border-bottom: 1px solid #90A5C3;
    background-image:url(res:thumb-v-hover.png);
}

MyObject.prototype=
{
  field = 100,
  MyFunction = function(){"some";}
}

A>Да конечно, это вообще-то основа JavaScript ... Прототипированный язык

MyObject.prototype=
{
  field = 100,
  MyFunction = function(){"some";}
}

function MyObject()
{
  this.field = 100,
}
MyObject.MyFunction = function(){"some";} // прицепили метод
MyObject.MyCommonVar = "some"; // прицепили свойство общее для всех instance порожденных с пом MyObject

var myObject = new MyObject();
myObject.MyFunction();

A>Отступление: А дебаггер будет? Мне очень нравиться DomInspector из мозиллы ...

A>Вот это обязательно!

function MyObjectBase(){}

MyObjectBase.prototype = {} // Some prototype;

function MyObject(){}

MyObject.prototype = new MyObjectBase(); // Наследование
MyObject.prototype.NewFunction = function() {} // Some new functionality

function MyObject() {/* конструктор объекта */ }

// Прототип объекта
MyObject.prototype = 
{
  field = 100, // default value
  MyFunction: function() { print(this.field); } 
}

var myObj1 = new MyObject(); // Cоздаём новый экземпляр объекта
myObj1.field = 1;

var myObj2 = new MyObject(); // Cоздаём новый экземпляр объекта
myObj2.field = 2;

myObj1.MyFunction(); // Печатает 1
myObj2.MyFunction(); // Печатает 2

myObj2.MyFunction = function() { print("Hello World!");} /* Переопределяем функцию экземпляра */

myObj2.MyFunction(); // Печатает Hello, World!

A>>Отступление: А дебаггер будет? Мне очень нравиться DomInspector из мозиллы ...

A>function MyObject() {/* конструктор объекта */ }

A>// Прототип объекта
A>MyObject.prototype = 
A>{
A>  field = 100, // default value
A>  MyFunction: function() { print(this.field); } 
A>}

A>var myObj1 = new MyObject(); // Cоздаём новый экземпляр объекта
A>myObj1.field = 1;

A>var myObj2 = new MyObject(); // Cоздаём новый экземпляр объекта
A>myObj2.field = 2;

A>myObj1.MyFunction(); // Печатает 1
A>myObj2.MyFunction(); // Печатает 2

A>myObj2.MyFunction = function() { print("Hello World!");} /* Переопределяем функцию экземпляра */

A>myObj2.MyFunction(); // Печатает Hello, World!
A>

function MyObject() { this.somefield = 10; }/* конструктор объекта он же и прототип!*/ }

MyObject.field = 100, // default value
MyObject.MyFunction = function() { print(this.field); } 


var myObj1 = new MyObject(); // Cоздаём новый экземпляр объекта
myObj1.field = 1;

var myObj2 = new MyObject(); // Cоздаём новый экземпляр объекта
myObj2.field = 2;

myObj1.MyFunction(); // Печатает 1
myObj2.MyFunction(); // Печатает 2

myObj2.MyFunction = function() { print("Hello World!");} /* Переопределяем функцию экземпляра */

myObj2.MyFunction(); // Печатает Hello, World!

MyObject.MyFunction = function() { print("Hello Universe!");} /* Переопределяем функцию для всех остальных экземпляров класса */

A>Я в исходники выкладывал EventFramework ...

A>Бороться с мозиллой боюсь на этом фронте будет тяжеловато

/* skip*/
function nsBody(ele)
{
    this.type = BODY_NORMAL;    
    this._ele = xGetElementById(ele);
    this._sections = new Array();
    this._menus = new Array();
    this._specialMenus = new Array();
    this.selectedMenu = '';
}

nsBody.prototype.addBodySection = function()
{
    this._sections.push(new nsBodySection());
    return this._sections[this._sections.length - 1];
}

/*skip*/

nsBody.prototype.generate = function()
{
    var n;
    var i = 0;
    
    
    while(true)
    {
        if(this.type == BODY_NORMAL) n = this._sections[i];
        if(this.type == BODY_NEWS)   n = this._sections.pop();

        n.generate(this._ele, i);
        
        if(this.type == BODY_NORMAL && ++i == this._sections.length) break;
        if(this._sections.length == 0) break;
    }
}

<!--skip-->
pageBody = new nsBody(ele);

section = pageBody.addBodySection();
section.contents = 'Hello, world!';

section = pageBody.addBodySection();
section.contents = 'Hello, world, yet again!';

pageBody.generate();

A>>Бороться с мозиллой боюсь на этом фронте будет тяжеловато

A>Вот это круто А системы расширения какие-то подразумеваются?

OBJECT[classid="..."]
{
  border: 1px solid red;
  behavior: my-cpp-implemented-behavior-name
};

/** hsmile DOM element behavior interface
 *  
 *  allows to redefine behavior of any standard dom element
 **/

struct HSMILE_BEHAVIOR 
{
    virtual xool::word HSMILE_CB will_handle  ( ) = 0;

/**Callback function for mouse events. 
 * \param he \b HELEMENT, 
 * \param target \b HELEMENT, 
 * \param event_type \b xool::dword, 
 * \param pt \b xool::point, 
 * \param mouseButtons \b xool::dword, 
 * \param keyboardStates \b xool::dword,
 * \return TRUE if application handled event, false otherwise.
 **/
    virtual bool HSMILE_CB on_mouse  (HELEMENT he, HELEMENT target, xool::dword event_type, xool::point pt, xool::dword mouseButtons, xool::dword keyboardStates ) = 0;
    virtual bool HSMILE_CB on_key    (HELEMENT he, HELEMENT target, xool::dword event_type, xool::dword code, xool::dword keyboardStates ) = 0;
    virtual bool HSMILE_CB on_focus  (HELEMENT he, HELEMENT target, xool::dword event_type ) = 0;
    virtual bool HSMILE_CB on_paint  (HELEMENT he, HDC hdc, xool::rect rc ) = 0;
    virtual bool HSMILE_CB on_measure(HELEMENT he, xool::size* min_size, xool::size* max_size ) = 0;
    virtual bool HSMILE_CB on_timer  (HELEMENT he, xool::dword timer_id ) = 0;
    virtual void HSMILE_CB detach    (HELEMENT he ) = 0;
};

Итак, вывод: прототипы объектов доступны по цепочке obj.constructor.prototype.constructor.prototype..., а не obj.prototype.prototype, как можно понять из многих руководств по JavaScript в Интернете. Конструктором объекта может быть только объект встроенного класса (обычно это Function).

function  MyObject() {  }
MyObject.myClassMethod = function() { alert("ku-ku"); } // цепляем метод к "классу"

var a = new MyObject();
a.myClassMethod(); // выдаст alert(ku-ku)

function  MyObject() {  }

MyObject.prototype.myClassMethod = function() { alert("ku-ku"); }

var a = new MyObject();
a.myClassMethod(); // выдаст alert(ku-ku)

Y>так что не надо думать, что ты умнее ECMA они придумывали стандарт не исходя из каких=то эфимерных целей, а исходя из практической реализации, так что pototype думаю придется делать однозначно

function MyClass() {
    this.field=4;
}

MyClass.prototype.method=function () {
    trace(this.field);
}

var myobj=new MyClass();
myobj.method();