dojo-rails 0.9.8 → 0.9.9

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

@@ -0,0 +1,400 @@
+define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){
+//  module:
+//    dojo/_base/connect
+//  summary:
+//    This module defines the dojo.connect API.
+//		This modules also provides keyboard event handling helpers.
+//		This module exports an extension event for emulating Firefox's keypress handling.
+//		However, this extension event exists primarily for backwards compatibility and
+//		is not recommended. WebKit and IE uses an alternate keypress handling (only
+//		firing for printable characters, to distinguish from keydown events), and most
+//		consider the WebKit/IE behavior more desirable.
+has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit
+	var testKeyEvent = {charCode: 0};
+	try{
+		testKeyEvent = document.createEvent("KeyboardEvent");
+		(testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3);
+	}catch(e){}
+	return testKeyEvent.charCode == 0 && !has("opera");
+});
+
+function connect_(obj, event, context, method, dontFix){
+	method = lang.hitch(context, method);
+	if(!obj || !(obj.addEventListener || obj.attachEvent)){
+		// it is a not a DOM node and we are using the dojo.connect style of treating a
+		// method like an event, must go right to aspect
+		return aspect.after(obj || kernel.global, event, method, true);
+	}
+	if(typeof event == "string" && event.substring(0, 2) == "on"){
+		event = event.substring(2);
+	}
+	if(!obj){
+		obj = kernel.global;
+	}
+	if(!dontFix){
+		switch(event){
+			// dojo.connect has special handling for these event types
+			case "keypress":
+				event = keypress;
+				break;
+			case "mouseenter":
+				event = mouse.enter;
+				break;
+			case "mouseleave":
+				event = mouse.leave;
+				break;
+		}
+	}
+	return on(obj, event, method, dontFix);
+}
+
+var _punctMap = {
+	106:42,
+	111:47,
+	186:59,
+	187:43,
+	188:44,
+	189:45,
+	190:46,
+	191:47,
+	192:96,
+	219:91,
+	220:92,
+	221:93,
+	222:39,
+	229:113
+};
+var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey";
+
+
+var _synthesizeEvent = function(evt, props){
+	var faux = lang.mixin({}, evt, props);
+	setKeyChar(faux);
+	// FIXME: would prefer to use lang.hitch: lang.hitch(evt, evt.preventDefault);
+	// but it throws an error when preventDefault is invoked on Safari
+	// does Event.preventDefault not support "apply" on Safari?
+	faux.preventDefault = function(){ evt.preventDefault(); };
+	faux.stopPropagation = function(){ evt.stopPropagation(); };
+	return faux;
+};
+function setKeyChar(evt){
+	evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+	evt.charOrCode = evt.keyChar || evt.keyCode;
+}
+var keypress;
+if(has("events-keypress-typed")){
+	// this emulates Firefox's keypress behavior where every keydown can correspond to a keypress
+	var _trySetKeyCode = function(e, code){
+		try{
+			// squelch errors when keyCode is read-only
+			// (e.g. if keyCode is ctrl or shift)
+			return (e.keyCode = code);
+		}catch(e){
+			return 0;
+		}
+	};
+	keypress = function(object, listener){
+		var keydownSignal = on(object, "keydown", function(evt){
+			// munge key/charCode
+			var k=evt.keyCode;
+			// These are Windows Virtual Key Codes
+			// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
+			var unprintable = (k!=13 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
+			// synthesize keypress for most unprintables and CTRL-keys
+			if(unprintable||evt.ctrlKey){
+				var c = unprintable ? 0 : k;
+				if(evt.ctrlKey){
+					if(k==3 || k==13){
+						return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
+					}else if(c>95 && c<106){
+						c -= 48; // map CTRL-[numpad 0-9] to ASCII
+					}else if((!evt.shiftKey)&&(c>=65&&c<=90)){
+						c += 32; // map CTRL-[A-Z] to lowercase
+					}else{
+						c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII
+					}
+				}
+				// simulate a keypress event
+				var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
+				listener.call(evt.currentTarget, faux);
+				if(has("ie")){
+					_trySetKeyCode(evt, faux.keyCode);
+				}
+			}
+		});
+		var keypressSignal = on(object, "keypress", function(evt){
+			var c = evt.charCode;
+			c = c>=32 ? c : 0;
+			evt = _synthesizeEvent(evt, {charCode: c, faux: true});
+			return listener.call(this, evt);
+		});
+		return {
+			remove: function(){
+				keydownSignal.remove();
+				keypressSignal.remove();
+			}
+		};
+	};
+}else{
+	if(has("opera")){
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				var c = evt.which;
+				if(c==3){
+					c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+				}
+				// can't trap some keys at all, like INSERT and DELETE
+				// there is no differentiating info between DELETE and ".", or INSERT and "-"
+				c = c<32 && !evt.shiftKey ? 0 : c;
+				if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
+					// lowercase CTRL-[A-Z] keys
+					c += 32;
+				}
+				return listener.call(this, _synthesizeEvent(evt, { charCode: c }));
+			});
+		};
+	}else{
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				setKeyChar(evt);
+				return listener.call(this, evt);
+			});
+		};
+	}
+}
+
+var connect = {
+	_keypress:keypress,
+
+	connect:function(obj, event, context, method, dontFix){
+		// normalize arguments
+		var a=arguments, args=[], i=0;
+		// if a[0] is a String, obj was omitted
+		args.push(typeof a[0] == "string" ? null : a[i++], a[i++]);
+		// if the arg-after-next is a String or Function, context was NOT omitted
+		var a1 = a[i+1];
+		args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]);
+		// absorb any additional arguments
+		for(var l=a.length; i<l; i++){	args.push(a[i]); }
+		return connect_.apply(this, args);
+	},
+
+	disconnect:function(handle){
+		if(handle){
+			handle.remove();
+		}
+	},
+
+	subscribe:function(topic, context, method){
+		return hub.subscribe(topic, lang.hitch(context, method));
+	},
+
+	publish:function(topic, args){
+		return hub.publish.apply(hub, [topic].concat(args));
+	},
+
+	connectPublisher:function(topic, obj, event){
+		var pf = function(){ connect.publish(topic, arguments); };
+		return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
+	},
+
+	isCopyKey: function(e){
+		return e[evtCopyKey];	// Boolean
+	}
+};
+connect.unsubscribe = connect.disconnect;
+
+1 && lang.mixin(kernel, connect);
+return connect;
+
+/*=====
+dojo.connect = function(obj, event, context, method, dontFix){
+	// summary:
+	//		`dojo.connect` is the core event handling and delegation method in
+	//		Dojo. It allows one function to "listen in" on the execution of
+	//		any other, triggering the second whenever the first is called. Many
+	//		listeners may be attached to a function, and source functions may
+	//		be either regular function calls or DOM events.
+	//
+	// description:
+	//		Connects listeners to actions, so that after event fires, a
+	//		listener is called with the same arguments passed to the original
+	//		function.
+	//
+	//		Since `dojo.connect` allows the source of events to be either a
+	//		"regular" JavaScript function or a DOM event, it provides a uniform
+	//		interface for listening to all the types of events that an
+	//		application is likely to deal with though a single, unified
+	//		interface. DOM programmers may want to think of it as
+	//		"addEventListener for everything and anything".
+	//
+	//		When setting up a connection, the `event` parameter must be a
+	//		string that is the name of the method/event to be listened for. If
+	//		`obj` is null, `kernel.global` is assumed, meaning that connections
+	//		to global methods are supported but also that you may inadvertently
+	//		connect to a global by passing an incorrect object name or invalid
+	//		reference.
+	//
+	//		`dojo.connect` generally is forgiving. If you pass the name of a
+	//		function or method that does not yet exist on `obj`, connect will
+	//		not fail, but will instead set up a stub method. Similarly, null
+	//		arguments may simply be omitted such that fewer than 4 arguments
+	//		may be required to set up a connection See the examples for details.
+	//
+	//		The return value is a handle that is needed to
+	//		remove this connection with `dojo.disconnect`.
+	//
+	// obj: Object|null:
+	//		The source object for the event function.
+	//		Defaults to `kernel.global` if null.
+	//		If obj is a DOM node, the connection is delegated
+	//		to the DOM event manager (unless dontFix is true).
+	//
+	// event: String:
+	//		String name of the event function in obj.
+	//		I.e. identifies a property `obj[event]`.
+	//
+	// context: Object|null
+	//		The object that method will receive as "this".
+	//
+	//		If context is null and method is a function, then method
+	//		inherits the context of event.
+	//
+	//		If method is a string then context must be the source
+	//		object object for method (context[method]). If context is null,
+	//		kernel.global is used.
+	//
+	// method: String|Function:
+	//		A function reference, or name of a function in context.
+	//		The function identified by method fires after event does.
+	//		method receives the same arguments as the event.
+	//		See context argument comments for information on method's scope.
+	//
+	// dontFix: Boolean?
+	//		If obj is a DOM node, set dontFix to true to prevent delegation
+	//		of this connection to the DOM event manager.
+	//
+	// example:
+	//		When obj.onchange(), do ui.update():
+	//	|	dojo.connect(obj, "onchange", ui, "update");
+	//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
+	//
+	// example:
+	//		Using return value for disconnect:
+	//	|	var link = dojo.connect(obj, "onchange", ui, "update");
+	//	|	...
+	//	|	dojo.disconnect(link);
+	//
+	// example:
+	//		When onglobalevent executes, watcher.handler is invoked:
+	//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked:
+	//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+	//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+	//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+	//
+	// example:
+	//		When globalEvent executes, globalHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(null, "globalEvent", null, globalHandler);
+	//	|	dojo.connect("globalEvent", globalHandler); // same
+}
+=====*/
+
+/*=====
+dojo.disconnect = function(handle){
+	// summary:
+	//		Remove a link created by dojo.connect.
+	// description:
+	//		Removes the connection between event and the method referenced by handle.
+	// handle: Handle:
+	//		the return value of the dojo.connect call that created the connection.
+}
+=====*/
+
+/*=====
+dojo.subscribe = function(topic, context, method){
+	//	summary:
+	//		Attach a listener to a named topic. The listener function is invoked whenever the
+	//		named topic is published (see: dojo.publish).
+	//		Returns a handle which is needed to unsubscribe this listener.
+	//	topic: String:
+	//		The topic to which to subscribe.
+	//	context: Object|null:
+	//		Scope in which method will be invoked, or null for default scope.
+	//	method: String|Function:
+	//		The name of a function in context, or a function reference. This is the function that
+	//		is invoked when topic is published.
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.unsubscribe = function(handle){
+	//	summary:
+	//		Remove a topic listener.
+	//	handle: Handle
+	//		The handle returned from a call to subscribe.
+	//	example:
+	//	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	...
+	//	|	dojo.unsubscribe(alerter);
+}
+=====*/
+
+/*=====
+dojo.publish = function(topic, args){
+	//	summary:
+	//		Invoke all listener method subscribed to topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	args: Array?
+	//		An array of arguments. The arguments will be applied
+	//		to each topic subscriber (as first class parameters, via apply).
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.connectPublisher = function(topic, obj, event){
+	//	summary:
+	//		Ensure that every time obj.event() is called, a message is published
+	//		on the topic. Returns a handle which can be passed to
+	//		dojo.disconnect() to disable subsequent automatic publication on
+	//		the topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	obj: Object|null:
+	//		The source object for the event function. Defaults to kernel.global
+	//		if null.
+	//	event: String:
+	//		The name of the event function in obj.
+	//		I.e. identifies a property obj[event].
+	//	example:
+	//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
+}
+=====*/
+
+/*=====
+dojo.isCopyKey = function(e){
+	// summary:
+	//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
+	// e: Event
+	//		Event object to examine
+}
+=====*/
+
+});
+
+

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

@@ -0,0 +1,430 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/_base/declare",["./kernel","../has","./lang"],function(_1,_2,_3){
+var _4=_3.mixin,op=Object.prototype,_5=op.toString,_6=new Function,_7=0,_8="constructor";
+function _9(_a,_b){
+throw new Error("declare"+(_b?" "+_b:"")+": "+_a);
+};
+function _c(_d,_e){
+var _f=[],_10=[{cls:0,refs:[]}],_11={},_12=1,l=_d.length,i=0,j,lin,_13,top,_14,rec,_15,_16;
+for(;i<l;++i){
+_13=_d[i];
+if(!_13){
+_9("mixin #"+i+" is unknown. Did you use dojo.require to pull it in?",_e);
+}else{
+if(_5.call(_13)!="[object Function]"){
+_9("mixin #"+i+" is not a callable constructor.",_e);
+}
+}
+lin=_13._meta?_13._meta.bases:[_13];
+top=0;
+for(j=lin.length-1;j>=0;--j){
+_14=lin[j].prototype;
+if(!_14.hasOwnProperty("declaredClass")){
+_14.declaredClass="uniqName_"+(_7++);
+}
+_15=_14.declaredClass;
+if(!_11.hasOwnProperty(_15)){
+_11[_15]={count:0,refs:[],cls:lin[j]};
+++_12;
+}
+rec=_11[_15];
+if(top&&top!==rec){
+rec.refs.push(top);
+++top.count;
+}
+top=rec;
+}
+++top.count;
+_10[0].refs.push(top);
+}
+while(_10.length){
+top=_10.pop();
+_f.push(top.cls);
+--_12;
+while(_16=top.refs,_16.length==1){
+top=_16[0];
+if(!top||--top.count){
+top=0;
+break;
+}
+_f.push(top.cls);
+--_12;
+}
+if(top){
+for(i=0,l=_16.length;i<l;++i){
+top=_16[i];
+if(!--top.count){
+_10.push(top);
+}
+}
+}
+}
+if(_12){
+_9("can't build consistent linearization",_e);
+}
+_13=_d[0];
+_f[0]=_13?_13._meta&&_13===_f[_f.length-_13._meta.bases.length]?_13._meta.bases.length:1:0;
+return _f;
+};
+function _17(_18,a,f){
+var _19,_1a,_1b,_1c,_1d,_1e,_1f,opf,pos,_20=this._inherited=this._inherited||{};
+if(typeof _18=="string"){
+_19=_18;
+_18=a;
+a=f;
+}
+f=0;
+_1c=_18.callee;
+_19=_19||_1c.nom;
+if(!_19){
+_9("can't deduce a name to call inherited()",this.declaredClass);
+}
+_1d=this.constructor._meta;
+_1b=_1d.bases;
+pos=_20.p;
+if(_19!=_8){
+if(_20.c!==_1c){
+pos=0;
+_1e=_1b[0];
+_1d=_1e._meta;
+if(_1d.hidden[_19]!==_1c){
+_1a=_1d.chains;
+if(_1a&&typeof _1a[_19]=="string"){
+_9("calling chained method with inherited: "+_19,this.declaredClass);
+}
+do{
+_1d=_1e._meta;
+_1f=_1e.prototype;
+if(_1d&&(_1f[_19]===_1c&&_1f.hasOwnProperty(_19)||_1d.hidden[_19]===_1c)){
+break;
+}
+}while(_1e=_1b[++pos]);
+pos=_1e?pos:-1;
+}
+}
+_1e=_1b[++pos];
+if(_1e){
+_1f=_1e.prototype;
+if(_1e._meta&&_1f.hasOwnProperty(_19)){
+f=_1f[_19];
+}else{
+opf=op[_19];
+do{
+_1f=_1e.prototype;
+f=_1f[_19];
+if(f&&(_1e._meta?_1f.hasOwnProperty(_19):f!==opf)){
+break;
+}
+}while(_1e=_1b[++pos]);
+}
+}
+f=_1e&&f||op[_19];
+}else{
+if(_20.c!==_1c){
+pos=0;
+_1d=_1b[0]._meta;
+if(_1d&&_1d.ctor!==_1c){
+_1a=_1d.chains;
+if(!_1a||_1a.constructor!=="manual"){
+_9("calling chained constructor with inherited",this.declaredClass);
+}
+while(_1e=_1b[++pos]){
+_1d=_1e._meta;
+if(_1d&&_1d.ctor===_1c){
+break;
+}
+}
+pos=_1e?pos:-1;
+}
+}
+while(_1e=_1b[++pos]){
+_1d=_1e._meta;
+f=_1d?_1d.ctor:_1e;
+if(f){
+break;
+}
+}
+f=_1e&&f;
+}
+_20.c=f;
+_20.p=pos;
+if(f){
+return a===true?f:f.apply(this,a||_18);
+}
+};
+function _21(_22,_23){
+if(typeof _22=="string"){
+return this.__inherited(_22,_23,true);
+}
+return this.__inherited(_22,true);
+};
+function _24(_25,a1,a2){
+var f=this.getInherited(_25,a1);
+if(f){
+return f.apply(this,a2||a1||_25);
+}
+};
+var _26=_1.config.isDebug?_24:_17;
+function _27(cls){
+var _28=this.constructor._meta.bases;
+for(var i=0,l=_28.length;i<l;++i){
+if(_28[i]===cls){
+return true;
+}
+}
+return this instanceof cls;
+};
+function _29(_2a,_2b){
+for(var _2c in _2b){
+if(_2c!=_8&&_2b.hasOwnProperty(_2c)){
+_2a[_2c]=_2b[_2c];
+}
+}
+if(_2("bug-for-in-skips-shadowed")){
+for(var _2d=_3._extraNames,i=_2d.length;i;){
+_2c=_2d[--i];
+if(_2c!=_8&&_2b.hasOwnProperty(_2c)){
+_2a[_2c]=_2b[_2c];
+}
+}
+}
+};
+function _2e(_2f,_30){
+var _31,t;
+for(_31 in _30){
+t=_30[_31];
+if((t!==op[_31]||!(_31 in op))&&_31!=_8){
+if(_5.call(t)=="[object Function]"){
+t.nom=_31;
+}
+_2f[_31]=t;
+}
+}
+if(_2("bug-for-in-skips-shadowed")){
+for(var _32=_3._extraNames,i=_32.length;i;){
+_31=_32[--i];
+t=_30[_31];
+if((t!==op[_31]||!(_31 in op))&&_31!=_8){
+if(_5.call(t)=="[object Function]"){
+t.nom=_31;
+}
+_2f[_31]=t;
+}
+}
+}
+return _2f;
+};
+function _33(_34){
+_35.safeMixin(this.prototype,_34);
+return this;
+};
+function _36(_37,_38){
+return function(){
+var a=arguments,_39=a,a0=a[0],f,i,m,l=_37.length,_3a;
+if(!(this instanceof a.callee)){
+return _3b(a);
+}
+if(_38&&(a0&&a0.preamble||this.preamble)){
+_3a=new Array(_37.length);
+_3a[0]=a;
+for(i=0;;){
+a0=a[0];
+if(a0){
+f=a0.preamble;
+if(f){
+a=f.apply(this,a)||a;
+}
+}
+f=_37[i].prototype;
+f=f.hasOwnProperty("preamble")&&f.preamble;
+if(f){
+a=f.apply(this,a)||a;
+}
+if(++i==l){
+break;
+}
+_3a[i]=a;
+}
+}
+for(i=l-1;i>=0;--i){
+f=_37[i];
+m=f._meta;
+f=m?m.ctor:f;
+if(f){
+f.apply(this,_3a?_3a[i]:a);
+}
+}
+f=this.postscript;
+if(f){
+f.apply(this,_39);
+}
+};
+};
+function _3c(_3d,_3e){
+return function(){
+var a=arguments,t=a,a0=a[0],f;
+if(!(this instanceof a.callee)){
+return _3b(a);
+}
+if(_3e){
+if(a0){
+f=a0.preamble;
+if(f){
+t=f.apply(this,t)||t;
+}
+}
+f=this.preamble;
+if(f){
+f.apply(this,t);
+}
+}
+if(_3d){
+_3d.apply(this,a);
+}
+f=this.postscript;
+if(f){
+f.apply(this,a);
+}
+};
+};
+function _3f(_40){
+return function(){
+var a=arguments,i=0,f,m;
+if(!(this instanceof a.callee)){
+return _3b(a);
+}
+for(;f=_40[i];++i){
+m=f._meta;
+f=m?m.ctor:f;
+if(f){
+f.apply(this,a);
+break;
+}
+}
+f=this.postscript;
+if(f){
+f.apply(this,a);
+}
+};
+};
+function _41(_42,_43,_44){
+return function(){
+var b,m,f,i=0,_45=1;
+if(_44){
+i=_43.length-1;
+_45=-1;
+}
+for(;b=_43[i];i+=_45){
+m=b._meta;
+f=(m?m.hidden:b.prototype)[_42];
+if(f){
+f.apply(this,arguments);
+}
+}
+};
+};
+function _46(_47){
+_6.prototype=_47.prototype;
+var t=new _6;
+_6.prototype=null;
+return t;
+};
+function _3b(_48){
+var _49=_48.callee,t=_46(_49);
+_49.apply(t,_48);
+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];
+}else{
+_50=[0];
+if(_4b){
+if(_5.call(_4b)=="[object Function]"){
+t=_4b._meta;
+_50=_50.concat(t?t.bases:_4b);
+}else{
+_9("base class is not a callable constructor.",_4a);
+}
+}else{
+if(_4b!==null){
+_9("unknown base class. Did you use dojo.require to pull it in?",_4a);
+}
+}
+}
+if(_4b){
+for(i=_52-1;;--i){
+_4d=_46(_4b);
+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;
+}
+}else{
+_4d={};
+}
+_35.safeMixin(_4d,_4c);
+t=_4c.constructor;
+if(t!==op.constructor){
+t.nom=_8;
+_4d.constructor=t;
+}
+for(i=_52-1;i;--i){
+t=_50[i]._meta;
+if(t&&t.chains){
+_51=_4(_51||{},t.chains);
+}
+}
+if(_4d["-chains-"]){
+_51=_4(_51||{},_4d["-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);
+}
+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;
+}
+}
+}
+return _4e;
+};
+_1.safeMixin=_35.safeMixin=_2e;
+_1.declare=_35;
+return _35;
+});