dojo-rails 0.11.0 → 0.14.0

data/vendor/assets/javascripts/dojo/NodeList.js.uncompressed.js

@@ -1,6 +0,0 @@
-define("dojo/NodeList", ["./query"], function(query){
-	// This class is just for documentation purposes, so NodeList shows up well in the API viewer,
-	// and to simplify writing API doc for all the methods that take NodeList as a parameter, or return a NodeList.
-	return query.NodeList;
-});
-

data/vendor/assets/javascripts/dojo/Stateful.js.uncompressed.js

@@ -1,213 +0,0 @@
-define("dojo/Stateful", ["./_base/declare", "./_base/lang", "./_base/array", "dojo/when"], function(declare, lang, array, when){
-	// module:
-	//		dojo/Stateful
-
-return declare("dojo.Stateful", null, {
-	// summary:
-	//		Base class for objects that provide named properties with optional getter/setter
-	//		control and the ability to watch for property changes
-	//
-	//		The class also provides the functionality to auto-magically manage getters
-	//		and setters for object attributes/properties.
-	//		
-	//		Getters and Setters should follow the format of _xxxGetter or _xxxSetter where 
-	//		the xxx is a name of the attribute to handle.  So an attribute of "foo" 
-	//		would have a custom getter of _fooGetter and a custom setter of _fooSetter.
-	//
-	// example:
-	//	|	var obj = new dojo.Stateful();
-	//	|	obj.watch("foo", function(){
-	//	|		console.log("foo changed to " + this.get("foo"));
-	//	|	});
-	//	|	obj.set("foo","bar");
-
-	// _attrPairNames: Hash
-	//		Used across all instances a hash to cache attribute names and their getter 
-	//		and setter names.
-	_attrPairNames: {},
-
-	_getAttrNames: function(name){
-		// summary:
-		//		Helper function for get() and set().
-		//		Caches attribute name values so we don't do the string ops every time.
-		// tags:
-		//		private
-
-		var apn = this._attrPairNames;
-		if(apn[name]){ return apn[name]; }
-		return (apn[name] = {
-			s: "_" + name + "Setter",
-			g: "_" + name + "Getter"
-		});
-	},
-
-	postscript: function(/*Object?*/ params){
-		// Automatic setting of params during construction
-		if (params){ this.set(params); }
-	},
-
-	_get: function(name, names){
-		// summary:
-		//		Private function that does a get based off a hash of names
-		// names:
-		//		Hash of names of custom attributes
-		return typeof this[names.g] === "function" ? this[names.g]() : this[name];
-	},
-	get: function(/*String*/name){
-		// summary:
-		//		Get a property on a Stateful instance.
-		// name:
-		//		The property to get.
-		// returns:
-		//		The property value on this Stateful instance.
-		// description:
-		//		Get a named property on a Stateful object. The property may
-		//		potentially be retrieved via a getter method in subclasses. In the base class
-		//		this just retrieves the object's property.
-		//		For example:
-		//	|	stateful = new dojo.Stateful({foo: 3});
-		//	|	stateful.get("foo") // returns 3
-		//	|	stateful.foo // returns 3
-
-		return this._get(name, this._getAttrNames(name)); //Any
-	},
-	set: function(/*String*/name, /*Object*/value){
-		// summary:
-		//		Set a property on a Stateful instance
-		// name:
-		//		The property to set.
-		// value:
-		//		The value to set in the property.
-		// returns:
-		//		The function returns this dojo.Stateful instance.
-		// description:
-		//		Sets named properties on a stateful object and notifies any watchers of
-		//		the property. A programmatic setter may be defined in subclasses.
-		//		For example:
-		//	|	stateful = new dojo.Stateful();
-		//	|	stateful.watch(function(name, oldValue, value){
-		//	|		// this will be called on the set below
-		//	|	}
-		//	|	stateful.set(foo, 5);
-		//
-		//	set() may also be called with a hash of name/value pairs, ex:
-		//	|	myObj.set({
-		//	|		foo: "Howdy",
-		//	|		bar: 3
-		//	|	})
-		//	This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
-
-		// If an object is used, iterate through object
-		if(typeof name === "object"){
-			for(var x in name){
-				if(name.hasOwnProperty(x) && x !="_watchCallbacks"){
-					this.set(x, name[x]);
-				}
-			}
-			return this;
-		}
-
-		var names = this._getAttrNames(name),
-			oldValue = this._get(name, names),
-			setter = this[names.s],
-			result;
-		if(typeof setter === "function"){
-			// use the explicit setter
-			result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
-		}else{
-			// no setter so set attribute directly
-			this[name] = value;
-		}
-		if(this._watchCallbacks){
-			var self = this;
-			// If setter returned a promise, wait for it to complete, otherwise call watches immediatly
-			when(result, function(){
-				self._watchCallbacks(name, oldValue, value);
-			});
-		}
-		return this; // dojo/Stateful
-	},
-	_changeAttrValue: function(name, value){
-		// summary:
-		//		Internal helper for directly changing an attribute value.
-		//
-		// name: String
-		//		The property to set.
-		// value: Mixed
-		//		The value to set in the property.
-		//
-		// description:
-		//		Directly change the value of an attribute on an object, bypassing any 
-		//		accessor setter.  Also handles the calling of watch and emitting events. 
-		//		It is designed to be used by descendent class when there are two values 
-		//		of attributes that are linked, but calling .set() is not appropriate.
-
-		var oldValue = this.get(name);
-		this[name] = value;
-		if(this._watchCallbacks){
-			this._watchCallbacks(name, oldValue, value);
-		}
-		return this; // dojo/Stateful
-	},
-	watch: function(/*String?*/name, /*Function*/callback){
-		// summary:
-		//		Watches a property for changes
-		// name:
-		//		Indicates the property to watch. This is optional (the callback may be the
-		//		only parameter), and if omitted, all the properties will be watched
-		// returns:
-		//		An object handle for the watch. The unwatch method of this object
-		//		can be used to discontinue watching this property:
-		//		|	var watchHandle = obj.watch("foo", callback);
-		//		|	watchHandle.unwatch(); // callback won't be called now
-		// callback:
-		//		The function to execute when the property changes. This will be called after
-		//		the property has been changed. The callback will be called with the |this|
-		//		set to the instance, the first argument as the name of the property, the
-		//		second argument as the old value and the third argument as the new value.
-
-		var callbacks = this._watchCallbacks;
-		if(!callbacks){
-			var self = this;
-			callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
-				var notify = function(propertyCallbacks){
-					if(propertyCallbacks){
-						propertyCallbacks = propertyCallbacks.slice();
-						for(var i = 0, l = propertyCallbacks.length; i < l; i++){
-							propertyCallbacks[i].call(self, name, oldValue, value);
-						}
-					}
-				};
-				notify(callbacks['_' + name]);
-				if(!ignoreCatchall){
-					notify(callbacks["*"]); // the catch-all
-				}
-			}; // we use a function instead of an object so it will be ignored by JSON conversion
-		}
-		if(!callback && typeof name === "function"){
-			callback = name;
-			name = "*";
-		}else{
-			// prepend with dash to prevent name conflicts with function (like "name" property)
-			name = '_' + name;
-		}
-		var propertyCallbacks = callbacks[name];
-		if(typeof propertyCallbacks !== "object"){
-			propertyCallbacks = callbacks[name] = [];
-		}
-		propertyCallbacks.push(callback);
-
-		// TODO: Remove unwatch in 2.0
-		var handle = {};
-		handle.unwatch = handle.remove = function(){
-			var index = array.indexOf(propertyCallbacks, callback);
-			if(index > -1){
-				propertyCallbacks.splice(index, 1);
-			}
-		};
-		return handle; //Object
-	}
-
-});
-
-});

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

@@ -1,214 +0,0 @@
-define("dojo/_base/Color", ["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){
-
-	var Color = dojo.Color = function(/*Array|String|Object*/ color){
-		// summary:
-		//		Takes a named string, hex string, array of rgb or rgba values,
-		//		an object with r, g, b, and a properties, or another `Color` object
-		//		and creates a new Color instance to work from.
-		//
-		// example:
-		//		Work with a Color instance:
-		//	 | var c = new Color();
-		//	 | c.setColor([0,0,0]); // black
-		//	 | var hex = c.toHex(); // #000000
-		//
-		// example:
-		//		Work with a node's color:
-		//	 | var color = dojo.style("someNode", "backgroundColor");
-		//	 | var n = new Color(color);
-		//	 | // adjust the color some
-		//	 | n.r *= .5;
-		//	 | console.log(n.toString()); // rgb(128, 255, 255);
-		if(color){ this.setColor(color); }
-	};
-
-	// FIXME:
-	// there's got to be a more space-efficient way to encode or discover
-	// these!! Use hex?
-	Color.named = {
-		// summary:
-		//		Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
-		"black":  [0,0,0],
-		"silver": [192,192,192],
-		"gray":	  [128,128,128],
-		"white":  [255,255,255],
-		"maroon": [128,0,0],
-		"red":	  [255,0,0],
-		"purple": [128,0,128],
-		"fuchsia":[255,0,255],
-		"green":  [0,128,0],
-		"lime":	  [0,255,0],
-		"olive":  [128,128,0],
-		"yellow": [255,255,0],
-		"navy":	  [0,0,128],
-		"blue":	  [0,0,255],
-		"teal":	  [0,128,128],
-		"aqua":	  [0,255,255],
-		"transparent": config.transparentColor || [0,0,0,0]
-	};
-
-	lang.extend(Color, {
-		r: 255, g: 255, b: 255, a: 1,
-		_set: function(r, g, b, a){
-			var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
-		},
-		setColor: function(/*Array|String|Object*/ color){
-			// summary:
-			//		Takes a named string, hex string, array of rgb or rgba values,
-			//		an object with r, g, b, and a properties, or another `Color` object
-			//		and sets this color instance to that value.
-			//
-			// example:
-			//	|	var c = new Color(); // no color
-			//	|	c.setColor("#ededed"); // greyish
-			if(lang.isString(color)){
-				Color.fromString(color, this);
-			}else if(lang.isArray(color)){
-				Color.fromArray(color, this);
-			}else{
-				this._set(color.r, color.g, color.b, color.a);
-				if(!(color instanceof Color)){ this.sanitize(); }
-			}
-			return this;	// Color
-		},
-		sanitize: function(){
-			// summary:
-			//		Ensures the object has correct attributes
-			// description:
-			//		the default implementation does nothing, include dojo.colors to
-			//		augment it with real checks
-			return this;	// Color
-		},
-		toRgb: function(){
-			// summary:
-			//		Returns 3 component array of rgb values
-			// example:
-			//	|	var c = new Color("#000000");
-			//	|	console.log(c.toRgb()); // [0,0,0]
-			var t = this;
-			return [t.r, t.g, t.b]; // Array
-		},
-		toRgba: function(){
-			// summary:
-			//		Returns a 4 component array of rgba values from the color
-			//		represented by this object.
-			var t = this;
-			return [t.r, t.g, t.b, t.a];	// Array
-		},
-		toHex: function(){
-			// summary:
-			//		Returns a CSS color string in hexadecimal representation
-			// example:
-			//	|	console.log(new Color([0,0,0]).toHex()); // #000000
-			var arr = ArrayUtil.map(["r", "g", "b"], function(x){
-				var s = this[x].toString(16);
-				return s.length < 2 ? "0" + s : s;
-			}, this);
-			return "#" + arr.join("");	// String
-		},
-		toCss: function(/*Boolean?*/ includeAlpha){
-			// summary:
-			//		Returns a css color string in rgb(a) representation
-			// example:
-			//	|	var c = new Color("#FFF").toCss();
-			//	|	console.log(c); // rgb('255','255','255')
-			var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
-			return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")";	// String
-		},
-		toString: function(){
-			// summary:
-			//		Returns a visual representation of the color
-			return this.toCss(true); // String
-		}
-	});
-
-	Color.blendColors = dojo.blendColors = function(
-		/*Color*/ start,
-		/*Color*/ end,
-		/*Number*/ weight,
-		/*Color?*/ obj
-	){
-		// summary:
-		//		Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
-		//		can reuse a previously allocated Color object for the result
-		var t = obj || new Color();
-		ArrayUtil.forEach(["r", "g", "b", "a"], function(x){
-			t[x] = start[x] + (end[x] - start[x]) * weight;
-			if(x != "a"){ t[x] = Math.round(t[x]); }
-		});
-		return t.sanitize();	// Color
-	};
-
-	Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*Color?*/ obj){
-		// summary:
-		//		Returns a `Color` instance from a string of the form
-		//		"rgb(...)" or "rgba(...)". Optionally accepts a `Color`
-		//		object to update with the parsed value and return instead of
-		//		creating a new object.
-		// returns:
-		//		A Color object. If obj is passed, it will be the return value.
-		var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
-		return m && Color.fromArray(m[1].split(/\s*,\s*/), obj);	// Color
-	};
-
-	Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*Color?*/ obj){
-		// summary:
-		//		Converts a hex string with a '#' prefix to a color object.
-		//		Supports 12-bit #rgb shorthand. Optionally accepts a
-		//		`Color` object to update with the parsed value.
-		//
-		// returns:
-		//		A Color object. If obj is passed, it will be the return value.
-		//
-		// example:
-		//	 | var thing = dojo.colorFromHex("#ededed"); // grey, longhand
-		//
-		// example:
-		//	| var thing = dojo.colorFromHex("#000"); // black, shorthand
-		var t = obj || new Color(),
-			bits = (color.length == 4) ? 4 : 8,
-			mask = (1 << bits) - 1;
-		color = Number("0x" + color.substr(1));
-		if(isNaN(color)){
-			return null; // Color
-		}
-		ArrayUtil.forEach(["b", "g", "r"], function(x){
-			var c = color & mask;
-			color >>= bits;
-			t[x] = bits == 4 ? 17 * c : c;
-		});
-		t.a = 1;
-		return t;	// Color
-	};
-
-	Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*Color?*/ obj){
-		// summary:
-		//		Builds a `Color` from a 3 or 4 element array, mapping each
-		//		element in sequence to the rgb(a) values of the color.
-		// example:
-		//		| var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha
-		// returns:
-		//		A Color object. If obj is passed, it will be the return value.
-		var t = obj || new Color();
-		t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
-		if(isNaN(t.a)){ t.a = 1; }
-		return t.sanitize();	// Color
-	};
-
-	Color.fromString = dojo.colorFromString = function(/*String*/ str, /*Color?*/ obj){
-		// summary:
-		//		Parses `str` for a color value. Accepts hex, rgb, and rgba
-		//		style color values.
-		// description:
-		//		Acceptable input values for str may include arrays of any form
-		//		accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
-		//		rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
-		//		10, 50)"
-		// returns:
-		//		A Color object. If obj is passed, it will be the return value.
-		var a = Color.named[str];
-		return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj);	// Color
-	};
-
-	return Color;
-});

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

@@ -1,349 +0,0 @@
-define("dojo/_base/Deferred", [
-	"./kernel",
-	"../Deferred",
-	"../promise/Promise",
-	"../errors/CancelError",
-	"../has",
-	"./lang",
-	"../when"
-], function(dojo, NewDeferred, Promise, CancelError, has, lang, when){
-	// module:
-	//		dojo/_base/Deferred
-
-	var mutator = function(){};
-	var freeze = Object.freeze || function(){};
-	// A deferred provides an API for creating and resolving a promise.
-	var Deferred = dojo.Deferred = function(/*Function?*/ canceller){
-		// summary:
-		//		Deprecated.   This module defines the legacy dojo/_base/Deferred API.
-		//		New code should use dojo/Deferred instead.
-		// description:
-		//		The Deferred API is based on the concept of promises that provide a
-		//		generic interface into the eventual completion of an asynchronous action.
-		//		The motivation for promises fundamentally is about creating a
-		//		separation of concerns that allows one to achieve the same type of
-		//		call patterns and logical data flow in asynchronous code as can be
-		//		achieved in synchronous code. Promises allows one
-		//		to be able to call a function purely with arguments needed for
-		//		execution, without conflating the call with concerns of whether it is
-		//		sync or async. One shouldn't need to alter a call's arguments if the
-		//		implementation switches from sync to async (or vice versa). By having
-		//		async functions return promises, the concerns of making the call are
-		//		separated from the concerns of asynchronous interaction (which are
-		//		handled by the promise).
-		//
-		//		The Deferred is a type of promise that provides methods for fulfilling the
-		//		promise with a successful result or an error. The most important method for
-		//		working with Dojo's promises is the then() method, which follows the
-		//		CommonJS proposed promise API. An example of using a Dojo promise:
-		//
-		//		|	var resultingPromise = someAsyncOperation.then(function(result){
-		//		|		... handle result ...
-		//		|	},
-		//		|	function(error){
-		//		|		... handle error ...
-		//		|	});
-		//
-		//		The .then() call returns a new promise that represents the result of the
-		//		execution of the callback. The callbacks will never affect the original promises value.
-		//
-		//		The Deferred instances also provide the following functions for backwards compatibility:
-		//
-		//		- addCallback(handler)
-		//		- addErrback(handler)
-		//		- callback(result)
-		//		- errback(result)
-		//
-		//		Callbacks are allowed to return promises themselves, so
-		//		you can build complicated sequences of events with ease.
-		//
-		//		The creator of the Deferred may specify a canceller.  The canceller
-		//		is a function that will be called if Deferred.cancel is called
-		//		before the Deferred fires. You can use this to implement clean
-		//		aborting of an XMLHttpRequest, etc. Note that cancel will fire the
-		//		deferred with a CancelledError (unless your canceller returns
-		//		another kind of error), so the errbacks should be prepared to
-		//		handle that error for cancellable Deferreds.
-		// example:
-		//	|	var deferred = new Deferred();
-		//	|	setTimeout(function(){ deferred.callback({success: true}); }, 1000);
-		//	|	return deferred;
-		// example:
-		//		Deferred objects are often used when making code asynchronous. It
-		//		may be easiest to write functions in a synchronous manner and then
-		//		split code using a deferred to trigger a response to a long-lived
-		//		operation. For example, instead of register a callback function to
-		//		denote when a rendering operation completes, the function can
-		//		simply return a deferred:
-		//
-		//		|	// callback style:
-		//		|	function renderLotsOfData(data, callback){
-		//		|		var success = false
-		//		|		try{
-		//		|			for(var x in data){
-		//		|				renderDataitem(data[x]);
-		//		|			}
-		//		|			success = true;
-		//		|		}catch(e){ }
-		//		|		if(callback){
-		//		|			callback(success);
-		//		|		}
-		//		|	}
-		//
-		//		|	// using callback style
-		//		|	renderLotsOfData(someDataObj, function(success){
-		//		|		// handles success or failure
-		//		|		if(!success){
-		//		|			promptUserToRecover();
-		//		|		}
-		//		|	});
-		//		|	// NOTE: no way to add another callback here!!
-		// example:
-		//		Using a Deferred doesn't simplify the sending code any, but it
-		//		provides a standard interface for callers and senders alike,
-		//		providing both with a simple way to service multiple callbacks for
-		//		an operation and freeing both sides from worrying about details
-		//		such as "did this get called already?". With Deferreds, new
-		//		callbacks can be added at any time.
-		//
-		//		|	// Deferred style:
-		//		|	function renderLotsOfData(data){
-		//		|		var d = new Deferred();
-		//		|		try{
-		//		|			for(var x in data){
-		//		|				renderDataitem(data[x]);
-		//		|			}
-		//		|			d.callback(true);
-		//		|		}catch(e){
-		//		|			d.errback(new Error("rendering failed"));
-		//		|		}
-		//		|		return d;
-		//		|	}
-		//
-		//		|	// using Deferred style
-		//		|	renderLotsOfData(someDataObj).then(null, function(){
-		//		|		promptUserToRecover();
-		//		|	});
-		//		|	// NOTE: addErrback and addCallback both return the Deferred
-		//		|	// again, so we could chain adding callbacks or save the
-		//		|	// deferred for later should we need to be notified again.
-		// example:
-		//		In this example, renderLotsOfData is synchronous and so both
-		//		versions are pretty artificial. Putting the data display on a
-		//		timeout helps show why Deferreds rock:
-		//
-		//		|	// Deferred style and async func
-		//		|	function renderLotsOfData(data){
-		//		|		var d = new Deferred();
-		//		|		setTimeout(function(){
-		//		|			try{
-		//		|				for(var x in data){
-		//		|					renderDataitem(data[x]);
-		//		|				}
-		//		|				d.callback(true);
-		//		|			}catch(e){
-		//		|				d.errback(new Error("rendering failed"));
-		//		|			}
-		//		|		}, 100);
-		//		|		return d;
-		//		|	}
-		//
-		//		|	// using Deferred style
-		//		|	renderLotsOfData(someDataObj).then(null, function(){
-		//		|		promptUserToRecover();
-		//		|	});
-		//
-		//		Note that the caller doesn't have to change his code at all to
-		//		handle the asynchronous case.
-
-		var result, finished, isError, head, nextListener;
-		var promise = (this.promise = new Promise());
-
-		function complete(value){
-			if(finished){
-				throw new Error("This deferred has already been resolved");
-			}
-			result = value;
-			finished = true;
-			notify();
-		}
-		function notify(){
-			var mutated;
-			while(!mutated && nextListener){
-				var listener = nextListener;
-				nextListener = nextListener.next;
-				if((mutated = (listener.progress == mutator))){ // assignment and check
-					finished = false;
-				}
-
-				var func = (isError ? listener.error : listener.resolved);
-				if(has("config-useDeferredInstrumentation")){
-					if(isError && NewDeferred.instrumentRejected){
-						NewDeferred.instrumentRejected(result, !!func);
-					}
-				}
-				if(func){
-					try{
-						var newResult = func(result);
-						if (newResult && typeof newResult.then === "function"){
-							newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
-							continue;
-						}
-						var unchanged = mutated && newResult === undefined;
-						if(mutated && !unchanged){
-							isError = newResult instanceof Error;
-						}
-						listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
-					}catch(e){
-						listener.deferred.reject(e);
-					}
-				}else{
-					if(isError){
-						listener.deferred.reject(result);
-					}else{
-						listener.deferred.resolve(result);
-					}
-				}
-			}
-		}
-		// calling resolve will resolve the promise
-		this.resolve = this.callback = function(value){
-			// summary:
-			//		Fulfills the Deferred instance successfully with the provide value
-			this.fired = 0;
-			this.results = [value, null];
-			complete(value);
-		};
-
-
-		// calling error will indicate that the promise failed
-		this.reject = this.errback = function(error){
-			// summary:
-			//		Fulfills the Deferred instance as an error with the provided error
-			isError = true;
-			this.fired = 1;
-			if(has("config-useDeferredInstrumentation")){
-				if(NewDeferred.instrumentRejected){
-					NewDeferred.instrumentRejected(error, !!nextListener);
-				}
-			}
-			complete(error);
-			this.results = [null, error];
-		};
-		// call progress to provide updates on the progress on the completion of the promise
-		this.progress = function(update){
-			// summary:
-			//		Send progress events to all listeners
-			var listener = nextListener;
-			while(listener){
-				var progress = listener.progress;
-				progress && progress(update);
-				listener = listener.next;
-			}
-		};
-		this.addCallbacks = function(callback, errback){
-			// summary:
-			//		Adds callback and error callback for this deferred instance.
-			// callback: Function?
-			//		The callback attached to this deferred object.
-			// errback: Function?
-			//		The error callback attached to this deferred object.
-			// returns:
-			//		Returns this deferred object.
-			this.then(callback, errback, mutator);
-			return this;	// Deferred
-		};
-		// provide the implementation of the promise
-		promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
-			// summary:
-			//		Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
-			//		completion of a promise. The fulfilledHandler is called when the promise
-			//		is fulfilled. The errorHandler is called when a promise fails. The
-			//		progressHandler is called for progress events. All arguments are optional
-			//		and non-function values are ignored. The progressHandler is not only an
-			//		optional argument, but progress events are purely optional. Promise
-			//		providers are not required to ever create progress events.
-			//
-			//		This function will return a new promise that is fulfilled when the given
-			//		fulfilledHandler or errorHandler callback is finished. This allows promise
-			//		operations to be chained together. The value returned from the callback
-			//		handler is the fulfillment value for the returned promise. If the callback
-			//		throws an error, the returned promise will be moved to failed state.
-			//
-			// returns:
-			//		Returns a new promise that represents the result of the
-			//		execution of the callback. The callbacks will never affect the original promises value.
-			// example:
-			//		An example of using a CommonJS compliant promise:
-			//		|	asyncComputeTheAnswerToEverything().
-			//		|		then(addTwo).
-			//		|		then(printResult, onError);
-			//		|	>44
-			//
-			var returnDeferred = progressCallback == mutator ? this : new Deferred(promise.cancel);
-			var listener = {
-				resolved: resolvedCallback,
-				error: errorCallback,
-				progress: progressCallback,
-				deferred: returnDeferred
-			};
-			if(nextListener){
-				head = head.next = listener;
-			}
-			else{
-				nextListener = head = listener;
-			}
-			if(finished){
-				notify();
-			}
-			return returnDeferred.promise; // Promise
-		};
-		var deferred = this;
-		promise.cancel = this.cancel = function(){
-			// summary:
-			//		Cancels the asynchronous operation
-			if(!finished){
-				var error = canceller && canceller(deferred);
-				if(!finished){
-					if (!(error instanceof Error)){
-						error = new CancelError(error);
-					}
-					error.log = false;
-					deferred.reject(error);
-				}
-			}
-		};
-		freeze(promise);
-	};
-	lang.extend(Deferred, {
-		addCallback: function(/*Function*/ callback){
-			// summary:
-			//		Adds successful callback for this deferred instance.
-			// returns:
-			//		Returns this deferred object.
-			return this.addCallbacks(lang.hitch.apply(dojo, arguments));	// Deferred
-		},
-
-		addErrback: function(/*Function*/ errback){
-			// summary:
-			//		Adds error callback for this deferred instance.
-			// returns:
-			//		Returns this deferred object.
-			return this.addCallbacks(null, lang.hitch.apply(dojo, arguments));	// Deferred
-		},
-
-		addBoth: function(/*Function*/ callback){
-			// summary:
-			//		Add handler as both successful callback and error callback for this deferred instance.
-			// returns:
-			//		Returns this deferred object.
-			var enclosed = lang.hitch.apply(dojo, arguments);
-			return this.addCallbacks(enclosed, enclosed);	// Deferred
-		},
-		fired: -1
-	});
-
-	Deferred.when = dojo.when = when;
-
-	return Deferred;
-});