dojo-rails 0.9.9 → 0.9.10

data/vendor/assets/javascripts/dojo/_base/declare.js

@@ -224,15 +224,18 @@ function _33(_34){
 _35.safeMixin(this.prototype,_34);
 return this;
 };
-function _36(_37,_38){
+function _36(_37){
+return _35([this].concat(_37));
+};
+function _38(_39,_3a){
 return function(){
-var a=arguments,_39=a,a0=a[0],f,i,m,l=_37.length,_3a;
+var a=arguments,_3b=a,a0=a[0],f,i,m,l=_39.length,_3c;
 if(!(this instanceof a.callee)){
-return _3b(a);
+return _3d(a);
 }
-if(_38&&(a0&&a0.preamble||this.preamble)){
-_3a=new Array(_37.length);
-_3a[0]=a;
+if(_3a&&(a0&&a0.preamble||this.preamble)){
+_3c=new Array(_39.length);
+_3c[0]=a;
 for(i=0;;){
 a0=a[0];
 if(a0){
@@ -241,7 +244,7 @@ if(f){
 a=f.apply(this,a)||a;
 }
 }
-f=_37[i].prototype;
+f=_39[i].prototype;
 f=f.hasOwnProperty("preamble")&&f.preamble;
 if(f){
 a=f.apply(this,a)||a;
@@ -249,30 +252,30 @@ a=f.apply(this,a)||a;
 if(++i==l){
 break;
 }
-_3a[i]=a;
+_3c[i]=a;
 }
 }
 for(i=l-1;i>=0;--i){
-f=_37[i];
+f=_39[i];
 m=f._meta;
 f=m?m.ctor:f;
 if(f){
-f.apply(this,_3a?_3a[i]:a);
+f.apply(this,_3c?_3c[i]:a);
 }
 }
 f=this.postscript;
 if(f){
-f.apply(this,_39);
+f.apply(this,_3b);
 }
 };
 };
-function _3c(_3d,_3e){
+function _3e(_3f,_40){
 return function(){
 var a=arguments,t=a,a0=a[0],f;
 if(!(this instanceof a.callee)){
-return _3b(a);
+return _3d(a);
 }
-if(_3e){
+if(_40){
 if(a0){
 f=a0.preamble;
 if(f){
@@ -284,8 +287,8 @@ if(f){
 f.apply(this,t);
 }
 }
-if(_3d){
-_3d.apply(this,a);
+if(_3f){
+_3f.apply(this,a);
 }
 f=this.postscript;
 if(f){
@@ -293,13 +296,13 @@ f.apply(this,a);
 }
 };
 };
-function _3f(_40){
+function _41(_42){
 return function(){
 var a=arguments,i=0,f,m;
 if(!(this instanceof a.callee)){
-return _3b(a);
+return _3d(a);
 }
-for(;f=_40[i];++i){
+for(;f=_42[i];++i){
 m=f._meta;
 f=m?m.ctor:f;
 if(f){
@@ -313,116 +316,117 @@ f.apply(this,a);
 }
 };
 };
-function _41(_42,_43,_44){
+function _43(_44,_45,_46){
 return function(){
-var b,m,f,i=0,_45=1;
-if(_44){
-i=_43.length-1;
-_45=-1;
+var b,m,f,i=0,_47=1;
+if(_46){
+i=_45.length-1;
+_47=-1;
 }
-for(;b=_43[i];i+=_45){
+for(;b=_45[i];i+=_47){
 m=b._meta;
-f=(m?m.hidden:b.prototype)[_42];
+f=(m?m.hidden:b.prototype)[_44];
 if(f){
 f.apply(this,arguments);
 }
 }
 };
 };
-function _46(_47){
-_6.prototype=_47.prototype;
+function _48(_49){
+_6.prototype=_49.prototype;
 var t=new _6;
 _6.prototype=null;
 return t;
 };
-function _3b(_48){
-var _49=_48.callee,t=_46(_49);
-_49.apply(t,_48);
+function _3d(_4a){
+var _4b=_4a.callee,t=_48(_4b);
+_4b.apply(t,_4a);
 return t;
 };
-function _35(_4a,_4b,_4c){
-if(typeof _4a!="string"){
-_4c=_4b;
-_4b=_4a;
-_4a="";
-}
-_4c=_4c||{};
-var _4d,i,t,_4e,_4f,_50,_51,_52=1,_53=_4b;
-if(_5.call(_4b)=="[object Array]"){
-_50=_c(_4b,_4a);
-t=_50[0];
-_52=_50.length-t;
-_4b=_50[_52];
+function _35(_4c,_4d,_4e){
+if(typeof _4c!="string"){
+_4e=_4d;
+_4d=_4c;
+_4c="";
+}
+_4e=_4e||{};
+var _4f,i,t,_50,_51,_52,_53,_54=1,_55=_4d;
+if(_5.call(_4d)=="[object Array]"){
+_52=_c(_4d,_4c);
+t=_52[0];
+_54=_52.length-t;
+_4d=_52[_54];
 }else{
-_50=[0];
-if(_4b){
-if(_5.call(_4b)=="[object Function]"){
-t=_4b._meta;
-_50=_50.concat(t?t.bases:_4b);
+_52=[0];
+if(_4d){
+if(_5.call(_4d)=="[object Function]"){
+t=_4d._meta;
+_52=_52.concat(t?t.bases:_4d);
 }else{
-_9("base class is not a callable constructor.",_4a);
+_9("base class is not a callable constructor.",_4c);
 }
 }else{
-if(_4b!==null){
-_9("unknown base class. Did you use dojo.require to pull it in?",_4a);
+if(_4d!==null){
+_9("unknown base class. Did you use dojo.require to pull it in?",_4c);
 }
 }
 }
-if(_4b){
-for(i=_52-1;;--i){
-_4d=_46(_4b);
+if(_4d){
+for(i=_54-1;;--i){
+_4f=_48(_4d);
 if(!i){
 break;
 }
-t=_50[i];
-(t._meta?_29:_4)(_4d,t.prototype);
-_4e=new Function;
-_4e.superclass=_4b;
-_4e.prototype=_4d;
-_4b=_4d.constructor=_4e;
+t=_52[i];
+(t._meta?_29:_4)(_4f,t.prototype);
+_50=new Function;
+_50.superclass=_4d;
+_50.prototype=_4f;
+_4d=_4f.constructor=_50;
 }
 }else{
-_4d={};
+_4f={};
 }
-_35.safeMixin(_4d,_4c);
-t=_4c.constructor;
+_35.safeMixin(_4f,_4e);
+t=_4e.constructor;
 if(t!==op.constructor){
 t.nom=_8;
-_4d.constructor=t;
+_4f.constructor=t;
 }
-for(i=_52-1;i;--i){
-t=_50[i]._meta;
+for(i=_54-1;i;--i){
+t=_52[i]._meta;
 if(t&&t.chains){
-_51=_4(_51||{},t.chains);
+_53=_4(_53||{},t.chains);
 }
 }
-if(_4d["-chains-"]){
-_51=_4(_51||{},_4d["-chains-"]);
+if(_4f["-chains-"]){
+_53=_4(_53||{},_4f["-chains-"]);
 }
-t=!_51||!_51.hasOwnProperty(_8);
-_50[0]=_4e=(_51&&_51.constructor==="manual")?_3f(_50):(_50.length==1?_3c(_4c.constructor,t):_36(_50,t));
-_4e._meta={bases:_50,hidden:_4c,chains:_51,parents:_53,ctor:_4c.constructor};
-_4e.superclass=_4b&&_4b.prototype;
-_4e.extend=_33;
-_4e.prototype=_4d;
-_4d.constructor=_4e;
-_4d.getInherited=_21;
-_4d.isInstanceOf=_27;
-_4d.inherited=_26;
-_4d.__inherited=_17;
-if(_4a){
-_4d.declaredClass=_4a;
-_3.setObject(_4a,_4e);
+t=!_53||!_53.hasOwnProperty(_8);
+_52[0]=_50=(_53&&_53.constructor==="manual")?_41(_52):(_52.length==1?_3e(_4e.constructor,t):_38(_52,t));
+_50._meta={bases:_52,hidden:_4e,chains:_53,parents:_55,ctor:_4e.constructor};
+_50.superclass=_4d&&_4d.prototype;
+_50.extend=_33;
+_50.createSubclass=_36;
+_50.prototype=_4f;
+_4f.constructor=_50;
+_4f.getInherited=_21;
+_4f.isInstanceOf=_27;
+_4f.inherited=_26;
+_4f.__inherited=_17;
+if(_4c){
+_4f.declaredClass=_4c;
+_3.setObject(_4c,_50);
 }
-if(_51){
-for(_4f in _51){
-if(_4d[_4f]&&typeof _51[_4f]=="string"&&_4f!=_8){
-t=_4d[_4f]=_41(_4f,_50,_51[_4f]==="after");
-t.nom=_4f;
+if(_53){
+for(_51 in _53){
+if(_4f[_51]&&typeof _53[_51]=="string"&&_51!=_8){
+t=_4f[_51]=_43(_51,_52,_53[_51]==="after");
+t.nom=_51;
 }
 }
 }
-return _4e;
+return _50;
 };
 _1.safeMixin=_35.safeMixin=_2e;
 _1.declare=_35;

data/vendor/assets/javascripts/dojo/_base/declare.js.uncompressed.js

@@ -1,8 +1,6 @@
 define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
 	// module:
 	//		dojo/_base/declare
-	// summary:
-	//		This module defines dojo.declare.
 
 	var mix = lang.mixin, op = Object.prototype, opts = op.toString,
 		xtor = new Function, counter = 0, cname = "constructor";
@@ -238,6 +236,63 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 
 	// implementation of safe mixin function
 	function safeMixin(target, source){
+		// summary:
+		//		Mix in properties skipping a constructor and decorating functions
+		//		like it is done by declare().
+		// target: Object
+		//		Target object to accept new properties.
+		// source: Object
+		//		Source object for new properties.
+		// description:
+		//		This function is used to mix in properties like lang.mixin does,
+		//		but it skips a constructor property and decorates functions like
+		//		declare() does.
+		//
+		//		It is meant to be used with classes and objects produced with
+		//		declare. Functions mixed in with dojo.safeMixin can use
+		//		this.inherited() like normal methods.
+		//
+		//		This function is used to implement extend() method of a constructor
+		//		produced with declare().
+		//
+		// example:
+		//	|	var A = declare(null, {
+		//	|		m1: function(){
+		//	|			console.log("A.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("A.m2");
+		//	|		}
+		//	|	});
+		//	|	var B = declare(A, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m1");
+		//	|		}
+		//	|	});
+		//	|	B.extend({
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m2");
+		//	|		}
+		//	|	});
+		//	|	var x = new B();
+		//	|	dojo.safeMixin(x, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m2");
+		//	|		}
+		//	|	});
+		//	|	x.m2();
+		//	|	// prints:
+		//	|	// A.m1
+		//	|	// B.m1
+		//	|	// X.m1
+
 		var name, t;
 		// add props adding metadata for incoming functions skipping a constructor
 		for(name in source){
@@ -271,7 +326,11 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		return this;
 	}
 
-	// chained constructor compatible with the legacy dojo.declare()
+	function createSubclass(mixins){
+		return declare([this].concat(mixins));
+	}
+
+	// chained constructor compatible with the legacy declare()
 	function chainedConstructor(bases, ctorSpecial){
 		return function(){
 			var a = arguments, args = a, a0 = a[0], f, i, m,
@@ -283,7 +342,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 			}
 
 			//this._inherited = {};
-			// perform the shaman's rituals of the original dojo.declare()
+			// perform the shaman's rituals of the original declare()
 			// 1) call two types of the preamble
 			if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
 				// full blown ritual
@@ -334,7 +393,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 	}
 
 
-	// chained constructor compatible with the legacy dojo.declare()
+	// chained constructor compatible with the legacy declare()
 	function singleConstructor(ctor, ctorSpecial){
 		return function(){
 			var a = arguments, t = a, a0 = a[0], f;
@@ -345,7 +404,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 			}
 
 			//this._inherited = {};
-			// perform the shaman's rituals of the original dojo.declare()
+			// perform the shaman's rituals of the original declare()
 			// 1) call two types of the preamble
 			if(ctorSpecial){
 				// full blown ritual
@@ -390,7 +449,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 			}
 
 			//this._inherited = {};
-			// perform the shaman's rituals of the original dojo.declare()
+			// perform the shaman's rituals of the original declare()
 			// 1) do not call the preamble
 			// 2) call the top constructor (it can use this.inherited())
 			for(; f = bases[i]; ++i){ // intentional assignment
@@ -451,134 +510,23 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 	}
 
 	function declare(className, superclass, props){
-		// crack parameters
-		if(typeof className != "string"){
-			props = superclass;
-			superclass = className;
-			className = "";
-		}
-		props = props || {};
-
-		var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
-
-		// build a prototype
-		if(opts.call(superclass) == "[object Array]"){
-			// C3 MRO
-			bases = c3mro(superclass, className);
-			t = bases[0];
-			mixins = bases.length - t;
-			superclass = bases[mixins];
-		}else{
-			bases = [0];
-			if(superclass){
-				if(opts.call(superclass) == "[object Function]"){
-					t = superclass._meta;
-					bases = bases.concat(t ? t.bases : superclass);
-				}else{
-					err("base class is not a callable constructor.", className);
-				}
-			}else if(superclass !== null){
-				err("unknown base class. Did you use dojo.require to pull it in?", className);
-			}
-		}
-		if(superclass){
-			for(i = mixins - 1;; --i){
-				proto = forceNew(superclass);
-				if(!i){
-					// stop if nothing to add (the last base)
-					break;
-				}
-				// mix in properties
-				t = bases[i];
-				(t._meta ? mixOwn : mix)(proto, t.prototype);
-				// chain in new constructor
-				ctor = new Function;
-				ctor.superclass = superclass;
-				ctor.prototype = proto;
-				superclass = proto.constructor = ctor;
-			}
-		}else{
-			proto = {};
-		}
-		// add all properties
-		declare.safeMixin(proto, props);
-		// add constructor
-		t = props.constructor;
-		if(t !== op.constructor){
-			t.nom = cname;
-			proto.constructor = t;
-		}
-
-		// collect chains and flags
-		for(i = mixins - 1; i; --i){ // intentional assignment
-			t = bases[i]._meta;
-			if(t && t.chains){
-				chains = mix(chains || {}, t.chains);
-			}
-		}
-		if(proto["-chains-"]){
-			chains = mix(chains || {}, proto["-chains-"]);
-		}
-
-		// build ctor
-		t = !chains || !chains.hasOwnProperty(cname);
-		bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
-			(bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
-
-		// add meta information to the constructor
-		ctor._meta  = {bases: bases, hidden: props, chains: chains,
-			parents: parents, ctor: props.constructor};
-		ctor.superclass = superclass && superclass.prototype;
-		ctor.extend = extend;
-		ctor.prototype = proto;
-		proto.constructor = ctor;
-
-		// add "standard" methods to the prototype
-		proto.getInherited = getInherited;
-		proto.isInstanceOf = isInstanceOf;
-		proto.inherited    = inheritedImpl;
-		proto.__inherited  = inherited;
-
-		// add name if specified
-		if(className){
-			proto.declaredClass = className;
-			lang.setObject(className, ctor);
-		}
-
-		// build chains and add them to the prototype
-		if(chains){
-			for(name in chains){
-				if(proto[name] && typeof chains[name] == "string" && name != cname){
-					t = proto[name] = chain(name, bases, chains[name] === "after");
-					t.nom = name;
-				}
-			}
-		}
-		// chained methods do not return values
-		// no need to chain "invisible" functions
-
-		return ctor;	// Function
-	}
-
-	/*=====
-	dojo.declare = function(className, superclass, props){
-		//	summary:
+		// summary:
 		//		Create a feature-rich constructor from compact notation.
-		//	className: String?:
+		// className: String?
 		//		The optional name of the constructor (loosely, a "class")
 		//		stored in the "declaredClass" property in the created prototype.
 		//		It will be used as a global name for a created constructor.
-		//	superclass: Function|Function[]:
+		// superclass: Function|Function[]
 		//		May be null, a Function, or an Array of Functions. This argument
 		//		specifies a list of bases (the left-most one is the most deepest
 		//		base).
-		//	props: Object:
+		// props: Object
 		//		An object whose properties are copied to the created prototype.
 		//		Add an instance-initialization function by making it a property
 		//		named "constructor".
-		//	returns:
+		// returns: dojo/_base/declare.__DeclareCreatedObject
 		//		New constructor function.
-		//	description:
+		// description:
 		//		Create a constructor using a compact notation for inheritance and
 		//		prototype extension.
 		//
@@ -588,7 +536,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//		they have been mixed in.
 		//
 		//		Ancestors can be compound classes created by this version of
-		//		dojo.declare. In complex cases all base classes are going to be
+		//		declare(). In complex cases all base classes are going to be
 		//		linearized according to C3 MRO algorithm
 		//		(see http://www.python.org/download/releases/2.3/mro/ for more
 		//		details).
@@ -605,7 +553,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//		cases.
 		//
 		//		It is possible to use constructors created "manually" (without
-		//		dojo.declare) as bases. They will be called as usual during the
+		//		declare()) as bases. They will be called as usual during the
 		//		creation of an instance, their methods will be chained, and even
 		//		called by "this.inherited()".
 		//
@@ -645,8 +593,8 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//		"before". Note that chaining assumes that chained methods do not
 		//		return any value: any returned value will be discarded.
 		//
-		//	example:
-		//	|	dojo.declare("my.classes.bar", my.classes.foo, {
+		// example:
+		//	|	declare("my.classes.bar", my.classes.foo, {
 		//	|		// properties to be added to the class prototype
 		//	|		someValue: 2,
 		//	|		// initialization function
@@ -659,30 +607,30 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//	|		}
 		//	|	});
 		//
-		//	example:
-		//	|	var MyBase = dojo.declare(null, {
+		// example:
+		//	|	var MyBase = declare(null, {
 		//	|		// constructor, properties, and methods go here
 		//	|		// ...
 		//	|	});
-		//	|	var MyClass1 = dojo.declare(MyBase, {
+		//	|	var MyClass1 = declare(MyBase, {
 		//	|		// constructor, properties, and methods go here
 		//	|		// ...
 		//	|	});
-		//	|	var MyClass2 = dojo.declare(MyBase, {
+		//	|	var MyClass2 = declare(MyBase, {
 		//	|		// constructor, properties, and methods go here
 		//	|		// ...
 		//	|	});
-		//	|	var MyDiamond = dojo.declare([MyClass1, MyClass2], {
+		//	|	var MyDiamond = declare([MyClass1, MyClass2], {
 		//	|		// constructor, properties, and methods go here
 		//	|		// ...
 		//	|	});
 		//
-		//	example:
+		// example:
 		//	|	var F = function(){ console.log("raw constructor"); };
 		//	|	F.prototype.method = function(){
 		//	|		console.log("raw method");
 		//	|	};
-		//	|	var A = dojo.declare(F, {
+		//	|	var A = declare(F, {
 		//	|		constructor: function(){
 		//	|			console.log("A.constructor");
 		//	|		},
@@ -700,13 +648,13 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//	|	// raw method
 		//	|	// ...back in A
 		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
+		// example:
+		//	|	var A = declare(null, {
 		//	|		"-chains-": {
 		//	|			destroy: "before"
 		//	|		}
 		//	|	});
-		//	|	var B = dojo.declare(A, {
+		//	|	var B = declare(A, {
 		//	|		constructor: function(){
 		//	|			console.log("B.constructor");
 		//	|		},
@@ -714,7 +662,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//	|			console.log("B.destroy");
 		//	|		}
 		//	|	});
-		//	|	var C = dojo.declare(B, {
+		//	|	var C = declare(B, {
 		//	|		constructor: function(){
 		//	|			console.log("C.constructor");
 		//	|		},
@@ -729,13 +677,13 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//	|	// C.destroy
 		//	|	// B.destroy
 		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
+		// example:
+		//	|	var A = declare(null, {
 		//	|		"-chains-": {
 		//	|			constructor: "manual"
 		//	|		}
 		//	|	});
-		//	|	var B = dojo.declare(A, {
+		//	|	var B = declare(A, {
 		//	|		constructor: function(){
 		//	|			// ...
 		//	|			// call the base constructor with new parameters
@@ -744,8 +692,8 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//	|		}
 		//	|	});
 		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
+		// example:
+		//	|	var A = declare(null, {
 		//	|		"-chains-": {
 		//	|			m1: "before"
 		//	|		},
@@ -756,7 +704,7 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//	|			console.log("A.m2");
 		//	|		}
 		//	|	});
-		//	|	var B = dojo.declare(A, {
+		//	|	var B = declare(A, {
 		//	|		"-chains-": {
 		//	|			m2: "after"
 		//	|		},
@@ -776,273 +724,320 @@ define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, ha
 		//	|	// prints:
 		//	|	// A.m2
 		//	|	// B.m2
-		return new Function(); // Function
-	};
-	=====*/
 
-	/*=====
-	dojo.safeMixin = function(target, source){
-		//	summary:
-		//		Mix in properties skipping a constructor and decorating functions
-		//		like it is done by dojo.declare.
-		//	target: Object
-		//		Target object to accept new properties.
-		//	source: Object
-		//		Source object for new properties.
-		//	description:
-		//		This function is used to mix in properties like lang.mixin does,
-		//		but it skips a constructor property and decorates functions like
-		//		dojo.declare does.
-		//
-		//		It is meant to be used with classes and objects produced with
-		//		dojo.declare. Functions mixed in with dojo.safeMixin can use
-		//		this.inherited() like normal methods.
-		//
-		//		This function is used to implement extend() method of a constructor
-		//		produced with dojo.declare().
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		m1: function(){
-		//	|			console.log("A.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			console.log("A.m2");
-		//	|		}
-		//	|	});
-		//	|	var B = dojo.declare(A, {
-		//	|		m1: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("B.m1");
-		//	|		}
-		//	|	});
-		//	|	B.extend({
-		//	|		m2: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("B.m2");
-		//	|		}
-		//	|	});
-		//	|	var x = new B();
-		//	|	dojo.safeMixin(x, {
-		//	|		m1: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("X.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("X.m2");
-		//	|		}
-		//	|	});
-		//	|	x.m2();
-		//	|	// prints:
-		//	|	// A.m1
-		//	|	// B.m1
-		//	|	// X.m1
-	};
-	=====*/
+		// crack parameters
+		if(typeof className != "string"){
+			props = superclass;
+			superclass = className;
+			className = "";
+		}
+		props = props || {};
 
-	/*=====
-	Object.inherited = function(name, args, newArgs){
-		//	summary:
-		//		Calls a super method.
-		//	name: String?
-		//		The optional method name. Should be the same as the caller's
-		//		name. Usually "name" is specified in complex dynamic cases, when
-		//		the calling method was dynamically added, undecorated by
-		//		dojo.declare, and it cannot be determined.
-		//	args: Arguments
-		//		The caller supply this argument, which should be the original
-		//		"arguments".
-		//	newArgs: Object?
-		//		If "true", the found function will be returned without
-		//		executing it.
-		//		If Array, it will be used to call a super method. Otherwise
-		//		"args" will be used.
-		//	returns:
-		//		Whatever is returned by a super method, or a super method itself,
-		//		if "true" was specified as newArgs.
-		//	description:
-		//		This method is used inside method of classes produced with
-		//		dojo.declare to call a super method (next in the chain). It is
-		//		used for manually controlled chaining. Consider using the regular
-		//		chaining, because it is faster. Use "this.inherited()" only in
-		//		complex cases.
-		//
-		//		This method cannot me called from automatically chained
-		//		constructors including the case of a special (legacy)
-		//		constructor chaining. It cannot be called from chained methods.
-		//
-		//		If "this.inherited()" cannot find the next-in-chain method, it
-		//		does nothing and returns "undefined". The last method in chain
-		//		can be a default method implemented in Object, which will be
-		//		called last.
-		//
-		//		If "name" is specified, it is assumed that the method that
-		//		received "args" is the parent method for this call. It is looked
-		//		up in the chain list and if it is found the next-in-chain method
-		//		is called. If it is not found, the first-in-chain method is
-		//		called.
-		//
-		//		If "name" is not specified, it will be derived from the calling
-		//		method (using a methoid property "nom").
-		//
-		//	example:
-		//	|	var B = dojo.declare(A, {
-		//	|		method1: function(a, b, c){
-		//	|			this.inherited(arguments);
-		//	|		},
-		//	|		method2: function(a, b){
-		//	|			return this.inherited(arguments, [a + b]);
-		//	|		}
-		//	|	});
-		//	|	// next method is not in the chain list because it is added
-		//	|	// manually after the class was created.
-		//	|	B.prototype.method3 = function(){
-		//	|		console.log("This is a dynamically-added method.");
-		//	|		this.inherited("method3", arguments);
-		//	|	};
-		//	example:
-		//	|	var B = dojo.declare(A, {
-		//	|		method: function(a, b){
-		//	|			var super = this.inherited(arguments, true);
-		//	|			// ...
-		//	|			if(!super){
-		//	|				console.log("there is no super method");
-		//	|				return 0;
-		//	|			}
-		//	|			return super.apply(this, arguments);
-		//	|		}
-		//	|	});
-		return	{};	// Object
-	}
-	=====*/
+		var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
 
-	/*=====
-	Object.getInherited = function(name, args){
-		//	summary:
-		//		Returns a super method.
-		//	name: String?
-		//		The optional method name. Should be the same as the caller's
-		//		name. Usually "name" is specified in complex dynamic cases, when
-		//		the calling method was dynamically added, undecorated by
-		//		dojo.declare, and it cannot be determined.
-		//	args: Arguments
-		//		The caller supply this argument, which should be the original
-		//		"arguments".
-		//	returns:
-		//		Returns a super method (Function) or "undefined".
-		//	description:
-		//		This method is a convenience method for "this.inherited()".
-		//		It uses the same algorithm but instead of executing a super
-		//		method, it returns it, or "undefined" if not found.
-		//
-		//	example:
-		//	|	var B = dojo.declare(A, {
-		//	|		method: function(a, b){
-		//	|			var super = this.getInherited(arguments);
-		//	|			// ...
-		//	|			if(!super){
-		//	|				console.log("there is no super method");
-		//	|				return 0;
-		//	|			}
-		//	|			return super.apply(this, arguments);
-		//	|		}
-		//	|	});
-		return	{};	// Object
-	}
-	=====*/
+		// build a prototype
+		if(opts.call(superclass) == "[object Array]"){
+			// C3 MRO
+			bases = c3mro(superclass, className);
+			t = bases[0];
+			mixins = bases.length - t;
+			superclass = bases[mixins];
+		}else{
+			bases = [0];
+			if(superclass){
+				if(opts.call(superclass) == "[object Function]"){
+					t = superclass._meta;
+					bases = bases.concat(t ? t.bases : superclass);
+				}else{
+					err("base class is not a callable constructor.", className);
+				}
+			}else if(superclass !== null){
+				err("unknown base class. Did you use dojo.require to pull it in?", className);
+			}
+		}
+		if(superclass){
+			for(i = mixins - 1;; --i){
+				proto = forceNew(superclass);
+				if(!i){
+					// stop if nothing to add (the last base)
+					break;
+				}
+				// mix in properties
+				t = bases[i];
+				(t._meta ? mixOwn : mix)(proto, t.prototype);
+				// chain in new constructor
+				ctor = new Function;
+				ctor.superclass = superclass;
+				ctor.prototype = proto;
+				superclass = proto.constructor = ctor;
+			}
+		}else{
+			proto = {};
+		}
+		// add all properties
+		declare.safeMixin(proto, props);
+		// add constructor
+		t = props.constructor;
+		if(t !== op.constructor){
+			t.nom = cname;
+			proto.constructor = t;
+		}
 
-	/*=====
-	Object.isInstanceOf = function(cls){
-		//	summary:
-		//		Checks the inheritance chain to see if it is inherited from this
-		//		class.
-		//	cls: Function
-		//		Class constructor.
-		//	returns:
-		//		"true", if this object is inherited from this class, "false"
-		//		otherwise.
-		//	description:
-		//		This method is used with instances of classes produced with
-		//		dojo.declare to determine of they support a certain interface or
-		//		not. It models "instanceof" operator.
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var B = dojo.declare(null, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var C = dojo.declare([A, B], {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var D = dojo.declare(A, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|
-		//	|	var a = new A(), b = new B(), c = new C(), d = new D();
-		//	|
-		//	|	console.log(a.isInstanceOf(A)); // true
-		//	|	console.log(b.isInstanceOf(A)); // false
-		//	|	console.log(c.isInstanceOf(A)); // true
-		//	|	console.log(d.isInstanceOf(A)); // true
-		//	|
-		//	|	console.log(a.isInstanceOf(B)); // false
-		//	|	console.log(b.isInstanceOf(B)); // true
-		//	|	console.log(c.isInstanceOf(B)); // true
-		//	|	console.log(d.isInstanceOf(B)); // false
-		//	|
-		//	|	console.log(a.isInstanceOf(C)); // false
-		//	|	console.log(b.isInstanceOf(C)); // false
-		//	|	console.log(c.isInstanceOf(C)); // true
-		//	|	console.log(d.isInstanceOf(C)); // false
-		//	|
-		//	|	console.log(a.isInstanceOf(D)); // false
-		//	|	console.log(b.isInstanceOf(D)); // false
-		//	|	console.log(c.isInstanceOf(D)); // false
-		//	|	console.log(d.isInstanceOf(D)); // true
-		return	{};	// Object
+		// collect chains and flags
+		for(i = mixins - 1; i; --i){ // intentional assignment
+			t = bases[i]._meta;
+			if(t && t.chains){
+				chains = mix(chains || {}, t.chains);
+			}
+		}
+		if(proto["-chains-"]){
+			chains = mix(chains || {}, proto["-chains-"]);
+		}
+
+		// build ctor
+		t = !chains || !chains.hasOwnProperty(cname);
+		bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
+			(bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
+
+		// add meta information to the constructor
+		ctor._meta  = {bases: bases, hidden: props, chains: chains,
+			parents: parents, ctor: props.constructor};
+		ctor.superclass = superclass && superclass.prototype;
+		ctor.extend = extend;
+		ctor.createSubclass = createSubclass;
+		ctor.prototype = proto;
+		proto.constructor = ctor;
+
+		// add "standard" methods to the prototype
+		proto.getInherited = getInherited;
+		proto.isInstanceOf = isInstanceOf;
+		proto.inherited    = inheritedImpl;
+		proto.__inherited  = inherited;
+
+		// add name if specified
+		if(className){
+			proto.declaredClass = className;
+			lang.setObject(className, ctor);
+		}
+
+		// build chains and add them to the prototype
+		if(chains){
+			for(name in chains){
+				if(proto[name] && typeof chains[name] == "string" && name != cname){
+					t = proto[name] = chain(name, bases, chains[name] === "after");
+					t.nom = name;
+				}
+			}
+		}
+		// chained methods do not return values
+		// no need to chain "invisible" functions
+
+		return ctor;	// Function
 	}
-	=====*/
 
 	/*=====
-	Object.extend = function(source){
-		//	summary:
-		//		Adds all properties and methods of source to constructor's
-		//		prototype, making them available to all instances created with
-		//		constructor. This method is specific to constructors created with
-		//		dojo.declare.
-		//	source: Object
-		//		Source object which properties are going to be copied to the
-		//		constructor's prototype.
-		//	description:
-		//		Adds source properties to the constructor's prototype. It can
-		//		override existing properties.
-		//
-		//		This method is similar to dojo.extend function, but it is specific
-		//		to constructors produced by dojo.declare. It is implemented
-		//		using dojo.safeMixin, and it skips a constructor property,
-		//		and properly decorates copied functions.
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		m1: function(){},
-		//	|		s1: "Popokatepetl"
-		//	|	});
-		//	|	A.extend({
-		//	|		m1: function(){},
-		//	|		m2: function(){},
-		//	|		f1: true,
-		//	|		d1: 42
-		//	|	});
+	declare.__DeclareCreatedObject = {
+		// summary:
+		//		dojo/_base/declare() returns a constructor `C`.   `new C()` returns an Object with the following
+		//		methods, in addition to the methods and properties specified via the arguments passed to declare().
+
+		inherited: function(name, args, newArgs){
+			// summary:
+			//		Calls a super method.
+			// name: String?
+			//		The optional method name. Should be the same as the caller's
+			//		name. Usually "name" is specified in complex dynamic cases, when
+			//		the calling method was dynamically added, undecorated by
+			//		declare(), and it cannot be determined.
+			// args: Arguments
+			//		The caller supply this argument, which should be the original
+			//		"arguments".
+			// newArgs: Object?
+			//		If "true", the found function will be returned without
+			//		executing it.
+			//		If Array, it will be used to call a super method. Otherwise
+			//		"args" will be used.
+			// returns:
+			//		Whatever is returned by a super method, or a super method itself,
+			//		if "true" was specified as newArgs.
+			// description:
+			//		This method is used inside method of classes produced with
+			//		declare() to call a super method (next in the chain). It is
+			//		used for manually controlled chaining. Consider using the regular
+			//		chaining, because it is faster. Use "this.inherited()" only in
+			//		complex cases.
+			//
+			//		This method cannot me called from automatically chained
+			//		constructors including the case of a special (legacy)
+			//		constructor chaining. It cannot be called from chained methods.
+			//
+			//		If "this.inherited()" cannot find the next-in-chain method, it
+			//		does nothing and returns "undefined". The last method in chain
+			//		can be a default method implemented in Object, which will be
+			//		called last.
+			//
+			//		If "name" is specified, it is assumed that the method that
+			//		received "args" is the parent method for this call. It is looked
+			//		up in the chain list and if it is found the next-in-chain method
+			//		is called. If it is not found, the first-in-chain method is
+			//		called.
+			//
+			//		If "name" is not specified, it will be derived from the calling
+			//		method (using a methoid property "nom").
+			//
+			// example:
+			//	|	var B = declare(A, {
+			//	|		method1: function(a, b, c){
+			//	|			this.inherited(arguments);
+			//	|		},
+			//	|		method2: function(a, b){
+			//	|			return this.inherited(arguments, [a + b]);
+			//	|		}
+			//	|	});
+			//	|	// next method is not in the chain list because it is added
+			//	|	// manually after the class was created.
+			//	|	B.prototype.method3 = function(){
+			//	|		console.log("This is a dynamically-added method.");
+			//	|		this.inherited("method3", arguments);
+			//	|	};
+			// example:
+			//	|	var B = declare(A, {
+			//	|		method: function(a, b){
+			//	|			var super = this.inherited(arguments, true);
+			//	|			// ...
+			//	|			if(!super){
+			//	|				console.log("there is no super method");
+			//	|				return 0;
+			//	|			}
+			//	|			return super.apply(this, arguments);
+			//	|		}
+			//	|	});
+			return	{};	// Object
+		},
+
+		getInherited: function(name, args){
+			// summary:
+			//		Returns a super method.
+			// name: String?
+			//		The optional method name. Should be the same as the caller's
+			//		name. Usually "name" is specified in complex dynamic cases, when
+			//		the calling method was dynamically added, undecorated by
+			//		declare(), and it cannot be determined.
+			// args: Arguments
+			//		The caller supply this argument, which should be the original
+			//		"arguments".
+			// returns:
+			//		Returns a super method (Function) or "undefined".
+			// description:
+			//		This method is a convenience method for "this.inherited()".
+			//		It uses the same algorithm but instead of executing a super
+			//		method, it returns it, or "undefined" if not found.
+			//
+			// example:
+			//	|	var B = declare(A, {
+			//	|		method: function(a, b){
+			//	|			var super = this.getInherited(arguments);
+			//	|			// ...
+			//	|			if(!super){
+			//	|				console.log("there is no super method");
+			//	|				return 0;
+			//	|			}
+			//	|			return super.apply(this, arguments);
+			//	|		}
+			//	|	});
+			return	{};	// Object
+		},
+
+		isInstanceOf: function(cls){
+			// summary:
+			//		Checks the inheritance chain to see if it is inherited from this
+			//		class.
+			// cls: Function
+			//		Class constructor.
+			// returns:
+			//		"true", if this object is inherited from this class, "false"
+			//		otherwise.
+			// description:
+			//		This method is used with instances of classes produced with
+			//		declare() to determine of they support a certain interface or
+			//		not. It models "instanceof" operator.
+			//
+			// example:
+			//	|	var A = declare(null, {
+			//	|		// constructor, properties, and methods go here
+			//	|		// ...
+			//	|	});
+			//	|	var B = declare(null, {
+			//	|		// constructor, properties, and methods go here
+			//	|		// ...
+			//	|	});
+			//	|	var C = declare([A, B], {
+			//	|		// constructor, properties, and methods go here
+			//	|		// ...
+			//	|	});
+			//	|	var D = declare(A, {
+			//	|		// constructor, properties, and methods go here
+			//	|		// ...
+			//	|	});
+			//	|
+			//	|	var a = new A(), b = new B(), c = new C(), d = new D();
+			//	|
+			//	|	console.log(a.isInstanceOf(A)); // true
+			//	|	console.log(b.isInstanceOf(A)); // false
+			//	|	console.log(c.isInstanceOf(A)); // true
+			//	|	console.log(d.isInstanceOf(A)); // true
+			//	|
+			//	|	console.log(a.isInstanceOf(B)); // false
+			//	|	console.log(b.isInstanceOf(B)); // true
+			//	|	console.log(c.isInstanceOf(B)); // true
+			//	|	console.log(d.isInstanceOf(B)); // false
+			//	|
+			//	|	console.log(a.isInstanceOf(C)); // false
+			//	|	console.log(b.isInstanceOf(C)); // false
+			//	|	console.log(c.isInstanceOf(C)); // true
+			//	|	console.log(d.isInstanceOf(C)); // false
+			//	|
+			//	|	console.log(a.isInstanceOf(D)); // false
+			//	|	console.log(b.isInstanceOf(D)); // false
+			//	|	console.log(c.isInstanceOf(D)); // false
+			//	|	console.log(d.isInstanceOf(D)); // true
+			return	{};	// Object
+		},
+
+		extend: function(source){
+			// summary:
+			//		Adds all properties and methods of source to constructor's
+			//		prototype, making them available to all instances created with
+			//		constructor. This method is specific to constructors created with
+			//		declare().
+			// source: Object
+			//		Source object which properties are going to be copied to the
+			//		constructor's prototype.
+			// description:
+			//		Adds source properties to the constructor's prototype. It can
+			//		override existing properties.
+			//
+			//		This method is similar to dojo.extend function, but it is specific
+			//		to constructors produced by declare(). It is implemented
+			//		using dojo.safeMixin, and it skips a constructor property,
+			//		and properly decorates copied functions.
+			//
+			// example:
+			//	|	var A = declare(null, {
+			//	|		m1: function(){},
+			//	|		s1: "Popokatepetl"
+			//	|	});
+			//	|	A.extend({
+			//	|		m1: function(){},
+			//	|		m2: function(){},
+			//	|		f1: true,
+			//	|		d1: 42
+			//	|	});
+		}
 	};
 	=====*/
 
+	// For back-compat, remove for 2.0
 	dojo.safeMixin = declare.safeMixin = safeMixin;
 	dojo.declare = declare;